#!/usr/bin/env python3

# pylint: disable=too-many-lines

"""
======= pySELL =================================================================

        A Python based Simple E-Learning Language
        for the simple creation of interactive courses

        https://pysell.org

LICENSE GPLv3

AUTHOR  Andreas Schwenk <mailto:contact@compiler-construction.com>

DOCS    Refer to https://github.com/andreas-schwenk/pysell and read the
        descriptions at the end of the page

INSTALL Run 'pip install pysell', or use the stand-alone implementation sell.py

CMD     pysell [-J] [-S] PATH

        -J          is optional and generates a JSON output file for debugging
        -S          silent mode (no info prints)

EXAMPLE pysell examples/ex1.txt

        outputs files examples/ex1.html and examples/ex1_DEBUG.html

FAQ

    Q: Why is this file so large?
    A: The goal is to offer pySELL as a single file for easy sharing.

    Q: Why not package and publish pySELL as a module?
    A: That's already available! Simply run "pip install pysell"
       to install it as a package.
"""

from __future__ import annotations

import base64
import datetime
import io
import json
import os
import re
import sys
from typing import Self


class SellError(Exception):
    """exception"""


# pylint: disable-next=too-few-public-methods
class Lexer:
    """Scanner that takes a string input and returns a sequence of tokens;
    one at a time."""

    def __init__(self, src: str) -> None:
        """sets the source to be scanned"""
        # the source code
        self.src: str = src
        # the current token
        self.token: str = ""
        # the current input position
        self.pos: int = 0
        # set the first token to self.token
        self.next()

    def next(self) -> None:
        """gets the next token"""
        # start with a fresh token
        self.token = ""
        # loop up to the next special character
        stop = False
        while not stop and self.pos < len(self.src):
            # get the next character from the input
            ch = self.src[self.pos]
            # in case that we get a special character (a.k.a delimiter),
            # we stop
            if ch in "`^'\"%#*$()[]{}\\,.:;+-*/_!<>\t\n =?|&":
                # if the current token is not empty, return it for now and
                # keep the delimiter to the next call of next()
                if len(self.token) > 0:
                    return
                # a delimiter stops further advancing in the input
                stop = True
                # keep quotes as a single token. Supported quote types are
                # double quotes ("...") and accent grave quotes (`...`)
                if ch in '"`':
                    kind = ch  # " or `
                    self.token += ch
                    self.pos += 1
                    # advance to the quotation end
                    while self.pos < len(self.src):
                        if self.src[self.pos] == kind:
                            break
                        self.token += self.src[self.pos]
                        self.pos += 1
            # add the current character to the token
            self.token += ch
            self.pos += 1


# # lexer tests
# lex = Lexer('a"x"bc 123 *blub* $`hello, world!`123$')
# while len(lex.token) > 0:
#     print(lex.token)
#     lex.next()
# exit(0)

# For drawing random variables and to calculate the sample solution, we will
# be executing Python code that is embedded in the quiz descriptions.
# The evaluation of code will populate local variables. Its data types also
# depend on the used libraries.
# The following lists cluster some of these types.
boolean_types = ["<class 'bool'>", "<class 'numpy.bool_'>"]
int_types = [
    "<class 'int'>",
    "<class 'numpy.int64'>",
    "<class 'sympy.core.numbers.Integer'>",
    "<class 'sage.rings.integer.Integer'>",
    "<class 'sage.rings.finite_rings.integer_mod.IntegerMod_int'>",
]
float_types = ["<class 'float'>"]

# The following list contains all of Pythons basic keywords. These are used
# in syntax highlighting in "*_DEBUG.html" files.
python_kws = [
    "and",
    "as",
    "assert",
    "break",
    "class",
    "continue",
    "def",
    "del",
    "elif",
    "else",
    "except",
    "False",
    "finally",
    "for",
    "from",
    "global",
    "if",
    "import",
    "in",
    "is",
    "lambda",
    "None",
    "nonlocal",
    "not",
    "or",
    "pass",
    "raise",
    "return",
    "True",
    "try",
    "while",
    "with",
    "yield",
]

# The following list of identifiers may be in locals of Python source that
# uses "sympy". These identifiers must be skipped in the JSON output.
skipVariables = [
    "acos",
    "acosh",
    "acoth",
    "asin",
    "asinh",
    "atan",
    "atan2",
    "atanh",
    "ceil",
    "ceiling",
    "cos",
    "cosh",
    "cot",
    "coth",
    "exp",
    "floor",
    "ln",
    "log",
    "pi",
    "round",
    "sin",
    "sinc",
    "sinh",
    "tan",
    "transpose",
]


# The following function rangeZ is provided as pseudo-intrinsic
# function in Python scripts, embedded into the question descriptions.
# It is an alternative version for "range", that excludes the zero.
# This is beneficial for drawing random numbers of questions for math classes.
# (the next line disables a warning, about camel-case function names)
# pylint: disable-next=invalid-name
def rangeZ(*a):
    """implements 'range', but excludes the zero"""
    r = []
    if len(a) == 1:
        r = list(range(a[0]))
    elif len(a) == 2:
        r = list(range(a[0], a[1]))
    elif len(a) == 3:
        r = list(range(a[0], a[1], a[2]))
    if 0 in r:
        r.remove(0)
    return r


# TODO: add comments starting from here


class TextNode:
    """Tree structure for the question text"""

    def __init__(self, question: Question, type_: str, data: str = "") -> None:
        self.question: Question = question
        self.type: str = type_
        self.data: str = data
        self.children: list[TextNode] = []

    # pylint: disable-next=too-many-branches,too-many-statements,too-many-locals
    def parse(self) -> None:
        """parses text recursively"""
        if self.type == "root":
            # Split text by "\n" and remove empty lines.
            # Keep the trailing "\n" in each line, also keep preceding white spaces
            text = self.data
            lines = [line + "\n" for line in text.split("\n") if line.strip() != ""]
            # as first character, add the type of the line
            tmp = []
            is_code = False
            for line in lines:
                if line.startswith("```"):
                    is_code = not is_code
                    continue
                t = ""
                if is_code:
                    t = "c"
                else:
                    line = line.lstrip()
                    t = line[0] if line[0] in "[(-!" else "p"
                tmp.append(t + line)
            lines = tmp
            # join lines that have the same type (except for trailing "\\")
            tmp = []
            last = ""
            for line in lines:
                if (
                    len(last) > 0
                    and line[0] == last[0]
                    and (not last.endswith("\\\\\n"))
                ):
                    tmp[-1] += line[1:]
                else:
                    tmp.append(line)
                last = line
            lines = tmp
            # replace trailing "\\\\\n" by "\n"
            tmp = []
            for line in lines:
                if line.endswith("\\\\\n"):
                    tmp.append(line[:-3].rstrip() + "\n")
                else:
                    tmp.append(line)
            lines = tmp
            # create children
            self.children = []
            types = {
                "p": "paragraph",
                "c": "code-block",
                "(": "single-choice",
                "[": "multi-choice",
                "-": "itemize",
                "!": "command",
            }
            for line in lines:
                t = types[line[0]]
                txt = line[1:]
                self.children.append(TextNode(self.question, t, txt))
            # parse children
            for child in self.children:
                child.parse()
            # remove redundant children (marked by type "trash")
            self.children = [c for c in self.children if c.type != "trash"]

        elif self.type in ("multi-choice", "single-choice"):
            options = self.data.strip().split("\n")
            self.data = ""
            for option in options:
                node = TextNode(self.question, "answer")
                self.children.append(node)
                text = ""
                if self.type == "multi-choice":
                    text = "]".join(option.split("]")[1:]).strip()
                else:
                    text = ")".join(option.split(")")[1:]).strip()
                if option.startswith("[!"):
                    # conditionally set option
                    # TODO: check, if variable exists and is of type bool
                    var_id = option[2:].split("]")[0]
                    node.children.append(TextNode(self.question, "var", var_id))
                else:
                    # statically set option
                    correct = option.startswith("[x]") or option.startswith("(x)")
                    node.children.append(
                        TextNode(self.question, "bool", "true" if correct else "false")
                    )
                node.children.append(TextNode(self.question, "paragraph", text))
                node.children[1].parse()

        elif self.type == "itemize":
            items = self.data.strip().split("\n")
            self.data = ""
            for child in items:
                node = TextNode(self.question, "paragraph", child[1:].strip())
                self.children.append(node)
                node.parse()

        elif self.type == "paragraph":
            lex = Lexer(self.data.strip())
            self.data = ""
            self.children.append(self.parse_span(lex))

        elif self.type == "command":
            if (
                ".svg" in self.data
                or ".png" in self.data
                or ".jpg" in self.data
                or ".jpeg" in self.data
            ):
                self.parse_image()
            elif "!TETRIS" in self.data:
                self.parse_game()
            else:
                self.question.error += f"Unknown command '{self.data[:5]}'... "

        elif self.type == "code-block":
            # do nothing
            pass

        else:
            raise SellError("unimplemented")

    def parse_image(self) -> Self:
        """parses an image inclusion, e.g. '!myImage.svg:25'"""
        # grammar: image = "!" path [ ":" width ];
        #          width = INT;
        img_path = self.data[1:].strip()
        img_width = 100  # percentage
        if ":" in img_path:
            tokens = img_path.split(":")
            img_path = tokens[0].strip()
            img_width = tokens[1].strip()
        self.type = "image"
        self.data = img_path
        self.children.append(TextNode(self.question, "width", img_width))

    def parse_game(self) -> Self:
        """parses game info, e.g. '!TETRIS x y z'"""
        # grammar: game = "!TETRIS" ID ID { ID };
        # TODO: switch game (yet !TETRIS is not parsed!)
        tokens = self.data[1:].replace("\n", "").split(" ")
        variable_ids = tokens[1:]
        if len(variable_ids) < 2:
            self.question.error += (
                "For TETRIS, at least two variables must be provided. "
            )
            return
        self.question.game = ["TETRIS", *variable_ids]
        for var_id in variable_ids:
            if var_id not in self.question.variables:
                self.question.error += (
                    f"Unknown variable '{var_id}' for the TETRIS game. "
                )
                return
        # draw more randomized question instances
        num_instances = 20  # TODO!
        self.question.build_random_instances(num_instances)
        # filter out instances, where one of the false solutions is equal to
        # the correct solution
        valid_instances = []
        correct_variable_id = self.question.game[1]
        incorrect_variable_ids = self.question.game[2:]
        for instance in self.question.instances:
            correct_value = instance[correct_variable_id]["v"]
            is_valid = True
            for v in incorrect_variable_ids:
                incorrect_value = instance[v]["v"]
                if incorrect_value == correct_value:
                    is_valid = False
                    break
            if is_valid:
                valid_instances.append(instance)
        self.question.instances = valid_instances
        # mark the present node for deletion (we extracted everything needed)
        self.type = "trash"

    def parse_span(self, lex: Lexer) -> Self:
        """parses a span element"""
        # grammar: span = { item };
        #          item = bold | math | input | string_var | plus_minus | text;
        #          bold = "*" { item } "*";
        #          math = "$" { item } "$";
        #          input = "%" ["!"] var;
        #          string_var = "&" var;
        #          plus_minus = "+" "-";
        #          text = "\\" | otherwise;
        span = TextNode(self.question, "span")
        while lex.token != "":
            span.children.append(self.parse_item(lex))
        return span

    # pylint: disable-next=too-many-return-statements
    def parse_item(self, lex: Lexer, math_mode=False) -> Self:
        """parses a single item of a span/paragraph"""
        if not math_mode and lex.token == "*":
            return self.parse_bold_italic(lex)
        if lex.token == "$":
            return self.parse_math(lex)
        if not math_mode and lex.token == "%":
            return self.parse_input(lex)
        if not math_mode and lex.token == "&":
            return self.parse_string_var(lex)
        if math_mode and lex.token == "+":
            n = TextNode(self.question, "text", lex.token)
            lex.next()
            if lex.token == "-":
                # "+-" automatically chooses "+" or "-",
                # depending on the sign or the following variable.
                # For the variable itself, only its absolute value is used.
                n.data += lex.token
                n.type = "plus_minus"
                lex.next()
            return n
        if not math_mode and lex.token == "\\":
            lex.next()
            if lex.token == "\\":
                lex.next()
            return TextNode(self.question, "text", "<br/>")
        n = TextNode(self.question, "text", lex.token)
        lex.next()
        return n

    def parse_bold_italic(self, lex: Lexer) -> Self:
        """parses bold or italic text"""
        node = TextNode(self.question, "italic")
        if lex.token == "*":
            lex.next()
        if lex.token == "*":
            node.type = "bold"
            lex.next()
        while lex.token not in ("", "*"):
            node.children.append(self.parse_item(lex))
        if lex.token == "*":
            lex.next()
        if lex.token == "*":
            lex.next()
        return node

    def parse_math(self, lex: Lexer) -> Self:
        """parses inline math or display style math"""
        math = TextNode(self.question, "math")
        if lex.token == "$":
            lex.next()
        if lex.token == "$":
            math.type = "display-math"
            lex.next()
        while lex.token not in ("", "$"):
            math.children.append(self.parse_item(lex, True))
        if lex.token == "$":
            lex.next()
        if math.type == "display-math" and lex.token == "$":
            lex.next()
        return math

    def parse_input(self, lex: Lexer) -> Self:
        """parses an input element field"""
        input_ = TextNode(self.question, "input")
        if lex.token == "%":
            lex.next()
        if lex.token == "!":
            input_.type = "input2"
            lex.next()
        input_.data = lex.token.strip()
        lex.next()
        return input_

    def parse_string_var(self, lex: Lexer) -> Self:
        """parses a string variable"""
        sv = TextNode(self.question, "string_var")
        if lex.token == "&":
            lex.next()
        sv.data = lex.token.strip()
        lex.next()
        return sv

    def optimize(self) -> Self:
        """optimizes the current text node recursively. E.g. multiple pure
        text items are concatenated into a single text node."""
        children_opt = []
        for c in self.children:
            opt = c.optimize()
            if (
                opt.type == "text"
                and opt.data.startswith('"') is False
                and opt.data.startswith("`") is False
                and len(children_opt) > 0
                and children_opt[-1].type == "text"
                and children_opt[-1].data.startswith('"') is False
                and children_opt[-1].data.startswith("`") is False
            ):
                children_opt[-1].data += opt.data
            else:
                children_opt.append(opt)
        self.children = children_opt
        return self

    def to_dict(self) -> dict:
        """recursively exports the text node instance to a dictionary"""
        # t := type, d := data, c := children
        return {
            "t": self.type,
            "d": self.data,
            "c": list(map(lambda o: o.to_dict(), self.children)),
        }


