math-exercises 3.0.149 → 3.0.150

package/lib/exercises/math/scratch/index.d.ts

@@ -1,2 +1,15 @@
 export * from "./scratchLoopStepsCount.js";
+export * from "./scratchLoopCond1.js";
+export * from "./scratchSwapUsingTmp.js";
+export * from "./scratchLoopCond2.js";
+export * from "./scratchPrintXY.js";
+export * from "./scratchOperations1.js";
+export * from "./scratchOperations2.js";
+export * from "./scratchLoop1.js";
+export * from "./scratchVarWaterfall.js";
+export * from "./scratchStringLoop.js";
+export * from "./scratchStringLoopCond.js";
+export * from "./scratchStringLoopCond2.js";
+export * from "./scratchStringLoopCond3.js";
+export * from "./scratchCond1.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/scratch/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC"}

package/lib/exercises/math/scratch/index.js

@@ -1 +1,15 @@
 export * from "./scratchLoopStepsCount.js";
+export * from "./scratchLoopCond1.js";
+export * from "./scratchSwapUsingTmp.js";
+export * from "./scratchLoopCond2.js";
+export * from "./scratchPrintXY.js";
+export * from "./scratchOperations1.js";
+export * from "./scratchOperations2.js";
+export * from "./scratchLoop1.js";
+export * from "./scratchVarWaterfall.js";
+export * from "./scratchStringLoop.js";
+export * from "./scratchStringLoopCond.js";
+export * from "./scratchStringLoopCond2.js";
+export * from "./scratchStringLoopCond3.js";
+export * from "./scratchCond1.js";
+// export * from "./scratchFunction1.js";

package/lib/exercises/math/scratch/scratchCond1.d.ts

@@ -0,0 +1,25 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Condition1 = {
+    isNOT: boolean;
+    isGreaterCond1: boolean;
+    thresholdCond1: number;
+};
+type Condition2 = {
+    isAND: boolean;
+    conditions: Condition1[];
+};
+type Condition = Condition1 | Condition2;
+type Identifiers = {
+    xStart: number;
+    factorStart: number;
+    condition: Condition;
+    offsetCondTrue: number;
+};
+type Options = {
+    isAllowAND: boolean;
+    isAllowOR: boolean;
+    isAllowNOT: boolean;
+};
+export declare const scratchCond1: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=scratchCond1.d.ts.map

package/lib/exercises/math/scratch/scratchCond1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchCond1.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchCond1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B,CAAC;AAEF,KAAK,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;AA4FzC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAoNF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAgCF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBvD,CAAC"}

package/lib/exercises/math/scratch/scratchCond1.js

