math-exercises 3.0.149 → 3.0.151

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    strStart: string;
+    repeatCount: number;
+    strBoundLow: string;
+    strBoundHigh: string;
+    arrStrAppend: string[];
+    arrRand: number[];
+};
+export declare const scratchStringLoopCond2: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchStringLoopCond2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scratchStringLoopCond2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchStringLoopCond2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAgTF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}

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

@@ -0,0 +1,273 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+const getStrScratchForRand = (rand, strAppend) => {
+    switch (rand) {
+        case 0:
+            return `  mettre [x v] à (regrouper (x) et [${strAppend}])`;
+        case 1:
+            return `  mettre [x v] à (regrouper [${strAppend}] et (x))`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { strStart, repeatCount, arrStrAppend, strBoundLow, strBoundHigh, arrRand, } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+mettre [x v] à [${strStart}]
+répéter (${repeatCount}) fois
+si <(lettre [1] de (x)) = [${strBoundLow}]> alors
+  ${getStrScratchForRand(arrRand[0], arrStrAppend[0])}
+sinon
+  si <(lettre (longueur de (x)) de (x)) = [${strBoundHigh}]> alors
+    ${getStrScratchForRand(arrRand[1], arrStrAppend[1])}
+  sinon
+    ${getStrScratchForRand(arrRand[2], arrStrAppend[2])}
+</svg>
+
+Quelle est la valeur de $x$ à la fin de l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { strStart, repeatCount, arrStrAppend, arrRand, strBoundHigh, strBoundLow, } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        let x;
+        x = strStart;
+        outDict[0] = {
+            x,
+        };
+        function strForXAndRandAndStrAppend(x, rand, strAppend) {
+            switch (rand) {
+                case 0:
+                    return x + strAppend;
+                case 1:
+                    return strAppend + x;
+                default:
+                    throw new Error("unsupported rand: " + rand);
+            }
+        }
+        //loop
+        let counter = 0;
+        while (counter < repeatCount) {
+            counter++;
+            //inside of loop
+            {
+                if (x[0] === strBoundLow) {
+                    x = strForXAndRandAndStrAppend(x, arrRand[0], arrStrAppend[0]);
+                }
+                else if (x[x.length - 1] === strBoundHigh) {
+                    x = strForXAndRandAndStrAppend(x, arrRand[1], arrStrAppend[1]);
+                }
+                else {
+                    x = strForXAndRandAndStrAppend(x, arrRand[2], arrStrAppend[2]);
+                }
+            }
+            //store step dict
+            outDict[counter] = {
+                x,
+            };
+        }
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    return getFunctionForScratchProgram(identifiers)(identifiers)[-1].x;
+};
+const getHint = () => {
+    return `La valeur de la variable $x$ change au cours de l'exécution du programme.
+À chaque itération, 
+détermine comment la variable évolue.
+On te demande de t'intéresser à la première lettre et à la dernière lettre de $x$.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrRand, arrStrAppend, strBoundHigh, strBoundLow } = identifiers;
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return `Initialement, $x$ vaut $${dictSteps[0].x}$.
+
+${Object.keys(dictSteps)
+        .map((k) => +k)
+        .filter((k) => k > 0)
+        .map((k) => {
+        const x = dictSteps[k - 1].x;
+        const isCondition1Verified = x[0] === strBoundLow;
+        const isCondition2Verified = x[x.length - 1] === strBoundHigh;
+        const indexCondition = isCondition1Verified
+            ? 0
+            : isCondition2Verified
+                ? 1
+                : 2;
+        const rand = arrRand[indexCondition];
+        const strAppend1 = arrStrAppend[indexCondition];
+        return `Itération n°$${k}$ :
+
+Au début, $x$ vaut $${x}$.
+
+La première lettre de $x$ est $${x[0]}$.
+
+La première condition ${isCondition1Verified ? "est vérifiée" : "n'est pas vérifiée"}.
+
+${(() => {
+            if (isCondition1Verified) {
+                return ``;
+            }
+            else {
+                return `La dernière lettre de $x$ est $${x[x.length - 1]}$.
+
+La deuxième condition ${isCondition2Verified ? "est vérifiée" : "n'est pas vérifiée"}.`;
+            }
+        })()}
+
+On va affecter à $x$ la chaîne de caractères composée par le regroupement de ${(() => {
+            switch (rand) {
+                case 0:
+                    return `$${dictSteps[k - 1].x}$ et de $${strAppend1}$`;
+                case 1:
+                    return `$${strAppend1}$ et de $${dictSteps[k - 1].x}$`;
+                default:
+                    throw new Error("unsupported rand: " + rand);
+            }
+        })()}.
+
+$x$ vaut maintenant $${dictSteps[k].x}$.`;
+    }).join(`
+    
+`)}
+
+À la fin de l'exécution du programme, $x$ vaut donc $${dictSteps[-1].x}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { strStart, repeatCount, arrRand, arrStrAppend } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //toggle on all checks
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            arrRand: arrRand.toReversed(),
+            arrStrAppend: arrStrAppend.toReversed(),
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //ABB instead of BBA
+    if (arrRand.includes(0) || arrRand.includes(1)) {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            arrRand: arrRand.map((rand) => (rand === 0 ? 1 : rand === 1 ? 0 : rand)),
+            arrStrAppend: arrStrAppend.toReversed(),
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //wrong repeatCount
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            repeatCount: repeatCount - 1,
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //strStart
+    tryToAddWrongProp(propositions, strStart);
+    //filler
+    propWhile(propositions, n, () => {
+        [...Array(repeatCount + 2).keys()].forEach((repeatCountW) => {
+            let strWrong = strStart;
+            [...Array(repeatCountW).keys()].forEach(() => {
+                const strAppend = random(arrStrAppend);
+                if (coinFlip()) {
+                    strWrong = strWrong + strAppend;
+                }
+                else {
+                    strWrong = strAppend + strWrong;
+                }
+            });
+            tryToAddWrongProp(propositions, strWrong);
+        });
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["A", "B", "C", "D"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getScratchStringLoopCond2Question = () => {
+    const arrRand = randomMany([0, 1, 2, 3], 3).map((i) => i % 2);
+    function createRandomStr(length) {
+        return [...Array(length).keys()].reduce((acc, _) => acc + random(["A", "B", "C", "D"]), "");
+    }
+    const repeatCount = randint(2, 5);
+    const strStart = createRandomStr(randint(1, 3));
+    let arrStrAppend;
+    {
+        let counter = -1;
+        let isValid = false;
+        while (!isValid && counter < 100) {
+            counter++;
+            const arrStrAppendCandidate = arrRand.map(() => createRandomStr(randint(1, 3)));
+            isValid = [...new Set(arrStrAppendCandidate)].length >= 2;
+            if (isValid) {
+                arrStrAppend = arrStrAppendCandidate;
+            }
+        }
+        if (!isValid) {
+            arrStrAppend = ["AB", "C", "DB"];
+        }
+    }
+    const [strBoundHigh, strBoundLow] = shuffle([
+        strStart,
+        random(arrStrAppend),
+    ]).map((str, i) => {
+        if (i === 0) {
+            return str[str.length - 1];
+        }
+        else {
+            return str[0];
+        }
+    });
+    const identifiers = {
+        strStart,
+        repeatCount,
+        arrStrAppend: arrStrAppend,
+        arrRand,
+        strBoundHigh,
+        strBoundLow,
+    };
+    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 scratchStringLoopCond2 = {
+    id: "scratchStringLoopCond2",
+    connector: "=",
+    label: "Utiliser une condition dans une boucle avec une chaîne de caractères en Scratch ($2$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchStringLoopCond2Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    strStart: string;
+    repeatCount: number;
+    strIncludes1: string;
+    strIncludes2: string;
+    arrStrAppend: string[];
+    arrRand: number[];
+};
+export declare const scratchStringLoopCond3: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchStringLoopCond3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scratchStringLoopCond3.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchStringLoopCond3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA0TF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}

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

@@ -0,0 +1,275 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../utils/alea/random.js";
+const getStrScratchForRand = (rand, strAppend) => {
+    switch (rand) {
+        case 0:
+            return `  mettre [x v] à (regrouper (x) et [${strAppend}])`;
+        case 1:
+            return `  mettre [x v] à (regrouper [${strAppend}] et (x))`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { strStart, repeatCount, arrStrAppend, strIncludes1, strIncludes2, arrRand, } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+mettre [x v] à [${strStart}]
+répéter (${repeatCount}) fois
+si <(x) contient [${strIncludes1}] ?> alors
+  ${getStrScratchForRand(arrRand[0], arrStrAppend[0])}
+sinon
+  si <(x) contient [${strIncludes2}] ?> alors
+    ${getStrScratchForRand(arrRand[1], arrStrAppend[1])}
+  sinon
+    ${getStrScratchForRand(arrRand[2], arrStrAppend[2])}
+</svg>
+
+Quelle est la valeur de $x$ à la fin de l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { strStart, repeatCount, arrStrAppend, arrRand, strIncludes1, strIncludes2, } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        let x;
+        x = strStart;
+        outDict[0] = {
+            x,
+        };
+        function strForXAndRandAndStrAppend(x, rand, strAppend) {
+            switch (rand) {
+                case 0:
+                    return x + strAppend;
+                case 1:
+                    return strAppend + x;
+                default:
+                    throw new Error("unsupported rand: " + rand);
+            }
+        }
+        //loop
+        let counter = 0;
+        while (counter < repeatCount) {
+            counter++;
+            //inside of loop
+            {
+                if (x.includes(strIncludes1)) {
+                    x = strForXAndRandAndStrAppend(x, arrRand[0], arrStrAppend[0]);
+                }
+                else if (x.includes(strIncludes2)) {
+                    x = strForXAndRandAndStrAppend(x, arrRand[1], arrStrAppend[1]);
+                }
+                else {
+                    x = strForXAndRandAndStrAppend(x, arrRand[2], arrStrAppend[2]);
+                }
+            }
+            //store step dict
+            outDict[counter] = {
+                x,
+            };
+        }
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    return getFunctionForScratchProgram(identifiers)(identifiers)[-1].x;
+};
+const getHint = () => {
+    return `La valeur de la variable $x$ change au cours de l'exécution du programme.
+À chaque itération, 
+détermine comment la variable évolue.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrRand, arrStrAppend, strIncludes1, strIncludes2 } = identifiers;
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return `Initialement, $x$ vaut $${dictSteps[0].x}$.
+
+${Object.keys(dictSteps)
+        .map((k) => +k)
+        .filter((k) => k > 0)
+        .map((k) => {
+        const x = dictSteps[k - 1].x;
+        const isCondition1Verified = x.includes(strIncludes1);
+        const isCondition2Verified = x.includes(strIncludes2);
+        const indexCondition = isCondition1Verified
+            ? 0
+            : isCondition2Verified
+                ? 1
+                : 2;
+        const rand = arrRand[indexCondition];
+        const strAppend1 = arrStrAppend[indexCondition];
+        return `Itération n°$${k}$ :
+
+Au début, $x$ vaut $${x}$.
+
+${isCondition1Verified
+            ? `$x$ contient $${strIncludes1}$.`
+            : `$x$ ne contient pas $${strIncludes1}$.`}
+
+La première condition ${isCondition1Verified ? "est vérifiée" : "n'est pas vérifiée"}.
+
+${(() => {
+            if (isCondition1Verified) {
+                return ``;
+            }
+            else {
+                return `${isCondition2Verified
+                    ? `$x$ contient $${strIncludes2}$.`
+                    : `$x$ ne contient pas $${strIncludes2}$.`}
+
+La deuxième condition ${isCondition2Verified ? "est vérifiée" : "n'est pas vérifiée"}.`;
+            }
+        })()}
+
+On va affecter à $x$ la chaîne de caractères composée par le regroupement de ${(() => {
+            switch (rand) {
+                case 0:
+                    return `$${dictSteps[k - 1].x}$ et de $${strAppend1}$`;
+                case 1:
+                    return `$${strAppend1}$ et de $${dictSteps[k - 1].x}$`;
+                default:
+                    throw new Error("unsupported rand: " + rand);
+            }
+        })()}.
+
+$x$ vaut maintenant $${dictSteps[k].x}$.`;
+    }).join(`
+    
+`)}
+
+À la fin de l'exécution du programme, $x$ vaut donc $${dictSteps[-1].x}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { strStart, repeatCount, arrRand, arrStrAppend } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //toggle on all checks
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            arrRand: arrRand.toReversed(),
+            arrStrAppend: arrStrAppend.toReversed(),
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //ABB instead of BBA
+    if (arrRand.includes(0) || arrRand.includes(1)) {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            arrRand: arrRand.map((rand) => (rand === 0 ? 1 : rand === 1 ? 0 : rand)),
+            arrStrAppend: arrStrAppend.toReversed(),
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //wrong repeatCount
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            repeatCount: repeatCount - 1,
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //strStart
+    tryToAddWrongProp(propositions, strStart);
+    //filler
+    propWhile(propositions, n, () => {
+        [...Array(repeatCount + 2).keys()].forEach((repeatCountW) => {
+            let strWrong = strStart;
+            [...Array(repeatCountW).keys()].forEach(() => {
+                const strAppend = random(arrStrAppend);
+                if (coinFlip()) {
+                    strWrong = strWrong + strAppend;
+                }
+                else {
+                    strWrong = strAppend + strWrong;
+                }
+            });
+            tryToAddWrongProp(propositions, strWrong);
+        });
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["A", "B", "C", "D"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getScratchStringLoopCond2Question = () => {
+    const arrRand = randomMany([0, 1, 2, 3], 3).map((i) => i % 2);
+    function createRandomStr(length) {
+        return [...Array(length).keys()].reduce((acc, _) => acc + random(["A", "B", "C", "D"]), "");
+    }
+    const repeatCount = randint(2, 5);
+    const strStart = createRandomStr(randint(1, 3));
+    let arrStrAppend;
+    {
+        let counter = -1;
+        let isValid = false;
+        while (!isValid && counter < 100) {
+            counter++;
+            const arrStrAppendCandidate = arrRand.map(() => createRandomStr(randint(1, 3)));
+            isValid = [...new Set(arrStrAppendCandidate)].length >= 2;
+            if (isValid) {
+                arrStrAppend = arrStrAppendCandidate;
+            }
+        }
+        if (!isValid) {
+            arrStrAppend = ["AB", "C", "DB"];
+        }
+    }
+    const strIncludesPool = arrRand.map((rand, i) => {
+        if (rand === 0) {
+            return [strStart[strStart.length - 1], arrStrAppend[i][0]].join("");
+        }
+        else {
+            return [arrStrAppend[i][arrStrAppend[i].length - 1], strStart[0]].join("");
+        }
+    });
+    const [strIncludes1, strIncludes2] = coinFlip()
+        ? randomMany(strIncludesPool, 2)
+        : [random(strIncludesPool), random(["A", "B", "C", "D"])];
+    const identifiers = {
+        strStart,
+        repeatCount,
+        arrStrAppend: arrStrAppend,
+        arrRand,
+        strIncludes1,
+        strIncludes2,
+    };
+    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 scratchStringLoopCond3 = {
+    id: "scratchStringLoopCond3",
+    connector: "=",
+    label: "Utiliser une condition dans une boucle avec une chaîne de caractères en Scratch ($3$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchStringLoopCond2Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    xStart: number;
+    yStart: number;
+    tStart: number;
+    steps: string[][];
+};
+export declare const scratchSwapUsingTmp: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchSwapUsingTmp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scratchSwapUsingTmp.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchSwapUsingTmp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;CACnB,CAAC;AAoNF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}