# pylint: disable-next=too-many-instance-attributes
class Question:
    """Question of the quiz"""

    def __init__(self, input_dirname: str, src_line_no: int) -> None:
        self.input_dirname: str = input_dirname
        self.src_line_no: int = src_line_no
        self.title: str = ""
        self.points: int = 1
        self.python_src: str = ""
        self.variables: set[str] = set()
        self.instances: list[dict] = []
        self.text_src: str = ""
        self.text: TextNode = None
        self.error: str = ""
        self.python_src_tokens: set[str] = set()
        self.game: list[str] = []  # e.g. ["TETRIS", "x", "y"]

    def build(self) -> None:
        """builds a question from text and Python sources"""
        self.build_random_instances()
        self.text = TextNode(self, "root", self.text_src)
        self.text.parse()
        var_occurrences: set[str] = set()
        self.post_process_text(self.text, False, var_occurrences)
        self.text.optimize()

    # pylint: disable-next=too-many-branches
    def post_process_text(
        self, node: TextNode, math, var_occurrences: set[str]
    ) -> None:
        """post processes the textual part. For example, a semantical check
        for the existing of referenced variables is applied. Also images
        are loaded and stringified."""
        for c in node.children:
            self.post_process_text(
                c,
                math or node.type == "math" or node.type == "display-math",
                var_occurrences,
            )
        if node.type == "input":
            if node.data.startswith('"'):
                # gap question
                node.type = "gap"
                node.data = node.data.replace('"', "")
            elif node.data in self.variables:
                var_id = node.data
                if var_id in var_occurrences:
                    self.error += "It is not allowed to refer to a variable "
                    self.error += "twice or more. Hint: Create a copy of "
                    self.error += f"variable '{var_id}' in Python and ask for "
                    self.error += "the new variable name. "
                    self.error += f"Example code: '{var_id}2 = {var_id}'."
                    self.error += f"Then ask for '%{var_id}2'."
                else:
                    var_occurrences.add(var_id)
            elif node.data not in self.variables:
                # ask for numerical/term variable
                var_id = node.data
                self.error += f"Unknown input variable '{var_id}'. "
        elif node.type == "string_var":
            var_id = node.data
            if var_id not in self.variables:
                self.error += f"Unknown string variable '{var_id}'. "
        elif node.type == "text":
            if (
                math
                and len(node.data) >= 2
                and node.data.startswith('"')
                and node.data.endswith('"')
            ):
                node.data = node.data[1:-1]
            elif math and (node.data in self.variables):
                node.type = "var"
            elif (
                not math
                and len(node.data) >= 2
                and node.data.startswith("`")
                and node.data.endswith("`")
            ):
                node.type = "code"
                node.data = node.data[1:-1]
        elif node.type == "image":
            # TODO: warning, if file size is (too) large
            path = os.path.join(self.input_dirname, node.data)
            img_type = os.path.splitext(path)[1][1:]
            supported_img_types = ["svg", "png", "jpg", "jpeg"]
            if img_type not in supported_img_types:
                self.error += f"ERROR: image type '{img_type}' is not supported. "
                self.error += f"Use one of {', '.join(supported_img_types)}"
            elif os.path.isfile(path) is False:
                self.error += "ERROR: cannot find image at path '" + path + '"'
            else:
                # load image
                f = open(path, "rb")
                data = f.read()
                f.close()
                b64 = base64.b64encode(data)
                node.children.append(TextNode(self, "data", b64.decode("utf-8")))

    def float_to_str(self, v: float) -> str:
        """Converts float to string and cuts '.0' if applicable"""
        s = str(v)
        if s.endswith(".0"):
            return s[:-2]
        return s

    def build_random_instances(self, num_instances: int = 5) -> None:
        """Runs the questions python code to build randomized instances"""
        self.instances = []
        if len(self.python_src) > 0:
            self.analyze_python_code()
            instances_str = []
            if len(self.error) == 0:
                for _ in range(0, num_instances):
                    # try to generate instances distinct to prior once
                    # TODO: give up and keep less than 5, if applicable!
                    instance = {}
                    instance_str = ""
                    for _ in range(0, 10):
                        self.error = ""
                        instance = self.run_python_code()
                        instance_str = str(instance)
                        if instance_str not in instances_str:
                            break
                    instances_str.append(instance_str)
                    self.instances.append(instance)
                    # if there is no randomization in the input, then one instance is enough
                    if "rand" not in self.python_src:
                        break
                if "No module named" in self.error:
                    print("!!! " + self.error)

    def analyze_python_code(self) -> None:
        """Get all tokens from Python source code. This is required to filter
        out all locals from libraries (refer to method run_python_code).
        Since relevant tokens are only those in the left-hand side of an
        assignment, we filter out non-assignment statements, as well as
        the right-hand side of statements. As a side effect, irrelevant symbols
        of packages are also filtered out (e.g. 'mod', is populated to the
        locals, when using 'sage.all.power_mod')"""
        lines = self.python_src.split("\n")
        for line in lines:
            if "=" not in line:
                continue
            lhs = line.split("=")[0]
            lex = Lexer(lhs)
            while len(lex.token) > 0:
                self.python_src_tokens.add(lex.token)
                lex.next()
        # check for forbidden code
        if "matplotlib" in self.python_src and "show(" in self.python_src:
            self.error += "Remove the call show(), "
            self.error += "since this would result in MANY open windows :-)"

    # pylint: disable-next=too-many-locals,too-many-branches,too-many-statements
    def run_python_code(self) -> dict:
        """Runs the questions python code and gathers all local variables."""
        local_variables = {}
        res = {}
        src = self.python_src
        try:
            # pylint: disable-next=exec-used
            exec(src, globals(), local_variables)
        # pylint: disable-next=broad-exception-caught
        except Exception as e:
            # print(e)
            self.error += str(e) + ". "
            return res
        for local_id, value in local_variables.items():
            if local_id in skipVariables or (local_id not in self.python_src_tokens):
                continue
            type_str = str(type(value))
            if type_str in ("<class 'module'>", "<class 'function'>"):
                continue
            self.variables.add(local_id)
            t = ""  # type
            v = ""  # value
            if type_str in boolean_types:
                t = "bool"
                v = str(value).lower()
            elif type_str in int_types:
                t = "int"
                v = str(value)
            elif type_str in float_types:
                t = "float"
                v = self.float_to_str(value)
            elif type_str == "<class 'complex'>":
                t = "complex"
                # convert "-0" to "0"
                real = 0 if value.real == 0 else value.real
                imag = 0 if value.imag == 0 else value.imag
                v = self.float_to_str(real) + "," + self.float_to_str(imag)
            elif type_str == "<class 'list'>":
                t = "vector"
                v = str(value).replace("[", "").replace("]", "").replace(" ", "")
            elif type_str == "<class 'set'>":
                t = "set"
                v = (
                    str(value)
                    .replace("{", "")
                    .replace("}", "")
                    .replace(" ", "")
                    .replace("j", "i")
                )
            elif type_str == "<class 'sympy.matrices.dense.MutableDenseMatrix'>":
                # e.g. 'Matrix([[-1, 0, -2], [-1, 5*sin(x)*cos(x)/7, 2], [-1, 2, 0]])'
                t = "matrix"
                v = str(value)[7:-1]
                v = v.replace("**", "^")
            elif (
                type_str == "<class 'numpy.matrix'>"
                or type_str == "<class 'numpy.ndarray'>"
            ):
                # e.g. '[[ -6 -13 -12]\n [-17  -3 -20]\n [-14  -8 -16]\n [ -7 -15  -8]]'
                t = "matrix"
                v = re.sub(" +", " ", str(value))  # remove double spaces
                v = re.sub(r"\[ ", "[", v)  # remove space(s) after "["
                v = re.sub(r" \]", "]", v)  # remove space(s) before "]"
                v = v.replace(" ", ",").replace("\n", "")
            elif type_str == "<class 'str'>":
                t = "string"
                v = value
            else:
                t = "term"
                v = str(value).replace("**", "^")
                # in case that an ODE is contained in the question
                # and only one constant ("C1") is present, then substitute
                # "C1" by "C"
                if "dsolve" in self.python_src:
                    if "C2" not in v:
                        v = v.replace("C1", "C")
            # t := type, v := value
            v = v.replace("I", "i")  # reformat sympy imaginary part
            res[local_id] = {"t": t, "v": v}
        if len(self.variables) > 50:
            self.error += "ERROR: Wrong usage of Python imports. Refer to pySELL docs!"
            # TODO: write the docs...

        if "matplotlib" in self.python_src and "plt" in local_variables:
            plt = local_variables["plt"]
            buf = io.BytesIO()
            plt.savefig(buf, format="svg", transparent=True)
            buf.seek(0)
            svg = buf.read()
            b64 = base64.b64encode(svg)
            res["__svg_image"] = {"t": "svg", "v": b64.decode("utf-8")}
            plt.clf()
        return res

    def to_dict(self) -> dict:
        """recursively exports the question to a dictionary"""
        return {
            "title": self.title,
            "points": self.points,
            "error": self.error,
            "is_ode": "dsolve"
            in self.python_src,  # contains an Ordinary Differential Equation?
            "game": ",".join(self.game),
            "variables": list(self.variables),
            "instances": self.instances,
            "text": self.text.to_dict(),
            # the following is only relevant for debugging purposes,
            # i.e. only present in _DEBUG.html
            "src_line": self.src_line_no,
            "text_src_html": self.syntax_highlight_text(self.text_src),
            "python_src_html": self.syntax_highlight_python(self.python_src),
            "python_src_tokens": list(self.python_src_tokens),
        }

    # pylint: disable-next=too-many-branches,too-many-statements
    def syntax_highlight_text_line(self, src: str) -> str:
        """syntax highlights a single questions text line and returns the
        formatted code in HTML format"""
        html = ""
        math = False
        code = False
        bold = False
        italic = False
        n = len(src)
        i = 0
        while i < n:
            ch = src[i]
            if ch == " ":
                html += "&nbsp;"
            elif not math and ch == "%":
                html += '<span style="color:green; font-weight: bold;">'
                html += ch
                if i + 1 < n and src[i + 1] == "!":
                    html += src[i + 1]
                    i += 1
                html += "</span>"
            elif ch == "*" and i + 1 < n and src[i + 1] == "*":
                i += 1
                bold = not bold
                if bold:
                    html += '<span style="font-weight: bold;">'
                    html += "**"
                else:
                    html += "**"
                    html += "</span>"
            elif ch == "*":
                italic = not italic
                if italic:
                    html += '<span style="font-style: italic;">'
                    html += "*"
                else:
                    html += "*"
                    html += "</span>"
            elif ch == "$":
                display_style = False
                if i + 1 < n and src[i + 1] == "$":
                    display_style = True
                    i += 1
                math = not math
                if math:
                    html += '<span style="color:#FF5733; font-weight: bold;">'
                    html += ch
                    if display_style:
                        html += ch
                else:
                    html += ch
                    if display_style:
                        html += ch
                    html += "</span>"
            elif ch == "`":
                code = not code
                if code:
                    html += '<span style="color:#33A5FF; font-weight: bold;">'
                    html += ch
                else:
                    html += ch
                    html += "</span>"
            else:
                html += ch
            i += 1
        if math:
            html += "</span>"
        if code:
            html += "</span>"
        if italic:
            html += "</span>"
        if bold:
            html += "</bold>"
        return html

    def red_colored_span(self, inner_html: str) -> str:
        """embeds HTML code into a red colored span"""
        return '<span style="color:#FF5733; font-weight:bold">' + inner_html + "</span>"

    def syntax_highlight_text(self, src: str) -> str:
        """syntax highlights a questions text and returns the formatted code in
        HTML format"""
        html = ""
        lines = src.split("\n")
        for line in lines:
            if len(line.strip()) == 0:
                continue
            if line.startswith("-"):
                html += self.red_colored_span("-")
                line = line[1:].replace(" ", "&nbsp;")
            elif line.startswith("["):
                l1 = line.split("]")[0] + "]".replace(" ", "&nbsp;")
                html += self.red_colored_span(l1)
                line = "]".join(line.split("]")[1:]).replace(" ", "&nbsp;")
            elif line.startswith("("):
                l1 = line.split(")")[0] + ")".replace(" ", "&nbsp;")
                html += self.red_colored_span(l1)
                line = ")".join(line.split(")")[1:]).replace(" ", "&nbsp;")
            html += self.syntax_highlight_text_line(line)
            html += "<br/>"
        return html

    def syntax_highlight_python(self, src: str) -> str:
        """syntax highlights a questions python code and returns the formatted
        code in HTML format"""
        lines = src.split("\n")
        html = ""
        for line in lines:
            if len(line.strip()) == 0:
                continue
            lex = Lexer(line)
            while len(lex.token) > 0:
                if len(lex.token) > 0 and lex.token[0] >= "0" and lex.token[0] <= "9":
                    html += '<span style="color:green; font-weight:bold">'
                    html += lex.token + "</span>"
                elif lex.token in python_kws:
                    html += '<span style="color:#FF5733; font-weight:bold">'
                    html += lex.token + "</span>"
                else:
                    html += lex.token.replace(" ", "&nbsp;")
                lex.next()
            html += "<br/>"
        return html


# pylint: disable-next=too-many-branches,too-many-locals
def compile_input_file(input_dirname: str, src: str) -> dict:
    """compiles a SELL input file to JSON"""
    lang = "en"  # language
    quiz_titel = ""
    author = ""
    topic = ""  # TODO: not yet processed!
    info = ""
    timer = -1  # time limit for the worksheet (default: off)
    questions = []
    question = None
    parsing_python = False
    lines = src.split("\n")
    for line_no, line in enumerate(lines):
        line = line.split("##")[0]  # remove comments
        line_not_stripped = line
        line = line.strip()
        if len(line) == 0:
            continue
        if line.startswith("LANG"):
            lang = line[4:].strip()
        elif line.startswith("TITLE"):
            quiz_titel = line[5:].strip()
        elif line.startswith("AUTHOR"):
            author = line[6:].strip()
        elif line.startswith("TOPIC"):
            topic = line[5:].strip()
        elif line.startswith("INFO"):
            info = line[4:].strip()
        elif line.startswith("TIMER"):
            timer = int(line[5:].strip())  # TODO: handle parse integer errors
        elif line.startswith("QUESTION"):
            question = Question(input_dirname, line_no + 1)
            questions.append(question)
            # extract title and points
            #   pattern = TITLE [ "(" INT "pts)" ];
            pattern = r"(?P<title>.+?)(?:\s\((?P<num>\d+)\spts\))?$"
            match = re.match(pattern, line[8:].strip())
            title = ""
            num = None
            if match:
                title = match.group("title").strip()
                num = match.group("num")  # This will be None if not present
                # print(f"Title: {title}, Points: {num}")
            question.title = title
            question.points = 1 if num is None else int(num)
            parsing_python = False
        elif question is not None:
            if line.startswith('"""'):
                parsing_python = not parsing_python
            else:
                if parsing_python:
                    question.python_src += (
                        line_not_stripped.replace("\t", "    ") + "\n"
                    )
                else:
                    question.text_src += line_not_stripped.rstrip() + "\n"
    for question in questions:
        question.build()
    return {
        "lang": lang,
        "title": quiz_titel,
        "author": author,
        "date": datetime.datetime.today().strftime("%Y-%m-%d"),
        "info": info,
        "timer": timer,
        "questions": list(map(lambda o: o.to_dict(), questions)),
    }