@@ -0,0 +1,290 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getFlatArrCondition = (condition) => {
+    if ("conditions" in condition) {
+        const conditions = condition.conditions;
+        return [
+            ...conditions.flatMap((conditionChild) => [
+                ...getFlatArrCondition(conditionChild),
+            ]),
+            condition,
+        ];
+    }
+    else {
+        if (condition.isNOT) {
+            return [Object.assign({}, condition, { isNOT: false }), condition];
+        }
+        else {
+            return [condition];
+        }
+    }
+};
+const getFunctionForCondition = (condition) => {
+    if ("conditions" in condition) {
+        const conditions = condition.conditions;
+        if (condition.isAND) {
+            return (x) => conditions.reduce((acc, conditionChild) => acc && getFunctionForCondition(conditionChild)(x), true);
+        }
+        else {
+            return (x) => conditions.reduce((acc, conditionChild) => acc || getFunctionForCondition(conditionChild)(x), false);
+        }
+    }
+    else {
+        const { isNOT, isGreaterCond1, thresholdCond1 } = condition;
+        if (isNOT) {
+            const conditionRaw = Object.assign({}, condition, { isNOT: !isNOT });
+            return (x) => !getFunctionForCondition(conditionRaw)(x);
+        }
+        else {
+            return (x) => {
+                return isGreaterCond1 ? x > thresholdCond1 : x < thresholdCond1;
+            };
+        }
+    }
+};
+const getStrScratchForCondition = (condition) => {
+    if ("conditions" in condition) {
+        const conditions = condition.conditions;
+        return `< ${getStrScratchForCondition(conditions[0])} ${condition.isAND ? " et " : " ou "} ${getStrScratchForCondition(conditions[1])} >`;
+    }
+    else {
+        const { isNOT, isGreaterCond1, thresholdCond1 } = condition;
+        if (isNOT) {
+            const conditionRaw = Object.assign({}, condition, { isNOT: !isNOT });
+            return `< non ${getStrScratchForCondition(conditionRaw)}>`;
+        }
+        else {
+            return `<(x) ${isGreaterCond1 ? ">" : "\\<"} (${thresholdCond1})>`;
+        }
+    }
+};
+const getTexForCondition = (condition) => {
+    if ("conditions" in condition) {
+        const conditions = condition.conditions;
+        return `(${getTexForCondition(conditions[0])} ${condition.isAND ? "\\ et\\ " : "\\ ou\\ "} ${getTexForCondition(conditions[1])})`;
+    }
+    else {
+        const { isNOT, isGreaterCond1, thresholdCond1 } = condition;
+        if (isNOT) {
+            return `non( x ${isGreaterCond1 ? ">" : "<"} ${thresholdCond1})`;
+        }
+        else {
+            return `x ${isGreaterCond1 ? ">" : "<"} ${thresholdCond1}`;
+        }
+    }
+};
+const getInstruction = (identifiers) => {
+    const { xStart, factorStart, condition, offsetCondTrue } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+mettre [x v] à ([${xStart}] * [${factorStart}])
+si ${getStrScratchForCondition(condition)} alors
+    ajouter (${offsetCondTrue}) à [x v]
+</svg>
+
+Quelle est la valeur de $x$ à la fin de l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { xStart, factorStart, condition, offsetCondTrue } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        let x = xStart * factorStart;
+        outDict[0] = {
+            x,
+        };
+        //cond
+        {
+            if (getFunctionForCondition(condition)(x)) {
+                x = x + offsetCondTrue;
+            }
+            //store step dict
+            outDict[1] = {
+                x,
+            };
+        }
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getAnswerNode = (identifiers) => {
+    return getFunctionForScratchProgram(identifiers)(identifiers)[-1].x.toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Cherche si la condition est vérifiée
+pour déterminer si l'instruction dans le bloc "si ... alors" va être exécutée.
+S'il y a un "et", il faut que toutes les conditions soient vérifiées.
+S'il y a un "ou", il faut qu'au moins une condition soit vérifiée.
+S'il y a un "non", il faut que la condition qu'il cible ne soit pas vérifiée.`;
+};
+const getCorrection = (identifiers) => {
+    const { condition } = identifiers;
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    const x = dictSteps[0].x;
+    return `Initialement, $x$ vaut $${dictSteps[0].x}$.
+
+${getFlatArrCondition(condition).map((conditionMember) => {
+        const isConditionVerified = getFunctionForCondition(conditionMember)(x);
+        return `La condition $${getTexForCondition(conditionMember)}$ ${isConditionVerified ? "est vérifiée" : "n'est pas vérifiée"}.`;
+    }).join(`
+  
+`)}
+
+À la fin de l'exécution du programme, $x$ vaut donc $${dictSteps[-1].x}$.
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { xStart, factorStart, offsetCondTrue } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //wrong cond
+    {
+        tryToAddWrongProp(propositions, (xStart * factorStart).frenchify());
+        tryToAddWrongProp(propositions, (xStart * factorStart + offsetCondTrue).frenchify());
+    }
+    //add instead of mult
+    {
+        tryToAddWrongProp(propositions, (xStart + factorStart).frenchify());
+    }
+    //problème de tables
+    {
+        const offset = randint(-10, 11);
+        tryToAddWrongProp(propositions, (xStart * factorStart + offset).frenchify());
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-20, 21).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScratchCond1Question = (optsIn) => {
+    const opts = (optsIn ?? optsDefault);
+    function createRandomCond1(isAllowNOT) {
+        const isNOT = isAllowNOT && coinFlip();
+        const isGreaterCond1 = coinFlip();
+        const thresholdCond1 = randint(-50, 51);
+        const condition1 = {
+            isNOT,
+            isGreaterCond1,
+            thresholdCond1,
+        };
+        return condition1;
+    }
+    const isAllowCond2 = opts.isAllowAND || opts.isAllowOR;
+    const isCond2 = isAllowCond2 && coinFlip();
+    const cond2Type = random([
+        ...(opts.isAllowAND ? ["and"] : []),
+        ...(opts.isAllowAND ? ["or"] : []),
+    ]);
+    let condition;
+    if (isCond2) {
+        let arrIsAllowNOT;
+        if (opts.isAllowNOT) {
+            arrIsAllowNOT = random([
+                [true, false],
+                [false, true],
+                [false, false],
+            ]);
+        }
+        else {
+            arrIsAllowNOT = [false, false];
+        }
+        condition = {
+            isAND: cond2Type === "and",
+            conditions: arrIsAllowNOT.map((isAllowNOT) => createRandomCond1(isAllowNOT)),
+        };
+    }
+    else {
+        condition = createRandomCond1(opts.isAllowNOT);
+    }
+    const xStart = randint(-10, 11);
+    const factorStart = randint(-10, 11);
+    const offsetCondTrue = randint(-20, 21);
+    const identifiers = {
+        xStart,
+        factorStart,
+        condition,
+        offsetCondTrue,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+};
+const optsDefault = {
+    isAllowAND: true,
+    isAllowOR: true,
+    isAllowNOT: true,
+};
+const options = [
+    {
+        id: "isAllowAND",
+        label: `autoriser "et"`,
+        target: GeneratorOptionTarget.instruction,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isAllowAND,
+    },
+    {
+        id: "isAllowOR",
+        label: `autoriser "ou"`,
+        target: GeneratorOptionTarget.instruction,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isAllowOR,
+    },
+    {
+        id: "isAllowNOT",
+        label: `autoriser "non"`,
+        target: GeneratorOptionTarget.instruction,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isAllowNOT,
+    },
+];
+export const scratchCond1 = {
+    id: "scratchCond1",
+    connector: "=",
+    label: "Utiliser une condition en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchCond1Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/scratch/scratchFunction1.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    xStart: number;
+    params: number[][];
+    arrIsUseFunc: boolean[];
+};
+export declare const scratchFunction1: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchFunction1.d.ts.map

package/lib/exercises/math/scratch/scratchFunction1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchFunction1.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchFunction1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,YAAY,EAAE,OAAO,EAAE,CAAC;CACzB,CAAC;AAiNF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}

package/lib/exercises/math/scratch/scratchFunction1.js

@@ -0,0 +1,199 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { probaFlip } from "../../../utils/alea/probaFlip.js";
+import { randomMany } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { xStart, params, arrIsUseFunc } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+définir mystère (a) (b)
+si <(x) \\< (a)> alors
+mettre [x v] à (a)
+fin
+si <(x) > (b)> alors
+mettre [x v] à (b)
+fin
+quand @greenFlag est cliqué
+mettre [x v] à [${xStart}]
+${arrIsUseFunc.map((isUseFunc, i) => {
+        if (isUseFunc) {
+            return `mystère [${params[i][0]}] [${params[i][1]}]`;
+        }
+        else {
+            return `ajouter [${params[i][0]}] à [x v]`;
+        }
+    }).join(`
+`)}
+</svg>
+
+Quelle est la valeur de $x$ à la fin de l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { xStart, params, arrIsUseFunc } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        let x = xStart;
+        outDict[0] = {
+            x,
+        };
+        //cond
+        arrIsUseFunc.forEach((isUseFunc, i) => {
+            if (isUseFunc) {
+                const [a, b] = params[i];
+                if (x < a) {
+                    x = a;
+                }
+                if (x > b) {
+                    x = b;
+                }
+            }
+            else {
+                x = x + params[i][0];
+            }
+            //store step dict
+            outDict[i + 1] = {
+                x,
+            };
+        });
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getAnswerNode = (identifiers) => {
+    return getFunctionForScratchProgram(identifiers)(identifiers)[-1].x.toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Une fois que tu as compris ce que fait le bloc mystère, tu peux l'appliquer avec les paramètres fournis.
+La valeur de la variable $x$ va évoluer tout au long du programme.`;
+};
+const getCorrection = (identifiers) => {
+    const { params, arrIsUseFunc } = identifiers;
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return `Initialement, $x$ vaut $${dictSteps[0].x}$.
+
+${arrIsUseFunc.map((isUseFunc, i) => {
+        const strInstruction = (() => {
+            if (isUseFunc) {
+                return `mystère($${params[i][0]}$, $${params[i][1]}$)`;
+            }
+            else {
+                return `mettre $x$ à $${params[i][0]}$`;
+            }
+        })();
+        return `Suite à l'instruction
+
+${strInstruction}
+
+$x$ vaut $${dictSteps[i + 1].x}$.
+`;
+    }).join(`
+  
+`)}
+
+À la fin de l'exécution du programme, $x$ vaut donc $${dictSteps[-1].x}$.
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { xStart, arrIsUseFunc, params } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //wrong cond
+    {
+        const arrIsUseFuncWrong = arrIsUseFunc.reduce((acc, _) => {
+            return acc.flatMap((arr) => [
+                [...arr, true],
+                [...arr, false],
+            ]);
+        }, [[]]);
+        arrIsUseFuncWrong.forEach((arrIsUseFunc) => {
+            const identifiersWrong = Object.assign({}, identifiers, { arrIsUseFunc });
+            const texWrong = getAnswer(identifiersWrong);
+            tryToAddWrongProp(propositions, texWrong);
+        });
+    }
+    //xStart
+    {
+        tryToAddWrongProp(propositions, xStart.frenchify());
+    }
+    //student does not want to think: a * b
+    {
+        const isLastInstructionUseFunc = arrIsUseFunc[arrIsUseFunc.length - 1];
+        if (isLastInstructionUseFunc) {
+            const [a, b] = params[params.length - 1];
+            tryToAddWrongProp(propositions, (a * b).frenchify());
+        }
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-20, 21).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScratchFunction1Question = () => {
+    const arrIsUseFunc = randomMany([0, 1, 2, 3], 3).map((i) => i % 2 === 0);
+    const params = arrIsUseFunc.map((isUseFunc) => isUseFunc
+        ? (() => {
+            let a = randint(-22, 23);
+            let b = randint(-22, 23);
+            if (probaFlip(0.8)) {
+                [a, b] = [a, b].toSorted((a, b) => a - b);
+            }
+            return [a, b];
+        })()
+        : [randint(-10, 11)]);
+    const xStart = randint(-10, 11);
+    const identifiers = {
+        xStart,
+        arrIsUseFunc,
+        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 scratchFunction1 = {
+    id: "scratchFunction1",
+    connector: "=",
+    label: "Utiliser un bloc personnalisé en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchFunction1Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/scratch/scratchLoop1.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    xStart: number;
+    repeatCount: number;
+    offset1: number;
+    isFoolish: boolean;
+};
+export declare const scratchLoop1: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchLoop1.d.ts.map

package/lib/exercises/math/scratch/scratchLoop1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchLoop1.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchLoop1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAmNF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAkB9C,CAAC"}