# the following code is automatically generated and updated by file "build.py"
# @begin(html)
HTML: str = b""
HTML += b'<!DOCTYPE html> <html> <head> <meta charset="UTF-8" /> <titl'
HTML += b'e>pySELL Quiz</title> <meta name="viewport" content="width=d'
HTML += b'evice-width, initial-scale=1.0" /> <link rel="icon" type="im'
HTML += b'age/x-icon" href="data:image/x-icon;base64,AAABAAEAEBAAAAEAI'
HTML += b"ABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAQAAAAAAAAAAAAAAAAAA"
HTML += b"AAAAACqqqr/PDw8/0VFRf/V1dX////////////09Pb/trbO/3t7q/9wcLH/c"
HTML += b"XG0/3NzqP+iosH/5OTr////////////j4+P/wAAAP8KCgr/x8fH///////k5"
HTML += b"Or/bGym/y4ukP8kJJD/IiKR/yIikv8jI5H/KCiP/1BQnP/Jydz//////5CQk"
HTML += b"P8BAQH/DAwM/8jIyP/7+/v/cHCo/yIij/8lJZP/KSmR/z4+lf9AQJH/Li6Q/"
HTML += b"yUlkv8jI5H/TEya/9/f6P+QkJD/AQEB/wwMDP/Ly8r/ycna/y4ujv8lJZP/N"
HTML += b"DSU/5+fw//j4+v/5+fs/76+0v9LS5f/JSWS/yYmkP+Skrr/kJCQ/wAAAP8MD"
HTML += b"Az/zc3L/5aWvP8iIo//ISGQ/39/sf////7/////////////////n5+7/yMjj"
HTML += b"P8kJJH/bm6p/5CQkP8BAQH/CgoK/6SkpP+Skp//XV2N/1dXi//Hx9X//////"
HTML += b"///////////9fX1/39/rP8kJI7/JCSR/25upP+QkJD/AQEB/wEBAf8ODg7/F"
HTML += b"BQT/xUVE/8hIR//XV1c/8vL0P/IyNv/lZW7/1panP8rK5D/JiaT/ycnjv+bm"
HTML += b"7v/kJCQ/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAH/wAAK/8aGmv/LCyO/yQkj"
HTML += b"/8jI5L/JSWT/yIikP9dXZ//6enu/5CQkP8BAQH/BQUF/0xMTP9lZWT/Pz9N/"
HTML += b"wUFVP8AAGz/AABu/xYWhf8jI5L/JCSP/zY2k/92dq7/4ODo//////+QkJD/A"
HTML += b"QEB/wwMDP/IyMj//Pz9/2lppf8ZGYf/AgJw/wAAZ/8cHHL/Zmak/5ubv//X1"
HTML += b"+T//v7+////////////kJCQ/wEBAf8MDAz/ycnJ/9/f6f85OZT/IyOR/wcHZ"
HTML += b"P8AAB7/UVFZ//n5+P//////0dHd/7i4yf++vs7/7e3z/5CQkP8AAAD/DAwM/"
HTML += b"87Ozf/Y2OP/MjKQ/x8fjv8EBEr/AAAA/1xcWv//////6ent/0tLlf8kJIn/M"
HTML += b"jKL/8fH2v+QkJD/AQEB/wcHB/98fHv/jo6T/yUlc/8JCXj/AABi/wAAK/9eX"
HTML += b"nj/trbS/2xspv8nJ5H/IyOT/0pKm//m5uz/kJCQ/wEBAf8AAAD/AAAA/wAAA"
HTML += b"P8AACH/AABk/wAAbf8EBHD/IyOM/ykpkv8jI5H/IyOS/ysrjP+kpMP//////"
HTML += b"5GRkf8CAgL/AQEB/wEBAf8BAQH/AgIE/woKK/8ZGWj/IyOG/ycnj/8nJ4//M"
HTML += b"DCS/0xMmf+lpcP/+vr6///////Pz8//kZGR/5CQkP+QkJD/kJCQ/5OTk/+ws"
HTML += b"K//zs7V/8LC2f+goL3/oaG+/8PD2P/n5+z/////////////////AAAAAAAAA"
HTML += b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
HTML += b'AAAAAAAAAAAAAAAAA==" sizes="16x16" /> <link rel="stylesheet"'
HTML += b' href="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.'
HTML += b'min.css" integrity="sha384-n8MVd4RsNIU0tAv4ct0nTaAbDJwPJzDEa'
HTML += b'qSD1odI+WdtXRGWt2kTvGFasHpSy3SV" crossorigin="anonymous" /> '
HTML += b'<script src="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/'
HTML += b'katex.min.js" integrity="sha384-XjKyOOlGwcjNTAIQHIpgOno0Hl1Y'
HTML += b'QqzUOEleOLALmuqehneUG+vnGctmUb0ZY0l8" crossorigin="anonymous'
HTML += b'" ></script> <style> :root { --pysell-black: #000000; --pyse'
HTML += b"ll-white: #ffffff; --pysell-grey: #5a5a5a; --pysell-green: r"
HTML += b"gb(24, 82, 1); --pysell-red: rgb(123, 0, 0); } html, body { "
HTML += b"font-family: Arial, Helvetica, sans-serif; margin: 0; paddin"
HTML += b"g: 0; background-color: white; } /* TODO: .pysell-ul as div "
HTML += b"element */ ul { user-select: none; margin-top: 0; margin-lef"
HTML += b"t: 0px; padding-left: 20px; } a { color: black; text-decorat"
HTML += b"ion: underline; } h1 { text-align: center; font-size: 28pt; "
HTML += b"word-wrap: break-word; margin-bottom: 10px; user-select: non"
HTML += b"e; }  .contents { max-width: 800px; margin-left: auto; margi"
HTML += b"n-right: auto; padding: 0; } .footer { position: relative; b"
HTML += b"ottom: 0; font-size: small; text-align: center; line-height:"
HTML += b" 1.8; color: var(--pysell-grey); margin: 0; padding: 10px 10"
HTML += b"px; user-select: none; }  .pysell-img { width: 100%; display"
HTML += b": block; margin-left: auto; margin-right: auto; user-select:"
HTML += b" none; } .pysell-author { text-align: center; font-size: 16p"
HTML += b"t; margin-bottom: 24px; user-select: none; } .pysell-course-"
HTML += b"info { text-align: center; user-select: none; } .pysell-ques"
HTML += b"tion { position: relative; /* required for feedback overlays"
HTML += b" */ color: black; background-color: white; border-top-style:"
HTML += b" solid; border-bottom-style: solid; border-width: 3px; borde"
HTML += b"r-color: black; padding: 4px; box-sizing: border-box; margin"
HTML += b"-top: 32px; margin-bottom: 32px; -webkit-box-shadow: 0px 0px"
HTML += b" 6px 3px #e8e8e8; box-shadow: 0px 0px 6px 3px #e8e8e8; overf"
HTML += b"low-x: auto; overflow-y: visible; } .pysell-button-group { d"
HTML += b"isplay: flex; align-items: center; justify-content: center; "
HTML += b"text-align: center; margin-left: auto; margin-right: auto; }"
HTML += b" @media (min-width: 800px) { .pysell-question { border-radiu"
HTML += b"s: 6px; padding: 16px; margin: 16px; border-left-style: soli"
HTML += b"d; border-right-style: solid; } } .pysell-question-feedback "
HTML += b"{ z-index: 10; display: none; position: absolute; pointer-ev"
HTML += b"ents: none; left: 0%; top: 0%; width: 100%; height: 100%; te"
HTML += b"xt-align: center; font-size: 4vw; text-shadow: 0px 0px 18px "
HTML += b"rgba(0, 0, 0, 0.15); background-color: rgba(255, 255, 255, 0"
HTML += b".95); padding: 10px; justify-content: center; align-items: c"
HTML += b"enter; box-sizing: border-box; } .pysell-question-title { us"
HTML += b"er-select: none; font-size: 24pt; } .pysell-code { font-fami"
HTML += b'ly: "Courier New", Courier, monospace; color: black; backgro'
HTML += b"und-color: rgba(248, 248, 248, 0.95); padding: 2px 5px; bord"
HTML += b"er-radius: 5px; border-style: solid; border-color: rgb(44, 4"
HTML += b"4, 44); border-width: 1px; margin: 1px 2px; cursor: default;"
HTML += b' } .pysell-code-block { font-family: "Courier New", Courier,'
HTML += b" monospace; color: black; background-color: rgba(248, 248, 2"
HTML += b"48, 0.95); padding: 2px 5px; border-radius: 5px; border-styl"
HTML += b"e: solid; border-color: rgb(44, 44, 44); border-width: 1px; "
HTML += b"margin: 2px 2px 10px 2px; cursor: default; } .pysell-debug-c"
HTML += b'ode { font-family: "Courier New", Courier, monospace; paddin'
HTML += b"g: 4px; margin-bottom: 5px; background-color: black; color: "
HTML += b"white; border-radius: 5px; opacity: 0.85; overflow-x: scroll"
HTML += b"; } .pysell-debug-info { text-align: end; font-size: 10pt; m"
HTML += b"argin-top: 2px; color: rgb(64, 64, 64); } .pysell-input-fiel"
HTML += b"d { position: relative; width: 32px; height: 24px; font-size"
HTML += b": 14pt; border-style: solid; border-color: black; border-rad"
HTML += b"ius: 5px; border-width: 0.2; padding-left: 5px; padding-righ"
HTML += b"t: 5px; outline-color: black; background-color: transparent;"
HTML += b" margin: 1px; } .pysell-input-field:focus { outline-color: m"
HTML += b"aroon; } .pysell-equation-preview { position: absolute; top:"
HTML += b" 120%; left: 0%; padding-left: 8px; padding-right: 8px; padd"
HTML += b"ing-top: 4px; padding-bottom: 4px; background-color: rgb(128"
HTML += b", 0, 0); border-radius: 5px; font-size: 12pt; color: white; "
HTML += b"text-align: start; z-index: 1000; opacity: 0.95; } .pysell-b"
HTML += b"utton { padding-left: 8px; padding-right: 8px; padding-top: "
HTML += b"5px; padding-bottom: 5px; font-size: 12pt; background-color:"
HTML += b" rgb(0, 150, 0); color: white; border-style: none; border-ra"
HTML += b"dius: 4px; height: 36px; cursor: pointer; } .pysell-start-bu"
HTML += b'tton { background-color: var(--pysell-green); font-size: "x-'
HTML += b'large"; } .pysell-matrix-resize-button { width: 20px; backgr'
HTML += b"ound-color: black; color: #fff; text-align: center; border-r"
HTML += b"adius: 3px; position: absolute; z-index: 1; height: 20px; cu"
HTML += b"rsor: pointer; overflow: hidden; font-size: 16px; } .pysell-"
HTML += b"timer { position: fixed; left: 0; top: 0; padding: 5px 15px;"
HTML += b" background-color: rgb(32, 32, 32); color: white; opacity: 0"
HTML += b".4; font-size: 32pt; z-index: 1000; border-bottom-right-radi"
HTML += b'us: 10px; text-align: center; font-family: "Courier New", Co'
HTML += b"urier, monospace; } .pysell-eval { text-align: center; backg"
HTML += b"round-color: black; color: white; padding: 10px; } @media (m"
HTML += b"in-width: 800px) { .pysell-eval { border-radius: 10px; } } ."
HTML += b"pysell-timer-info { font-size: x-large; text-align: center; "
HTML += b"background-color: black; color: white; padding: 20px 10px; u"
HTML += b"ser-select: none; } @media (min-width: 800px) { .pysell-time"
HTML += b"r-info { border-radius: 6px; } } </style> </head> <body> <di"
HTML += b'v id="timer"></div> <div id="header"></div> <br /> <div clas'
HTML += b's="contents"> <div id="timer-info"></div> <div id="questions'
HTML += b'"></div> <div id="timer-footer"></div> <div id="timer-eval">'
HTML += b'</div> </div> <br /><br /><br /><br /> <div class="footer"> '
HTML += b'<div class="contents"> <span id="date"></span> &mdash; This '
HTML += b"quiz was developed using pySELL, a Python-based Simple E-Lea"
HTML += b'rning Language &mdash; <a href="https://pysell.org" style="c'
HTML += b'olor: var(--grey)" >https://pysell.org</a > <br /> <div styl'
HTML += b'e="width: 100%; display: flex; justify-content: center"> <im'
HTML += b'g style="max-width: 48px; padding: 16px 0px" src="data:image'
HTML += b"/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRG"
HTML += b"LTgiPz4KPCEtLSBDcmVhdGVkIHdpdGggSW5rc2NhcGUgKGh0dHA6Ly93d3cu"
HTML += b"aW5rc2NhcGUub3JnLykgLS0+Cjxzdmcgd2lkdGg9IjEwMG1tIiBoZWlnaHQ9"
HTML += b"IjEwMG1tIiB2ZXJzaW9uPSIxLjEiIHZpZXdCb3g9IjAgMCAxMDAgMTAwIiB4"
HTML += b"bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5r"
HTML += b"PSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIj4KIDxkZWZzPgogIDxs"
HTML += b"aW5lYXJHcmFkaWVudCBpZD0ibGluZWFyR3JhZGllbnQzNjU4IiB4MT0iMjgu"
HTML += b"NTI3IiB4Mj0iMTI4LjUzIiB5MT0iNzkuNjQ4IiB5Mj0iNzkuNjQ4IiBncmFk"
HTML += b"aWVudFRyYW5zZm9ybT0ibWF0cml4KDEuMDE2MSAwIDAgMS4wMTYxIC0yOS43"
HTML += b"OSAtMzAuOTI4KSIgZ3JhZGllbnRVbml0cz0idXNlclNwYWNlT25Vc2UiPgog"
HTML += b"ICA8c3RvcCBzdG9wLWNvbG9yPSIjNTkwMDVlIiBvZmZzZXQ9IjAiLz4KICAg"
HTML += b"PHN0b3Agc3RvcC1jb2xvcj0iI2FkMDA3ZiIgb2Zmc2V0PSIxIi8+CiAgPC9s"
HTML += b"aW5lYXJHcmFkaWVudD4KIDwvZGVmcz4KIDxyZWN0IHdpZHRoPSIxMDAiIGhl"
HTML += b"aWdodD0iMTAwIiByeT0iMCIgZmlsbD0idXJsKCNsaW5lYXJHcmFkaWVudDM2"
HTML += b"NTgpIi8+CiA8ZyBmaWxsPSIjZmZmIj4KICA8ZyB0cmFuc2Zvcm09Im1hdHJp"
HTML += b"eCguNDA3NDMgMCAwIC40MDc0MyAtNDIuODQyIC0zNi4xMzYpIiBzdHJva2Ut"
HTML += b"d2lkdGg9IjMuNzc5NSIgc3R5bGU9InNoYXBlLWluc2lkZTp1cmwoI3JlY3Q5"
HTML += b"NTItNyk7c2hhcGUtcGFkZGluZzo2LjUzMTQ0O3doaXRlLXNwYWNlOnByZSIg"
HTML += b"YXJpYS1sYWJlbD0iU0VMTCI+CiAgIDxwYXRoIGQ9Im0xNzEuMDEgMjM4LjM5"
HTML += b"cS0yLjExMi0yLjY4OC01LjU2OC00LjIyNC0zLjM2LTEuNjMyLTYuNTI4LTEu"
HTML += b"NjMyLTEuNjMyIDAtMy4zNiAwLjI4OC0xLjYzMiAwLjI4OC0yLjk3NiAxLjE1"
HTML += b"Mi0xLjM0NCAwLjc2OC0yLjMwNCAyLjExMi0wLjg2NCAxLjI0OC0wLjg2NCAz"
HTML += b"LjI2NCAwIDEuNzI4IDAuNjcyIDIuODggMC43NjggMS4xNTIgMi4xMTIgMi4w"
HTML += b"MTYgMS40NCAwLjg2NCAzLjM2IDEuNjMyIDEuOTIgMC42NzIgNC4zMiAxLjQ0"
HTML += b"IDMuNDU2IDEuMTUyIDcuMiAyLjU5MiAzLjc0NCAxLjM0NCA2LjgxNiAzLjY0"
HTML += b"OHQ1LjA4OCA1Ljc2cTIuMDE2IDMuMzYgMi4wMTYgOC40NDggMCA1Ljg1Ni0y"
HTML += b"LjIwOCAxMC4xNzYtMi4xMTIgNC4yMjQtNS43NiA3LjAwOHQtOC4zNTIgNC4x"
HTML += b"MjgtOS42OTYgMS4zNDRxLTcuMjk2IDAtMTQuMTEyLTIuNDk2LTYuODE2LTIu"
HTML += b"NTkyLTExLjMyOC03LjI5NmwxMC43NTItMTAuOTQ0cTIuNDk2IDMuMDcyIDYu"
HTML += b"NTI4IDUuMTg0IDQuMTI4IDIuMDE2IDguMTYgMi4wMTYgMS44MjQgMCAzLjU1"
HTML += b"Mi0wLjM4NHQyLjk3Ni0xLjI0OHExLjM0NC0wLjg2NCAyLjExMi0yLjMwNHQw"
HTML += b"Ljc2OC0zLjQ1NnEwLTEuOTItMC45Ni0zLjI2NHQtMi43ODQtMi40cS0xLjcy"
HTML += b"OC0xLjE1Mi00LjQxNi0yLjAxNi0yLjU5Mi0wLjk2LTUuOTUyLTIuMDE2LTMu"
HTML += b"MjY0LTEuMDU2LTYuNDMyLTIuNDk2LTMuMDcyLTEuNDQtNS41NjgtMy42NDgt"
HTML += b"Mi40LTIuMzA0LTMuOTM2LTUuNDcyLTEuNDQtMy4yNjQtMS40NC03Ljg3MiAw"
HTML += b"LTUuNjY0IDIuMzA0LTkuNjk2dDYuMDQ4LTYuNjI0IDguNDQ4LTMuNzQ0cTQu"
HTML += b"NzA0LTEuMjQ4IDkuNTA0LTEuMjQ4IDUuNzYgMCAxMS43MTIgMi4xMTIgNi4w"
HTML += b"NDggMi4xMTIgMTAuNTYgNi4yNHoiLz4KICAgPHBhdGggZD0ibTE5MS44NCAy"
HTML += b"ODguN3YtNjcuOTY4aDUyLjE5bC0xLjI5ODggMTMuOTJoLTM1LjA1MXYxMi43"
HTML += b"NjhoMzMuNDE5bC0xLjI5ODggMTMuMTUyaC0zMi4xMnYxNC4xMTJoMzEuNTg0"
HTML += b"bC0xLjI5ODggMTQuMDE2eiIvPgogIDwvZz4KICA8ZyB0cmFuc2Zvcm09Im1h"
HTML += b"dHJpeCguNDA3NDMgMCAwIC40MDc0MyAtNDAuMTY4IC03OC4wODIpIiBzdHJv"
HTML += b"a2Utd2lkdGg9IjMuNzc5NSIgc3R5bGU9InNoYXBlLWluc2lkZTp1cmwoI3Jl"
HTML += b"Y3Q5NTItOS05KTtzaGFwZS1wYWRkaW5nOjYuNTMxNDQ7d2hpdGUtc3BhY2U6"
HTML += b"cHJlIiBhcmlhLWxhYmVsPSJweSI+CiAgIDxwYXRoIGQ9Im0xODcuNDMgMjY0"
HTML += b"LjZxMCA0Ljk5Mi0xLjUzNiA5LjZ0LTQuNTEyIDguMTZxLTIuODggMy40NTYt"
HTML += b"Ny4xMDQgNS41Njh0LTkuNiAyLjExMnEtNC40MTYgMC04LjM1Mi0xLjcyOC0z"
HTML += b"LjkzNi0xLjgyNC02LjE0NC00Ljg5NmgtMC4xOTJ2MjguMzJoLTE1Ljc0NHYt"
HTML += b"NzAuODQ4aDE0Ljk3NnY1Ljg1NmgwLjI4OHEyLjIwOC0yLjg4IDYuMDQ4LTQu"
HTML += b"OTkyIDMuOTM2LTIuMjA4IDkuMjE2LTIuMjA4IDUuMTg0IDAgOS40MDggMi4w"
HTML += b"MTZ0Ny4xMDQgNS40NzJxMi45NzYgMy40NTYgNC41MTIgOC4wNjQgMS42MzIg"
HTML += b"NC41MTIgMS42MzIgOS41MDR6bS0xNS4yNjQgMHEwLTIuMzA0LTAuNzY4LTQu"
HTML += b"NTEyLTAuNjcyLTIuMjA4LTIuMTEyLTMuODQtMS4zNDQtMS43MjgtMy40NTYt"
HTML += b"Mi43ODR0LTQuODk2LTEuMDU2cS0yLjY4OCAwLTQuOCAxLjA1NnQtMy42NDgg"
HTML += b"Mi43ODRxLTEuNDQgMS43MjgtMi4zMDQgMy45MzYtMC43NjggMi4yMDgtMC43"
HTML += b"NjggNC41MTJ0MC43NjggNC41MTJxMC44NjQgMi4yMDggMi4zMDQgMy45MzYg"
HTML += b"MS41MzYgMS43MjggMy42NDggMi43ODR0NC44IDEuMDU2cTIuNzg0IDAgNC44"
HTML += b"OTYtMS4wNTZ0My40NTYtMi43ODRxMS40NC0xLjcyOCAyLjExMi0zLjkzNiAw"
HTML += b"Ljc2OC0yLjMwNCAwLjc2OC00LjYwOHoiLz4KICAgPHBhdGggZD0ibTIyNC4y"
HTML += b"OSAyOTUuOXEtMS40NCAzLjc0NC0zLjI2NCA2LjYyNC0xLjcyOCAyLjk3Ni00"
HTML += b"LjIyNCA0Ljk5Mi0yLjQgMi4xMTItNS43NiAzLjE2OC0zLjI2NCAxLjA1Ni03"
HTML += b"Ljc3NiAxLjA1Ni0yLjIwOCAwLTQuNjA4LTAuMjg4LTIuMzA0LTAuMjg4LTQu"
HTML += b"MDMyLTAuNzY4bDEuNzI4LTEzLjI0OHExLjE1MiAwLjM4NCAyLjQ5NiAwLjU3"
HTML += b"NiAxLjQ0IDAuMjg4IDIuNTkyIDAuMjg4IDMuNjQ4IDAgNS4yOC0xLjcyOCAx"
HTML += b"LjYzMi0xLjYzMiAyLjc4NC00LjcwNGwxLjUzNi0zLjkzNi0xOS45NjgtNDcu"
HTML += b"MDRoMTcuNDcybDEwLjY1NiAzMC43MmgwLjI4OGw5LjUwNC0zMC43MmgxNi43"
HTML += b"MDR6Ii8+CiAgPC9nPgogIDxwYXRoIGQ9Im02OC4wOTYgMTUuNzc1aDcuODAy"
HTML += b"OWwtOC45ODU0IDY5Ljc5MWgtNy44MDN6IiBzdHJva2Utd2lkdGg9IjEuMTE3"
HTML += b"NiIvPgogIDxwYXRoIGQ9Im04My44NTMgMTUuNzQ4aDcuODAzbC04Ljk4NTQg"
HTML += b"NjkuNzkxaC03LjgwM3oiIHN0cm9rZS13aWR0aD0iMS4xMTc2Ii8+CiA8L2c+"
HTML += b'Cjwvc3ZnPgo=" /> </div> <span id="data-policy"></span> </div'
HTML += b"> </div>  <script>let debug = false; let quizSrc = {};var py"
HTML += b"sell=(()=>{var H=Object.defineProperty;var pe=Object.getOwnP"
HTML += b"ropertyDescriptor;var de=Object.getOwnPropertyNames;var ue=O"
HTML += b'bject.prototype.hasOwnProperty;var f=(r,e)=>H(r,"name",{valu'
HTML += b"e:e,configurable:!0});var me=(r,e)=>{for(var t in e)H(r,t,{g"
HTML += b'et:e[t],enumerable:!0})},fe=(r,e,t,s)=>{if(e&&typeof e=="obj'
HTML += b'ect"||typeof e=="function")for(let i of de(e))!ue.call(r,i)&'
HTML += b"&i!==t&&H(r,i,{get:()=>e[i],enumerable:!(s=pe(e,i))||s.enume"
HTML += b'rable});return r};var ge=r=>fe(H({},"__esModule",{value:!0})'
HTML += b',r);var ke={};me(ke,{init:()=>be});var F={en:"This page oper'
HTML += b"ates entirely in your browser and does not store any data on"
HTML += b' external servers.",de:"Diese Seite wird in Ihrem Browser au'
HTML += b'sgef\\xFChrt und speichert keine Daten auf Servern.",es:"Esta'
HTML += b" p\\xE1gina se ejecuta en su navegador y no almacena ning\\xFA"
HTML += b'n dato en los servidores.",it:"Questa pagina viene eseguita '
HTML += b'nel browser e non memorizza alcun dato sui server.",fr:"Cett'
HTML += b"e page fonctionne dans votre navigateur et ne stocke aucune "
HTML += b'donn\\xE9e sur des serveurs."},O={en:"* this page to receive '
HTML += b'a new set of randomized tasks.",de:"Sie k\\xF6nnen diese Seit'
HTML += b'e *, um neue randomisierte Aufgaben zu erhalten.",es:"Puedes'
HTML += b' * esta p\\xE1gina para obtener nuevas tareas aleatorias.",it'
HTML += b':"\\xC8 possibile * questa pagina per ottenere nuovi compiti '
HTML += b'randomizzati",fr:"Vous pouvez * cette page pour obtenir de n'
HTML += b'ouvelles t\\xE2ches al\\xE9atoires"},K={en:"Refresh",de:"aktua'
HTML += b'lisieren",es:"recargar",it:"ricaricare",fr:"recharger"},Z={e'
HTML += b'n:["awesome","great","well done","nice","you got it","good"]'
HTML += b',de:["super","gut gemacht","weiter so","richtig"],es:["impre'
HTML += b'sionante","genial","correcto","bien hecho"],it:["fantastico"'
HTML += b',"grande","corretto","ben fatto"],fr:["g\\xE9nial","super","c'
HTML += b'orrect","bien fait"]},X={en:["please complete all fields"],d'
HTML += b'e:["bitte alles ausf\\xFCllen"],es:["por favor, rellene todo"'
HTML += b'],it:["compilare tutto"],fr:["remplis tout s\'il te plait"]},'
HTML += b'Y={en:["try again","still some mistakes","wrong answer","no"'
HTML += b'],de:["leider falsch","nicht richtig","versuch\'s nochmal"],e'
HTML += b's:["int\\xE9ntalo de nuevo","todav\\xEDa algunos errores","res'
HTML += b'puesta incorrecta"],it:["riprova","ancora qualche errore","r'
HTML += b'isposta sbagliata"],fr:["r\\xE9essayer","encore des erreurs",'
HTML += b'"mauvaise r\\xE9ponse"]},G={en:"point(s)",de:"Punkt(e)",es:"p'
HTML += b'unto(s)",it:"punto/i",fr:"point(s)"},J={en:"Evaluate now",de'
HTML += b':"Jetzt auswerten",es:"Evaluar ahora",it:"Valuta ora",fr:"\\x'
HTML += b'C9valuer maintenant"},$={en:"Data Policy: This website does '
HTML += b"not collect, store, or process any personal data on external"
HTML += b" servers. All functionality is executed locally in your brow"
HTML += b"ser, ensuring complete privacy. No cookies are used, and no "
HTML += b"data is transmitted to or from the server. Your activity on "
HTML += b"this site remains entirely private and local to your device."
HTML += b'",de:"Datenschutzrichtlinie: Diese Website sammelt, speicher'
HTML += b"t oder verarbeitet keine personenbezogenen Daten auf externe"
HTML += b"n Servern. Alle Funktionen werden lokal in Ihrem Browser aus"
HTML += b"gef\\xFChrt, um vollst\\xE4ndige Privatsph\\xE4re zu gew\\xE4hrl"
HTML += b"eisten. Es werden keine Cookies verwendet, und es werden kei"
HTML += b"ne Daten an den Server gesendet oder von diesem empfangen. I"
HTML += b"hre Aktivit\\xE4t auf dieser Seite bleibt vollst\\xE4ndig priv"
HTML += b'at und lokal auf Ihrem Ger\\xE4t.",es:"Pol\\xEDtica de datos: '
HTML += b"Este sitio web no recopila, almacena ni procesa ning\\xFAn da"
HTML += b"to personal en servidores externos. Toda la funcionalidad se"
HTML += b" ejecuta localmente en su navegador, garantizando una privac"
HTML += b"idad completa. No se utilizan cookies y no se transmiten dat"
HTML += b"os hacia o desde el servidor. Su actividad en este sitio per"
HTML += b'manece completamente privada y local en su dispositivo.",it:'
HTML += b'"Politica sui dati: Questo sito web non raccoglie, memorizza'
HTML += b" o elabora alcun dato personale su server esterni. Tutte le "
HTML += b"funzionalit\\xE0 vengono eseguite localmente nel tuo browser,"
HTML += b" garantendo una privacy completa. Non vengono utilizzati coo"
HTML += b"kie e nessun dato viene trasmesso da o verso il server. La t"
HTML += b"ua attivit\\xE0 su questo sito rimane completamente privata e"
HTML += b' locale sul tuo dispositivo.",fr:"Politique de confidentiali'
HTML += b"t\\xE9: Ce site web ne collecte, ne stocke ni ne traite aucun"
HTML += b"e donn\\xE9e personnelle sur des serveurs externes. Toutes le"
HTML += b"s fonctionnalit\\xE9s sont ex\\xE9cut\\xE9es localement dans vo"
HTML += b"tre navigateur, garantissant une confidentialit\\xE9 totale. "
HTML += b"Aucun cookie n\\u2019est utilis\\xE9 et aucune donn\\xE9e n\\u20"
HTML += b"19est transmise vers ou depuis le serveur. Votre activit\\xE9"
HTML += b" sur ce site reste enti\\xE8rement priv\\xE9e et locale sur vo"
HTML += b'tre appareil."},ee={en:"You have a limited time to complete '
HTML += b"this quiz. The countdown, displayed in minutes, is visible a"
HTML += b"t the top-left of the screen. When you're ready to begin, si"
HTML += b'mply press the Start button.",de:"Die Zeit f\\xFCr dieses Qui'
HTML += b"z ist begrenzt. Der Countdown, in Minuten angezeigt, l\\xE4uf"
HTML += b"t oben links auf dem Bildschirm. Mit dem Start-Button beginn"
HTML += b't das Quiz.",es:"Tienes un tiempo limitado para completar es'
HTML += b"te cuestionario. La cuenta regresiva, mostrada en minutos, s"
HTML += b"e encuentra en la parte superior izquierda de la pantalla. C"
HTML += b"uando est\\xE9s listo, simplemente presiona el bot\\xF3n de in"
HTML += b'icio.",it:"Hai un tempo limitato per completare questo quiz.'
HTML += b" Il conto alla rovescia, visualizzato in minuti, \\xE8 visibi"
HTML += b"le in alto a sinistra dello schermo. Quando sei pronto, prem"
HTML += b'i semplicemente il pulsante Start.",fr:"Vous disposez d\\u201'
HTML += b"9un temps limit\\xE9 pour compl\\xE9ter ce quiz. Le compte \\xE"
HTML += b"0 rebours, affich\\xE9 en minutes, est visible en haut \\xE0 g"
HTML += b"auche de l\\u2019\\xE9cran. Lorsque vous \\xEAtes pr\\xEAt, appu"
HTML += b'yez simplement sur le bouton D\\xE9marrer."};function w(r=[])'
HTML += b'{let e=document.createElement("div");return e.append(...r),e'
HTML += b'}f(w,"genDiv");function te(r=[]){let e=document.createElemen'
HTML += b't("ul");return e.append(...r),e}f(te,"genUl");function ie(r)'
HTML += b'{let e=document.createElement("li");return e.appendChild(r),'
HTML += b'e}f(ie,"genLi");function W(r){let e=document.createElement("'
HTML += b'input");return e.spellcheck=!1,e.type="text",e.classList.add'
HTML += b'("pysell-input-field"),e.style.width=r+"px",e}f(W,"genInputF'
HTML += b'ield");function se(){let r=document.createElement("button");'
HTML += b'return r.type="button",r.classList.add("pysell-button"),r}f('
HTML += b'se,"genButton");function k(r,e=[]){let t=document.createElem'
HTML += b'ent("span");return e.length>0?t.append(...e):t.innerHTML=r,t'
HTML += b'}f(k,"genSpan");function N(r,e,t=!1){katex.render(e,r,{throw'
HTML += b'OnError:!1,displayMode:t,macros:{"\\\\RR":"\\\\mathbb{R}","\\\\NN"'
HTML += b':"\\\\mathbb{N}","\\\\QQ":"\\\\mathbb{Q}","\\\\ZZ":"\\\\mathbb{Z}","\\\\'
HTML += b'CC":"\\\\mathbb{C}"}})}f(N,"updateMathElement");function T(r,e'
HTML += b'=!1){let t=document.createElement("span");return N(t,r,e),t}'
HTML += b'f(T,"genMathSpan");function ne(r,e){let t=Array(e.length+1).'
HTML += b"fill(null).map(()=>Array(r.length+1).fill(null));for(let s=0"
HTML += b";s<=r.length;s+=1)t[0][s]=s;for(let s=0;s<=e.length;s+=1)t[s"
HTML += b"][0]=s;for(let s=1;s<=e.length;s+=1)for(let i=1;i<=r.length;"
HTML += b"i+=1){let o=r[i-1]===e[s-1]?0:1;t[s][i]=Math.min(t[s][i-1]+1"
HTML += b",t[s-1][i]+1,t[s-1][i-1]+o)}return t[e.length][r.length]}f(n"
HTML += b'e,"levenshteinDistance");var re=\'<svg xmlns="http://www.w3.o'
HTML += b'rg/2000/svg" height="28" viewBox="0 0 448 512"><path fill="b'
HTML += b'lack" d="M384 80c8.8 0 16 7.2 16 16V416c0 8.8-7.2 16-16 16H6'
HTML += b"4c-8.8 0-16-7.2-16-16V96c0-8.8 7.2-16 16-16H384zM64 32C28.7 "
HTML += b"32 0 60.7 0 96V416c0 35.3 28.7 64 64 64H384c35.3 0 64-28.7 6"
HTML += b"4-64V96c0-35.3-28.7-64-64-64H64z\"/></svg>',ae='<svg xmlns=\"h"
HTML += b'ttp://www.w3.org/2000/svg" height="28" viewBox="0 0 448 512"'
HTML += b'><path fill="black" d="M64 80c-8.8 0-16 7.2-16 16V416c0 8.8 '
HTML += b"7.2 16 16 16H384c8.8 0 16-7.2 16-16V96c0-8.8-7.2-16-16-16H64"
HTML += b"zM0 96C0 60.7 28.7 32 64 32H384c35.3 0 64 28.7 64 64V416c0 3"
HTML += b"5.3-28.7 64-64 64H64c-35.3 0-64-28.7-64-64V96zM337 209L209 3"
HTML += b"37c-9.4 9.4-24.6 9.4-33.9 0l-64-64c-9.4-9.4-9.4-24.6 0-33.9s"
HTML += b"24.6-9.4 33.9 0l47 47L303 175c9.4-9.4 24.6-9.4 33.9 0s9.4 24"
HTML += b'.6 0 33.9z"/>\',le=\'<svg xmlns="http://www.w3.org/2000/svg" h'
HTML += b'eight="28" viewBox="0 0 512 512"><path fill="black" d="M464 '
HTML += b"256A208 208 0 1 0 48 256a208 208 0 1 0 416 0zM0 256a256 256 "
HTML += b"0 1 1 512 0A256 256 0 1 1 0 256z\"/></svg>',oe='<svg xmlns=\"h"
HTML += b'ttp://www.w3.org/2000/svg" height="28" viewBox="0 0 512 512"'
HTML += b'><path fill="black" d="M256 48a208 208 0 1 1 0 416 208 208 0'
HTML += b" 1 1 0-416zm0 464A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM3"
HTML += b"69 209c9.4-9.4 9.4-24.6 0-33.9s-24.6-9.4-33.9 0l-111 111-47-"
HTML += b"47c-9.4-9.4-24.6-9.4-33.9 0s-9.4 24.6 0 33.9l64 64c9.4 9.4 2"
HTML += b"4.6 9.4 33.9 0L369 209z\"/></svg>',D='<svg xmlns=\"http://www."
HTML += b'w3.org/2000/svg" width="50" height="25" viewBox="0 0 384 512'
HTML += b'" fill="white"><path d="M73 39c-14.8-9.1-33.4-9.4-48.5-.9S0 '
HTML += b"62.6 0 80V432c0 17.4 9.4 33.4 24.5 41.9s33.7 8.1 48.5-.9L361"
HTML += b" 297c14.3-8.7 23-24.2 23-41s-8.7-32.2-23-41L73 39z\"/></svg>'"
HTML += b',Q=\'<svg xmlns="http://www.w3.org/2000/svg" width="50" heigh'
HTML += b't="25" viewBox="0 0 512 512" fill="white"><path d="M0 224c0 '
HTML += b"17.7 14.3 32 32 32s32-14.3 32-32c0-53 43-96 96-96H320v32c0 1"
HTML += b"2.9 7.8 24.6 19.8 29.6s25.7 2.2 34.9-6.9l64-64c12.5-12.5 12."
HTML += b"5-32.8 0-45.3l-64-64c-9.2-9.2-22.9-11.9-34.9-6.9S320 19.1 32"
HTML += b"0 32V64H160C71.6 64 0 135.6 0 224zm512 64c0-17.7-14.3-32-32-"
HTML += b"32s-32 14.3-32 32c0 53-43 96-96 96H192V352c0-12.9-7.8-24.6-1"
HTML += b"9.8-29.6s-25.7-2.2-34.9 6.9l-64 64c-12.5 12.5-12.5 32.8 0 45"
HTML += b".3l64 64c9.2 9.2 22.9 11.9 34.9 6.9s19.8-16.6 19.8-29.6V448H"
HTML += b"352c88.4 0 160-71.6 160-160z\"/></svg>';function P(r,e=!1){le"
HTML += b"t t=new Array(r);for(let s=0;s<r;s++)t[s]=s;if(e)for(let s=0"
HTML += b";s<r;s++){let i=Math.floor(Math.random()*r),o=Math.floor(Mat"
HTML += b'h.random()*r),l=t[i];t[i]=t[o],t[o]=l}return t}f(P,"range");'
HTML += b"function _(r,e,t=-1){if(t<0&&(t=r.length),t==1){e.push([...r"
HTML += b"]);return}for(let s=0;s<t;s++){_(r,e,t-1);let i=t%2==0?s:0,o"
HTML += b'=r[i];r[i]=r[t-1],r[t-1]=o}}f(_,"heapsAlgorithm");var L=clas'
HTML += b's r{static{f(this,"Matrix")}constructor(e,t){this.m=e,this.n'
HTML += b'=t,this.v=new Array(e*t).fill("0")}getElement(e,t){return e<'
HTML += b'0||e>=this.m||t<0||t>=this.n?"":this.v[e*this.n+t]}resize(e,'
HTML += b"t,s){if(e<1||e>50||t<1||t>50)return!1;let i=new r(e,t);i.v.f"
HTML += b"ill(s);for(let o=0;o<i.m;o++)for(let l=0;l<i.n;l++)i.v[o*i.n"
HTML += b"+l]=this.getElement(o,l);return this.fromMatrix(i),!0}fromMa"
HTML += b"trix(e){this.m=e.m,this.n=e.n,this.v=[...e.v]}fromString(e){"
HTML += b'this.m=e.split("],").length,this.v=e.replaceAll("[","").repl'
HTML += b'aceAll("]","").split(",").map(t=>t.trim()),this.n=this.v.len'
HTML += b"gth/this.m}getMaxCellStrlen(){let e=0;for(let t of this.v)t."
HTML += b"length>e&&(e=t.length);return e}toTeXString(e=!1,t=!0){let s"
HTML += b'="";t?s+=e?"\\\\left[\\\\begin{array}":"\\\\begin{bmatrix}":s+=e?"'
HTML += b'\\\\left(\\\\begin{array}":"\\\\begin{pmatrix}",e&&(s+="{"+"c".rep'
HTML += b'eat(this.n-1)+"|c}");for(let i=0;i<this.m;i++){for(let o=0;o'
HTML += b'<this.n;o++){o>0&&(s+="&");let l=this.getElement(i,o);try{l='
HTML += b'b.parse(l).toTexString()}catch{}s+=l}s+="\\\\\\\\"}return t?s+=e'
HTML += b'?"\\\\end{array}\\\\right]":"\\\\end{bmatrix}":s+=e?"\\\\end{array}\\'
HTML += b'\\right)":"\\\\end{pmatrix}",s}},b=class r{static{f(this,"Term"'
HTML += b')}constructor(){this.root=null,this.src="",this.token="",thi'
HTML += b"s.skippedWhiteSpace=!1,this.pos=0}clone(){let e=new r;return"
HTML += b' e.root=this.root.clone(),e}getVars(e,t="",s=null){if(s==nul'
HTML += b'l&&(s=this.root),s.op.startsWith("var:")){let i=s.op.substri'
HTML += b"ng(4);(t.length==0||t.length>0&&i.startsWith(t))&&e.add(i)}f"
HTML += b"or(let i of s.c)this.getVars(e,t,i)}setVars(e,t=null){t==nul"
HTML += b"l&&(t=this.root);for(let s of t.c)this.setVars(e,s);if(t.op."
HTML += b'startsWith("var:")){let s=t.op.substring(4);if(s in e){let i'
HTML += b"=e[s].clone();t.op=i.op,t.c=i.c,t.re=i.re,t.im=i.im}}}rename"
HTML += b"Var(e,t,s=null){s==null&&(s=this.root);for(let i of s.c)this"
HTML += b'.renameVar(e,t,i);s.op.startsWith("var:")&&s.op.substring(4)'
HTML += b'===e&&(s.op="var:"+t)}eval(e,t=null){let i=a.const(),o=0,l=0'
HTML += b',h=null;switch(t==null&&(t=this.root),t.op){case"const":i=t;'
HTML += b'break;case"+":case"-":case"*":case"/":case"^":{let n=this.ev'
HTML += b'al(e,t.c[0]),c=this.eval(e,t.c[1]);switch(t.op){case"+":i.re'
HTML += b'=n.re+c.re,i.im=n.im+c.im;break;case"-":i.re=n.re-c.re,i.im='
HTML += b'n.im-c.im;break;case"*":i.re=n.re*c.re-n.im*c.im,i.im=n.re*c'
HTML += b'.im+n.im*c.re;break;case"/":o=c.re*c.re+c.im*c.im,i.re=(n.re'
HTML += b'*c.re+n.im*c.im)/o,i.im=(n.im*c.re-n.re*c.im)/o;break;case"^'
HTML += b'":h=new a("exp",[new a("*",[c,new a("ln",[n])])]),i=this.eva'
HTML += b'l(e,h);break}break}case".-":case"abs":case"acos":case"acosh"'
HTML += b':case"asin":case"asinh":case"atan":case"atanh":case"ceil":ca'
HTML += b'se"cos":case"cosh":case"cot":case"exp":case"floor":case"ln":'
HTML += b'case"log":case"log10":case"log2":case"round":case"sin":case"'
HTML += b'sinc":case"sinh":case"sqrt":case"tan":case"tanh":{let n=this'
HTML += b'.eval(e,t.c[0]);switch(t.op){case".-":i.re=-n.re,i.im=-n.im;'
HTML += b'break;case"abs":i.re=Math.sqrt(n.re*n.re+n.im*n.im),i.im=0;b'
HTML += b'reak;case"acos":h=new a("*",[a.const(0,-1),new a("ln",[new a'
HTML += b'("+",[a.const(0,1),new a("sqrt",[new a("-",[a.const(1,0),new'
HTML += b' a("*",[n,n])])])])])]),i=this.eval(e,h);break;case"acosh":h'
HTML += b'=new a("*",[n,new a("sqrt",[new a("-",[new a("*",[n,n]),a.co'
HTML += b'nst(1,0)])])]),i=this.eval(e,h);break;case"asin":h=new a("*"'
HTML += b',[a.const(0,-1),new a("ln",[new a("+",[new a("*",[a.const(0,'
HTML += b'1),n]),new a("sqrt",[new a("-",[a.const(1,0),new a("*",[n,n]'
HTML += b')])])])])]),i=this.eval(e,h);break;case"asinh":h=new a("*",['
HTML += b'n,new a("sqrt",[new a("+",[new a("*",[n,n]),a.const(1,0)])])'
HTML += b']),i=this.eval(e,h);break;case"atan":h=new a("*",[a.const(0,'
HTML += b'.5),new a("ln",[new a("/",[new a("-",[a.const(0,1),new a("*"'
HTML += b',[a.const(0,1),n])]),new a("+",[a.const(0,1),new a("*",[a.co'
HTML += b'nst(0,1),n])])])])]),i=this.eval(e,h);break;case"atanh":h=ne'
HTML += b'w a("*",[a.const(.5,0),new a("ln",[new a("/",[new a("+",[a.c'
HTML += b'onst(1,0),n]),new a("-",[a.const(1,0),n])])])]),i=this.eval('
HTML += b'e,h);break;case"ceil":i.re=Math.ceil(n.re),i.im=Math.ceil(n.'
HTML += b'im);break;case"cos":i.re=Math.cos(n.re)*Math.cosh(n.im),i.im'
HTML += b'=-Math.sin(n.re)*Math.sinh(n.im);break;case"cosh":h=new a("*'
HTML += b'",[a.const(.5,0),new a("+",[new a("exp",[n]),new a("exp",[ne'
HTML += b'w a(".-",[n])])])]),i=this.eval(e,h);break;case"cot":o=Math.'
HTML += b"sin(n.re)*Math.sin(n.re)+Math.sinh(n.im)*Math.sinh(n.im),i.r"
HTML += b"e=Math.sin(n.re)*Math.cos(n.re)/o,i.im=-(Math.sinh(n.im)*Mat"
HTML += b'h.cosh(n.im))/o;break;case"exp":i.re=Math.exp(n.re)*Math.cos'
HTML += b'(n.im),i.im=Math.exp(n.re)*Math.sin(n.im);break;case"floor":'
HTML += b'i.re=Math.floor(n.re),i.im=Math.floor(n.im);break;case"ln":c'
HTML += b'ase"log":i.re=Math.log(Math.sqrt(n.re*n.re+n.im*n.im)),o=Mat'
HTML += b'h.abs(n.im)<1e-9?0:n.im,i.im=Math.atan2(o,n.re);break;case"l'
HTML += b'og10":h=new a("/",[new a("ln",[n]),new a("ln",[a.const(10)])'
HTML += b']),i=this.eval(e,h);break;case"log2":h=new a("/",[new a("ln"'
HTML += b',[n]),new a("ln",[a.const(2)])]),i=this.eval(e,h);break;case'
HTML += b'"round":i.re=Math.round(n.re),i.im=Math.round(n.im);break;ca'
HTML += b'se"sin":i.re=Math.sin(n.re)*Math.cosh(n.im),i.im=Math.cos(n.'
HTML += b're)*Math.sinh(n.im);break;case"sinc":h=new a("/",[new a("sin'
HTML += b'",[n]),n]),i=this.eval(e,h);break;case"sinh":h=new a("*",[a.'
HTML += b'const(.5,0),new a("-",[new a("exp",[n]),new a("exp",[new a("'
HTML += b'.-",[n])])])]),i=this.eval(e,h);break;case"sqrt":h=new a("^"'
HTML += b',[n,a.const(.5)]),i=this.eval(e,h);break;case"tan":o=Math.co'
HTML += b"s(n.re)*Math.cos(n.re)+Math.sinh(n.im)*Math.sinh(n.im),i.re="
HTML += b"Math.sin(n.re)*Math.cos(n.re)/o,i.im=Math.sinh(n.im)*Math.co"
HTML += b'sh(n.im)/o;break;case"tanh":h=new a("/",[new a("-",[new a("e'
HTML += b'xp",[n]),new a("exp",[new a(".-",[n])])]),new a("+",[new a("'
HTML += b'exp",[n]),new a("exp",[new a(".-",[n])])])]),i=this.eval(e,h'
HTML += b');break}break}default:if(t.op.startsWith("var:")){let n=t.op'
HTML += b'.substring(4);if(n==="pi")return a.const(Math.PI);if(n==="e"'
HTML += b')return a.const(Math.E);if(n==="i")return a.const(0,1);if(n='
HTML += b'=="true")return a.const(1);if(n==="false")return a.const(0);'
HTML += b'if(n in e)return e[n];throw new Error("eval-error: unknown v'
HTML += b'ariable \'"+n+"\'")}else throw new Error("UNIMPLEMENTED eval \''
HTML += b'"+t.op+"\'")}return i}static parse(e){let t=new r;if(t.src=e,'
HTML += b't.token="",t.skippedWhiteSpace=!1,t.pos=0,t.next(),t.root=t.'
HTML += b'parseExpr(!1),t.token!=="")throw new Error("remaining tokens'
HTML += b': "+t.token+"...");return t}parseExpr(e){return this.parseAd'
HTML += b'd(e)}parseAdd(e){let t=this.parseMul(e);for(;["+","-"].inclu'
HTML += b"des(this.token)&&!(e&&this.skippedWhiteSpace);){let s=this.t"
HTML += b"oken;this.next(),t=new a(s,[t,this.parseMul(e)])}return t}pa"
HTML += b"rseMul(e){let t=this.parsePow(e);for(;!(e&&this.skippedWhite"
HTML += b'Space);){let s="*";if(["*","/"].includes(this.token))s=this.'
HTML += b'token,this.next();else if(!e&&this.token==="(")s="*";else if'
HTML += b"(this.token.length>0&&(this.isAlpha(this.token[0])||this.isN"
HTML += b'um(this.token[0])))s="*";else break;t=new a(s,[t,this.parseP'
HTML += b"ow(e)])}return t}parsePow(e){let t=this.parseUnary(e);for(;["
HTML += b'"^"].includes(this.token)&&!(e&&this.skippedWhiteSpace);){le'
HTML += b"t s=this.token;this.next(),t=new a(s,[t,this.parseUnary(e)])"
HTML += b'}return t}parseUnary(e){return this.token==="-"?(this.next()'
HTML += b',new a(".-",[this.parseMul(e)])):this.parseInfix(e)}parseInf'
HTML += b'ix(e){if(this.token.length==0)throw new Error("expected unar'
HTML += b'y");if(this.isNum(this.token[0])){let t=this.token;return th'
HTML += b'is.next(),this.token==="."&&(t+=".",this.next(),this.token.l'
HTML += b'ength>0&&(t+=this.token,this.next())),new a("const",[],parse'
HTML += b"Float(t))}else if(this.fun1().length>0){let t=this.fun1();th"
HTML += b'is.next(t.length);let s=null;if(this.token==="(")if(this.nex'
HTML += b't(),s=this.parseExpr(e),this.token+="",this.token===")")this'
HTML += b".next();else throw Error(\"expected ')'\");else s=this.parseMu"
HTML += b'l(!0);return new a(t,[s])}else if(this.token==="("){this.nex'
HTML += b't();let t=this.parseExpr(e);if(this.token+="",this.token==="'
HTML += b')")this.next();else throw Error("expected \')\'");return t.exp'
HTML += b'licitParentheses=!0,t}else if(this.token==="|"){this.next();'
HTML += b'let t=this.parseExpr(e);if(this.token+="",this.token==="|")t'
HTML += b'his.next();else throw Error("expected \'|\'");return new a("ab'
HTML += b's",[t])}else if(this.isAlpha(this.token[0])){let t="";return'
HTML += b' this.token.startsWith("pi")?t="pi":this.token.startsWith("t'
HTML += b'rue")?t="true":this.token.startsWith("false")?t="false":this'
HTML += b'.token.startsWith("C1")?t="C1":this.token.startsWith("C2")?t'
HTML += b'="C2":t=this.token[0],t==="I"&&(t="i"),this.next(t.length),n'
HTML += b'ew a("var:"+t,[])}else throw new Error("expected unary")}sta'
HTML += b"tic compare(e,t,s={}){let l=new Set;e.getVars(l),t.getVars(l"
HTML += b");for(let h=0;h<10;h++){let n={};for(let g of l)g in s?n[g]="
HTML += b"s[g]:n[g]=a.const(Math.random(),Math.random());let c=e.eval("
HTML += b"n),p=t.eval(n),m=c.re-p.re,u=c.im-p.im;if(Math.sqrt(m*m+u*u)"
HTML += b'>1e-9)return!1}return!0}fun1(){let e=["abs","acos","acosh","'
HTML += b'asin","asinh","atan","atanh","ceil","cos","cosh","cot","exp"'
HTML += b',"floor","ln","log","log10","log2","round","sin","sinc","sin'
HTML += b'h","sqrt","tan","tanh"];for(let t of e)if(this.token.toLower'
HTML += b'Case().startsWith(t))return t;return""}next(e=-1){if(e>0&&th'
HTML += b"is.token.length>e){this.token=this.token.substring(e),this.s"
HTML += b'kippedWhiteSpace=!1;return}this.token="";let t=!1,s=this.src'
HTML += b".length;for(this.skippedWhiteSpace=!1;this.pos<s&&`\t\n `.incl"
HTML += b"udes(this.src[this.pos]);)this.skippedWhiteSpace=!0,this.pos"
HTML += b"++;for(;!t&&this.pos<s;){let i=this.src[this.pos];if(this.to"
HTML += b"ken.length>0&&(this.isNum(this.token[0])&&this.isAlpha(i)||t"
HTML += b'his.isAlpha(this.token[0])&&this.isNum(i))&&this.token!="C")'
HTML += b"return;if(`^%#*$()[]{},.:;+-*/_!<>=?|\t\n `.includes(i)){if(th"
HTML += b"is.token.length>0)return;t=!0}`\t\n `.includes(i)==!1&&(this.t"
HTML += b"oken+=i),this.pos++}}isNum(e){return e.charCodeAt(0)>=48&&e."
HTML += b"charCodeAt(0)<=57}isAlpha(e){return e.charCodeAt(0)>=65&&e.c"
HTML += b"harCodeAt(0)<=90||e.charCodeAt(0)>=97&&e.charCodeAt(0)<=122|"
HTML += b'|e==="_"}toString(){return this.root==null?"":this.root.toSt'
HTML += b'ring()}toTexString(){return this.root==null?"":this.root.toT'
HTML += b'exString()}},a=class r{static{f(this,"TermNode")}constructor'
HTML += b"(e,t,s=0,i=0){this.op=e,this.c=t,this.re=s,this.im=i,this.ex"
HTML += b"plicitParentheses=!1}clone(){let e=new r(this.op,this.c.map("
HTML += b"t=>t.clone()),this.re,this.im);return e.explicitParentheses="
HTML += b"this.explicitParentheses,e}static const(e=0,t=0){return new "
HTML += b'r("const",[],e,t)}compare(e,t=0,s=1e-9){let i=this.re-e,o=th'
HTML += b'is.im-t;return Math.sqrt(i*i+o*o)<s}toString(){let e="";if(t'
HTML += b'his.op==="const"){let t=Math.abs(this.re)>1e-14,s=Math.abs(t'
HTML += b'his.im)>1e-14;t&&s&&this.im>=0?e="("+this.re+"+"+this.im+"i)'
HTML += b'":t&&s&&this.im<0?e="("+this.re+"-"+-this.im+"i)":t&&this.re'
HTML += b'>0?e=""+this.re:t&&this.re<0?e="("+this.re+")":s?e="("+this.'
HTML += b'im+"i)":e="0"}else this.op.startsWith("var")?e=this.op.split'
HTML += b'(":")[1]:this.c.length==1?e=(this.op===".-"?"-":this.op)+"("'
HTML += b'+this.c.toString()+")":e="("+this.c.map(t=>t.toString()).joi'
HTML += b'n(this.op)+")";return e}toTexString(e=!1){let s="";switch(th'
HTML += b'is.op){case"const":{let i=Math.abs(this.re)>1e-9,o=Math.abs('
HTML += b'this.im)>1e-9,l=i?""+this.re:"",h=o?""+this.im+"i":"";h==="1'
HTML += b'i"?h="i":h==="-1i"&&(h="-i"),!i&&!o?s="0":(o&&this.im>=0&&i&'
HTML += b'&(h="+"+h),s=l+h);break}case".-":s="-"+this.c[0].toTexString'
HTML += b'();break;case"+":case"-":case"*":case"^":{let i=this.c[0].to'
HTML += b'TexString(),o=this.c[1].toTexString(),l=this.op==="*"?"\\\\cdo'
HTML += b't ":this.op;s="{"+i+"}"+l+"{"+o+"}";break}case"/":{let i=thi'
HTML += b's.c[0].toTexString(!0),o=this.c[1].toTexString(!0);s="\\\\frac'
HTML += b'{"+i+"}{"+o+"}";break}case"floor":{let i=this.c[0].toTexStri'
HTML += b'ng(!0);s+="\\\\"+this.op+"\\\\left\\\\lfloor"+i+"\\\\right\\\\rfloor";'
HTML += b'break}case"ceil":{let i=this.c[0].toTexString(!0);s+="\\\\"+th'
HTML += b'is.op+"\\\\left\\\\lceil"+i+"\\\\right\\\\rceil";break}case"round":{'
HTML += b'let i=this.c[0].toTexString(!0);s+="\\\\"+this.op+"\\\\left["+i+'
HTML += b'"\\\\right]";break}case"acos":case"acosh":case"asin":case"asin'
HTML += b'h":case"atan":case"atanh":case"cos":case"cosh":case"cot":cas'
HTML += b'e"exp":case"ln":case"log":case"log10":case"log2":case"sin":c'
HTML += b'ase"sinc":case"sinh":case"tan":case"tanh":{let i=this.c[0].t'
HTML += b'oTexString(!0);s+="\\\\"+this.op+"\\\\left("+i+"\\\\right)";break}'
HTML += b'case"sqrt":{let i=this.c[0].toTexString(!0);s+="\\\\"+this.op+'
HTML += b'"{"+i+"}";break}case"abs":{let i=this.c[0].toTexString(!0);s'
HTML += b'+="\\\\left|"+i+"\\\\right|";break}default:if(this.op.startsWith'
HTML += b'("var:")){let i=this.op.substring(4);switch(i){case"pi":i="\\'
HTML += b'\\pi";break}s=" "+i+" "}else{let i="warning: Node.toString(..'
HTML += b'):";i+=" unimplemented operator \'"+this.op+"\'",console.log(i'
HTML += b'),s=this.op,this.c.length>0&&(s+="\\\\left({"+this.c.map(o=>o.'
HTML += b'toTexString(!0)).join(",")+"}\\\\right)")}}return!e&&this.expl'
HTML += b'icitParentheses&&(s="\\\\left({"+s+"}\\\\right)"),s}};function h'
HTML += b"e(r,e){let t=1e-9;if(b.compare(r,e))return!0;r=r.clone(),e=e"
HTML += b".clone(),U(r.root),U(e.root);let s=new Set;r.getVars(s),e.ge"
HTML += b'tVars(s);let i=[],o=[];for(let n of s.keys())n.startsWith("C'
HTML += b'")?i.push(n):o.push(n);let l=i.length;for(let n=0;n<l;n++){l'
HTML += b'et c=i[n];r.renameVar(c,"_C"+n),e.renameVar(c,"_C"+n)}for(le'
HTML += b't n=0;n<l;n++)r.renameVar("_C"+n,"C"+n),e.renameVar("_C"+n,"'
HTML += b'C"+n);i=[];for(let n=0;n<l;n++)i.push("C"+n);let h=[];_(P(l)'
HTML += b",h);for(let n of h){let c=r.clone(),p=e.clone();for(let u=0;"
HTML += b'u<l;u++)p.renameVar("C"+u,"__C"+n[u]);for(let u=0;u<l;u++)p.'
HTML += b'renameVar("__C"+u,"C"+u);let m=!0;for(let u=0;u<l;u++){let d'
HTML += b'="C"+u,g={};g[d]=new a("*",[new a("var:C"+u,[]),new a("var:K'
HTML += b'",[])]),p.setVars(g);let v={};v[d]=a.const(Math.random(),Mat'
HTML += b'h.random());for(let C=0;C<l;C++)u!=C&&(v["C"+C]=a.const(0,0)'
HTML += b');let M=new a("abs",[new a("-",[c.root,p.root])]),E=new b;E.'
HTML += b"root=M;for(let C of o)v[C]=a.const(Math.random(),Math.random"
HTML += b'());let y=ve(E,"K",v)[0];p.setVars({K:a.const(y,0)}),v={};fo'
HTML += b'r(let C=0;C<l;C++)u!=C&&(v["C"+C]=a.const(0,0));if(b.compare'
HTML += b"(c,p,v)==!1){m=!1;break}}if(m&&b.compare(c,p))return!0}retur"
HTML += b'n!1}f(he,"compareODE");function ve(r,e,t){let s=1e-11,i=1e3,'
HTML += b"o=0,l=0,h=1,n=888;for(;o<i;){t[e]=a.const(l);let p=r.eval(t)"
HTML += b".re;t[e]=a.const(l+h);let m=r.eval(t).re;t[e]=a.const(l-h);l"
HTML += b"et u=r.eval(t).re,d=0;if(m<p&&(p=m,d=1),u<p&&(p=u,d=-1),d==1"
HTML += b"&&(l+=h),d==-1&&(l-=h),p<s)break;(d==0||d!=n)&&(h/=2),n=d,o+"
HTML += b'+}t[e]=a.const(l);let c=r.eval(t).re;return[l,c]}f(ve,"minim'
HTML += b'ize");function U(r){for(let e of r.c)U(e);switch(r.op){case"'
HTML += b'+":case"-":case"*":case"/":case"^":{let e=[r.c[0].op,r.c[1].'
HTML += b'op],t=[e[0]==="const",e[1]==="const"],s=[e[0].startsWith("va'
HTML += b'r:C"),e[1].startsWith("var:C")];s[0]&&t[1]?(r.op=r.c[0].op,r'
HTML += b".c=[]):s[1]&&t[0]?(r.op=r.c[1].op,r.c=[]):s[0]&&s[1]&&e[0]=="
HTML += b'e[1]&&(r.op=r.c[0].op,r.c=[]);break}case".-":case"abs":case"'
HTML += b'sin":case"sinc":case"cos":case"tan":case"cot":case"exp":case'
HTML += b'"ln":case"log":case"sqrt":r.c[0].op.startsWith("var:C")&&(r.'
HTML += b'op=r.c[0].op,r.c=[]);break}}f(U,"prepareODEconstantCompariso'
HTML += b'n");var A=class{static{f(this,"GapInput")}constructor(e,t,s,'
HTML += b"i){this.question=t,this.inputId=s,s.length==0&&(this.inputId"
HTML += b'=s="gap-"+t.gapIdx,t.types[this.inputId]="string",t.expected'
HTML += b'[this.inputId]=i,t.gapIdx++),s in t.student||(t.student[s]="'
HTML += b'");let o=i.split("|"),l=0;for(let p=0;p<o.length;p++){let m='
HTML += b'o[p];m.length>l&&(l=m.length)}let h=k("");e.appendChild(h);l'
HTML += b"et n=Math.max(l*15,24),c=W(n);if(t.gapInputs[this.inputId]=c"
HTML += b',c.addEventListener("keyup",()=>{t.editingEnabled!=!1&&(this'
HTML += b".question.editedQuestion(),c.value=c.value.toUpperCase(),thi"
HTML += b"s.question.student[this.inputId]=c.value.trim())}),h.appendC"
HTML += b"hild(c),this.question.showSolution&&(this.question.student[t"
HTML += b'his.inputId]=c.value=o[0],o.length>1)){let p=k("["+o.join("|'
HTML += b'")+"]");p.style.fontSize="small",p.style.textDecoration="und'
HTML += b'erline",h.appendChild(p)}}},z=class{static{f(this,"TermInput'
HTML += b'")}constructor(e,t,s,i,o,l,h=!1){s in t.student||(t.student['
HTML += b's]=""),this.question=t,this.inputId=s,this.outerSpan=k(""),t'
HTML += b'his.outerSpan.style.position="relative",e.appendChild(this.o'
HTML += b"uterSpan),this.inputElement=W(Math.max(i*12,48)),this.outerS"
HTML += b"pan.appendChild(this.inputElement),this.equationPreviewDiv=w"
HTML += b'(),this.equationPreviewDiv.classList.add("pysell-equation-pr'
HTML += b'eview"),this.equationPreviewDiv.style.display="none",this.ou'
HTML += b"terSpan.appendChild(this.equationPreviewDiv),this.inputEleme"
HTML += b'nt.addEventListener("click",()=>{if(t.editingEnabled==!1){th'
HTML += b"is.inputElement.blur();return}this.question.editedQuestion()"
HTML += b',this.edited()}),this.inputElement.addEventListener("keyup",'
HTML += b"()=>{t.editingEnabled!=!1&&(this.question.editedQuestion(),t"
HTML += b'his.edited())}),this.inputElement.addEventListener("focus",('
HTML += b")=>{t.editingEnabled!=!1}),this.inputElement.addEventListene"
HTML += b'r("focusout",()=>{this.equationPreviewDiv.innerHTML="",this.'
HTML += b'equationPreviewDiv.style.display="none"}),this.inputElement.'
HTML += b'addEventListener("keydown",n=>{if(t.editingEnabled==!1){n.pr'
HTML += b'eventDefault();return}let c="abcdefghijklmnopqrstuvwxyz";c+='
HTML += b'"ABCDEFGHIJKLMNOPQRSTUVWXYZ",c+="0123456789",c+="+-*/^(). <>'
HTML += b'=|",l&&(c="-0123456789"),n.key.length<3&&c.includes(n.key)=='
HTML += b"!1&&n.preventDefault();let p=this.inputElement.value.length*"
HTML += b"12;this.inputElement.offsetWidth<p&&(this.inputElement.style"
HTML += b'.width=""+p+"px")}),(h||this.question.showSolution)&&(t.stud'
HTML += b"ent[s]=this.inputElement.value=o)}edited(){let e=this.inputE"
HTML += b'lement.value.trim(),t="",s=!1;try{let i=b.parse(e);s=i.root.'
HTML += b'op==="const",t=i.toTexString(),this.inputElement.style.color'
HTML += b'=this.question.quiz.darkMode?"var(--pysell-white)":"var(--py'
HTML += b'sell-black)",this.equationPreviewDiv.style.backgroundColor="'
HTML += b'var(--pysell-green)"}catch{t=e.replaceAll("^","\\\\hat{~}").re'
HTML += b'placeAll("_","\\\\_"),this.inputElement.style.color="maroon",t'
HTML += b'his.equationPreviewDiv.style.backgroundColor="maroon"}N(this'
HTML += b".equationPreviewDiv,t,!0),this.equationPreviewDiv.style.disp"
HTML += b'lay=e.length>0&&!s?"block":"none",this.question.student[this'
HTML += b'.inputId]=e}},B=class{static{f(this,"MatrixInput")}construct'
HTML += b"or(e,t,s,i){this.parent=e,this.question=t,this.inputId=s,thi"
HTML += b"s.matExpected=new L(0,0),this.matExpected.fromString(i),this"
HTML += b".matStudent=new L(this.matExpected.m==1?1:3,this.matExpected"
HTML += b".n==1?1:3),t.showSolution&&this.matStudent.fromMatrix(this.m"
HTML += b"atExpected),this.genMatrixDom(!0)}genMatrixDom(e){let t=w();"
HTML += b'this.parent.innerHTML="",this.parent.appendChild(t),t.style.'
HTML += b'position="relative",t.style.display="inline-block";let s=doc'
HTML += b'ument.createElement("table");s.style.borderCollapse="collaps'
HTML += b'e",t.appendChild(s);let i=this.matExpected.getMaxCellStrlen('
HTML += b");for(let d=0;d<this.matStudent.m;d++){let g=document.create"
HTML += b'Element("tr");g.style.borderCollapse="collapse",g.style.bord'
HTML += b'erStyle="none",s.appendChild(g),d==0&&g.appendChild(this.gen'
HTML += b"erateMatrixParenthesis(!0,this.matStudent.m));for(let v=0;v<"
HTML += b"this.matStudent.n;v++){let M=d*this.matStudent.n+v,E=documen"
HTML += b't.createElement("td");E.style.borderCollapse="collapse",g.ap'
HTML += b'pendChild(E);let y=this.inputId+"-"+M;new z(E,this.question,'
HTML += b"y,i,this.matStudent.v[M],!1,!e)}d==0&&g.appendChild(this.gen"
HTML += b'erateMatrixParenthesis(!1,this.matStudent.m))}let o=["+","-"'
HTML += b',"+","-"],l=[0,0,1,-1],h=[1,-1,0,0],n=[0,22,888,888],c=[888,'
HTML += b"888,-23,-23],p=[-22,-22,0,22],m=[this.matExpected.n!=1,this."
HTML += b"matExpected.n!=1,this.matExpected.m!=1,this.matExpected.m!=1"
HTML += b"],u=[this.matStudent.n>=10,this.matStudent.n<=1,this.matStud"
HTML += b"ent.m>=10,this.matStudent.m<=1];for(let d=0;d<4;d++){if(m[d]"
HTML += b'==!1)continue;let g=k(o[d]);n[d]!=888&&(g.style.top=""+n[d]+'
HTML += b'"px"),c[d]!=888&&(g.style.bottom=""+c[d]+"px"),p[d]!=888&&(g'
HTML += b'.style.right=""+p[d]+"px"),g.classList.add("pysell-matrix-re'
HTML += b'size-button"),t.appendChild(g),u[d]?g.style.opacity="0.5":g.'
HTML += b'addEventListener("click",()=>{for(let v=0;v<this.matStudent.'
HTML += b"m;v++)for(let M=0;M<this.matStudent.n;M++){let E=v*this.matS"
HTML += b'tudent.n+M,y=this.inputId+"-"+E,S=this.question.student[y];t'
HTML += b"his.matStudent.v[E]=S,delete this.question.student[y]}this.m"
HTML += b"atStudent.resize(this.matStudent.m+l[d],this.matStudent.n+h["
HTML += b'd],""),this.genMatrixDom(!1)})}}generateMatrixParenthesis(e,'
HTML += b't){let s=document.createElement("td");s.style.width="3px";fo'
HTML += b'r(let i of["Top",e?"Left":"Right","Bottom"])s.style["border"'
HTML += b'+i+"Width"]="2px",s.style["border"+i+"Style"]="solid";return'
HTML += b' this.question.language=="de"&&(e?s.style.borderTopLeftRadiu'
HTML += b's="5px":s.style.borderTopRightRadius="5px",e?s.style.borderB'
HTML += b'ottomLeftRadius="5px":s.style.borderBottomRightRadius="5px")'
HTML += b",s.rowSpan=t,s}};var x={init:0,errors:1,passed:2,incomplete:"
HTML += b'3},q=class{static{f(this,"Question")}constructor(e,t,s,i,o){'
HTML += b"this.quiz=e,this.state=x.init,this.language=i,this.src=s,thi"
HTML += b"s.debug=o,this.instanceOrder=P(s.instances.length,!0),this.i"
HTML += b"nstanceIdx=0,this.choiceIdx=0,this.includesSingleChoice=!1,t"
HTML += b"his.gapIdx=0,this.expected={},this.types={},this.student={},"
HTML += b"this.gapInputs={},this.parentDiv=t,this.questionDiv=null,thi"
HTML += b"s.feedbackPopupDiv=null,this.titleDiv=null,this.checkAndRepe"
HTML += b"atBtn=null,this.showSolution=!1,this.feedbackSpan=null,this."
HTML += b"numCorrect=0,this.numChecked=0,this.hasCheckButton=!0,this.e"
HTML += b"ditingEnabled=!0}reset(){this.gapIdx=0,this.choiceIdx=0,this"
HTML += b".instanceIdx=(this.instanceIdx+1)%this.src.instances.length}"
HTML += b"getCurrentInstance(){let e=this.instanceOrder[this.instanceI"
HTML += b"dx];return this.src.instances[e]}editedQuestion(){this.state"
HTML += b"=x.init,this.updateVisualQuestionState();let e=this.quiz.dar"
HTML += b'kMode?"var(--pysell-white)":"var(--pysell-black)";this.quest'
HTML += b"ionDiv.style.color=e,this.checkAndRepeatBtn.innerHTML=this.q"
HTML += b'uiz.darkMode?D.replace("white","black"):D,this.checkAndRepea'
HTML += b'tBtn.style.display="block",this.checkAndRepeatBtn.style.colo'
HTML += b'r=e}updateVisualQuestionState(){let e=this.quiz.darkMode?"va'
HTML += b'r(--pysell-white)":"var(--pysell-black)",t="transparent";swi'
HTML += b'tch(this.state){case x.init:e=this.quiz.darkMode?"var(--pyse'
HTML += b'll-white)":"var(--pysell-black)";break;case x.passed:e="var('
HTML += b'--pysell-green)",t="rgba(0,150,0, 0.035)";break;case x.incom'
HTML += b'plete:case x.errors:e="var(--pysell-red)",t="rgba(150,0,0, 0'
HTML += b'.035)",this.includesSingleChoice==!1&&this.numChecked>=5&&(t'
HTML += b'his.feedbackSpan.innerHTML="&nbsp;&nbsp;"+this.numCorrect+" '
HTML += b'/ "+this.numChecked);break}this.questionDiv.style.background'
HTML += b"Color=t,this.questionDiv.style.borderColor=e}populateDom(e=!"
HTML += b'1){if(this.parentDiv.innerHTML="",this.questionDiv=w(),this.'
HTML += b"parentDiv.appendChild(this.questionDiv),this.questionDiv.cla"
HTML += b'ssList.add("pysell-question"),this.questionDiv.style.borderC'
HTML += b'olor=this.quiz.darkMode?"var(--pysell-white)":"var(--pysell-'
HTML += b'black)",this.feedbackPopupDiv=w(),this.feedbackPopupDiv.clas'
HTML += b'sList.add("pysell-question-feedback"),this.questionDiv.appen'
HTML += b"dChild(this.feedbackPopupDiv),this.feedbackPopupDiv.innerHTM"
HTML += b'L="awesome",this.debug&&"src_line"in this.src){let i=w();i.c'
HTML += b'lassList.add("pysell-debug-info"),i.innerHTML="Source code: '
HTML += b'lines "+this.src.src_line+"..",this.questionDiv.appendChild('
HTML += b"i)}if(this.titleDiv=w(),this.questionDiv.appendChild(this.ti"
HTML += b'tleDiv),this.titleDiv.classList.add("pysell-question-title")'
HTML += b',this.titleDiv.style.color=this.quiz.darkMode?"var(--pysell-'
HTML += b'white)":"var(--pysell-black)",this.titleDiv.innerHTML=this.s'
HTML += b"rc.title,this.src.error.length>0){let i=k(this.src.error);th"
HTML += b'is.questionDiv.appendChild(i),i.style.color="red";return}let'
HTML += b' t=this.getCurrentInstance();if(t!=null&&"__svg_image"in t){'
HTML += b"let i=t.__svg_image.v,o=w();this.questionDiv.appendChild(o);"
HTML += b'let l=document.createElement("img");o.appendChild(l),l.class'
HTML += b'List.add("pysell-img"),l.src="data:image/svg+xml;base64,"+i}'
HTML += b"for(let i of this.src.text.c)this.questionDiv.appendChild(th"
HTML += b'is.generateText(i));let s=w();if(s.innerHTML="",s.classList.'
HTML += b'add("pysell-button-group"),this.questionDiv.appendChild(s),t'
HTML += b"his.hasCheckButton=Object.keys(this.expected).length>0,this."
HTML += b"hasCheckButton&&(this.checkAndRepeatBtn=se(),s.appendChild(t"
HTML += b"his.checkAndRepeatBtn),this.checkAndRepeatBtn.innerHTML=this"
HTML += b'.quiz.darkMode?D.replace("white","black"):D,this.checkAndRep'
HTML += b'eatBtn.style.backgroundColor=this.quiz.darkMode?"var(--pysel'
HTML += b'l-white)":"var(--pysell-black)",e&&(this.checkAndRepeatBtn.s'
HTML += b'tyle.height="32px",this.checkAndRepeatBtn.style.visibility="'
HTML += b'hidden")),this.feedbackSpan=k(""),this.feedbackSpan.style.us'
HTML += b'erSelect="none",s.appendChild(this.feedbackSpan),this.debug)'
HTML += b'{if(this.src.variables.length>0){let l=w();l.classList.add("'
HTML += b'pysell-debug-info"),l.innerHTML="Variables generated by Pyth'
HTML += b'on Code",this.questionDiv.appendChild(l);let h=w();h.classLi'
HTML += b'st.add("pysell-debug-code"),this.questionDiv.appendChild(h);'
HTML += b'let n=this.getCurrentInstance(),c="",p=[...this.src.variable'
HTML += b"s];p.sort();for(let m of p){let u=n[m].t,d=n[m].v;switch(u){"
HTML += b'case"vector":d="["+d+"]";break;case"set":d="{"+d+"}";break}c'
HTML += b'+=u+" "+m+" = "+d+"<br/>"}h.innerHTML=c}let i=["python_src_h'
HTML += b'tml","text_src_html"],o=["Python Source Code","Text Source C'
HTML += b'ode"];for(let l=0;l<i.length;l++){let h=i[l];if(h in this.sr'
HTML += b'c&&this.src[h].length>0){let n=w();n.classList.add("pysell-d'
HTML += b'ebug-info"),n.innerHTML=o[l],this.questionDiv.appendChild(n)'
HTML += b';let c=w();c.classList.add("pysell-debug-code"),this.questio'
HTML += b"nDiv.append(c),c.innerHTML=this.src[h]}}}this.hasCheckButton"
HTML += b'&&this.checkAndRepeatBtn.addEventListener("click",()=>{this.'
HTML += b"state==x.passed?(this.state=x.init,this.editingEnabled=!0,th"
HTML += b"is.reset(),this.populateDom()):V(this)})}generateMathString("
HTML += b'e){let t="";switch(e.t){case"math":case"display-math":for(le'
HTML += b't s of e.c){let i=this.generateMathString(s);s.t==="var"&&t.'
HTML += b'includes("!PM")&&(i.startsWith("{-")?(i="{"+i.substring(2),t'
HTML += b'=t.replaceAll("!PM","-")):t=t.replaceAll("!PM","+")),t+=i}br'
HTML += b'eak;case"text":return e.d;case"plus_minus":{t+=" !PM ";break'
HTML += b'}case"var":{let s=this.getCurrentInstance(),i=s[e.d].t,o=s[e'
HTML += b'.d].v;switch(i){case"vector":return"\\\\left["+o+"\\\\right]";ca'
HTML += b'se"set":return"\\\\left\\\\{"+o+"\\\\right\\\\}";case"complex":{let '
HTML += b'l=o.split(","),h=parseFloat(l[0]),n=parseFloat(l[1]);return '
HTML += b'a.const(h,n).toTexString()}case"matrix":{let l=new L(0,0);re'
HTML += b'turn l.fromString(o),t=l.toTeXString(e.d.includes("augmented'
HTML += b'"),this.language!="de"),t}case"term":{try{t=b.parse(o).toTex'
HTML += b'String()}catch{}break}default:t=o}}}return e.t==="plus_minus'
HTML += b'"?t:"{"+t+"}"}generateText(e,t=!1){switch(e.t){case"paragrap'
HTML += b'h":case"span":{let s=document.createElement(e.t=="span"||t?"'
HTML += b'span":"p");for(let i of e.c)s.appendChild(this.generateText('
HTML += b'i));return s.style.userSelect="none",s}case"text":return k(e'
HTML += b'.d);case"code":{let s=k(e.d);return s.classList.add("pysell-'
HTML += b'code"),s}case"code-block":{let s=w();return s.classList.add('
HTML += b'"pysell-code-block"),s.innerHTML=e.d.replaceAll(`\n`,"<br/>")'
HTML += b'.replaceAll(" ","&nbsp;"),s}case"italic":case"bold":{let s=k'
HTML += b'("");return s.append(...e.c.map(i=>this.generateText(i))),e.'
HTML += b't==="bold"?s.style.fontWeight="bold":s.style.fontStyle="ital'
HTML += b'ic",s}case"math":case"display-math":{let s=this.generateMath'
HTML += b'String(e);return T(s,e.t==="display-math")}case"string_var":'
HTML += b'{let s=k(""),i=this.getCurrentInstance(),o=i[e.d].t,l=i[e.d]'
HTML += b'.v;return o==="string"?s.innerHTML=l:(s.innerHTML="EXPECTED '
HTML += b'VARIABLE OF TYPE STRING",s.style.color="red"),s}case"gap":{l'
HTML += b'et s=k("");return new A(s,this,"",e.d),s}case"input":case"in'
HTML += b'put2":{let s=e.t==="input2",i=k("");i.style.verticalAlign="t'
HTML += b'ext-bottom";let o=e.d,l=this.getCurrentInstance()[o];if(this'
HTML += b'.expected[o]=l.v,this.types[o]=l.t,!s)switch(l.t){case"set":'
HTML += b'i.append(T("\\\\{"),k(" "));break;case"vector":i.append(T("[")'
HTML += b',k(" "));break}if(l.t==="string")new A(i,this,o,this.expecte'
HTML += b'd[o]);else if(l.t==="vector"||l.t==="set"){let h=l.v.split("'
HTML += b',"),n=h.length;for(let c=0;c<n;c++){c>0&&i.appendChild(k(" ,'
HTML += b' "));let p=o+"-"+c;new z(i,this,p,h[c].length,h[c],!1)}}else'
HTML += b' if(l.t==="matrix"){let h=w();i.appendChild(h),new B(h,this,'
HTML += b'o,l.v)}else if(l.t==="complex"){let h=l.v.split(",");new z(i'
HTML += b',this,o+"-0",h[0].length,h[0],!1),i.append(k(" "),T("+"),k("'
HTML += b' ")),new z(i,this,o+"-1",h[1].length,h[1],!1),i.append(k(" "'
HTML += b'),T("i"))}else{let h=l.t==="int";new z(i,this,o,l.v.length,l'
HTML += b'.v,h)}if(!s)switch(l.t){case"set":i.append(k(" "),T("\\\\}"));'
HTML += b'break;case"vector":i.append(k(" "),T("]"));break}return i}ca'
HTML += b'se"itemize":return te(e.c.map(s=>ie(this.generateText(s))));'
HTML += b'case"single-choice":case"multi-choice":{let s=e.t=="multi-ch'
HTML += b'oice";s||(this.includesSingleChoice=!0);let i=document.creat'
HTML += b'eElement("table");i.style.border="none",i.style.borderCollap'
HTML += b'se="collapse";let o=e.c.length,l=this.debug==!1,h=P(o,l),n=s'
HTML += b'?ae:oe,c=s?re:le;this.quiz.darkMode&&(n=n.replace("black","w'
HTML += b'hite"),c=c.replace("black","white"));let p=[],m=[];for(let u'
HTML += b'=0;u<o;u++){let d=h[u],g=e.c[d],v="mc-"+this.choiceIdx+"-"+d'
HTML += b';m.push(v);let M=g.c[0].t=="bool"?g.c[0].d:this.getCurrentIn'
HTML += b'stance()[g.c[0].d].v;this.expected[v]=M,this.types[v]="bool"'
HTML += b',this.student[v]=this.showSolution?M:"false";let E=this.gene'
HTML += b'rateText(g.c[1],!0),y=document.createElement("tr");i.appendC'
HTML += b'hild(y),y.style.cursor="pointer",y.style.borderStyle="none";'
HTML += b'let S=document.createElement("td");S.style.width="40px",p.pu'
HTML += b'sh(S),y.appendChild(S),S.innerHTML=this.student[v]=="true"?n'
HTML += b':c;let C=document.createElement("td");y.appendChild(C),C.app'
HTML += b'endChild(E),s?y.addEventListener("click",()=>{this.editingEn'
HTML += b"abled!=!1&&(this.editedQuestion(),this.student[v]=this.stude"
HTML += b'nt[v]==="true"?"false":"true",this.student[v]==="true"?S.inn'
HTML += b'erHTML=n:S.innerHTML=c)}):y.addEventListener("click",()=>{if'
HTML += b"(this.editingEnabled!=!1){this.editedQuestion();for(let I of"
HTML += b' m)this.student[I]="false";this.student[v]="true";for(let I='
HTML += b"0;I<m.length;I++){let j=h[I];p[j].innerHTML=this.student[m[j"
HTML += b']]=="true"?n:c}}})}return this.choiceIdx++,i}case"image":{le'
HTML += b't s=w(),o=e.d.split("."),l=o[o.length-1],h=e.c[0].d,n=e.c[1]'
HTML += b'.d,c=document.createElement("img");s.appendChild(c),c.classL'
HTML += b'ist.add("pysell-img"),c.style.width=h+"%";let p={svg:"svg+xm'
HTML += b'l",png:"png",jpg:"jpeg"};return c.src="data:image/"+p[l]+";b'
HTML += b'ase64,"+n,s}default:{let s=k("UNIMPLEMENTED("+e.t+")");retur'
HTML += b'n s.style.color="red",s}}}};function V(r){r.feedbackSpan.inn'
HTML += b'erHTML="",r.numChecked=0,r.numCorrect=0;let e=!0;for(let i i'
HTML += b"n r.expected){let o=r.types[i],l=r.student[i],h=r.expected[i"
HTML += b'];switch(l!=null&&l.length==0&&(e=!1),o){case"bool":r.numChe'
HTML += b"cked++,l.toLowerCase()===h.toLowerCase()&&r.numCorrect++;bre"
HTML += b'ak;case"string":{r.numChecked++;let n=r.gapInputs[i],c=l.tri'
HTML += b'm().toUpperCase(),p=h.trim().toUpperCase().split("|"),m=!1;f'
HTML += b"or(let u of p)if(ne(c,u)<=1){m=!0,r.numCorrect++,r.gapInputs"
HTML += b'[i].value=u,r.student[i]=u;break}n.style.color=m?"black":"wh'
HTML += b'ite",n.style.backgroundColor=m?"transparent":"maroon";break}'
HTML += b'case"int":r.numChecked++,Math.abs(parseFloat(l)-parseFloat(h'
HTML += b'))<1e-9&&r.numCorrect++;break;case"float":case"term":{r.numC'
HTML += b"hecked++;try{let n=b.parse(h),c=b.parse(l),p=!1;r.src.is_ode"
HTML += b"?p=he(n,c):p=b.compare(n,c),p&&r.numCorrect++}catch(n){r.deb"
HTML += b'ug&&(console.log("term invalid"),console.log(n))}break}case"'
HTML += b'vector":case"complex":case"set":{let n=h.split(",");r.numChe'
HTML += b"cked+=n.length;let c=[];for(let p=0;p<n.length;p++){let m=r."
HTML += b'student[i+"-"+p];m.length==0&&(e=!1),c.push(m)}if(o==="set")'
HTML += b"for(let p=0;p<n.length;p++)try{let m=b.parse(n[p]);for(let u"
HTML += b"=0;u<c.length;u++){let d=b.parse(c[u]);if(b.compare(m,d)){r."
HTML += b"numCorrect++;break}}}catch(m){r.debug&&console.log(m)}else f"
HTML += b"or(let p=0;p<n.length;p++)try{let m=b.parse(c[p]),u=b.parse("
HTML += b"n[p]);b.compare(m,u)&&r.numCorrect++}catch(m){r.debug&&conso"
HTML += b'le.log(m)}break}case"matrix":{let n=new L(0,0);n.fromString('
HTML += b"h),r.numChecked+=n.m*n.n;for(let c=0;c<n.m;c++)for(let p=0;p"
HTML += b'<n.n;p++){let m=c*n.n+p;l=r.student[i+"-"+m],l!=null&&l.leng'
HTML += b"th==0&&(e=!1);let u=n.v[m];try{let d=b.parse(u),g=b.parse(l)"
HTML += b";b.compare(d,g)&&r.numCorrect++}catch(d){r.debug&&console.lo"
HTML += b'g(d)}}break}default:r.feedbackSpan.innerHTML="UNIMPLEMENTED '
HTML += b'EVAL OF TYPE "+o}}e==!1?r.state=x.incomplete:r.state=r.numCo'
HTML += b"rrect==r.numChecked?x.passed:x.errors,r.updateVisualQuestion"
HTML += b"State();let t=[];switch(r.state){case x.passed:t=Z[r.languag"
HTML += b"e];break;case x.incomplete:t=X[r.language];break;case x.erro"
HTML += b"rs:t=Y[r.language];break}let s=t[Math.floor(Math.random()*t."
HTML += b"length)];r.feedbackPopupDiv.innerHTML=s,r.feedbackPopupDiv.s"
HTML += b'tyle.color=r.state===x.passed?"var(--pysell-green)":"var(--p'
HTML += b'ysell-red)",r.feedbackPopupDiv.style.display="flex",setTimeo'
HTML += b'ut(()=>{r.feedbackPopupDiv.style.display="none"},1e3),r.edit'
HTML += b"ingEnabled=!0,r.state===x.passed?(r.editingEnabled=!1,r.src."
HTML += b"instances.length>1?r.checkAndRepeatBtn.innerHTML=r.quiz.dark"
HTML += b'Mode?Q.replace("white","black"):Q:r.checkAndRepeatBtn.style.'
HTML += b'visibility="hidden"):r.checkAndRepeatBtn!=null&&(r.checkAndR'
HTML += b'epeatBtn.innerHTML=r.quiz.darkMode?D.replace("white","black"'
HTML += b'):D)}f(V,"evalQuestion");var R=class{static{f(this,"Quiz")}c'
HTML += b"onstructor(e,t,s,i=!1,o=!0){if(this.quizSrc=e,this.htmlEleme"
HTML += b'nts=t,["en","de","es","it","fr"].includes(this.quizSrc.lang)'
HTML += b'==!1&&(this.quizSrc.lang="en"),this.debug=s,this.darkMode=i,'
HTML += b"this.questionNumbering=o,this.questions=[],this.timeLeft=e.t"
HTML += b"imer,this.timeLimited=e.timer>0,this.fillPageMetadata(),this"
HTML += b'.timeLimited){let l=t.timerInfo;l.classList.add("pysell-time'
HTML += b'r-info");let h=document.createElement("span");h.innerHTML=ee'
HTML += b"[this.quizSrc.lang],l.appendChild(h),l.appendChild(document."
HTML += b'createElement("br")),l.appendChild(document.createElement("b'
HTML += b'r"));let n=document.createElement("button");n.classList.add('
HTML += b'"pysell-button pysell-start-button"),n.innerHTML="Start",n.a'
HTML += b'ddEventListener("click",()=>{l.style.display="none",this.gen'
HTML += b"erateQuestions(),this.runTimer()}),l.appendChild(n)}else thi"
HTML += b's.generateQuestions()}fillPageMetadata(){if("date"in this.ht'
HTML += b"mlElements){let e=this.htmlElements.date;e.innerHTML=this.qu"
HTML += b'izSrc.date}if("header"in this.htmlElements){let e=this.htmlE'
HTML += b'lements.header,t=document.createElement("h1");t.innerHTML=th'
HTML += b'is.quizSrc.title.split(" -- ").join("<br/>"),e.appendChild(t'
HTML += b');let s=document.createElement("div");s.style.marginTop="15p'
HTML += b'x",e.appendChild(s);let i=document.createElement("div");i.cl'
HTML += b'assList.add("pysell-author"),i.innerHTML=this.quizSrc.author'
HTML += b',e.appendChild(i);let o=document.createElement("p");if(o.cla'
HTML += b'ssList.add("pysell-course-info"),e.appendChild(o),this.quizS'
HTML += b"rc.info.length>0)o.innerHTML=this.quizSrc.info;else{o.innerH"
HTML += b"TML=F[this.quizSrc.lang];let l='<span onclick=\"location.relo"
HTML += b'ad()" style="text-decoration: none; font-weight: bold; curso'
HTML += b'r: pointer">\'+K[this.quizSrc.lang]+"</span>",h=document.crea'
HTML += b'teElement("p");h.classList.add("pysell-course-info"),e.appen'
HTML += b'dChild(h),h.innerHTML=O[this.quizSrc.lang].replace("*",l)}if'
HTML += b'(this.debug){let l=document.createElement("h1");l.classList.'
HTML += b'add("pysell-debug-code"),l.innerHTML="DEBUG VERSION",e.appen'
HTML += b"dChild(l)}}}generateQuestions(){let e=1;for(let t of this.qu"
HTML += b'izSrc.questions){let s=t.title;this.questionNumbering&&(s=""'
HTML += b'+e+". "+s),t.title=s;let i=w();this.htmlElements.questions.a'
HTML += b"ppendChild(i);let o=new q(this,i,t,this.quizSrc.lang,this.de"
HTML += b"bug);o.showSolution=this.debug,this.questions.push(o),o.popu"
HTML += b"lateDom(this.timeLimited),this.debug&&t.error.length==0&&o.h"
HTML += b"asCheckButton&&o.checkAndRepeatBtn.click(),e++}}runTimer(){l"
HTML += b'et e=this.htmlElements.timerFooter;e.style.textAlign="center'
HTML += b'";let t=document.createElement("button");t.classList.add("py'
HTML += b'sell-button"),t.style.backgroundColor="var(--pysell-green)",'
HTML += b't.innerHTML=J[this.quizSrc.lang],t.addEventListener("click",'
HTML += b"()=>{this.timeLeft=1}),e.appendChild(t);let s=this.htmlEleme"
HTML += b'nts.timer;s.classList.add("pysell-timer"),s.innerHTML=ce(thi'
HTML += b"s.timeLeft);let i=setInterval(()=>{this.timeLeft--,s.innerHT"
HTML += b"ML=ce(this.timeLeft),this.timeLeft<=0&&this.stopTimer(i)},1e"
HTML += b"3)}stopTimer(e){let t=this.htmlElements.timerFooter;t.style."
HTML += b'display="none",clearInterval(e);let s=0,i=0;for(let h of thi'
HTML += b"s.questions){let n=h.src.points;i+=n,V(h),h.state===x.passed"
HTML += b"&&(s+=n),h.editingEnabled=!1}let o=this.htmlElements.timerEv"
HTML += b'al;o.classList.add("pysell-eval");let l=document.createEleme'
HTML += b'nt("h1");o.appendChild(l),l.innerHTML=i==0?"":""+s+" / "+i+"'
HTML += b' "+G[this.quizSrc.lang]+" <br/><br/>"+Math.round(s/i*100)+" '
HTML += b'%"}};function ce(r){let e=Math.floor(r/60),t=r%60;return e+"'
HTML += b':"+(""+t).padStart(2,"0")}f(ce,"formatTime");function be(r,e'
HTML += b'){let t={date:document.getElementById("date"),header:documen'
HTML += b't.getElementById("header"),questions:document.getElementById'
HTML += b'("questions"),timer:document.getElementById("timer"),timerIn'
HTML += b'fo:document.getElementById("timer-info"),timerFooter:documen'
HTML += b't.getElementById("timer-footer"),timerEval:document.getEleme'
HTML += b'ntById("timer-eval")};new R(r,t,e),document.getElementById("'
HTML += b'data-policy").innerHTML=$[r.lang]}f(be,"init");return ge(ke)'
HTML += b";})();pysell.init(quizSrc,debug);</script></body> </html> "
HTML = HTML.decode("utf-8")
# @end(html)


def main(args):
    """the main function"""

    silent_mode = "-S" in args

    if silent_mode is False:
        print("---------------------------------------------------------------------")
        print("pySELL by Andreas Schwenk - Licensed under GPLv3 - https://pysell.org")
        print("---------------------------------------------------------------------")

    # get input and output path
    if len(args) < 2:
        print("USAGE: pysell [-J] [-S] INPUT_PATH.txt")
        print("   option -J enables to output a JSON file for debugging purposes")
        print("   option -S enables silent mode, i.e. prevents info logs")
        print("EXAMPLE: pysell my-quiz.txt")
        print(
            "   compiles quiz definition in file 'my-quiz.txt' to file 'my-quiz.html'"
        )
        sys.exit(-1)
    write_explicit_json_file = "-J" in args
    input_path = args[-1]
    input_dirname = os.path.dirname(input_path)
    output_path = input_path.replace(".txt", ".html")
    output_debug_path = input_path.replace(".txt", "_DEBUG.html")
    output_json_path = input_path.replace(".txt", ".json")
    if os.path.isfile(input_path) is False:
        print("error: input file path does not exist")
        sys.exit(-1)

    # read input
    input_src: str = ""
    with open(input_path, mode="r", encoding="utf-8") as f:
        input_src = f.read()

    # compile
    out = compile_input_file(input_dirname, input_src)
    output_debug_json = json.dumps(out)
    output_debug_json_formatted = json.dumps(out, indent=2)
    for question in out["questions"]:
        del question["src_line"]
        del question["text_src_html"]
        del question["python_src_html"]
        del question["python_src_tokens"]
    output_json = json.dumps(out)

    # write test output
    if write_explicit_json_file:
        with open(output_json_path, "w", encoding="utf-8") as f:
            f.write(output_debug_json_formatted)

    # write html
    # (a) debug version (*_DEBUG.html)
    with open(output_debug_path, "w", encoding="utf-8") as f:
        f.write(
            HTML.replace(
                "let quizSrc = {};", "let quizSrc = " + output_debug_json + ";"
            ).replace("let debug = false;", "let debug = true;")
        )
    # (b) release version (*.html)
    with open(output_path, "w", encoding="utf-8") as f:
        f.write(
            HTML.replace(
                "let quizSrc = {};",
                "/*@PYSELL_JSON@*/let quizSrc = " + output_json + ";/*@PYSELL_JSON@*/",
            )
        )

    # exit normally
    return


if __name__ == "__main__":
    main(sys.argv)
    sys.exit(0)