jaclang 0.5.11__py3-none-any.whl → 0.5.16__py3-none-any.whl

jaclang/compiler/generated/jac_parser.py

@@ -0,0 +1,4069 @@
+# The file was automatically generated by Lark v1.1.9
+__version__ = "1.1.9"
+
+#
+#
+#   Lark Stand-alone Generator Tool
+# ----------------------------------
+# Generates a stand-alone LALR(1) parser
+#
+# Git:    https://github.com/erezsh/lark
+# Author: Erez Shinan (erezshin@gmail.com)
+#
+#
+#    >>> LICENSE
+#
+#    This tool and its generated code use a separate license from Lark,
+#    and are subject to the terms of the Mozilla Public License, v. 2.0.
+#    If a copy of the MPL was not distributed with this
+#    file, You can obtain one at https://mozilla.org/MPL/2.0/.
+#
+#    If you wish to purchase a commercial license for this tool and its
+#    generated code, you may contact me via email or otherwise.
+#
+#    If MPL2 is incompatible with your free or open-source project,
+#    contact me and we'll work it out.
+#
+#
+
+from copy import deepcopy
+from abc import ABC, abstractmethod
+from types import ModuleType
+from typing import (
+    TypeVar,
+    Generic,
+    Type,
+    Tuple,
+    List,
+    Dict,
+    Iterator,
+    Collection,
+    Callable,
+    Optional,
+    FrozenSet,
+    Any,
+    Union,
+    Iterable,
+    IO,
+    TYPE_CHECKING,
+    overload,
+    Sequence,
+    Pattern as REPattern,
+    ClassVar,
+    Set,
+    Mapping,
+)
+
+
+
+
+class LarkError(Exception):
+    pass
+
+
+class ConfigurationError(LarkError, ValueError):
+    pass
+
+
+def assert_config(value, options: Collection, msg="Got %r, expected one of %s"):
+    if value not in options:
+        raise ConfigurationError(msg % (value, options))
+
+
+class GrammarError(LarkError):
+    pass
+
+
+class ParseError(LarkError):
+    pass
+
+
+class LexError(LarkError):
+    pass
+
+
+T = TypeVar("T")
+
+
+class UnexpectedInput(LarkError):
+    #--
+
+    line: int
+    column: int
+    pos_in_stream = None
+    state: Any
+    _terminals_by_name = None
+    interactive_parser: "InteractiveParser"
+
+    def get_context(self, text: str, span: int = 40) -> str:
+        #--
+        assert self.pos_in_stream is not None, self
+        pos = self.pos_in_stream
+        start = max(pos - span, 0)
+        end = pos + span
+        if not isinstance(text, bytes):
+            before = text[start:pos].rsplit("\n", 1)[-1]
+            after = text[pos:end].split("\n", 1)[0]
+            return before + after + "\n" + " " * len(before.expandtabs()) + "^\n"
+        else:
+            before = text[start:pos].rsplit(b"\n", 1)[-1]
+            after = text[pos:end].split(b"\n", 1)[0]
+            return (
+                before + after + b"\n" + b" " * len(before.expandtabs()) + b"^\n"
+            ).decode("ascii", "backslashreplace")
+
+    def match_examples(
+        self,
+        parse_fn: "Callable[[str], Tree]",
+        examples: Union[Mapping[T, Iterable[str]], Iterable[Tuple[T, Iterable[str]]]],
+        token_type_match_fallback: bool = False,
+        use_accepts: bool = True,
+    ) -> Optional[T]:
+        #--
+        assert self.state is not None, "Not supported for this exception"
+
+        if isinstance(examples, Mapping):
+            examples = examples.items()
+
+        candidate = (None, False)
+        for i, (label, example) in enumerate(examples):
+            assert not isinstance(example, str), "Expecting a list"
+
+            for j, malformed in enumerate(example):
+                try:
+                    parse_fn(malformed)
+                except UnexpectedInput as ut:
+                    if ut.state == self.state:
+                        if (
+                            use_accepts
+                            and isinstance(self, UnexpectedToken)
+                            and isinstance(ut, UnexpectedToken)
+                            and ut.accepts != self.accepts
+                        ):
+                            logger.debug(
+                                "Different accepts with same state[%d]: %s != %s at example [%s][%s]"
+                                % (self.state, self.accepts, ut.accepts, i, j)
+                            )
+                            continue
+                        if isinstance(
+                            self, (UnexpectedToken, UnexpectedEOF)
+                        ) and isinstance(ut, (UnexpectedToken, UnexpectedEOF)):
+                            if ut.token == self.token:  ##
+
+                                logger.debug("Exact Match at example [%s][%s]" % (i, j))
+                                return label
+
+                            if token_type_match_fallback:
+                                ##
+
+                                if (ut.token.type == self.token.type) and not candidate[
+                                    -1
+                                ]:
+                                    logger.debug(
+                                        "Token Type Fallback at example [%s][%s]"
+                                        % (i, j)
+                                    )
+                                    candidate = label, True
+
+                        if candidate[0] is None:
+                            logger.debug(
+                                "Same State match at example [%s][%s]" % (i, j)
+                            )
+                            candidate = label, False
+
+        return candidate[0]
+
+    def _format_expected(self, expected):
+        if self._terminals_by_name:
+            d = self._terminals_by_name
+            expected = [
+                d[t_name].user_repr() if t_name in d else t_name for t_name in expected
+            ]
+        return "Expected one of: \n\t* %s\n" % "\n\t* ".join(expected)
+
+
+class UnexpectedEOF(ParseError, UnexpectedInput):
+    #--
+
+    expected: "List[Token]"
+
+    def __init__(self, expected, state=None, terminals_by_name=None):
+        super(UnexpectedEOF, self).__init__()
+
+        self.expected = expected
+        self.state = state
+        from .lexer import Token
+
+        self.token = Token("<EOF>", "")  ##
+
+        self.pos_in_stream = -1
+        self.line = -1
+        self.column = -1
+        self._terminals_by_name = terminals_by_name
+
+    def __str__(self):
+        message = "Unexpected end-of-input. "
+        message += self._format_expected(self.expected)
+        return message
+
+
+class UnexpectedCharacters(LexError, UnexpectedInput):
+    #--
+
+    allowed: Set[str]
+    considered_tokens: Set[Any]
+
+    def __init__(
+        self,
+        seq,
+        lex_pos,
+        line,
+        column,
+        allowed=None,
+        considered_tokens=None,
+        state=None,
+        token_history=None,
+        terminals_by_name=None,
+        considered_rules=None,
+    ):
+        super(UnexpectedCharacters, self).__init__()
+
+        ##
+
+        self.line = line
+        self.column = column
+        self.pos_in_stream = lex_pos
+        self.state = state
+        self._terminals_by_name = terminals_by_name
+
+        self.allowed = allowed
+        self.considered_tokens = considered_tokens
+        self.considered_rules = considered_rules
+        self.token_history = token_history
+
+        if isinstance(seq, bytes):
+            self.char = seq[lex_pos : lex_pos + 1].decode("ascii", "backslashreplace")
+        else:
+            self.char = seq[lex_pos]
+        self._context = self.get_context(seq)
+
+    def __str__(self):
+        message = (
+            "No terminal matches '%s' in the current parser context, at line %d col %d"
+            % (self.char, self.line, self.column)
+        )
+        message += "\n\n" + self._context
+        if self.allowed:
+            message += self._format_expected(self.allowed)
+        if self.token_history:
+            message += "\nPrevious tokens: %s\n" % ", ".join(
+                repr(t) for t in self.token_history
+            )
+        return message
+
+
+class UnexpectedToken(ParseError, UnexpectedInput):
+    #--
+
+    expected: Set[str]
+    considered_rules: Set[str]
+
+    def __init__(
+        self,
+        token,
+        expected,
+        considered_rules=None,
+        state=None,
+        interactive_parser=None,
+        terminals_by_name=None,
+        token_history=None,
+    ):
+        super(UnexpectedToken, self).__init__()
+
+        ##
+
+        self.line = getattr(token, "line", "?")
+        self.column = getattr(token, "column", "?")
+        self.pos_in_stream = getattr(token, "start_pos", None)
+        self.state = state
+
+        self.token = token
+        self.expected = expected  ##
+
+        self._accepts = NO_VALUE
+        self.considered_rules = considered_rules
+        self.interactive_parser = interactive_parser
+        self._terminals_by_name = terminals_by_name
+        self.token_history = token_history
+
+    @property
+    def accepts(self) -> Set[str]:
+        if self._accepts is NO_VALUE:
+            self._accepts = (
+                self.interactive_parser and self.interactive_parser.accepts()
+            )
+        return self._accepts
+
+    def __str__(self):
+        message = "Unexpected token %r at line %s, column %s.\n%s" % (
+            self.token,
+            self.line,
+            self.column,
+            self._format_expected(self.accepts or self.expected),
+        )
+        if self.token_history:
+            message += "Previous tokens: %r\n" % self.token_history
+
+        return message
+
+
+class VisitError(LarkError):
+    #--
+
+    obj: "Union[Tree, Token]"
+    orig_exc: Exception
+
+    def __init__(self, rule, obj, orig_exc):
+        message = 'Error trying to process rule "%s":\n\n%s' % (rule, orig_exc)
+        super(VisitError, self).__init__(message)
+
+        self.rule = rule
+        self.obj = obj
+        self.orig_exc = orig_exc
+
+
+class MissingVariableError(LarkError):
+    pass
+
+
+
+import sys, re
+import logging
+
+logger: logging.Logger = logging.getLogger("lark")
+logger.addHandler(logging.StreamHandler())
+##
+
+##
+
+logger.setLevel(logging.CRITICAL)
+
+
+NO_VALUE = object()
+
+T = TypeVar("T")
+
+
+def classify(
+    seq: Iterable, key: Optional[Callable] = None, value: Optional[Callable] = None
+) -> Dict:
+    d: Dict[Any, Any] = {}
+    for item in seq:
+        k = key(item) if (key is not None) else item
+        v = value(item) if (value is not None) else item
+        try:
+            d[k].append(v)
+        except KeyError:
+            d[k] = [v]
+    return d
+
+
+def _deserialize(data: Any, namespace: Dict[str, Any], memo: Dict) -> Any:
+    if isinstance(data, dict):
+        if "__type__" in data:  ##
+
+            class_ = namespace[data["__type__"]]
+            return class_.deserialize(data, memo)
+        elif "@" in data:
+            return memo[data["@"]]
+        return {
+            key: _deserialize(value, namespace, memo) for key, value in data.items()
+        }
+    elif isinstance(data, list):
+        return [_deserialize(value, namespace, memo) for value in data]
+    return data
+
+
+_T = TypeVar("_T", bound="Serialize")
+
+
+class Serialize:
+    #--
+
+    def memo_serialize(self, types_to_memoize: List) -> Any:
+        memo = SerializeMemoizer(types_to_memoize)
+        return self.serialize(memo), memo.serialize()
+
+    def serialize(self, memo=None) -> Dict[str, Any]:
+        if memo and memo.in_types(self):
+            return {"@": memo.memoized.get(self)}
+
+        fields = getattr(self, "__serialize_fields__")
+        res = {f: _serialize(getattr(self, f), memo) for f in fields}
+        res["__type__"] = type(self).__name__
+        if hasattr(self, "_serialize"):
+            self._serialize(res, memo)  ##
+
+        return res
+
+    @classmethod
+    def deserialize(cls: Type[_T], data: Dict[str, Any], memo: Dict[int, Any]) -> _T:
+        namespace = getattr(cls, "__serialize_namespace__", [])
+        namespace = {c.__name__: c for c in namespace}
+
+        fields = getattr(cls, "__serialize_fields__")
+
+        if "@" in data:
+            return memo[data["@"]]
+
+        inst = cls.__new__(cls)
+        for f in fields:
+            try:
+                setattr(inst, f, _deserialize(data[f], namespace, memo))
+            except KeyError as e:
+                raise KeyError("Cannot find key for class", cls, e)
+
+        if hasattr(inst, "_deserialize"):
+            inst._deserialize()  ##
+
+
+        return inst
+
+
+class SerializeMemoizer(Serialize):
+    #--
+
+    __serialize_fields__ = ("memoized",)
+
+    def __init__(self, types_to_memoize: List) -> None:
+        self.types_to_memoize = tuple(types_to_memoize)
+        self.memoized = Enumerator()
+
+    def in_types(self, value: Serialize) -> bool:
+        return isinstance(value, self.types_to_memoize)
+
+    def serialize(self) -> Dict[int, Any]:  ##
+
+        return _serialize(self.memoized.reversed(), None)
+
+    @classmethod
+    def deserialize(cls, data: Dict[int, Any], namespace: Dict[str, Any], memo: Dict[Any, Any]) -> Dict[int, Any]:  ##
+
+        return _deserialize(data, namespace, memo)
+
+
+try:
+    import regex
+
+    _has_regex = True
+except ImportError:
+    _has_regex = False
+
+if sys.version_info >= (3, 11):
+    import re._parser as sre_parse
+    import re._constants as sre_constants
+else:
+    import sre_parse
+    import sre_constants
+
+categ_pattern = re.compile(r"\\p{[A-Za-z_]+}")
+
+
+def get_regexp_width(expr: str) -> Union[Tuple[int, int], List[int]]:
+    if _has_regex:
+        ##
+
+        ##
+
+        ##
+
+        regexp_final = re.sub(categ_pattern, "A", expr)
+    else:
+        if re.search(categ_pattern, expr):
+            raise ImportError(
+                "`regex` module must be installed in order to use Unicode categories.",
+                expr,
+            )
+        regexp_final = expr
+    try:
+        ##
+
+        return [int(x) for x in sre_parse.parse(regexp_final).getwidth()]  ##
+
+    except sre_constants.error:
+        if not _has_regex:
+            raise ValueError(expr)
+        else:
+            ##
+
+            ##
+
+            c = regex.compile(regexp_final)
+            ##
+
+            ##
+
+            MAXWIDTH = getattr(sre_parse, "MAXWIDTH", sre_constants.MAXREPEAT)
+            if c.match("") is None:
+                ##
+
+                return 1, int(MAXWIDTH)
+            else:
+                return 0, int(MAXWIDTH)
+
+
+
+from collections import OrderedDict
+
+
+class Meta:
+
+    empty: bool
+    line: int
+    column: int
+    start_pos: int
+    end_line: int
+    end_column: int
+    end_pos: int
+    orig_expansion: "List[TerminalDef]"
+    match_tree: bool
+
+    def __init__(self):
+        self.empty = True
+
+
+_Leaf_T = TypeVar("_Leaf_T")
+Branch = Union[_Leaf_T, "Tree[_Leaf_T]"]
+
+
+class Tree(Generic[_Leaf_T]):
+    #--
+
+    data: str
+    children: "List[Branch[_Leaf_T]]"
+
+    def __init__(
+        self, data: str, children: "List[Branch[_Leaf_T]]", meta: Optional[Meta] = None
+    ) -> None:
+        self.data = data
+        self.children = children
+        self._meta = meta
+
+    @property
+    def meta(self) -> Meta:
+        if self._meta is None:
+            self._meta = Meta()
+        return self._meta
+
+    def __repr__(self):
+        return "Tree(%r, %r)" % (self.data, self.children)
+
+    def _pretty_label(self):
+        return self.data
+
+    def _pretty(self, level, indent_str):
+        yield f"{indent_str*level}{self._pretty_label()}"
+        if len(self.children) == 1 and not isinstance(self.children[0], Tree):
+            yield f"\t{self.children[0]}\n"
+        else:
+            yield "\n"
+            for n in self.children:
+                if isinstance(n, Tree):
+                    yield from n._pretty(level + 1, indent_str)
+                else:
+                    yield f"{indent_str*(level+1)}{n}\n"
+
+    def pretty(self, indent_str: str = "  ") -> str:
+        #--
+        return "".join(self._pretty(0, indent_str))
+
+    def __rich__(self, parent: Optional["rich.tree.Tree"] = None) -> "rich.tree.Tree":
+        #--
+        return self._rich(parent)
+
+    def _rich(self, parent):
+        if parent:
+            tree = parent.add(f"[bold]{self.data}[/bold]")
+        else:
+            import rich.tree
+
+            tree = rich.tree.Tree(self.data)
+
+        for c in self.children:
+            if isinstance(c, Tree):
+                c._rich(tree)
+            else:
+                tree.add(f"[green]{c}[/green]")
+
+        return tree
+
+    def __eq__(self, other):
+        try:
+            return self.data == other.data and self.children == other.children
+        except AttributeError:
+            return False
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((self.data, tuple(self.children)))
+
+    def iter_subtrees(self) -> "Iterator[Tree[_Leaf_T]]":
+        #--
+        queue = [self]
+        subtrees = OrderedDict()
+        for subtree in queue:
+            subtrees[id(subtree)] = subtree
+            ##
+
+            queue += [
+                c
+                for c in reversed(subtree.children)  ##
+
+                if isinstance(c, Tree) and id(c) not in subtrees
+            ]
+
+        del queue
+        return reversed(list(subtrees.values()))
+
+    def iter_subtrees_topdown(self):
+        #--
+        stack = [self]
+        stack_append = stack.append
+        stack_pop = stack.pop
+        while stack:
+            node = stack_pop()
+            if not isinstance(node, Tree):
+                continue
+            yield node
+            for child in reversed(node.children):
+                stack_append(child)
+
+    def find_pred(
+        self, pred: "Callable[[Tree[_Leaf_T]], bool]"
+    ) -> "Iterator[Tree[_Leaf_T]]":
+        #--
+        return filter(pred, self.iter_subtrees())
+
+    def find_data(self, data: str) -> "Iterator[Tree[_Leaf_T]]":
+        #--
+        return self.find_pred(lambda t: t.data == data)
+
+
+from functools import wraps, update_wrapper
+from inspect import getmembers, getmro
+
+_Return_T = TypeVar("_Return_T")
+_Return_V = TypeVar("_Return_V")
+_Leaf_T = TypeVar("_Leaf_T")
+_Leaf_U = TypeVar("_Leaf_U")
+_R = TypeVar("_R")
+_FUNC = Callable[..., _Return_T]
+_DECORATED = Union[_FUNC, type]
+
+
+class _DiscardType:
+    #--
+
+    def __repr__(self):
+        return "lark.visitors.Discard"
+
+
+Discard = _DiscardType()
+
+##
+
+
+
+class _Decoratable:
+    #--
+
+    @classmethod
+    def _apply_v_args(cls, visit_wrapper):
+        mro = getmro(cls)
+        assert mro[0] is cls
+        libmembers = {name for _cls in mro[1:] for name, _ in getmembers(_cls)}
+        for name, value in getmembers(cls):
+
+            ##
+
+            if name.startswith("_") or (
+                name in libmembers and name not in cls.__dict__
+            ):
+                continue
+            if not callable(value):
+                continue
+
+            ##
+
+            if isinstance(cls.__dict__[name], _VArgsWrapper):
+                continue
+
+            setattr(cls, name, _VArgsWrapper(cls.__dict__[name], visit_wrapper))
+        return cls
+
+    def __class_getitem__(cls, _):
+        return cls
+
+
+class Transformer(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]):
+    #--
+
+    __visit_tokens__ = True  ##
+
+
+    def __init__(self, visit_tokens: bool = True) -> None:
+        self.__visit_tokens__ = visit_tokens
+
+    def _call_userfunc(self, tree, new_children=None):
+        ##
+
+        children = new_children if new_children is not None else tree.children
+        try:
+            f = getattr(self, tree.data)
+        except AttributeError:
+            return self.__default__(tree.data, children, tree.meta)
+        else:
+            try:
+                wrapper = getattr(f, "visit_wrapper", None)
+                if wrapper is not None:
+                    return f.visit_wrapper(f, tree.data, children, tree.meta)
+                else:
+                    return f(children)
+            except GrammarError:
+                raise
+            except Exception as e:
+                raise VisitError(tree.data, tree, e)
+
+    def _call_userfunc_token(self, token):
+        try:
+            f = getattr(self, token.type)
+        except AttributeError:
+            return self.__default_token__(token)
+        else:
+            try:
+                return f(token)
+            except GrammarError:
+                raise
+            except Exception as e:
+                raise VisitError(token.type, token, e)
+
+    def _transform_children(self, children):
+        for c in children:
+            if isinstance(c, Tree):
+                res = self._transform_tree(c)
+            elif self.__visit_tokens__ and isinstance(c, Token):
+                res = self._call_userfunc_token(c)
+            else:
+                res = c
+
+            if res is not Discard:
+                yield res
+
+    def _transform_tree(self, tree):
+        children = list(self._transform_children(tree.children))
+        return self._call_userfunc(tree, children)
+
+    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        #--
+        return self._transform_tree(tree)
+
+    def __mul__(
+        self: "Transformer[_Leaf_T, Tree[_Leaf_U]]",
+        other: "Union[Transformer[_Leaf_U, _Return_V], TransformerChain[_Leaf_U, _Return_V,]]",
+    ) -> "TransformerChain[_Leaf_T, _Return_V]":
+        #--
+        return TransformerChain(self, other)
+
+    def __default__(self, data, children, meta):
+        #--
+        return Tree(data, children, meta)
+
+    def __default_token__(self, token):
+        #--
+        return token
+
+
+def merge_transformers(base_transformer=None, **transformers_to_merge):
+    #--
+    if base_transformer is None:
+        base_transformer = Transformer()
+    for prefix, transformer in transformers_to_merge.items():
+        for method_name in dir(transformer):
+            method = getattr(transformer, method_name)
+            if not callable(method):
+                continue
+            if method_name.startswith("_") or method_name == "transform":
+                continue
+            prefixed_method = prefix + "__" + method_name
+            if hasattr(base_transformer, prefixed_method):
+                raise AttributeError(
+                    "Cannot merge: method '%s' appears more than once" % prefixed_method
+                )
+
+            setattr(base_transformer, prefixed_method, method)
+
+    return base_transformer
+
+
+class InlineTransformer(Transformer):  ##
+
+    def _call_userfunc(self, tree, new_children=None):
+        ##
+
+        children = new_children if new_children is not None else tree.children
+        try:
+            f = getattr(self, tree.data)
+        except AttributeError:
+            return self.__default__(tree.data, children, tree.meta)
+        else:
+            return f(*children)
+
+
+class TransformerChain(Generic[_Leaf_T, _Return_T]):
+
+    transformers: "Tuple[Union[Transformer, TransformerChain], ...]"
+
+    def __init__(self, *transformers: "Union[Transformer, TransformerChain]") -> None:
+        self.transformers = transformers
+
+    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        for t in self.transformers:
+            tree = t.transform(tree)
+        return cast(_Return_T, tree)
+
+    def __mul__(
+        self: "TransformerChain[_Leaf_T, Tree[_Leaf_U]]",
+        other: "Union[Transformer[_Leaf_U, _Return_V], TransformerChain[_Leaf_U, _Return_V]]",
+    ) -> "TransformerChain[_Leaf_T, _Return_V]":
+        return TransformerChain(*self.transformers + (other,))
+
+
+class Transformer_InPlace(Transformer[_Leaf_T, _Return_T]):
+    #--
+
+    def _transform_tree(self, tree):  ##
+
+        return self._call_userfunc(tree)
+
+    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        for subtree in tree.iter_subtrees():
+            subtree.children = list(self._transform_children(subtree.children))
+
+        return self._transform_tree(tree)
+
+
+class Transformer_NonRecursive(Transformer[_Leaf_T, _Return_T]):
+    #--
+
+    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        ##
+
+        rev_postfix = []
+        q: List[Branch[_Leaf_T]] = [tree]
+        while q:
+            t = q.pop()
+            rev_postfix.append(t)
+            if isinstance(t, Tree):
+                q += t.children
+
+        ##
+
+        stack: List = []
+        for x in reversed(rev_postfix):
+            if isinstance(x, Tree):
+                size = len(x.children)
+                if size:
+                    args = stack[-size:]
+                    del stack[-size:]
+                else:
+                    args = []
+
+                res = self._call_userfunc(x, args)
+                if res is not Discard:
+                    stack.append(res)
+
+            elif self.__visit_tokens__ and isinstance(x, Token):
+                res = self._call_userfunc_token(x)
+                if res is not Discard:
+                    stack.append(res)
+            else:
+                stack.append(x)
+
+        (result,) = stack  ##
+
+        ##
+
+        ##
+
+        ##
+
+        return cast(_Return_T, result)
+
+
+class Transformer_InPlaceRecursive(Transformer):
+    #--
+
+    def _transform_tree(self, tree):
+        tree.children = list(self._transform_children(tree.children))
+        return self._call_userfunc(tree)
+
+
+##
+
+
+
+class VisitorBase:
+    def _call_userfunc(self, tree):
+        return getattr(self, tree.data, self.__default__)(tree)
+
+    def __default__(self, tree):
+        #--
+        return tree
+
+    def __class_getitem__(cls, _):
+        return cls
+
+
+class Visitor(VisitorBase, ABC, Generic[_Leaf_T]):
+    #--
+
+    def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]:
+        #--
+        for subtree in tree.iter_subtrees():
+            self._call_userfunc(subtree)
+        return tree
+
+    def visit_topdown(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]:
+        #--
+        for subtree in tree.iter_subtrees_topdown():
+            self._call_userfunc(subtree)
+        return tree
+
+
+class Visitor_Recursive(VisitorBase, Generic[_Leaf_T]):
+    #--
+
+    def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]:
+        #--
+        for child in tree.children:
+            if isinstance(child, Tree):
+                self.visit(child)
+
+        self._call_userfunc(tree)
+        return tree
+
+    def visit_topdown(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]:
+        #--
+        self._call_userfunc(tree)
+
+        for child in tree.children:
+            if isinstance(child, Tree):
+                self.visit_topdown(child)
+
+        return tree
+
+
+class Interpreter(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]):
+    #--
+
+    def visit(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        ##
+
+        ##
+
+        ##
+
+        return self._visit_tree(tree)
+
+    def _visit_tree(self, tree: Tree[_Leaf_T]):
+        f = getattr(self, tree.data)
+        wrapper = getattr(f, "visit_wrapper", None)
+        if wrapper is not None:
+            return f.visit_wrapper(f, tree.data, tree.children, tree.meta)
+        else:
+            return f(tree)
+
+    def visit_children(self, tree: Tree[_Leaf_T]) -> List:
+        return [
+            self._visit_tree(child) if isinstance(child, Tree) else child
+            for child in tree.children
+        ]
+
+    def __getattr__(self, name):
+        return self.__default__
+
+    def __default__(self, tree):
+        return self.visit_children(tree)
+
+
+_InterMethod = Callable[[Type[Interpreter], _Return_T], _R]
+
+
+def visit_children_decor(func: _InterMethod) -> _InterMethod:
+    #--
+
+    @wraps(func)
+    def inner(cls, tree):
+        values = cls.visit_children(tree)
+        return func(cls, values)
+
+    return inner
+
+
+##
+
+
+
+def _apply_v_args(obj, visit_wrapper):
+    try:
+        _apply = obj._apply_v_args
+    except AttributeError:
+        return _VArgsWrapper(obj, visit_wrapper)
+    else:
+        return _apply(visit_wrapper)
+
+
+class _VArgsWrapper:
+    #--
+
+    base_func: Callable
+
+    def __init__(
+        self, func: Callable, visit_wrapper: Callable[[Callable, str, list, Any], Any]
+    ):
+        if isinstance(func, _VArgsWrapper):
+            func = func.base_func
+        ##
+
+        self.base_func = func  ##
+
+        self.visit_wrapper = visit_wrapper
+        update_wrapper(self, func)
+
+    def __call__(self, *args, **kwargs):
+        return self.base_func(*args, **kwargs)
+
+    def __get__(self, instance, owner=None):
+        try:
+            ##
+
+            ##
+
+            g = type(self.base_func).__get__
+        except AttributeError:
+            return self
+        else:
+            return _VArgsWrapper(g(self.base_func, instance, owner), self.visit_wrapper)
+
+    def __set_name__(self, owner, name):
+        try:
+            f = type(self.base_func).__set_name__
+        except AttributeError:
+            return
+        else:
+            f(self.base_func, owner, name)
+
+
+def _vargs_inline(f, _data, children, _meta):
+    return f(*children)
+
+
+def _vargs_meta_inline(f, _data, children, meta):
+    return f(meta, *children)
+
+
+def _vargs_meta(f, _data, children, meta):
+    return f(meta, children)
+
+
+def _vargs_tree(f, data, children, meta):
+    return f(Tree(data, children, meta))
+
+
+def v_args(
+    inline: bool = False,
+    meta: bool = False,
+    tree: bool = False,
+    wrapper: Optional[Callable] = None,
+) -> Callable[[_DECORATED], _DECORATED]:
+    #--
+    if tree and (meta or inline):
+        raise ValueError(
+            "Visitor functions cannot combine 'tree' with 'meta' or 'inline'."
+        )
+
+    func = None
+    if meta:
+        if inline:
+            func = _vargs_meta_inline
+        else:
+            func = _vargs_meta
+    elif inline:
+        func = _vargs_inline
+    elif tree:
+        func = _vargs_tree
+
+    if wrapper is not None:
+        if func is not None:
+            raise ValueError(
+                "Cannot use 'wrapper' along with 'tree', 'meta' or 'inline'."
+            )
+        func = wrapper
+
+    def _visitor_args_dec(obj):
+        return _apply_v_args(obj, func)
+
+    return _visitor_args_dec
+
+
+
+TOKEN_DEFAULT_PRIORITY = 0
+
+
+class Symbol(Serialize):
+    __slots__ = ("name",)
+
+    name: str
+    is_term: ClassVar[bool] = NotImplemented
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __eq__(self, other):
+        assert isinstance(other, Symbol), other
+        return self.is_term == other.is_term and self.name == other.name
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __repr__(self):
+        return "%s(%r)" % (type(self).__name__, self.name)
+
+    fullrepr = property(__repr__)
+
+    def renamed(self, f):
+        return type(self)(f(self.name))
+
+
+class Terminal(Symbol):
+    __serialize_fields__ = "name", "filter_out"
+
+    is_term: ClassVar[bool] = True
+
+    def __init__(self, name, filter_out=False):
+        self.name = name
+        self.filter_out = filter_out
+
+    @property
+    def fullrepr(self):
+        return "%s(%r, %r)" % (type(self).__name__, self.name, self.filter_out)
+
+    def renamed(self, f):
+        return type(self)(f(self.name), self.filter_out)
+
+
+class NonTerminal(Symbol):
+    __serialize_fields__ = ("name",)
+
+    is_term: ClassVar[bool] = False
+
+
+class RuleOptions(Serialize):
+    __serialize_fields__ = (
+        "keep_all_tokens",
+        "expand1",
+        "priority",
+        "template_source",
+        "empty_indices",
+    )
+
+    keep_all_tokens: bool
+    expand1: bool
+    priority: Optional[int]
+    template_source: Optional[str]
+    empty_indices: Tuple[bool, ...]
+
+    def __init__(
+        self,
+        keep_all_tokens: bool = False,
+        expand1: bool = False,
+        priority: Optional[int] = None,
+        template_source: Optional[str] = None,
+        empty_indices: Tuple[bool, ...] = (),
+    ) -> None:
+        self.keep_all_tokens = keep_all_tokens
+        self.expand1 = expand1
+        self.priority = priority
+        self.template_source = template_source
+        self.empty_indices = empty_indices
+
+    def __repr__(self):
+        return "RuleOptions(%r, %r, %r, %r)" % (
+            self.keep_all_tokens,
+            self.expand1,
+            self.priority,
+            self.template_source,
+        )
+
+
+class Rule(Serialize):
+    #--
+
+    __slots__ = ("origin", "expansion", "alias", "options", "order", "_hash")
+
+    __serialize_fields__ = "origin", "expansion", "order", "alias", "options"
+    __serialize_namespace__ = Terminal, NonTerminal, RuleOptions
+
+    origin: NonTerminal
+    expansion: Sequence[Symbol]
+    order: int
+    alias: Optional[str]
+    options: RuleOptions
+    _hash: int
+
+    def __init__(
+        self,
+        origin: NonTerminal,
+        expansion: Sequence[Symbol],
+        order: int = 0,
+        alias: Optional[str] = None,
+        options: Optional[RuleOptions] = None,
+    ):
+        self.origin = origin
+        self.expansion = expansion
+        self.alias = alias
+        self.order = order
+        self.options = options or RuleOptions()
+        self._hash = hash((self.origin, tuple(self.expansion)))
+
+    def _deserialize(self):
+        self._hash = hash((self.origin, tuple(self.expansion)))
+
+    def __str__(self):
+        return "<%s : %s>" % (
+            self.origin.name,
+            " ".join(x.name for x in self.expansion),
+        )
+
+    def __repr__(self):
+        return "Rule(%r, %r, %r, %r)" % (
+            self.origin,
+            self.expansion,
+            self.alias,
+            self.options,
+        )
+
+    def __hash__(self):
+        return self._hash
+
+    def __eq__(self, other):
+        if not isinstance(other, Rule):
+            return False
+        return self.origin == other.origin and self.expansion == other.expansion
+
+
+
+from copy import copy
+
+try:  ##
+
+    has_interegular = bool(interegular)
+except NameError:
+    has_interegular = False
+
+
+class Pattern(Serialize, ABC):
+    #--
+
+    value: str
+    flags: Collection[str]
+    raw: Optional[str]
+    type: ClassVar[str]
+
+    def __init__(
+        self, value: str, flags: Collection[str] = (), raw: Optional[str] = None
+    ) -> None:
+        self.value = value
+        self.flags = frozenset(flags)
+        self.raw = raw
+
+    def __repr__(self):
+        return repr(self.to_regexp())
+
+    ##
+
+    def __hash__(self):
+        return hash((type(self), self.value, self.flags))
+
+    def __eq__(self, other):
+        return (
+            type(self) == type(other)
+            and self.value == other.value
+            and self.flags == other.flags
+        )
+
+    @abstractmethod
+    def to_regexp(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def min_width(self) -> int:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def max_width(self) -> int:
+        raise NotImplementedError()
+
+    def _get_flags(self, value):
+        for f in self.flags:
+            value = "(?%s:%s)" % (f, value)
+        return value
+
+
+class PatternStr(Pattern):
+    __serialize_fields__ = "value", "flags", "raw"
+
+    type: ClassVar[str] = "str"
+
+    def to_regexp(self) -> str:
+        return self._get_flags(re.escape(self.value))
+
+    @property
+    def min_width(self) -> int:
+        return len(self.value)
+
+    @property
+    def max_width(self) -> int:
+        return len(self.value)
+
+
+class PatternRE(Pattern):
+    __serialize_fields__ = "value", "flags", "raw", "_width"
+
+    type: ClassVar[str] = "re"
+
+    def to_regexp(self) -> str:
+        return self._get_flags(self.value)
+
+    _width = None
+
+    def _get_width(self):
+        if self._width is None:
+            self._width = get_regexp_width(self.to_regexp())
+        return self._width
+
+    @property
+    def min_width(self) -> int:
+        return self._get_width()[0]
+
+    @property
+    def max_width(self) -> int:
+        return self._get_width()[1]
+
+
+class TerminalDef(Serialize):
+    #--
+    __serialize_fields__ = "name", "pattern", "priority"
+    __serialize_namespace__ = PatternStr, PatternRE
+
+    name: str
+    pattern: Pattern
+    priority: int
+
+    def __init__(
+        self, name: str, pattern: Pattern, priority: int = TOKEN_DEFAULT_PRIORITY
+    ) -> None:
+        assert isinstance(pattern, Pattern), pattern
+        self.name = name
+        self.pattern = pattern
+        self.priority = priority
+
+    def __repr__(self):
+        return "%s(%r, %r)" % (type(self).__name__, self.name, self.pattern)
+
+    def user_repr(self) -> str:
+        if self.name.startswith("__"):  ##
+
+            return self.pattern.raw or self.name
+        else:
+            return self.name
+
+
+_T = TypeVar("_T", bound="Token")
+
+
+class Token(str):
+    #--
+
+    __slots__ = (
+        "type",
+        "start_pos",
+        "value",
+        "line",
+        "column",
+        "end_line",
+        "end_column",
+        "end_pos",
+    )
+
+    __match_args__ = ("type", "value")
+
+    type: str
+    start_pos: Optional[int]
+    value: Any
+    line: Optional[int]
+    column: Optional[int]
+    end_line: Optional[int]
+    end_column: Optional[int]
+    end_pos: Optional[int]
+
+    @overload
+    def __new__(
+        cls,
+        type: str,
+        value: Any,
+        start_pos: Optional[int] = None,
+        line: Optional[int] = None,
+        column: Optional[int] = None,
+        end_line: Optional[int] = None,
+        end_column: Optional[int] = None,
+        end_pos: Optional[int] = None,
+    ) -> "Token": ...
+
+    @overload
+    def __new__(
+        cls,
+        type_: str,
+        value: Any,
+        start_pos: Optional[int] = None,
+        line: Optional[int] = None,
+        column: Optional[int] = None,
+        end_line: Optional[int] = None,
+        end_column: Optional[int] = None,
+        end_pos: Optional[int] = None,
+    ) -> "Token": ...
+
+    def __new__(cls, *args, **kwargs):
+        if "type_" in kwargs:
+            warnings.warn(
+                "`type_` is deprecated use `type` instead", DeprecationWarning
+            )
+
+            if "type" in kwargs:
+                raise TypeError(
+                    "Error: using both 'type' and the deprecated 'type_' as arguments."
+                )
+            kwargs["type"] = kwargs.pop("type_")
+
+        return cls._future_new(*args, **kwargs)
+
+    @classmethod
+    def _future_new(
+        cls,
+        type,
+        value,
+        start_pos=None,
+        line=None,
+        column=None,
+        end_line=None,
+        end_column=None,
+        end_pos=None,
+    ):
+        inst = super(Token, cls).__new__(cls, value)
+
+        inst.type = type
+        inst.start_pos = start_pos
+        inst.value = value
+        inst.line = line
+        inst.column = column
+        inst.end_line = end_line
+        inst.end_column = end_column
+        inst.end_pos = end_pos
+        return inst
+
+    @overload
+    def update(
+        self, type: Optional[str] = None, value: Optional[Any] = None
+    ) -> "Token": ...
+
+    @overload
+    def update(
+        self, type_: Optional[str] = None, value: Optional[Any] = None
+    ) -> "Token": ...
+
+    def update(self, *args, **kwargs):
+        if "type_" in kwargs:
+            warnings.warn(
+                "`type_` is deprecated use `type` instead", DeprecationWarning
+            )
+
+            if "type" in kwargs:
+                raise TypeError(
+                    "Error: using both 'type' and the deprecated 'type_' as arguments."
+                )
+            kwargs["type"] = kwargs.pop("type_")
+
+        return self._future_update(*args, **kwargs)
+
+    def _future_update(
+        self, type: Optional[str] = None, value: Optional[Any] = None
+    ) -> "Token":
+        return Token.new_borrow_pos(
+            type if type is not None else self.type,
+            value if value is not None else self.value,
+            self,
+        )
+
+    @classmethod
+    def new_borrow_pos(cls: Type[_T], type_: str, value: Any, borrow_t: "Token") -> _T:
+        return cls(
+            type_,
+            value,
+            borrow_t.start_pos,
+            borrow_t.line,
+            borrow_t.column,
+            borrow_t.end_line,
+            borrow_t.end_column,
+            borrow_t.end_pos,
+        )
+
+    def __reduce__(self):
+        return (
+            self.__class__,
+            (self.type, self.value, self.start_pos, self.line, self.column),
+        )
+
+    def __repr__(self):
+        return "Token(%r, %r)" % (self.type, self.value)
+
+    def __deepcopy__(self, memo):
+        return Token(self.type, self.value, self.start_pos, self.line, self.column)
+
+    def __eq__(self, other):
+        if isinstance(other, Token) and self.type != other.type:
+            return False
+
+        return str.__eq__(self, other)
+
+    __hash__ = str.__hash__
+
+
+class LineCounter:
+    #--
+
+    __slots__ = "char_pos", "line", "column", "line_start_pos", "newline_char"
+
+    def __init__(self, newline_char):
+        self.newline_char = newline_char
+        self.char_pos = 0
+        self.line = 1
+        self.column = 1
+        self.line_start_pos = 0
+
+    def __eq__(self, other):
+        if not isinstance(other, LineCounter):
+            return NotImplemented
+
+        return (
+            self.char_pos == other.char_pos and self.newline_char == other.newline_char
+        )
+
+    def feed(self, token: Token, test_newline=True):
+        #--
+        if test_newline:
+            newlines = token.count(self.newline_char)
+            if newlines:
+                self.line += newlines
+                self.line_start_pos = (
+                    self.char_pos + token.rindex(self.newline_char) + 1
+                )
+
+        self.char_pos += len(token)
+        self.column = self.char_pos - self.line_start_pos + 1
+
+
+class UnlessCallback:
+    def __init__(self, scanner):
+        self.scanner = scanner
+
+    def __call__(self, t):
+        res = self.scanner.match(t.value, 0)
+        if res:
+            _value, t.type = res
+        return t
+
+
+class CallChain:
+    def __init__(self, callback1, callback2, cond):
+        self.callback1 = callback1
+        self.callback2 = callback2
+        self.cond = cond
+
+    def __call__(self, t):
+        t2 = self.callback1(t)
+        return self.callback2(t) if self.cond(t2) else t2
+
+
+def _get_match(re_, regexp, s, flags):
+    m = re_.match(regexp, s, flags)
+    if m:
+        return m.group(0)
+
+
+def _create_unless(terminals, g_regex_flags, re_, use_bytes):
+    tokens_by_type = classify(terminals, lambda t: type(t.pattern))
+    assert len(tokens_by_type) <= 2, tokens_by_type.keys()
+    embedded_strs = set()
+    callback = {}
+    for retok in tokens_by_type.get(PatternRE, []):
+        unless = []
+        for strtok in tokens_by_type.get(PatternStr, []):
+            if strtok.priority != retok.priority:
+                continue
+            s = strtok.pattern.value
+            if s == _get_match(re_, retok.pattern.to_regexp(), s, g_regex_flags):
+                unless.append(strtok)
+                if strtok.pattern.flags <= retok.pattern.flags:
+                    embedded_strs.add(strtok)
+        if unless:
+            callback[retok.name] = UnlessCallback(
+                Scanner(
+                    unless, g_regex_flags, re_, match_whole=True, use_bytes=use_bytes
+                )
+            )
+
+    new_terminals = [t for t in terminals if t not in embedded_strs]
+    return new_terminals, callback
+
+
+class Scanner:
+    def __init__(self, terminals, g_regex_flags, re_, use_bytes, match_whole=False):
+        self.terminals = terminals
+        self.g_regex_flags = g_regex_flags
+        self.re_ = re_
+        self.use_bytes = use_bytes
+        self.match_whole = match_whole
+
+        self.allowed_types = {t.name for t in self.terminals}
+
+        self._mres = self._build_mres(terminals, len(terminals))
+
+    def _build_mres(self, terminals, max_size):
+        ##
+
+        ##
+
+        ##
+
+        postfix = "$" if self.match_whole else ""
+        mres = []
+        while terminals:
+            pattern = "|".join(
+                "(?P<%s>%s)" % (t.name, t.pattern.to_regexp() + postfix)
+                for t in terminals[:max_size]
+            )
+            if self.use_bytes:
+                pattern = pattern.encode("latin-1")
+            try:
+                mre = self.re_.compile(pattern, self.g_regex_flags)
+            except AssertionError:  ##
+
+                return self._build_mres(terminals, max_size // 2)
+
+            mres.append(mre)
+            terminals = terminals[max_size:]
+        return mres
+
+    def match(self, text, pos):
+        for mre in self._mres:
+            m = mre.match(text, pos)
+            if m:
+                return m.group(0), m.lastgroup
+
+
+def _regexp_has_newline(r: str):
+    #--
+    return (
+        "\n" in r or "\\n" in r or "\\s" in r or "[^" in r or ("(?s" in r and "." in r)
+    )
+
+
+class LexerState:
+    #--
+
+    __slots__ = "text", "line_ctr", "last_token"
+
+    text: str
+    line_ctr: LineCounter
+    last_token: Optional[Token]
+
+    def __init__(
+        self,
+        text: str,
+        line_ctr: Optional[LineCounter] = None,
+        last_token: Optional[Token] = None,
+    ):
+        self.text = text
+        self.line_ctr = line_ctr or LineCounter(
+            b"\n" if isinstance(text, bytes) else "\n"
+        )
+        self.last_token = last_token
+
+    def __eq__(self, other):
+        if not isinstance(other, LexerState):
+            return NotImplemented
+
+        return (
+            self.text is other.text
+            and self.line_ctr == other.line_ctr
+            and self.last_token == other.last_token
+        )
+
+    def __copy__(self):
+        return type(self)(self.text, copy(self.line_ctr), self.last_token)
+
+
+class LexerThread:
+    #--
+
+    def __init__(self, lexer: "Lexer", lexer_state: LexerState):
+        self.lexer = lexer
+        self.state = lexer_state
+
+    @classmethod
+    def from_text(cls, lexer: "Lexer", text: str) -> "LexerThread":
+        return cls(lexer, LexerState(text))
+
+    def lex(self, parser_state):
+        return self.lexer.lex(self.state, parser_state)
+
+    def __copy__(self):
+        return type(self)(self.lexer, copy(self.state))
+
+    _Token = Token
+
+
+_Callback = Callable[[Token], Token]
+
+
+class Lexer(ABC):
+    #--
+
+    @abstractmethod
+    def lex(self, lexer_state: LexerState, parser_state: Any) -> Iterator[Token]:
+        return NotImplemented
+
+    def make_lexer_state(self, text):
+        #--
+        return LexerState(text)
+
+
+def _check_regex_collisions(
+    terminal_to_regexp: Dict[TerminalDef, str],
+    comparator,
+    strict_mode,
+    max_collisions_to_show=8,
+):
+    if not comparator:
+        comparator = interegular.Comparator.from_regexes(terminal_to_regexp)
+
+    ##
+
+    ##
+
+    max_time = 2 if strict_mode else 0.2
+
+    ##
+
+    if comparator.count_marked_pairs() >= max_collisions_to_show:
+        return
+    for group in classify(terminal_to_regexp, lambda t: t.priority).values():
+        for a, b in comparator.check(group, skip_marked=True):
+            assert a.priority == b.priority
+            ##
+
+            comparator.mark(a, b)
+
+            ##
+
+            message = f"Collision between Terminals {a.name} and {b.name}. "
+            try:
+                example = comparator.get_example_overlap(
+                    a, b, max_time
+                ).format_multiline()
+            except ValueError:
+                ##
+
+                example = "No example could be found fast enough. However, the collision does still exists"
+            if strict_mode:
+                raise LexError(f"{message}\n{example}")
+            logger.warning(
+                "%s The lexer will choose between them arbitrarily.\n%s",
+                message,
+                example,
+            )
+            if comparator.count_marked_pairs() >= max_collisions_to_show:
+                logger.warning("Found 8 regex collisions, will not check for more.")
+                return
+
+
+class AbstractBasicLexer(Lexer):
+    terminals_by_name: Dict[str, TerminalDef]
+
+    @abstractmethod
+    def __init__(self, conf: "LexerConf", comparator=None) -> None: ...
+
+    @abstractmethod
+    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: ...
+
+    def lex(self, state: LexerState, parser_state: Any) -> Iterator[Token]:
+        with suppress(EOFError):
+            while True:
+                yield self.next_token(state, parser_state)
+
+
+class BasicLexer(AbstractBasicLexer):
+    terminals: Collection[TerminalDef]
+    ignore_types: FrozenSet[str]
+    newline_types: FrozenSet[str]
+    user_callbacks: Dict[str, _Callback]
+    callback: Dict[str, _Callback]
+    re: ModuleType
+
+    def __init__(self, conf: "LexerConf", comparator=None) -> None:
+        terminals = list(conf.terminals)
+        assert all(isinstance(t, TerminalDef) for t in terminals), terminals
+
+        self.re = conf.re_module
+
+        if not conf.skip_validation:
+            ##
+
+            terminal_to_regexp = {}
+            for t in terminals:
+                regexp = t.pattern.to_regexp()
+                try:
+                    self.re.compile(regexp, conf.g_regex_flags)
+                except self.re.error:
+                    raise LexError("Cannot compile token %s: %s" % (t.name, t.pattern))
+
+                if t.pattern.min_width == 0:
+                    raise LexError(
+                        "Lexer does not allow zero-width terminals. (%s: %s)"
+                        % (t.name, t.pattern)
+                    )
+                if t.pattern.type == "re":
+                    terminal_to_regexp[t] = regexp
+
+            if not (set(conf.ignore) <= {t.name for t in terminals}):
+                raise LexError(
+                    "Ignore terminals are not defined: %s"
+                    % (set(conf.ignore) - {t.name for t in terminals})
+                )
+
+            if has_interegular:
+                _check_regex_collisions(terminal_to_regexp, comparator, conf.strict)
+            elif conf.strict:
+                raise LexError(
+                    "interegular must be installed for strict mode. Use `pip install 'lark[interegular]'`."
+                )
+
+        ##
+
+        self.newline_types = frozenset(
+            t.name for t in terminals if _regexp_has_newline(t.pattern.to_regexp())
+        )
+        self.ignore_types = frozenset(conf.ignore)
+
+        terminals.sort(
+            key=lambda x: (
+                -x.priority,
+                -x.pattern.max_width,
+                -len(x.pattern.value),
+                x.name,
+            )
+        )
+        self.terminals = terminals
+        self.user_callbacks = conf.callbacks
+        self.g_regex_flags = conf.g_regex_flags
+        self.use_bytes = conf.use_bytes
+        self.terminals_by_name = conf.terminals_by_name
+
+        self._scanner = None
+
+    def _build_scanner(self):
+        terminals, self.callback = _create_unless(
+            self.terminals, self.g_regex_flags, self.re, self.use_bytes
+        )
+        assert all(self.callback.values())
+
+        for type_, f in self.user_callbacks.items():
+            if type_ in self.callback:
+                ##
+
+                self.callback[type_] = CallChain(
+                    self.callback[type_], f, lambda t: t.type == type_
+                )
+            else:
+                self.callback[type_] = f
+
+        self._scanner = Scanner(terminals, self.g_regex_flags, self.re, self.use_bytes)
+
+    @property
+    def scanner(self):
+        if self._scanner is None:
+            self._build_scanner()
+        return self._scanner
+
+    def match(self, text, pos):
+        return self.scanner.match(text, pos)
+
+    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token:
+        line_ctr = lex_state.line_ctr
+        while line_ctr.char_pos < len(lex_state.text):
+            res = self.match(lex_state.text, line_ctr.char_pos)
+            if not res:
+                allowed = self.scanner.allowed_types - self.ignore_types
+                if not allowed:
+                    allowed = {"<END-OF-FILE>"}
+                raise UnexpectedCharacters(
+                    lex_state.text,
+                    line_ctr.char_pos,
+                    line_ctr.line,
+                    line_ctr.column,
+                    allowed=allowed,
+                    token_history=lex_state.last_token and [lex_state.last_token],
+                    state=parser_state,
+                    terminals_by_name=self.terminals_by_name,
+                )
+
+            value, type_ = res
+
+            ignored = type_ in self.ignore_types
+            t = None
+            if not ignored or type_ in self.callback:
+                t = Token(
+                    type_, value, line_ctr.char_pos, line_ctr.line, line_ctr.column
+                )
+            line_ctr.feed(value, type_ in self.newline_types)
+            if t is not None:
+                t.end_line = line_ctr.line
+                t.end_column = line_ctr.column
+                t.end_pos = line_ctr.char_pos
+                if t.type in self.callback:
+                    t = self.callback[t.type](t)
+                if not ignored:
+                    if not isinstance(t, Token):
+                        raise LexError(
+                            "Callbacks must return a token (returned %r)" % t
+                        )
+                    lex_state.last_token = t
+                    return t
+
+        ##
+
+        raise EOFError(self)
+
+
+class ContextualLexer(Lexer):
+    lexers: Dict[int, AbstractBasicLexer]
+    root_lexer: AbstractBasicLexer
+
+    BasicLexer: Type[AbstractBasicLexer] = BasicLexer
+
+    def __init__(
+        self,
+        conf: "LexerConf",
+        states: Dict[int, Collection[str]],
+        always_accept: Collection[str] = (),
+    ) -> None:
+        terminals = list(conf.terminals)
+        terminals_by_name = conf.terminals_by_name
+
+        trad_conf = copy(conf)
+        trad_conf.terminals = terminals
+
+        if has_interegular and not conf.skip_validation:
+            comparator = interegular.Comparator.from_regexes(
+                {t: t.pattern.to_regexp() for t in terminals}
+            )
+        else:
+            comparator = None
+        lexer_by_tokens: Dict[FrozenSet[str], AbstractBasicLexer] = {}
+        self.lexers = {}
+        for state, accepts in states.items():
+            key = frozenset(accepts)
+            try:
+                lexer = lexer_by_tokens[key]
+            except KeyError:
+                accepts = set(accepts) | set(conf.ignore) | set(always_accept)
+                lexer_conf = copy(trad_conf)
+                lexer_conf.terminals = [
+                    terminals_by_name[n] for n in accepts if n in terminals_by_name
+                ]
+                lexer = self.BasicLexer(lexer_conf, comparator)
+                lexer_by_tokens[key] = lexer
+
+            self.lexers[state] = lexer
+
+        assert trad_conf.terminals is terminals
+        trad_conf.skip_validation = True  ##
+
+        self.root_lexer = self.BasicLexer(trad_conf, comparator)
+
+    def lex(
+        self, lexer_state: LexerState, parser_state: "ParserState"
+    ) -> Iterator[Token]:
+        try:
+            while True:
+                lexer = self.lexers[parser_state.position]
+                yield lexer.next_token(lexer_state, parser_state)
+        except EOFError:
+            pass
+        except UnexpectedCharacters as e:
+            ##
+
+            ##
+
+            try:
+                last_token = (
+                    lexer_state.last_token
+                )  ##
+
+                token = self.root_lexer.next_token(lexer_state, parser_state)
+                raise UnexpectedToken(
+                    token,
+                    e.allowed,
+                    state=parser_state,
+                    token_history=[last_token],
+                    terminals_by_name=self.root_lexer.terminals_by_name,
+                )
+            except UnexpectedCharacters:
+                raise e  ##
+
+
+
+
+
+_ParserArgType: "TypeAlias" = 'Literal["earley", "lalr", "cyk", "auto"]'
+_LexerArgType: "TypeAlias" = (
+    'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]'
+)
+_LexerCallback = Callable[[Token], Token]
+ParserCallbacks = Dict[str, Callable]
+
+
+class LexerConf(Serialize):
+    __serialize_fields__ = (
+        "terminals",
+        "ignore",
+        "g_regex_flags",
+        "use_bytes",
+        "lexer_type",
+    )
+    __serialize_namespace__ = (TerminalDef,)
+
+    terminals: Collection[TerminalDef]
+    re_module: ModuleType
+    ignore: Collection[str]
+    postlex: "Optional[PostLex]"
+    callbacks: Dict[str, _LexerCallback]
+    g_regex_flags: int
+    skip_validation: bool
+    use_bytes: bool
+    lexer_type: Optional[_LexerArgType]
+    strict: bool
+
+    def __init__(
+        self,
+        terminals: Collection[TerminalDef],
+        re_module: ModuleType,
+        ignore: Collection[str] = (),
+        postlex: "Optional[PostLex]" = None,
+        callbacks: Optional[Dict[str, _LexerCallback]] = None,
+        g_regex_flags: int = 0,
+        skip_validation: bool = False,
+        use_bytes: bool = False,
+        strict: bool = False,
+    ):
+        self.terminals = terminals
+        self.terminals_by_name = {t.name: t for t in self.terminals}
+        assert len(self.terminals) == len(self.terminals_by_name)
+        self.ignore = ignore
+        self.postlex = postlex
+        self.callbacks = callbacks or {}
+        self.g_regex_flags = g_regex_flags
+        self.re_module = re_module
+        self.skip_validation = skip_validation
+        self.use_bytes = use_bytes
+        self.strict = strict
+        self.lexer_type = None
+
+    def _deserialize(self):
+        self.terminals_by_name = {t.name: t for t in self.terminals}
+
+    def __deepcopy__(self, memo=None):
+        return type(self)(
+            deepcopy(self.terminals, memo),
+            self.re_module,
+            deepcopy(self.ignore, memo),
+            deepcopy(self.postlex, memo),
+            deepcopy(self.callbacks, memo),
+            deepcopy(self.g_regex_flags, memo),
+            deepcopy(self.skip_validation, memo),
+            deepcopy(self.use_bytes, memo),
+        )
+
+
+class ParserConf(Serialize):
+    __serialize_fields__ = "rules", "start", "parser_type"
+
+    rules: List["Rule"]
+    callbacks: ParserCallbacks
+    start: List[str]
+    parser_type: _ParserArgType
+
+    def __init__(
+        self, rules: List["Rule"], callbacks: ParserCallbacks, start: List[str]
+    ):
+        assert isinstance(start, list)
+        self.rules = rules
+        self.callbacks = callbacks
+        self.start = start
+
+
+
+from functools import partial, wraps
+from itertools import product
+
+
+class ExpandSingleChild:
+    def __init__(self, node_builder):
+        self.node_builder = node_builder
+
+    def __call__(self, children):
+        if len(children) == 1:
+            return children[0]
+        else:
+            return self.node_builder(children)
+
+
+class PropagatePositions:
+    def __init__(self, node_builder, node_filter=None):
+        self.node_builder = node_builder
+        self.node_filter = node_filter
+
+    def __call__(self, children):
+        res = self.node_builder(children)
+
+        if isinstance(res, Tree):
+            ##
+
+            ##
+
+            ##
+
+            ##
+
+
+            res_meta = res.meta
+
+            first_meta = self._pp_get_meta(children)
+            if first_meta is not None:
+                if not hasattr(res_meta, "line"):
+                    ##
+
+                    res_meta.line = getattr(
+                        first_meta, "container_line", first_meta.line
+                    )
+                    res_meta.column = getattr(
+                        first_meta, "container_column", first_meta.column
+                    )
+                    res_meta.start_pos = getattr(
+                        first_meta, "container_start_pos", first_meta.start_pos
+                    )
+                    res_meta.empty = False
+
+                res_meta.container_line = getattr(
+                    first_meta, "container_line", first_meta.line
+                )
+                res_meta.container_column = getattr(
+                    first_meta, "container_column", first_meta.column
+                )
+                res_meta.container_start_pos = getattr(
+                    first_meta, "container_start_pos", first_meta.start_pos
+                )
+
+            last_meta = self._pp_get_meta(reversed(children))
+            if last_meta is not None:
+                if not hasattr(res_meta, "end_line"):
+                    res_meta.end_line = getattr(
+                        last_meta, "container_end_line", last_meta.end_line
+                    )
+                    res_meta.end_column = getattr(
+                        last_meta, "container_end_column", last_meta.end_column
+                    )
+                    res_meta.end_pos = getattr(
+                        last_meta, "container_end_pos", last_meta.end_pos
+                    )
+                    res_meta.empty = False
+
+                res_meta.container_end_line = getattr(
+                    last_meta, "container_end_line", last_meta.end_line
+                )
+                res_meta.container_end_column = getattr(
+                    last_meta, "container_end_column", last_meta.end_column
+                )
+                res_meta.container_end_pos = getattr(
+                    last_meta, "container_end_pos", last_meta.end_pos
+                )
+
+        return res
+
+    def _pp_get_meta(self, children):
+        for c in children:
+            if self.node_filter is not None and not self.node_filter(c):
+                continue
+            if isinstance(c, Tree):
+                if not c.meta.empty:
+                    return c.meta
+            elif isinstance(c, Token):
+                return c
+            elif hasattr(c, "__lark_meta__"):
+                return c.__lark_meta__()
+
+
+def make_propagate_positions(option):
+    if callable(option):
+        return partial(PropagatePositions, node_filter=option)
+    elif option is True:
+        return PropagatePositions
+    elif option is False:
+        return None
+
+    raise ConfigurationError("Invalid option for propagate_positions: %r" % option)
+
+
+class ChildFilter:
+    def __init__(self, to_include, append_none, node_builder):
+        self.node_builder = node_builder
+        self.to_include = to_include
+        self.append_none = append_none
+
+    def __call__(self, children):
+        filtered = []
+
+        for i, to_expand, add_none in self.to_include:
+            if add_none:
+                filtered += [None] * add_none
+            if to_expand:
+                filtered += children[i].children
+            else:
+                filtered.append(children[i])
+
+        if self.append_none:
+            filtered += [None] * self.append_none
+
+        return self.node_builder(filtered)
+
+
+class ChildFilterLALR(ChildFilter):
+    #--
+
+    def __call__(self, children):
+        filtered = []
+        for i, to_expand, add_none in self.to_include:
+            if add_none:
+                filtered += [None] * add_none
+            if to_expand:
+                if filtered:
+                    filtered += children[i].children
+                else:  ##
+
+                    filtered = children[i].children
+            else:
+                filtered.append(children[i])
+
+        if self.append_none:
+            filtered += [None] * self.append_none
+
+        return self.node_builder(filtered)
+
+
+class ChildFilterLALR_NoPlaceholders(ChildFilter):
+    #--
+
+    def __init__(self, to_include, node_builder):
+        self.node_builder = node_builder
+        self.to_include = to_include
+
+    def __call__(self, children):
+        filtered = []
+        for i, to_expand in self.to_include:
+            if to_expand:
+                if filtered:
+                    filtered += children[i].children
+                else:  ##
+
+                    filtered = children[i].children
+            else:
+                filtered.append(children[i])
+        return self.node_builder(filtered)
+
+
+def _should_expand(sym):
+    return not sym.is_term and sym.name.startswith("_")
+
+
+def maybe_create_child_filter(
+    expansion, keep_all_tokens, ambiguous, _empty_indices: List[bool]
+):
+    ##
+
+    if _empty_indices:
+        assert _empty_indices.count(False) == len(expansion)
+        s = "".join(str(int(b)) for b in _empty_indices)
+        empty_indices = [len(ones) for ones in s.split("0")]
+        assert len(empty_indices) == len(expansion) + 1, (empty_indices, len(expansion))
+    else:
+        empty_indices = [0] * (len(expansion) + 1)
+
+    to_include = []
+    nones_to_add = 0
+    for i, sym in enumerate(expansion):
+        nones_to_add += empty_indices[i]
+        if keep_all_tokens or not (sym.is_term and sym.filter_out):
+            to_include.append((i, _should_expand(sym), nones_to_add))
+            nones_to_add = 0
+
+    nones_to_add += empty_indices[len(expansion)]
+
+    if (
+        _empty_indices
+        or len(to_include) < len(expansion)
+        or any(to_expand for i, to_expand, _ in to_include)
+    ):
+        if _empty_indices or ambiguous:
+            return partial(
+                ChildFilter if ambiguous else ChildFilterLALR, to_include, nones_to_add
+            )
+        else:
+            ##
+
+            return partial(
+                ChildFilterLALR_NoPlaceholders, [(i, x) for i, x, _ in to_include]
+            )
+
+
+class AmbiguousExpander:
+    #--
+
+    def __init__(self, to_expand, tree_class, node_builder):
+        self.node_builder = node_builder
+        self.tree_class = tree_class
+        self.to_expand = to_expand
+
+    def __call__(self, children):
+        def _is_ambig_tree(t):
+            return hasattr(t, "data") and t.data == "_ambig"
+
+        ##
+
+        ##
+
+        ##
+
+        ##
+
+        ambiguous = []
+        for i, child in enumerate(children):
+            if _is_ambig_tree(child):
+                if i in self.to_expand:
+                    ambiguous.append(i)
+
+                child.expand_kids_by_data("_ambig")
+
+        if not ambiguous:
+            return self.node_builder(children)
+
+        expand = [
+            child.children if i in ambiguous else (child,)
+            for i, child in enumerate(children)
+        ]
+        return self.tree_class(
+            "_ambig", [self.node_builder(list(f)) for f in product(*expand)]
+        )
+
+
+def maybe_create_ambiguous_expander(tree_class, expansion, keep_all_tokens):
+    to_expand = [
+        i
+        for i, sym in enumerate(expansion)
+        if keep_all_tokens
+        or ((not (sym.is_term and sym.filter_out)) and _should_expand(sym))
+    ]
+    if to_expand:
+        return partial(AmbiguousExpander, to_expand, tree_class)
+
+
+class AmbiguousIntermediateExpander:
+    #--
+
+    def __init__(self, tree_class, node_builder):
+        self.node_builder = node_builder
+        self.tree_class = tree_class
+
+    def __call__(self, children):
+        def _is_iambig_tree(child):
+            return hasattr(child, "data") and child.data == "_iambig"
+
+        def _collapse_iambig(children):
+            #--
+
+            ##
+
+            ##
+
+            if children and _is_iambig_tree(children[0]):
+                iambig_node = children[0]
+                result = []
+                for grandchild in iambig_node.children:
+                    collapsed = _collapse_iambig(grandchild.children)
+                    if collapsed:
+                        for child in collapsed:
+                            child.children += children[1:]
+                        result += collapsed
+                    else:
+                        new_tree = self.tree_class(
+                            "_inter", grandchild.children + children[1:]
+                        )
+                        result.append(new_tree)
+                return result
+
+        collapsed = _collapse_iambig(children)
+        if collapsed:
+            processed_nodes = [self.node_builder(c.children) for c in collapsed]
+            return self.tree_class("_ambig", processed_nodes)
+
+        return self.node_builder(children)
+
+
+def inplace_transformer(func):
+    @wraps(func)
+    def f(children):
+        ##
+
+        tree = Tree(func.__name__, children)
+        return func(tree)
+
+    return f
+
+
+def apply_visit_wrapper(func, name, wrapper):
+    if wrapper is _vargs_meta or wrapper is _vargs_meta_inline:
+        raise NotImplementedError("Meta args not supported for internal transformer")
+
+    @wraps(func)
+    def f(children):
+        return wrapper(func, name, children, None)
+
+    return f
+
+
+class ParseTreeBuilder:
+    def __init__(
+        self,
+        rules,
+        tree_class,
+        propagate_positions=False,
+        ambiguous=False,
+        maybe_placeholders=False,
+    ):
+        self.tree_class = tree_class
+        self.propagate_positions = propagate_positions
+        self.ambiguous = ambiguous
+        self.maybe_placeholders = maybe_placeholders
+
+        self.rule_builders = list(self._init_builders(rules))
+
+    def _init_builders(self, rules):
+        propagate_positions = make_propagate_positions(self.propagate_positions)
+
+        for rule in rules:
+            options = rule.options
+            keep_all_tokens = options.keep_all_tokens
+            expand_single_child = options.expand1
+
+            wrapper_chain = list(
+                filter(
+                    None,
+                    [
+                        (expand_single_child and not rule.alias) and ExpandSingleChild,
+                        maybe_create_child_filter(
+                            rule.expansion,
+                            keep_all_tokens,
+                            self.ambiguous,
+                            options.empty_indices if self.maybe_placeholders else None,
+                        ),
+                        propagate_positions,
+                        self.ambiguous
+                        and maybe_create_ambiguous_expander(
+                            self.tree_class, rule.expansion, keep_all_tokens
+                        ),
+                        self.ambiguous
+                        and partial(AmbiguousIntermediateExpander, self.tree_class),
+                    ],
+                )
+            )
+
+            yield rule, wrapper_chain
+
+    def create_callback(self, transformer=None):
+        callbacks = {}
+
+        default_handler = getattr(transformer, "__default__", None)
+        if default_handler:
+
+            def default_callback(data, children):
+                return default_handler(data, children, None)
+
+        else:
+            default_callback = self.tree_class
+
+        for rule, wrapper_chain in self.rule_builders:
+
+            user_callback_name = (
+                rule.alias or rule.options.template_source or rule.origin.name
+            )
+            try:
+                f = getattr(transformer, user_callback_name)
+                wrapper = getattr(f, "visit_wrapper", None)
+                if wrapper is not None:
+                    f = apply_visit_wrapper(f, user_callback_name, wrapper)
+                elif isinstance(transformer, Transformer_InPlace):
+                    f = inplace_transformer(f)
+            except AttributeError:
+                f = partial(default_callback, user_callback_name)
+
+            for w in wrapper_chain:
+                f = w(f)
+
+            if rule in callbacks:
+                raise GrammarError("Rule '%s' already exists" % (rule,))
+
+            callbacks[rule] = f
+
+        return callbacks
+
+
+
+
+
+class Action:
+    def __init__(self, name):
+        self.name = name
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return str(self)
+
+
+Shift = Action("Shift")
+Reduce = Action("Reduce")
+
+StateT = TypeVar("StateT")
+
+
+class ParseTableBase(Generic[StateT]):
+    states: Dict[StateT, Dict[str, Tuple]]
+    start_states: Dict[str, StateT]
+    end_states: Dict[str, StateT]
+
+    def __init__(self, states, start_states, end_states):
+        self.states = states
+        self.start_states = start_states
+        self.end_states = end_states
+
+    def serialize(self, memo):
+        tokens = Enumerator()
+
+        states = {
+            state: {
+                tokens.get(token): (
+                    (1, arg.serialize(memo)) if action is Reduce else (0, arg)
+                )
+                for token, (action, arg) in actions.items()
+            }
+            for state, actions in self.states.items()
+        }
+
+        return {
+            "tokens": tokens.reversed(),
+            "states": states,
+            "start_states": self.start_states,
+            "end_states": self.end_states,
+        }
+
+    @classmethod
+    def deserialize(cls, data, memo):
+        tokens = data["tokens"]
+        states = {
+            state: {
+                tokens[token]: (
+                    (Reduce, Rule.deserialize(arg, memo))
+                    if action == 1
+                    else (Shift, arg)
+                )
+                for token, (action, arg) in actions.items()
+            }
+            for state, actions in data["states"].items()
+        }
+        return cls(states, data["start_states"], data["end_states"])
+
+
+class ParseTable(ParseTableBase["State"]):
+    #--
+
+    pass
+
+
+class IntParseTable(ParseTableBase[int]):
+    #--
+
+    @classmethod
+    def from_ParseTable(cls, parse_table: ParseTable):
+        enum = list(parse_table.states)
+        state_to_idx: Dict["State", int] = {s: i for i, s in enumerate(enum)}
+        int_states = {}
+
+        for s, la in parse_table.states.items():
+            la = {
+                k: (v[0], state_to_idx[v[1]]) if v[0] is Shift else v
+                for k, v in la.items()
+            }
+            int_states[state_to_idx[s]] = la
+
+        start_states = {
+            start: state_to_idx[s] for start, s in parse_table.start_states.items()
+        }
+        end_states = {
+            start: state_to_idx[s] for start, s in parse_table.end_states.items()
+        }
+        return cls(int_states, start_states, end_states)
+
+
+
+
+
+class ParseConf(Generic[StateT]):
+    __slots__ = (
+        "parse_table",
+        "callbacks",
+        "start",
+        "start_state",
+        "end_state",
+        "states",
+    )
+
+    parse_table: ParseTableBase[StateT]
+    callbacks: ParserCallbacks
+    start: str
+
+    start_state: StateT
+    end_state: StateT
+    states: Dict[StateT, Dict[str, tuple]]
+
+    def __init__(
+        self,
+        parse_table: ParseTableBase[StateT],
+        callbacks: ParserCallbacks,
+        start: str,
+    ):
+        self.parse_table = parse_table
+
+        self.start_state = self.parse_table.start_states[start]
+        self.end_state = self.parse_table.end_states[start]
+        self.states = self.parse_table.states
+
+        self.callbacks = callbacks
+        self.start = start
+
+
+class ParserState(Generic[StateT]):
+    __slots__ = "parse_conf", "lexer", "state_stack", "value_stack"
+
+    parse_conf: ParseConf[StateT]
+    lexer: LexerThread
+    state_stack: List[StateT]
+    value_stack: list
+
+    def __init__(
+        self,
+        parse_conf: ParseConf[StateT],
+        lexer: LexerThread,
+        state_stack=None,
+        value_stack=None,
+    ):
+        self.parse_conf = parse_conf
+        self.lexer = lexer
+        self.state_stack = state_stack or [self.parse_conf.start_state]
+        self.value_stack = value_stack or []
+
+    @property
+    def position(self) -> StateT:
+        return self.state_stack[-1]
+
+    ##
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, ParserState):
+            return NotImplemented
+        return (
+            len(self.state_stack) == len(other.state_stack)
+            and self.position == other.position
+        )
+
+    def __copy__(self):
+        return type(self)(
+            self.parse_conf,
+            self.lexer,  ##
+
+            copy(self.state_stack),
+            deepcopy(self.value_stack),
+        )
+
+    def copy(self) -> "ParserState[StateT]":
+        return copy(self)
+
+    def feed_token(self, token: Token, is_end=False) -> Any:
+        state_stack = self.state_stack
+        value_stack = self.value_stack
+        states = self.parse_conf.states
+        end_state = self.parse_conf.end_state
+        callbacks = self.parse_conf.callbacks
+
+        while True:
+            state = state_stack[-1]
+            try:
+                action, arg = states[state][token.type]
+            except KeyError:
+                expected = {s for s in states[state].keys() if s.isupper()}
+                raise UnexpectedToken(
+                    token, expected, state=self, interactive_parser=None
+                )
+
+            assert arg != end_state
+
+            if action is Shift:
+                ##
+
+                assert not is_end
+                state_stack.append(arg)
+                value_stack.append(
+                    token
+                    if token.type not in callbacks
+                    else callbacks[token.type](token)
+                )
+                return
+            else:
+                ##
+
+                rule = arg
+                size = len(rule.expansion)
+                if size:
+                    s = value_stack[-size:]
+                    del state_stack[-size:]
+                    del value_stack[-size:]
+                else:
+                    s = []
+
+                value = callbacks[rule](s) if callbacks else s
+
+                _action, new_state = states[state_stack[-1]][rule.origin.name]
+                assert _action is Shift
+                state_stack.append(new_state)
+                value_stack.append(value)
+
+                if is_end and state_stack[-1] == end_state:
+                    return value_stack[-1]
+
+
+
+
+
+class LALR_Parser(Serialize):
+    def __init__(
+        self, parser_conf: ParserConf, debug: bool = False, strict: bool = False
+    ):
+        analysis = LALR_Analyzer(parser_conf, debug=debug, strict=strict)
+        analysis.compute_lalr()
+        callbacks = parser_conf.callbacks
+
+        self._parse_table = analysis.parse_table
+        self.parser_conf = parser_conf
+        self.parser = _Parser(analysis.parse_table, callbacks, debug)
+
+    @classmethod
+    def deserialize(cls, data, memo, callbacks, debug=False):
+        inst = cls.__new__(cls)
+        inst._parse_table = IntParseTable.deserialize(data, memo)
+        inst.parser = _Parser(inst._parse_table, callbacks, debug)
+        return inst
+
+    def serialize(self, memo: Any = None) -> Dict[str, Any]:
+        return self._parse_table.serialize(memo)
+
+    def parse_interactive(self, lexer: LexerThread, start: str):
+        return self.parser.parse(lexer, start, start_interactive=True)
+
+    def parse(self, lexer, start, on_error=None):
+        try:
+            return self.parser.parse(lexer, start)
+        except UnexpectedInput as e:
+            if on_error is None:
+                raise
+
+            while True:
+                if isinstance(e, UnexpectedCharacters):
+                    s = e.interactive_parser.lexer_thread.state
+                    p = s.line_ctr.char_pos
+
+                if not on_error(e):
+                    raise e
+
+                if isinstance(e, UnexpectedCharacters):
+                    ##
+
+                    if p == s.line_ctr.char_pos:
+                        s.line_ctr.feed(s.text[p : p + 1])
+
+                try:
+                    return e.interactive_parser.resume_parse()
+                except UnexpectedToken as e2:
+                    if (
+                        isinstance(e, UnexpectedToken)
+                        and e.token.type == e2.token.type == "$END"
+                        and e.interactive_parser == e2.interactive_parser
+                    ):
+                        ##
+
+                        raise e2
+                    e = e2
+                except UnexpectedCharacters as e2:
+                    e = e2
+
+
+class _Parser:
+    parse_table: ParseTableBase
+    callbacks: ParserCallbacks
+    debug: bool
+
+    def __init__(
+        self,
+        parse_table: ParseTableBase,
+        callbacks: ParserCallbacks,
+        debug: bool = False,
+    ):
+        self.parse_table = parse_table
+        self.callbacks = callbacks
+        self.debug = debug
+
+    def parse(
+        self,
+        lexer: LexerThread,
+        start: str,
+        value_stack=None,
+        state_stack=None,
+        start_interactive=False,
+    ):
+        parse_conf = ParseConf(self.parse_table, self.callbacks, start)
+        parser_state = ParserState(parse_conf, lexer, state_stack, value_stack)
+        if start_interactive:
+            return InteractiveParser(self, parser_state, parser_state.lexer)
+        return self.parse_from_state(parser_state)
+
+    def parse_from_state(self, state: ParserState, last_token: Optional[Token] = None):
+        #--
+        try:
+            token = last_token
+            for token in state.lexer.lex(state):
+                assert token is not None
+                state.feed_token(token)
+
+            end_token = (
+                Token.new_borrow_pos("$END", "", token)
+                if token
+                else Token("$END", "", 0, 1, 1)
+            )
+            return state.feed_token(end_token, True)
+        except UnexpectedInput as e:
+            try:
+                e.interactive_parser = InteractiveParser(self, state, state.lexer)
+            except NameError:
+                pass
+            raise e
+        except Exception as e:
+            if self.debug:
+                print("")
+                print("STATE STACK DUMP")
+                print("----------------")
+                for i, s in enumerate(state.state_stack):
+                    print("%d)" % i, s)
+                print("")
+
+            raise
+
+
+
+
+
+class InteractiveParser:
+    #--
+
+    def __init__(self, parser, parser_state, lexer_thread: LexerThread):
+        self.parser = parser
+        self.parser_state = parser_state
+        self.lexer_thread = lexer_thread
+        self.result = None
+
+    @property
+    def lexer_state(self) -> LexerThread:
+        warnings.warn(
+            "lexer_state will be removed in subsequent releases. Use lexer_thread instead.",
+            DeprecationWarning,
+        )
+        return self.lexer_thread
+
+    def feed_token(self, token: Token):
+        #--
+        return self.parser_state.feed_token(token, token.type == "$END")
+
+    def iter_parse(self) -> Iterator[Token]:
+        #--
+        for token in self.lexer_thread.lex(self.parser_state):
+            yield token
+            self.result = self.feed_token(token)
+
+    def exhaust_lexer(self) -> List[Token]:
+        #--
+        return list(self.iter_parse())
+
+    def feed_eof(self, last_token=None):
+        #--
+        eof = (
+            Token.new_borrow_pos("$END", "", last_token)
+            if last_token is not None
+            else self.lexer_thread._Token("$END", "", 0, 1, 1)
+        )
+        return self.feed_token(eof)
+
+    def __copy__(self):
+        #--
+        return type(self)(
+            self.parser,
+            copy(self.parser_state),
+            copy(self.lexer_thread),
+        )
+
+    def copy(self):
+        return copy(self)
+
+    def __eq__(self, other):
+        if not isinstance(other, InteractiveParser):
+            return False
+
+        return (
+            self.parser_state == other.parser_state
+            and self.lexer_thread == other.lexer_thread
+        )
+
+    def as_immutable(self):
+        #--
+        p = copy(self)
+        return ImmutableInteractiveParser(p.parser, p.parser_state, p.lexer_thread)
+
+    def pretty(self):
+        #--
+        out = ["Parser choices:"]
+        for k, v in self.choices().items():
+            out.append("\t- %s -> %r" % (k, v))
+        out.append("stack size: %s" % len(self.parser_state.state_stack))
+        return "\n".join(out)
+
+    def choices(self):
+        #--
+        return self.parser_state.parse_conf.parse_table.states[
+            self.parser_state.position
+        ]
+
+    def accepts(self):
+        #--
+        accepts = set()
+        conf_no_callbacks = copy(self.parser_state.parse_conf)
+        ##
+
+        ##
+
+        conf_no_callbacks.callbacks = {}
+        for t in self.choices():
+            if t.isupper():  ##
+
+                new_cursor = copy(self)
+                new_cursor.parser_state.parse_conf = conf_no_callbacks
+                try:
+                    new_cursor.feed_token(self.lexer_thread._Token(t, ""))
+                except UnexpectedToken:
+                    pass
+                else:
+                    accepts.add(t)
+        return accepts
+
+    def resume_parse(self):
+        #--
+        return self.parser.parse_from_state(
+            self.parser_state, last_token=self.lexer_thread.state.last_token
+        )
+
+
+class ImmutableInteractiveParser(InteractiveParser):
+    #--
+
+    result = None
+
+    def __hash__(self):
+        return hash((self.parser_state, self.lexer_thread))
+
+    def feed_token(self, token):
+        c = copy(self)
+        c.result = InteractiveParser.feed_token(c, token)
+        return c
+
+    def exhaust_lexer(self):
+        #--
+        cursor = self.as_mutable()
+        cursor.exhaust_lexer()
+        return cursor.as_immutable()
+
+    def as_mutable(self):
+        #--
+        p = copy(self)
+        return InteractiveParser(p.parser, p.parser_state, p.lexer_thread)
+
+
+
+
+
+def _wrap_lexer(lexer_class):
+    future_interface = getattr(lexer_class, "__future_interface__", False)
+    if future_interface:
+        return lexer_class
+    else:
+
+        class CustomLexerWrapper(Lexer):
+            def __init__(self, lexer_conf):
+                self.lexer = lexer_class(lexer_conf)
+
+            def lex(self, lexer_state, parser_state):
+                return self.lexer.lex(lexer_state.text)
+
+        return CustomLexerWrapper
+
+
+def _deserialize_parsing_frontend(data, memo, lexer_conf, callbacks, options):
+    parser_conf = ParserConf.deserialize(data["parser_conf"], memo)
+    cls = (options and options._plugins.get("LALR_Parser")) or LALR_Parser
+    parser = cls.deserialize(data["parser"], memo, callbacks, options.debug)
+    parser_conf.callbacks = callbacks
+    return ParsingFrontend(lexer_conf, parser_conf, options, parser=parser)
+
+
+_parser_creators: "Dict[str, Callable[[LexerConf, Any, Any], Any]]" = {}
+
+
+class ParsingFrontend(Serialize):
+    __serialize_fields__ = "lexer_conf", "parser_conf", "parser"
+
+    lexer_conf: LexerConf
+    parser_conf: ParserConf
+    options: Any
+
+    def __init__(
+        self, lexer_conf: LexerConf, parser_conf: ParserConf, options, parser=None
+    ):
+        self.parser_conf = parser_conf
+        self.lexer_conf = lexer_conf
+        self.options = options
+
+        ##
+
+        if parser:  ##
+
+            self.parser = parser
+        else:
+            create_parser = _parser_creators.get(parser_conf.parser_type)
+            assert (
+                create_parser is not None
+            ), "{} is not supported in standalone mode".format(parser_conf.parser_type)
+            self.parser = create_parser(lexer_conf, parser_conf, options)
+
+        ##
+
+        lexer_type = lexer_conf.lexer_type
+        self.skip_lexer = False
+        if lexer_type in ("dynamic", "dynamic_complete"):
+            assert lexer_conf.postlex is None
+            self.skip_lexer = True
+            return
+
+        if isinstance(lexer_type, type):
+            assert issubclass(lexer_type, Lexer)
+            self.lexer = _wrap_lexer(lexer_type)(lexer_conf)
+        elif isinstance(lexer_type, str):
+            create_lexer = {
+                "basic": create_basic_lexer,
+                "contextual": create_contextual_lexer,
+            }[lexer_type]
+            self.lexer = create_lexer(
+                lexer_conf, self.parser, lexer_conf.postlex, options
+            )
+        else:
+            raise TypeError("Bad value for lexer_type: {lexer_type}")
+
+        if lexer_conf.postlex:
+            self.lexer = PostLexConnector(self.lexer, lexer_conf.postlex)
+
+    def _verify_start(self, start=None):
+        if start is None:
+            start_decls = self.parser_conf.start
+            if len(start_decls) > 1:
+                raise ConfigurationError(
+                    "Lark initialized with more than 1 possible start rule. Must specify which start rule to parse",
+                    start_decls,
+                )
+            (start,) = start_decls
+        elif start not in self.parser_conf.start:
+            raise ConfigurationError(
+                "Unknown start rule %s. Must be one of %r"
+                % (start, self.parser_conf.start)
+            )
+        return start
+
+    def _make_lexer_thread(self, text: str) -> Union[str, LexerThread]:
+        cls = (self.options and self.options._plugins.get("LexerThread")) or LexerThread
+        return text if self.skip_lexer else cls.from_text(self.lexer, text)
+
+    def parse(self, text: str, start=None, on_error=None):
+        chosen_start = self._verify_start(start)
+        kw = {} if on_error is None else {"on_error": on_error}
+        stream = self._make_lexer_thread(text)
+        return self.parser.parse(stream, chosen_start, **kw)
+
+    def parse_interactive(self, text: Optional[str] = None, start=None):
+        ##
+
+        ##
+
+        chosen_start = self._verify_start(start)
+        if self.parser_conf.parser_type != "lalr":
+            raise ConfigurationError(
+                "parse_interactive() currently only works with parser='lalr' "
+            )
+        stream = self._make_lexer_thread(text)  ##
+
+        return self.parser.parse_interactive(stream, chosen_start)
+
+
+def _validate_frontend_args(parser, lexer) -> None:
+    assert_config(parser, ("lalr", "earley", "cyk"))
+    if not isinstance(lexer, type):  ##
+
+        expected = {
+            "lalr": ("basic", "contextual"),
+            "earley": ("basic", "dynamic", "dynamic_complete"),
+            "cyk": ("basic",),
+        }[parser]
+        assert_config(
+            lexer,
+            expected,
+            "Parser %r does not support lexer %%r, expected one of %%s" % parser,
+        )
+
+
+def _get_lexer_callbacks(transformer, terminals):
+    result = {}
+    for terminal in terminals:
+        callback = getattr(transformer, terminal.name, None)
+        if callback is not None:
+            result[terminal.name] = callback
+    return result
+
+
+class PostLexConnector:
+    def __init__(self, lexer, postlexer):
+        self.lexer = lexer
+        self.postlexer = postlexer
+
+    def lex(self, lexer_state, parser_state):
+        i = self.lexer.lex(lexer_state, parser_state)
+        return self.postlexer.process(i)
+
+
+def create_basic_lexer(lexer_conf, parser, postlex, options) -> BasicLexer:
+    cls = (options and options._plugins.get("BasicLexer")) or BasicLexer
+    return cls(lexer_conf)
+
+
+def create_contextual_lexer(
+    lexer_conf: LexerConf, parser, postlex, options
+) -> ContextualLexer:
+    cls = (options and options._plugins.get("ContextualLexer")) or ContextualLexer
+    parse_table: ParseTableBase[int] = parser._parse_table
+    states: Dict[int, Collection[str]] = {
+        idx: list(t.keys()) for idx, t in parse_table.states.items()
+    }
+    always_accept: Collection[str] = postlex.always_accept if postlex else ()
+    return cls(lexer_conf, states, always_accept=always_accept)
+
+
+def create_lalr_parser(
+    lexer_conf: LexerConf, parser_conf: ParserConf, options=None
+) -> LALR_Parser:
+    debug = options.debug if options else False
+    strict = options.strict if options else False
+    cls = (options and options._plugins.get("LALR_Parser")) or LALR_Parser
+    return cls(parser_conf, debug=debug, strict=strict)
+
+
+_parser_creators["lalr"] = create_lalr_parser
+
+
+
+
+class PostLex(ABC):
+    @abstractmethod
+    def process(self, stream: Iterator[Token]) -> Iterator[Token]:
+        return stream
+
+    always_accept: Iterable[str] = ()
+
+
+class LarkOptions(Serialize):
+    #--
+
+    start: List[str]
+    debug: bool
+    strict: bool
+    transformer: "Optional[Transformer]"
+    propagate_positions: Union[bool, str]
+    maybe_placeholders: bool
+    cache: Union[bool, str]
+    regex: bool
+    g_regex_flags: int
+    keep_all_tokens: bool
+    tree_class: Optional[Callable[[str, List], Any]]
+    parser: _ParserArgType
+    lexer: _LexerArgType
+    ambiguity: 'Literal["auto", "resolve", "explicit", "forest"]'
+    postlex: Optional[PostLex]
+    priority: 'Optional[Literal["auto", "normal", "invert"]]'
+    lexer_callbacks: Dict[str, Callable[[Token], Token]]
+    use_bytes: bool
+    ordered_sets: bool
+    edit_terminals: Optional[Callable[[TerminalDef], TerminalDef]]
+    import_paths: "List[Union[str, Callable[[Union[None, str, PackageResource], str], Tuple[str, str]]]]"
+    source_path: Optional[str]
+
+    OPTIONS_DOC = r"""
+    **===  General Options  ===**
+
+    start
+            The start symbol. Either a string, or a list of strings for multiple possible starts (Default: "start")
+    debug
+            Display debug information and extra warnings. Use only when debugging (Default: ``False``)
+            When used with Earley, it generates a forest graph as "sppf.png", if 'dot' is installed.
+    strict
+            Throw an exception on any potential ambiguity, including shift/reduce conflicts, and regex collisions.
+    transformer
+            Applies the transformer to every parse tree (equivalent to applying it after the parse, but faster)
+    propagate_positions
+            Propagates positional attributes into the 'meta' attribute of all tree branches.
+            Sets attributes: (line, column, end_line, end_column, start_pos, end_pos,
+                              container_line, container_column, container_end_line, container_end_column)
+            Accepts ``False``, ``True``, or a callable, which will filter which nodes to ignore when propagating.
+    maybe_placeholders
+            When ``True``, the ``[]`` operator returns ``None`` when not matched.
+            When ``False``,  ``[]`` behaves like the ``?`` operator, and returns no value at all.
+            (default= ``True``)
+    cache
+            Cache the results of the Lark grammar analysis, for x2 to x3 faster loading. LALR only for now.
+
+            - When ``False``, does nothing (default)
+            - When ``True``, caches to a temporary file in the local directory
+            - When given a string, caches to the path pointed by the string
+    regex
+            When True, uses the ``regex`` module instead of the stdlib ``re``.
+    g_regex_flags
+            Flags that are applied to all terminals (both regex and strings)
+    keep_all_tokens
+            Prevent the tree builder from automagically removing "punctuation" tokens (Default: ``False``)
+    tree_class
+            Lark will produce trees comprised of instances of this class instead of the default ``lark.Tree``.
+
+    **=== Algorithm Options ===**
+
+    parser
+            Decides which parser engine to use. Accepts "earley" or "lalr". (Default: "earley").
+            (there is also a "cyk" option for legacy)
+    lexer
+            Decides whether or not to use a lexer stage
+
+            - "auto" (default): Choose for me based on the parser
+            - "basic": Use a basic lexer
+            - "contextual": Stronger lexer (only works with parser="lalr")
+            - "dynamic": Flexible and powerful (only with parser="earley")
+            - "dynamic_complete": Same as dynamic, but tries *every* variation of tokenizing possible.
+    ambiguity
+            Decides how to handle ambiguity in the parse. Only relevant if parser="earley"
+
+            - "resolve": The parser will automatically choose the simplest derivation
+              (it chooses consistently: greedy for tokens, non-greedy for rules)
+            - "explicit": The parser will return all derivations wrapped in "_ambig" tree nodes (i.e. a forest).
+            - "forest": The parser will return the root of the shared packed parse forest.
+
+    **=== Misc. / Domain Specific Options ===**
+
+    postlex
+            Lexer post-processing (Default: ``None``) Only works with the basic and contextual lexers.
+    priority
+            How priorities should be evaluated - "auto", ``None``, "normal", "invert" (Default: "auto")
+    lexer_callbacks
+            Dictionary of callbacks for the lexer. May alter tokens during lexing. Use with caution.
+    use_bytes
+            Accept an input of type ``bytes`` instead of ``str``.
+    ordered_sets
+            Should Earley use ordered-sets to achieve stable output (~10% slower than regular sets. Default: True)
+    edit_terminals
+            A callback for editing the terminals before parse.
+    import_paths
+            A List of either paths or loader functions to specify from where grammars are imported
+    source_path
+            Override the source of from where the grammar was loaded. Useful for relative imports and unconventional grammar loading
+    **=== End of Options ===**
+    """
+    if __doc__:
+        __doc__ += OPTIONS_DOC
+
+    ##
+
+    ##
+
+    ##
+
+    ##
+
+    ##
+
+    ##
+
+    _defaults: Dict[str, Any] = {
+        "debug": False,
+        "strict": False,
+        "keep_all_tokens": False,
+        "tree_class": None,
+        "cache": False,
+        "postlex": None,
+        "parser": "earley",
+        "lexer": "auto",
+        "transformer": None,
+        "start": "start",
+        "priority": "auto",
+        "ambiguity": "auto",
+        "regex": False,
+        "propagate_positions": False,
+        "lexer_callbacks": {},
+        "maybe_placeholders": True,
+        "edit_terminals": None,
+        "g_regex_flags": 0,
+        "use_bytes": False,
+        "ordered_sets": True,
+        "import_paths": [],
+        "source_path": None,
+        "_plugins": {},
+    }
+
+    def __init__(self, options_dict: Dict[str, Any]) -> None:
+        o = dict(options_dict)
+
+        options = {}
+        for name, default in self._defaults.items():
+            if name in o:
+                value = o.pop(name)
+                if isinstance(default, bool) and name not in (
+                    "cache",
+                    "use_bytes",
+                    "propagate_positions",
+                ):
+                    value = bool(value)
+            else:
+                value = default
+
+            options[name] = value
+
+        if isinstance(options["start"], str):
+            options["start"] = [options["start"]]
+
+        self.__dict__["options"] = options
+
+        assert_config(self.parser, ("earley", "lalr", "cyk", None))
+
+        if self.parser == "earley" and self.transformer:
+            raise ConfigurationError(
+                "Cannot specify an embedded transformer when using the Earley algorithm. "
+                "Please use your transformer on the resulting parse tree, or use a different algorithm (i.e. LALR)"
+            )
+
+        if o:
+            raise ConfigurationError("Unknown options: %s" % o.keys())
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self.__dict__["options"][name]
+        except KeyError as e:
+            raise AttributeError(e)
+
+    def __setattr__(self, name: str, value: str) -> None:
+        assert_config(
+            name, self.options.keys(), "%r isn't a valid option. Expected one of: %s"
+        )
+        self.options[name] = value
+
+    def serialize(self, memo=None) -> Dict[str, Any]:
+        return self.options
+
+    @classmethod
+    def deserialize(
+        cls, data: Dict[str, Any], memo: Dict[int, Union[TerminalDef, Rule]]
+    ) -> "LarkOptions":
+        return cls(data)
+
+
+##
+
+##
+
+_LOAD_ALLOWED_OPTIONS = {
+    "postlex",
+    "transformer",
+    "lexer_callbacks",
+    "use_bytes",
+    "debug",
+    "g_regex_flags",
+    "regex",
+    "propagate_positions",
+    "tree_class",
+    "_plugins",
+}
+
+_VALID_PRIORITY_OPTIONS = ("auto", "normal", "invert", None)
+_VALID_AMBIGUITY_OPTIONS = ("auto", "resolve", "explicit", "forest")
+
+
+_T = TypeVar("_T", bound="Lark")
+
+
+class Lark(Serialize):
+    #--
+
+    source_path: str
+    source_grammar: str
+    grammar: "Grammar"
+    options: LarkOptions
+    lexer: Lexer
+    parser: "ParsingFrontend"
+    terminals: Collection[TerminalDef]
+
+    def __init__(self, grammar: "Union[Grammar, str, IO[str]]", **options) -> None:
+        self.options = LarkOptions(options)
+        re_module: types.ModuleType
+
+        ##
+
+        use_regex = self.options.regex
+        if use_regex:
+            if _has_regex:
+                re_module = regex
+            else:
+                raise ImportError(
+                    "`regex` module must be installed if calling `Lark(regex=True)`."
+                )
+        else:
+            re_module = re
+
+        ##
+
+        if self.options.source_path is None:
+            try:
+                self.source_path = grammar.name  ##
+
+            except AttributeError:
+                self.source_path = "<string>"
+        else:
+            self.source_path = self.options.source_path
+
+        ##
+
+        try:
+            read = grammar.read  ##
+
+        except AttributeError:
+            pass
+        else:
+            grammar = read()
+
+        cache_fn = None
+        cache_sha256 = None
+        if isinstance(grammar, str):
+            self.source_grammar = grammar
+            if self.options.use_bytes:
+                if not isascii(grammar):
+                    raise ConfigurationError(
+                        "Grammar must be ascii only, when use_bytes=True"
+                    )
+
+            if self.options.cache:
+                if self.options.parser != "lalr":
+                    raise ConfigurationError(
+                        "cache only works with parser='lalr' for now"
+                    )
+
+                unhashable = (
+                    "transformer",
+                    "postlex",
+                    "lexer_callbacks",
+                    "edit_terminals",
+                    "_plugins",
+                )
+                options_str = "".join(
+                    k + str(v) for k, v in options.items() if k not in unhashable
+                )
+                from . import __version__
+
+                s = grammar + options_str + __version__ + str(sys.version_info[:2])
+                cache_sha256 = sha256_digest(s)
+
+                if isinstance(self.options.cache, str):
+                    cache_fn = self.options.cache
+                else:
+                    if self.options.cache is not True:
+                        raise ConfigurationError("cache argument must be bool or str")
+
+                    try:
+                        username = getpass.getuser()
+                    except Exception:
+                        ##
+
+                        ##
+
+                        ##
+
+                        username = "unknown"
+
+                    cache_fn = (
+                        tempfile.gettempdir()
+                        + "/.lark_cache_%s_%s_%s_%s.tmp"
+                        % (username, cache_sha256, *sys.version_info[:2])
+                    )
+
+                old_options = self.options
+                try:
+                    with FS.open(cache_fn, "rb") as f:
+                        logger.debug("Loading grammar from cache: %s", cache_fn)
+                        ##
+
+                        for name in set(options) - _LOAD_ALLOWED_OPTIONS:
+                            del options[name]
+                        file_sha256 = f.readline().rstrip(b"\n")
+                        cached_used_files = pickle.load(f)
+                        if file_sha256 == cache_sha256.encode(
+                            "utf8"
+                        ) and verify_used_files(cached_used_files):
+                            cached_parser_data = pickle.load(f)
+                            self._load(cached_parser_data, **options)
+                            return
+                except FileNotFoundError:
+                    ##
+
+                    pass
+                except (
+                    Exception
+                ):  ##
+
+                    logger.exception(
+                        "Failed to load Lark from cache: %r. We will try to carry on.",
+                        cache_fn,
+                    )
+
+                    ##
+
+                    ##
+
+                    self.options = old_options
+
+            ##
+
+            self.grammar, used_files = load_grammar(
+                grammar,
+                self.source_path,
+                self.options.import_paths,
+                self.options.keep_all_tokens,
+            )
+        else:
+            assert isinstance(grammar, Grammar)
+            self.grammar = grammar
+
+        if self.options.lexer == "auto":
+            if self.options.parser == "lalr":
+                self.options.lexer = "contextual"
+            elif self.options.parser == "earley":
+                if self.options.postlex is not None:
+                    logger.info(
+                        "postlex can't be used with the dynamic lexer, so we use 'basic' instead. "
+                        "Consider using lalr with contextual instead of earley"
+                    )
+                    self.options.lexer = "basic"
+                else:
+                    self.options.lexer = "dynamic"
+            elif self.options.parser == "cyk":
+                self.options.lexer = "basic"
+            else:
+                assert False, self.options.parser
+        lexer = self.options.lexer
+        if isinstance(lexer, type):
+            assert issubclass(
+                lexer, Lexer
+            )  ##
+
+        else:
+            assert_config(lexer, ("basic", "contextual", "dynamic", "dynamic_complete"))
+            if self.options.postlex is not None and "dynamic" in lexer:
+                raise ConfigurationError(
+                    "Can't use postlex with a dynamic lexer. Use basic or contextual instead"
+                )
+
+        if self.options.ambiguity == "auto":
+            if self.options.parser == "earley":
+                self.options.ambiguity = "resolve"
+        else:
+            assert_config(
+                self.options.parser,
+                ("earley", "cyk"),
+                "%r doesn't support disambiguation. Use one of these parsers instead: %s",
+            )
+
+        if self.options.priority == "auto":
+            self.options.priority = "normal"
+
+        if self.options.priority not in _VALID_PRIORITY_OPTIONS:
+            raise ConfigurationError(
+                "invalid priority option: %r. Must be one of %r"
+                % (self.options.priority, _VALID_PRIORITY_OPTIONS)
+            )
+        if self.options.ambiguity not in _VALID_AMBIGUITY_OPTIONS:
+            raise ConfigurationError(
+                "invalid ambiguity option: %r. Must be one of %r"
+                % (self.options.ambiguity, _VALID_AMBIGUITY_OPTIONS)
+            )
+
+        if self.options.parser is None:
+            terminals_to_keep = "*"
+        elif self.options.postlex is not None:
+            terminals_to_keep = set(self.options.postlex.always_accept)
+        else:
+            terminals_to_keep = set()
+
+        ##
+
+        self.terminals, self.rules, self.ignore_tokens = self.grammar.compile(
+            self.options.start, terminals_to_keep
+        )
+
+        if self.options.edit_terminals:
+            for t in self.terminals:
+                self.options.edit_terminals(t)
+
+        self._terminals_dict = {t.name: t for t in self.terminals}
+
+        ##
+
+        if self.options.priority == "invert":
+            for rule in self.rules:
+                if rule.options.priority is not None:
+                    rule.options.priority = -rule.options.priority
+            for term in self.terminals:
+                term.priority = -term.priority
+        ##
+
+        ##
+
+        ##
+
+        elif self.options.priority is None:
+            for rule in self.rules:
+                if rule.options.priority is not None:
+                    rule.options.priority = None
+            for term in self.terminals:
+                term.priority = 0
+
+        ##
+
+        self.lexer_conf = LexerConf(
+            self.terminals,
+            re_module,
+            self.ignore_tokens,
+            self.options.postlex,
+            self.options.lexer_callbacks,
+            self.options.g_regex_flags,
+            use_bytes=self.options.use_bytes,
+            strict=self.options.strict,
+        )
+
+        if self.options.parser:
+            self.parser = self._build_parser()
+        elif lexer:
+            self.lexer = self._build_lexer()
+
+        if cache_fn:
+            logger.debug("Saving grammar to cache: %s", cache_fn)
+            try:
+                with FS.open(cache_fn, "wb") as f:
+                    assert cache_sha256 is not None
+                    f.write(cache_sha256.encode("utf8") + b"\n")
+                    pickle.dump(used_files, f)
+                    self.save(f, _LOAD_ALLOWED_OPTIONS)
+            except IOError as e:
+                logger.exception("Failed to save Lark to cache: %r.", cache_fn, e)
+
+    if __doc__:
+        __doc__ += "\n\n" + LarkOptions.OPTIONS_DOC
+
+    __serialize_fields__ = "parser", "rules", "options"
+
+    def _build_lexer(self, dont_ignore: bool = False) -> BasicLexer:
+        lexer_conf = self.lexer_conf
+        if dont_ignore:
+            from copy import copy
+
+            lexer_conf = copy(lexer_conf)
+            lexer_conf.ignore = ()
+        return BasicLexer(lexer_conf)
+
+    def _prepare_callbacks(self) -> None:
+        self._callbacks = {}
+        ##
+
+        if self.options.ambiguity != "forest":
+            self._parse_tree_builder = ParseTreeBuilder(
+                self.rules,
+                self.options.tree_class or Tree,
+                self.options.propagate_positions,
+                self.options.parser != "lalr" and self.options.ambiguity == "explicit",
+                self.options.maybe_placeholders,
+            )
+            self._callbacks = self._parse_tree_builder.create_callback(
+                self.options.transformer
+            )
+        self._callbacks.update(
+            _get_lexer_callbacks(self.options.transformer, self.terminals)
+        )
+
+    def _build_parser(self) -> "ParsingFrontend":
+        self._prepare_callbacks()
+        _validate_frontend_args(self.options.parser, self.options.lexer)
+        parser_conf = ParserConf(self.rules, self._callbacks, self.options.start)
+        return _construct_parsing_frontend(
+            self.options.parser,
+            self.options.lexer,
+            self.lexer_conf,
+            parser_conf,
+            options=self.options,
+        )
+
+    def save(self, f, exclude_options: Collection[str] = ()) -> None:
+        #--
+        if self.options.parser != "lalr":
+            raise NotImplementedError(
+                "Lark.save() is only implemented for the LALR(1) parser."
+            )
+        data, m = self.memo_serialize([TerminalDef, Rule])
+        if exclude_options:
+            data["options"] = {
+                n: v for n, v in data["options"].items() if n not in exclude_options
+            }
+        pickle.dump({"data": data, "memo": m}, f, protocol=pickle.HIGHEST_PROTOCOL)
+
+    @classmethod
+    def load(cls: Type[_T], f) -> _T:
+        #--
+        inst = cls.__new__(cls)
+        return inst._load(f)
+
+    def _deserialize_lexer_conf(
+        self,
+        data: Dict[str, Any],
+        memo: Dict[int, Union[TerminalDef, Rule]],
+        options: LarkOptions,
+    ) -> LexerConf:
+        lexer_conf = LexerConf.deserialize(data["lexer_conf"], memo)
+        lexer_conf.callbacks = options.lexer_callbacks or {}
+        lexer_conf.re_module = regex if options.regex else re
+        lexer_conf.use_bytes = options.use_bytes
+        lexer_conf.g_regex_flags = options.g_regex_flags
+        lexer_conf.skip_validation = True
+        lexer_conf.postlex = options.postlex
+        return lexer_conf
+
+    def _load(self: _T, f: Any, **kwargs) -> _T:
+        if isinstance(f, dict):
+            d = f
+        else:
+            d = pickle.load(f)
+        memo_json = d["memo"]
+        data = d["data"]
+
+        assert memo_json
+        memo = SerializeMemoizer.deserialize(
+            memo_json, {"Rule": Rule, "TerminalDef": TerminalDef}, {}
+        )
+        options = dict(data["options"])
+        if (set(kwargs) - _LOAD_ALLOWED_OPTIONS) & set(LarkOptions._defaults):
+            raise ConfigurationError(
+                "Some options are not allowed when loading a Parser: {}".format(
+                    set(kwargs) - _LOAD_ALLOWED_OPTIONS
+                )
+            )
+        options.update(kwargs)
+        self.options = LarkOptions.deserialize(options, memo)
+        self.rules = [Rule.deserialize(r, memo) for r in data["rules"]]
+        self.source_path = "<deserialized>"
+        _validate_frontend_args(self.options.parser, self.options.lexer)
+        self.lexer_conf = self._deserialize_lexer_conf(
+            data["parser"], memo, self.options
+        )
+        self.terminals = self.lexer_conf.terminals
+        self._prepare_callbacks()
+        self._terminals_dict = {t.name: t for t in self.terminals}
+        self.parser = _deserialize_parsing_frontend(
+            data["parser"],
+            memo,
+            self.lexer_conf,
+            self._callbacks,
+            self.options,  ##
+
+        )
+        return self
+
+    @classmethod
+    def _load_from_dict(cls, data, memo, **kwargs):
+        inst = cls.__new__(cls)
+        return inst._load({"data": data, "memo": memo}, **kwargs)
+
+    @classmethod
+    def open(
+        cls: Type[_T], grammar_filename: str, rel_to: Optional[str] = None, **options
+    ) -> _T:
+        #--
+        if rel_to:
+            basepath = os.path.dirname(rel_to)
+            grammar_filename = os.path.join(basepath, grammar_filename)
+        with open(grammar_filename, encoding="utf8") as f:
+            return cls(f, **options)
+
+    @classmethod
+    def open_from_package(
+        cls: Type[_T],
+        package: str,
+        grammar_path: str,
+        search_paths: "Sequence[str]" = [""],
+        **options
+    ) -> _T:
+        #--
+        package_loader = FromPackageLoader(package, search_paths)
+        full_path, text = package_loader(None, grammar_path)
+        options.setdefault("source_path", full_path)
+        options.setdefault("import_paths", [])
+        options["import_paths"].append(package_loader)
+        return cls(text, **options)
+
+    def __repr__(self):
+        return "Lark(open(%r), parser=%r, lexer=%r, ...)" % (
+            self.source_path,
+            self.options.parser,
+            self.options.lexer,
+        )
+
+    def lex(self, text: str, dont_ignore: bool = False) -> Iterator[Token]:
+        #--
+        lexer: Lexer
+        if not hasattr(self, "lexer") or dont_ignore:
+            lexer = self._build_lexer(dont_ignore)
+        else:
+            lexer = self.lexer
+        lexer_thread = LexerThread.from_text(lexer, text)
+        stream = lexer_thread.lex(None)
+        if self.options.postlex:
+            return self.options.postlex.process(stream)
+        return stream
+
+    def get_terminal(self, name: str) -> TerminalDef:
+        #--
+        return self._terminals_dict[name]
+
+    def parse_interactive(
+        self, text: Optional[str] = None, start: Optional[str] = None
+    ) -> "InteractiveParser":
+        #--
+        return self.parser.parse_interactive(text, start=start)
+
+    def parse(
+        self,
+        text: str,
+        start: Optional[str] = None,
+        on_error: "Optional[Callable[[UnexpectedInput], bool]]" = None,
+    ) -> "ParseTree":
+        #--
+        return self.parser.parse(text, start=start, on_error=on_error)
+
+
+
+
+
+class DedentError(LarkError):
+    pass
+
+
+class Indenter(PostLex, ABC):
+    paren_level: int
+    indent_level: List[int]
+
+    def __init__(self) -> None:
+        self.paren_level = 0
+        self.indent_level = [0]
+        assert self.tab_len > 0
+
+    def handle_NL(self, token: Token) -> Iterator[Token]:
+        if self.paren_level > 0:
+            return
+
+        yield token
+
+        indent_str = token.rsplit("\n", 1)[1]  ##
+
+        indent = indent_str.count(" ") + indent_str.count("\t") * self.tab_len
+
+        if indent > self.indent_level[-1]:
+            self.indent_level.append(indent)
+            yield Token.new_borrow_pos(self.INDENT_type, indent_str, token)
+        else:
+            while indent < self.indent_level[-1]:
+                self.indent_level.pop()
+                yield Token.new_borrow_pos(self.DEDENT_type, indent_str, token)
+
+            if indent != self.indent_level[-1]:
+                raise DedentError(
+                    "Unexpected dedent to column %s. Expected dedent to %s"
+                    % (indent, self.indent_level[-1])
+                )
+
+    def _process(self, stream):
+        for token in stream:
+            if token.type == self.NL_type:
+                yield from self.handle_NL(token)
+            else:
+                yield token
+
+            if token.type in self.OPEN_PAREN_types:
+                self.paren_level += 1
+            elif token.type in self.CLOSE_PAREN_types:
+                self.paren_level -= 1
+                assert self.paren_level >= 0
+
+        while len(self.indent_level) > 1:
+            self.indent_level.pop()
+            yield Token(self.DEDENT_type, "")
+
+        assert self.indent_level == [0], self.indent_level
+
+    def process(self, stream):
+        self.paren_level = 0
+        self.indent_level = [0]
+        return self._process(stream)
+
+    ##
+
+    @property
+    def always_accept(self):
+        return (self.NL_type,)
+
+    @property
+    @abstractmethod
+    def NL_type(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def OPEN_PAREN_types(self) -> List[str]:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def CLOSE_PAREN_types(self) -> List[str]:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def INDENT_type(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def DEDENT_type(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def tab_len(self) -> int:
+        raise NotImplementedError()
+
+
+class PythonIndenter(Indenter):
+    NL_type = "_NEWLINE"
+    OPEN_PAREN_types = ["LPAR", "LSQB", "LBRACE"]
+    CLOSE_PAREN_types = ["RPAR", "RSQB", "RBRACE"]
+    INDENT_type = "_INDENT"
+    DEDENT_type = "_DEDENT"
+    tab_len = 8
+
+
+
+import pickle, zlib, base64
+DATA = (
+b'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'
+)
+DATA = pickle.loads(zlib.decompress(base64.b64decode(DATA)))
+MEMO = (
+b'eJzdfQl8G8X1f+L7zH2HEDCEXCTOwWlyINtKIlYjGdmOCXHYyvImliJLRpJzQMJRSingQgEDpVCuchboSSmFUgqlN70oUCilXL0P2l9/0F/v/ne1K+3szM7set+ubP7wgWRnNTPf933vzbw596LK6ydNmjxJ+efw6DJB+d9IRSo6KI2O1HXt6BA7uyKB0NbRkeqhaC4nZVKjyg8q90WTw/IvyrO5zOhI5e5kdE92dJf8nInul5+b5OSm0ZEaUcwdHJJEUS6qQ83dKf9+eKRmKBNPZ+K5g6PCpIGGkfouKTMYT0WT7dLu0WFhslzDQNlItVJ7INQ1OlChJFSNlMdTudGBml2jA3VyFfJD0+hAw0Dj8MAUpZSBqcNCmZqzVsm5JRj26XlliOloMXd1U/6Ryl+u5q9R8gcDnXr2imQ8W8xd1aQ8UZkrsMq7ujuCfr3y3PBQUtIrzz9S+SsxsTv9mNhZCRNbfqByVmGw2wNtGOz+eAyDrTxRmauxzK3hcFDP3JdOJ/XMyhOVuQaTuXVHl79Tl7nvYE7K6jLnH6n8tZjMvtAOXeZo6qAus/xA5azDYMv/6WRXKCanw1aeqMz1auYqoUcM4kwncaaTJkw3qBnr5Yy+VtkzfBjZ5dG+LIa5j5a2UcMs524L+joxsmLJaBYjK/9IZZ+ikS1nD7ee4cerTvcl9KrlByrvVI1oOa8/1I10tqTU8KDOlvJE5Z2m5w2F2zGmU+l+jGnlico7Xccc2BoKR/TcVfE9qXSmmL+mSX2mSpihk7Y90BnAXHpfPBvHXDr/SGWfqWavk7NH/MYCqjOSoYjaJi2BKmSWjqGzw9cT0jFkh6L7UzqG/COVfbZOYE+ga5tO4P54bkAnUHmi8s7Rq/aHuiK6i1RKqVzmoF51/pHKPhfT+1mY7BXSgTjWMihPVN55mO5QRzjShelucCidyWG6yz9TJczXyQ+E2oLdmPFUx1Ox5LBuP7VNWgJVyAJdhC2RMGa6uzNpzHSVJyrvQjVvpeKvuruVRYu+VtEUpR3tCIy09q2YwUv9ezCDV56ovIt00np8QcEf0UnbH03ulTI6aeozVcKRusZ9nTtCbbrGo9mDqZiu8fwjlX0xlr3Hh/tLdH8U95f8I5X9KF12uTnHDEZuvjGDUZ6ovEfrssutmx83GLk9k3CDUZ+pEpp0fQW26PqK79b1Fd9N5ToG01cQy1chJfWcsr6SJnmPxfN24rpOZnFdy09U3iV6N7IlrCu6fHc6o7fG8gOV8ThdzK6wLmYurYuZS1O5luq5WvV2oKzvoJ6rj24Blun20LMtgEcl+wfieFSSf6SyL9d7vLZwqCsQ6tZLqImlU7l4arhYSF1TIYUqZ4UOozXi9wlYoJCRonuxQEF5pLKvVLM3yNnbA53+0FYf5pe1/fGslNoT1Z2zvqmYRBV1vI5kR8AfbNeRHIxLyX4dSf6Ryr5KN5hOIdChG0x2b3xINxjlicq7WneQiN/YomYkY4uqPlMlNOMldHVHQngJueFMCi9BeaZKWKOX0O6Xox+dxvJ+KanbrfxA5V2rGzzeFZVjHVFlk1k3tE6v1H9Wm78DE1w6EJOGMMHVZ6qE9XpXsiUQ8gWDevXVu5WxQ/Kg3pVoCVQhJ+iqj/gCmLdXZqLxLOYL+Ucq+4lY6xTCWqcU1jrRhJ+E5cL6oDjWB8XpPuhk3cw6IoHtupnJQ6d9upkpT1TeU3Q1dXS36moaGu7T1SQ/UBlPxSsNY5HSUCadk2JYpKQlUCW06FVvw3rc8oEoFhsPmPS5p+kWsjUYbvVh45A9yXSfLrHyROXeoFfb5tNVUx6LpvRq5Qcq40a92s4uX1dA722rsrloLh7TDVN9pkrYpDeQ4e3+SCSABTk16X1SJhPvxxrIQgpVzmbdNpGvq02PEisHo7nYgG6b+Ucq++m66tp8eD8Wi+L9mPJE5fXpebf5sRC9YkDKYHmVJypvK9Yc+oNY35uVkljfqzxRedv0vIEQHpzGU3hwqjxRedv1DqEj3NllLKBmKJ3N4YXUNRVSqIL8WGzf3YHFa5XZ4SE9XJNje+WRyr5FlyESxlymIpNOYzIoT1TerVrLYJyqOHpZb//KZb2re/tXLD+k/LFy+bKdkn/XzpWrdm1WnjYXij2m2fKnzaMjVeL+eL88ztg1ukwou6Lyv/I/k6SBhpFabUpGVjiGaZvWzraH2wpTPwVgi5uampatPlR3qHH5is3y3w8tXbq0+Cz/vQBrSbP6w97Uod6M4aeFFPmpeTTx2ORJkxRQVTqoxJflNAXNZBVNQGO3Y0coGAjpljm7pWXoYEtLsXb1sQBgfnPxdaFGNQGrtMGkUo2CM7TGhBB/+bLM5r7Nh/o2ZzYvb9p5TlNj3a4VTYewxKU7z1mqJBaJaG4msvRmelMmmdRknJIyNjpBRVdhmKup68oMS4e2RLGYtaFZT8NKrhAqTXgO6u1nCOvaGnr7Uulcb3ZlPNVbbIKnNOOp9vSI9PIDnYby41m5IKU4Q/l6qr3yQ2r55dv8ZxULn7Fm54Gzdu1cs+rU6KrdvlVbxF0rC1XMaqbfYRWVs9kPaxW1YizVr9nZ1yoXtharobEZS7RXdIdWdBib2GlYszMdVnCejJU9pRlPtVf4mVrh+HxqgyJ/ngRx1wq9cDwVK3wyu/CIZpKh7iDWbYfSKb3zaFaeDGZYYaLGzmKQ5+9sE0M+pHv8vA2bdkZXnedbdba4S/uLEfiCZtYv7DHUVRACr3UOv855zZY1cmjr1noeXyQSlkdFAZ26DatWbdKpU57Y1GmFbddaSrUwXQ3lcu5iCKQUhbMhlJuU1GMoCRvWYqAqm42YzEs6S1OnhknsWIuL2NuCi9jbYlncDkNxEbFjnY6tBcfWYgPb2SQ2vbCyliJjFXJZeLMslJkUtZPEtRbjTJdS5swgpHlhvVpA2kZZRdWG3pW9K4ti1jSrz5aWsUszszbSNCrzBRQDHLU8S+LOMRaHxUsGeNXNJDrz4kQtfG4zMZI8wBYjQGszeZ+xRIOdVLRgEKuaW+wgjFIIcbvTCaxUirPUbx+FDnMKXNyqZkJa8/Jimr2ogyYxrE9INLTsaTnUogyXoskWvXnHUw2y15iU3q+hDYVDwXCbsfypLamkXFQqnUqmY1gV05uJFwYLrTOpRdJkUCdMjTLsl0tSJ0pxGbBUSxl2a+2ZsnaBl13Xksqj7Jda9JhJTzOUW2VS7h6tXGWK2FiuJJehTA7j5RbTLMsdKDiYskSEF9zYEktm5WLyq0PFsqc2G5Kx4iuFapPi4xrZ6hISXn5tS1ouJt2XKJZd31xMMsCuNCk3odGhLMYZVPi+Qy05uRBlIQ5TIZ6Kd5emlOwtUB3qRnjZVS3KglWL3iSqz3jMaFpestBitwaCga4dRhJiCpfRFE5CIcmShMFCwWJHQKZhS0871qtswnqVTZaOndJcTyuqVcDL2tCil7XBupFIayZFgSrvPYT1m/KDZVFDmvnQoMo39B7CIo3eQ5ZlnauptT3cRaBajaNabY0qowmolESCWo2DWm1ZVFbjXZ1eFbfhEXPZKkyHq6xh5TRY/uD2gMGVy3s3Y3GB/GBZ1HChFZNjbDGsT5+X9W7WIfVuNrjSZJNy9mn6Q74u1B0U/WfqJZ2+US/p9I2WiPYXOPe3hQ2N9uTTC+WUN59uCejA4eLQ0BfSFVd13HGHoql+3bXVZwMqQ2+tDSEOqsUps63Ykkx176HeQ4f0ZZnaZi2BLaVW3nkaPF97O05Wee/KjZgCV1rTdb5WUGd3q4H1VRjrq6yLOaSZZ2eXT44d5AgCK6uqd4X870adM/XZMsI5rEEjDKK8dwUu4wprcBeoBTVsCYZlk2gPbMeLq+xt7m3eqEdz+UdLbBdq2IjCyrGiKomCzLFdVBAybFBk2RKM/yXWxVys+U9r3lwNJR2HlXScdUnv1/ynVbFUo2yHcNkOWRd1iQ7qLLKsc/CyzrEu6wN6WSG5NcUFvAAT8ALrki7VSgp2bgtsMZRUvmEDhkp+sDSDD2plReiyNm3CypIfLMu6TLMEFRfWqW7AOtUNluJ9SCsmQhSzCesjNln3EZerxZQHsZW4sg0Y0xusmb5CK2MrXsYmrIxN1mVcqZZRhs2ylh2NFXG0dREjGowQNg9entKnwSubUiaz4B/Wo/9Id6fB4Fqw+lus679Ka/vbwsGwPj03uUXvjlosu6OrC8bRGvG16VRMPl8v5HzLQj5SMA2ikMN6IYctC7lGLaSi04/0SYDJp+lFnGZZxLWaTv2YTjdinG605vS6QhG6WiZv1DFstMQwWoyBgoGOTmwFtKp3tfIv1lvlny3d93rNytoxKyvTy5GjoNWWoG7QpArqRUzeoEu1wbKAG7UCtmIFbNIL2GRZwEeLtoqQTy/jeL2M4y3LuEmzkI5gN7awrM9IyFSstCzkYxoQFAhhpUxepQNZZVnGzZqOC0EJNqMhRyDYjIb8ZGlxt+CFySEJJtkKTLIVlqg+rjUsxWgEgyWHDBgs+V9LWLcWzA4rp0wvpcJYhjmi27Qy5BhEZ3qJzvQSyxJu11qWVmO0PPk4vZDjLAu5Q1N5qyFGLtOHb7IwhyxLuVOHcpahmHOwYs6xLOYTejF4vzH5Al2iCywLuavQanf4In5sa0bvMgzLMsti7i6022Qxy7FillsWc49aTHWw88xuH7aeXta7Eytnp2U592rlRKhydmHl7LIs5z61nLotnV0RZZsDtu+oTFmVL/TOu3ub9N5ZG//cr3ljPq8fN7lixoomPJ9W5yfVfI1qnWdS1S7Vc+9eStX6gJq7vpDbUHExa3nTUqreB3FZOwJ+rPut3XlO7/m9h5v0lbSGZjWpt8mwjmayZnOGkqDW8BAhmbGSOq3EpSa1LB1DLZ8qNF5KLa3+Tmwb6PnnHzpcjCSqm/OPluPYT2u2pPQ3fmxKY+YxvSuKy+i9K445dMzqYis7t1l9WVhE117bW936jNZD9uidSsOyzS07j6ptaKzbtbzATojLx3+KfHxWLmKkKp2J74mntJCiLhnN7F2dlA5IyhmUrvReKTV6nXJ6JdId9Msp2Vw0kxsV5suMTM6Nyi1Uw0h9KJ0qHDYZHR6plQ4MRVPZeDo1uksrtGow3T+sbItsSNxeIYOIjlSmM/1yDcKkkcpoMh7NjoZGqtNDOTlTNn8WZupeSRoSo8mkmFMgZEcvH6nOl9u/dvTygSmhkak5aXAoGc1JYjY9nIlJcgGNckruoBhP9cdjUnZ0uQItIlcb1sodlhMqlITRYeFzciWJGyvyx3MGyhI3y39blrhF/n8Rq6BMrGsiqqgTd1TkSdWU3p+OibnonuJrLVlKSoOScqbGkDxVFNVyRYVAcU3xtZS4W/5DmJS4R/4jlLhXhZS4X/7z8sQnlf/L0iYeyL98UP6/LFXiISWj/OenlD+FzxtF+bz8N1PEiUewN2rKo1iKBmSycyAP2wXyKAXkMRpImXMgX7AEQuOIqrWWO6/1Ecta1SoqnFfxRZsMs4xzmmaconIqQpR/M2qphkrnaB+1aw8vUPbwExpIlXMgX7JpDzgOzR6qndf6GLOJKWpHuFuoNm1jtGazcEywbnc8mZMyYno4J7d+DSM1enMbBbcfjxtx/pbBjmH3WuKP+ZIbEm9jXAGaji8zuaJNVnhaqHGjYYa3vE+wNVyoTPilUMfRcL16xkfuFAZ1YHCVfsUIrLKSodLaaCY2EFfP9hkrB+jySZuVV0f74knluCpRNaDh/6rNquvUpXpxXzRD1g7oAJ6yy/rujCSJsfw5P2PlgK7haZuVNw4dzFct9iXTsb0kAEBr/zWbALQzT8Z6AY37M0wnNDgX+tBkYSav2cBO5BlbN22slh3uE/MnuIlmpXCCzixTrXJ+ThyKKgcSDbm0GSqzPA0a6rgc4GaJbOq0pTEXvBn7upHBdbTmYBQV9GDCwyxRxJSkxsZr7QsNaKW+YVPoxFb5jYm0iUAlGbQIVEqYygsPbr9pCbxgR+rRT9O+BdDKfYvpb5i1o/Vlwlyet80QxeKvVbWvs2M1cGP/thF+jEFfYqCSigUB1vYdm7XupmsFmMp3LZtGVVnnlQkLuE2j4tT9YkbazXRfXY/ryaZOPSZs1mCo24Ldbs6eNUp9gOnZ51P+erjSzfHw95wDuZDR6FzsQYPyfUuYNEp4M/IDpm0aO0D0mTJhIc84ZxdtMJ9BNcITGI2J8hMXG5MfGoW4iUXdra42Jj+ydOu8mOi1MuEIR25dcpd9zijR/SweH3SVxx8zedQjGVRRLizikaiti5eOq+c5joP3+Gh+uXAkDzl+gYRL4Zw38ekL7IhDH7+ineXC0Vxx+6VYOhPNpTNUVK1e1+Jaq/CiEe8LzHb/JbLdH2ksCiT2Y24J74t+4hzTFBxTLEmCAvQ8L1mCUl/81NWe52Wbtb5B1woYn//UZq2/oWsFDMpfYboOqVX0sXKhidtbKBlEw1yR5ljRWEzKZk2m3KpMZwvZjaP6Zmo8NSBl5C6sX1SqJL21YVAa7JMyxPwF3Gt/ZqTq30wPmVRFRmtlVEpFlXn8VsVIryFL8GjU++p4CllXRUXXgMbj5+MpymwqXQK3S6+5KZBtQzPTCqCZe318hGDqA9B2vlEKUUzYB8yFvlkKyEyuAWtlbzkHDm5qzXRQ41yUX4ynKEzd1DoX6JelE8hEE3XOgf+qdMCZvNc7h/9r5/BBtt/gHPJvSgGZyXWjc+C/dR+4CbNTnAP8nfsAmTxOdQ7z94dZ4w1iZIveKReO4S4QKKvDYi6dHwOIsYGociFYSQYCf2DKgE8hoGMqhGM5K/szRVH/tTiUHM6KJ7q4wv9HNkhsOIa2VQhLHM5eFe8rc3s6520j9E9UsUz5HnPDLV7B5vbg6E9QYMV75dyeov8zU9vUYBmdVyEs5alcOZ5hBn6eKBJlqVPpJ5FuJ1v0YDxm6pLKyQ23zeV/jLJ/mamVJxnt3NeoFvHrrJYPYDx/sQmT43KJp6hZAB7ZpgXBbe1/7fL9HIPvFyi+f+LBaPkdpktgE1Xo3QphBaeRxi4UNt3RBjDbd434fkHTqEPQLh53e1PdX21CKF7JbAoAYEr/NwYA+UvQTQEAjORvNgHol8ebIgDMh/ydaabG8AVlKoW1vGa7cHbSrOmeLYp4YWq7fTI5GRsxKwDePv/DKGFlNau9qKk2by8aqHR4a/xPJu31GlPqGtnNlcI6B3tJGZvo4GT+y4h7HpPMhdVkVzEt2pfNZaKxnEjuq4TT+W/nsKhdnvAe6j/O0ZhseIV3Rf91jqdmIJo1btACT8GiSZMB/NBbU8ETqWiyNSD1xSLsBXhjKCqzW+2xdLXOpzJRud1qV9LVOp92RBV2q11HV+t8chBV2q32VLpa51N7qMputafT1TqfkkPVRLX4lpGiJ6PJVcJ6q53G2r3YrOGt8gEds3fstdapSv3RbDa+JyWq31Wyu5zovLtCNQQf/cymZg+j848z0gfJpimRdj9MQLVQ/MU72c1k2EvJMAapnPePqA6slQvgWnHen6J62/hZ1gNiHtD1NoCRjwEnoEdutI2TZQkghgGd+hQw8jHgBEQBU9k9BdVSo0CVcAKvw7Bo2zmHSaYpoW6/qOSPJaPDWSqsAzT+0wgRH2L1wQ/TfTCgzZ7OZpaWFn2gSjjR2R5Y9sw4b1tTTX6Fg+6elat+TDt06cBQRu7RldPy7qlmBsHRk0wveZryhmcYfvMNRvq3qEGE9i0l08NNhi9LuN2dzxwnseFd9iwAckoBie8wMD9LYwZ007NdxfwiA/NLHnTTc1xCDu+I53IGFMWWBL1WJZzkcBXPm/ZlHhu2upka1VcLp3Im3muUXxm2OINn3NF8AlR1DWvKXasc28sM75YWsCnB6kPHVwsbuBOOhW+Jjm3058lO27o8bpenONFCgqg5tJo055tfY94kLKwhnXIR45eLGelHkyV4s90WHTEBZD2mxs2OatEEkGg1lQ7vzI70QC7b1memI0D3tnhcZWFqB9BNHlVCiUx0ARivHl1C5EzmAePYJjB+cNtsphHARPkxE0AipqYAM/HHllwuE70ApvSXlBw/UwuAFYLjwFKA/ML53l20tITImcw738KLlnmG34Rn5zt50XLPcDJZdb6hF63gDFCLYzh0uFrYyN/Mm9+SlRbzWcw2s3kz1ljJRo9XiO6uFjY53XwzUxT1otStN6cQwqkDQMMyv1auN3ty0PGE3J9n2tgjDFt6jPLZL7OsCzA+WgXGyUQFGOOsthrKq8u8r1cLp/OMhj3udji3XNo55GaChR8wdfMcQzcvMdJ/SrenABtaYxenmwqBG9laa9jqi19TLIL3RaJ1Niu3uC0OMEZdz/ax4o4x1F0j+J1d6VCvlWF2iwLAJ04gUP+LpbTJtW4ueZ1oXa0lIzX5O112hMz3nDTofLl5wwM6yS7yREMt2eFMq6WaCYDJn2wbyZRa82bLBA/AAU6xa0rTaFMCzKSc6oIpNe6RUtE4a5spYLKkxS4ny2lOAHMcp7HbIqNfoG/VCAFeg1SvbObf7o9EAow7dWxs/WrzMVZyHE3+V0dTB01Wt2t3D6diRmfXavFiWzPaQDB8Qi3L+U5mON+pjPTTGOkbqeZkM+OXPuqXbWSKR6sDG99LrIw0SPuUa5iJbSTqr/100wjoNDa9l3hJnEOlRKi88O5r8wTgxIanmFkCoJM8/T0iNVPjgJ7aNyFlp63dROOAEKD1PSI1U+OAOKSt5LID+kQzvQNWZdrfU7IztQ9Yv/FPYAZseT1g7WfLe0p2pvYB60ZbS86AQx8HrDBtm5AyMrUJWIsKTABJbfksYB3rjAkpI1ObgDUwASxpSUapZvqd5lzq4HtEaqbGpzuXHU1I2W159AznUofeI1IzNT7TuezhEsru0JdnOZeuY4JJx9TgbOcynjmuMtryzTnOpYtMMOmYGpzrXMZOz2R0uVed51zGrgkpI1Ob851L2j0BJLXllQucy7h9QsrI1OZC55L2eCapQx88wrksZ42rLEztLHIu0Y4SSmTLp450LsvZ4yoLUzuLnUu007ZE47rKaabHo5xL3fsekZqp8aOdy75rQspuy3ObnEt9zntEaqbGj3Euu1hC2R368rHOpXvfBJOOqcElzmWMjquMtnzzOOfS9U0w6ZgaXOpcxphnMrrcqy5zLmP/hJSRqc3lziWVJoCktrxyhXMZd09IGZnaXOlc0j2eSerQB493LsvAuMrC1M4q5xLFSyiRLZ9a7VyWxLjKwtROs3OJ9tqWaNzGiWucS5ecYNIxNbjWuYyD4yqjLY9b51y61ASTjqnB9c5lTHsgo0NfO8G5FEPjJAVTIyc6l+Xckshiy3dOci5FZpykYGrkZOeyZMGyuNwrneJclty4ysLUzqnOJRouoUS2vKbFuSz7xlUWpnZOcy7RfrBEDn1kg3PMB0qCmcn2RufID3qA3JbNb3KO+bySYGayvdk58vPZ5ysN57TR6bXCGbauEcl/G9DsGpESn2s8REj2VD1LJ8/UE0xzz9N9q56yHMA5w8Ns/umPxqAP1grC/99nXBUJfK1ygT7qo1vqD7z5WMIFhBpeZBrLy/XmDvwKI/1VRvprpNEl3mD88q0xmeevGaX8lkqHG++FE4A1ip3EL6mUMXMCOCB70YTk5F04J4ADsheXnBPbvuSGtQAO0b5/AjPjgs0AjtheUnJmPLENwHHbD0wABlywAcCh20vBDHjQ+7phFYDDuB+ckJy4YCeA47mXlZATT+wBcDz3Q+Mquwt6BxzMvdwz2UvaGgCO7V4xARhwwQYAx3mv9IwBT3QNONQ7UkJJXdAp4FDvh21LWsJRtxvaBxz5vWpCcuKCnQCOAl9dQk48sQfAgeCPjKvsLugdcCD4Gs9kL2lrADg0fO0EYMAFGwAcKb7OMwY80TXgePFoCSV1QaeAQ8bX25Z0gvbvgMPHN4yr7C7oHXAc+UYPZPdEv4DjyB8tiYwu6BFwEPkmsIwl9VbAMeWPlVBSF3QKOL58M1hST3QHOMR8iwcSuaAjwCHmj7M3ERD3gaP/1grB/793EHC+cFwfzaUH4zExFk2SubzZVnAroZi2RpapbWk0N5dtjPQzGOnBRtIQO6iUCJXSxShtO/XLs6hfwrcR3FZylkKM9BJxBdhecHvJuSoRJ4DtBXeAObHvTeNsOYCtBneWkKUSsQHYXvAJz9gYZwsBbDi4yzNOSiQ7YKvB3bZlh/fI42whgM0H95SQpRKxAdh2cK9nbIyzhQC2I9znGSclkh2wHeF+27K/Z9oKwNaET3rARomkBmxHeAAs9ThrHLBB4UGw7CWSEbA14SH2VItxVz5K1gmIN9NSLfSIPYGubbY/G6pn858VMD8cwZtHqY/4u7ojIXFbIGSe2ZtPlX6KIGzaFJZRzJxirtjZU0jFzmX8ciEjfRFWAny64tMlkQg+VfAZ93Hmv1TpD3VFTOfXEvPhegFMA3x27PJeXzVp8iTlH0sFnQgXDTB2/5wHJkdLBB9Vfx6Mk+XaLpgWYGT8sGdyjQE/YHT7BQ/ww0eTj4BRsbzSBWsBjAu/6JlcY8APGMM96gF++OjqS+zIC1sLQl+vE0K8sKsq2OGL+M0XqKYVyxGHopnoIPlx3aoIO69leMWLzTjfOPcmKnuMIPMQU8UXMlR8MdWhXML45aWM9CtdjcoeL4lE8Kjsy2CcY+X5Mkb65fb1AojKnii5vCb4AaHXVzzADw+0nrSNykOrAARUXwXjN8EDCJCessYDDneeZndgdMeDFtULYV4/Nl8UyUxiNhfNiKeSGyXyL8V90YyL/cfXCFm+S/Olvvgh9iIKbuSf4cQAupgoWC908Lir6ezyRcSOcI/5DRMhHzLf+8Lppnm9e03u4JBksuulzH9mCbv8rxPcvcJ0uZ8zXO51RvqbjPRfMNJ/5WrH/w3P5MJxqim/Yfzyd7REgBDhmyWRCN61f8suTs3hUHfQdNrIC7sas74AIcK3beurdmrJPQsQZHzHM7lAmgKEHd8tiUTwcORZ2zgnhO8AgqLvjauk8Lme74Pxg5gHzPL8wFXk8PmdH7Jju7o9yXRfNKkGd5+rFzq5EzxCjxj0M5a4mDuQp0bleGtPalBZwUvGs7mSbA/+ESFyaCpLBWcymqPuqaTx9FC/hIdYz9nFmd8dvjUYbvWZ9/SdFNwxCACIqH5sm+h+ONGAiOp5tg9QBoreqRe6eI5gYdLyYAYhH8NNijldHIC8QAiXo5WgvjgfewEfM77ImzfOSJKo3D45ik5uEHocL9dzl0VHarLDfWIqOkhc1efRvZc/IeT9INPWL2fY+pWM9KunUu09QC8vcQ6tDB0UMW7QeQ3C2aa60VTTsSMUDITIMXsUTOXLbIgVOUnxwZsbhF1WVtPl72RcZcmcaPDGMn5KiHM30zLuY1jAg65awCtsemfnb5NNZwoHl7QLZdH3G4T38fhm5DP6XfFiW/xUEZzenxHiPMqk93GyMxmpyeM2wQOg91VrPOqLJ+j2FtDX/txutc/Q1QK6ztfYxjQjfyWxcjWxQrJmSbMbhSjYkphqA5jR64Qgz7P4e9nVbvINHn/01c4o0Cj0TVRPfJOQ5RcsCn/rKoVv2aBQSg0PFii8qFGIwU0wX6K7/P2CEOQdFn9/d5W/X7L50x0NfaFRkDjBQG0sKUevBkLggcCvCGQV08wJGalL9yWkWM6segAxv7Zd/f5ocq+UMase0KL/xm71NVL/HsmsckC7/lvblaeUmMmkcsDM7u84FlmsDi2YIuzlBoGhcLtfDHeYn6dWBgb9Ljvw7zm4izpCJ00Rklzc/vatpcX9B84cEGbaKDJFGOQhr+3xBQV/pKTY/8gZZ+ptEspMEVLctcm2oK+zs6TI3+awjrVn6CNThDSX9XDrGf62rpJi/xPP0gs9I/rMFGGIb+mhblRS3H9m4zYERejZKcK5POh1vtZAMNC1o6To/4djMfjAvWGqkONvxmuN+NrMx8CzRGwOQN3asHYNtSHPLD9cvr8Q8mXoTkcbyg1PMx8pH6TS4QO6/+W0MDI/OSk/YYfWTRX2cQKk+vjgUDqTkxkdzLkYIr1DgLuU1U9XF+4icS8+etdu3bVKGBlXtmO4GB791bbk8d2mrAOio/+zW3fd/oF4UjKtHhAf/c1u9TW75WGMWeWA5em/2648lzloWjlgJfkftokfjObkoYtZ9YAF4n/atvj98Zx57YBF239Z117onbSVO/r+Hs6KGmA59t+2kTWk0im5ZxkrNsCC63/s6myq0kD1i7HcAWIKOApeZP2vbX7qM1JuOJMymo4lPYDzwpPKbBvVwbiU7BeVXXL2kQHO9E62jywTjWelMXIGOHFbZhtZvTwAkche3xIa4KBsuX3STFYbLZEBbtKusE9av5SUcmPVJ+BC60r70DISHcVZQgPcN11lX5/Ms8scZIDboKttI6uN5TLJMVIGuKS5xhqYWj2x3kk094BLkmvtIqjXZlfMAgXA1cV1dus3U0AUfJ9wPVE9NmAqxuJo53ThGt4YVblPMLBljKf0zRZwNRuUkuQwAD5ebSAEXT2dNV5dO918vLoey6GmnEimKNDJzg0+qG30GDp889AUthVhykQ3TReutdoK4A9OdEuaSgiLmOroYKgjQqmjqzSWNM1j6HBLms61pAIj6JXpwnXWltRZyq0jM9jI8ZkFNGWGcAN3dlvZRbUtEGRgH5MXwKWayZZKn7BAwRnCTVYy+Tp3hNgX4m4JR2zvs9M7na7wGEni3HzLronbvjCcFED5LILyDzCd9DKGk17OSL+Sct4PM355NfXLaxi/vI765fV0gwBosmbbZmPiSK2m3OhqwzjnPcgDfLfvXLtSA5qYhsKV1yZbR/KRrf1bB5y3F4AZ5nm2LeOrDC0+zUh/htLuNxi//Bb1y+/QdgCYyJ5vW0avZVFTnqWlA8yUL5gw0sHPZS3kBAzFRQZUP1P4uNUJFdZecbZ71UsHYtKQ6VZ+E8/TvH93PBVNJg+63YsfQfDwJ6ZO/8LQ1DuUpv5KpfzN1b52UUkw/8PVfvFIjzHD+7DFHiD8mx1WAX3KUR5jhvcIR3uA0IRDQKve5CpCeMt8DLtlNjScCM0UbuXsjpgtitjPxaHkcFZcu9bFfRLHckbSWs39yr6f3TOF27ibrfL3gLb5O+xf5qlHfb7OCXEgZQnBxYYZLCPaPMPciHwzSDPfOsPNTuM4traMfSu6faZwO3eflhKkB0K+YNB+xw9neCnH2rCNCejlmcInrOY4kK+rbay31Vps8NIhaJ62rkQbvJaxeZmmgopFs8VtbPNnCXdZTci1+RgTcvVD0VxOUlbSpXPNBmBjnRBmX0KT2D+Nsn0AR8sJjoaY3plleOcw5Z3nM35pghzgtSs4nQGuDbR/lnAvpzOoS2dE7fcu9gArCXRX0Lxq1UezrOoB5BzPaRIwedGts4T7eEYvu6/+c21/5nrCVqtJ+HCrXEXAv4nBXuJW7AWctdUc1jA1oa/NEu7ndgMmJuWoX4Yz2cxZHS3K86tZwgMcD5majMu/iyY9cJM1BLxHWG4yPRtP7UlKuXTKA29ZaxfF1Fh0KDeckVgYAKPAdXYxTJMbtWEpFWOCAAz01tsmYjA6NCRrhIUBMHA7wS6GRvXABQMBYGB2IttnKFdAV84WHub4Tjl9Uyzca04iAL7KoqhySzDsY9QP8JeT7dZfPziczMlDrIxsKi76yilsBZm0E+iF2cIXOSqqCHUHyZtM4Do6lcD4FxZHFa3hMKN6gIpaODZMNmJo+hzhMS5BdM8EJ+g0TnRONXGobY7wBDc6D3ae2e2LmEfnM/LD/HgqJbH65QWiSNapRTsnkNFOxLQieE+9geCjbiYrEm+caR5fT51JRuIzqV/C4+6NdnFyb+G2VEliOikN42Zu+ATsJtvMH8VgvolifgmLeUDvvJnj02R/jP4zR3jK6amsGf3xGN9f5ivDekONmrucWKKx/ekEF+uYOjuRobOTKZ2d5oG3+MA4magAFt/KtiQzx0ThucLTvNNmZrMf8B6ijUAZYrY03KtHeSMrgGbbORya+A+6eK7wNe5NXqxR1mGLGSFz+uEu5icEFC3oH8tVy3D6t7DpJwYG6M25wjd4zLNnxHk92NS9+4ttn8lyLbezAmhlKyF3jtmg7Gc0KAcZ6Yc9aP622UXrUAkNHA1w7r6D6A7Q7AZs6+4Kho5GGOlXUZ3ZqAcByBmchRIDneicecK3eS7nUG8etXQCIdedtF7UF/fPdHO6MciJ50gDRVfNE77D7T74Js0h1eTyAPUF6+p6j7SACDoeZnrH45S1P8HwiydnurnkEOJs7daP4KJfzRO+53wvMfcOygZlxUiMZs1U7M3iYpiQ+VmmVn7E0MGPKW294KpWOjitkoEutHC+8H2eYuaIIp5BG9KcRM4AaL9xkeQzCRHeZDVAv3a1AYpwFgcKQqLW+cIPuIsdTjYhePP1i05yzo1F47uu0tjFWTbCjsajD88XnuPu9lAvVeZe8mJ0fDhl3RznMRyeRw/NF37MQ18fCoeC4bYS49/OaZL1+tCP5gvP88DPFMXirzW3P5ncf+nFHTs9BPwFsxgWu3iWmxZ7FifyIO8lQIsXCD/hKt7JN4e97LJ2cHYG4BceoIEFwk+ttl+pwpWwETubQH8yyyRaZpH9LdwwdnKaMuxCBnT7AuFVqxBnR8AfbGeGOFsiYVRCVnsJwbbSrBY+W07RqqaHZrkZtOziEI3dL4F+vkB43YroiC/AOifI/cJ4iVVwDiHy2UwV7GKoQHRVBaI1HhYc+BLm+zhtFH6LB1q1UHjLqo3ydXb6I2PeIsr5NIAn+o+Ssx9M/e9n6P+gq/rv46gAvxMEHVwo/MpKBe3+oL/LvhPC2YxxOzn92hD02YXCb607uY7wGAwIjr6fE7bp93eg3y0U/sD7JoAMvVMIkOEmfOVBIuDdxmga8s1va8TvE1xfwN9tF0K9si81HOoKhLoZi/SAZmoPx8rw20TQqUcIf+JtstwXz8Zdv45wgJwxYnHUkJHYAABKitsFMKVf7tJTe6J7zG/nA2goYRdCfXxPKp0xrx8wJ7yXE8hgnKP7jxDetQpktgc6A+at0NR4akDKxHPyyES53ZH8Zje7l/PkfHuSkPkHzJ7sOUZP9vwsck7sRTKFd18RwGQHwdgppImX6H4ZYNEpDxC+Qf0SvhqS5kydGNobVLVI+JvVsZGIn239JTbvIUKwd5kK+BtDAf8okTGfC0b6L1dNNwPGUzHbfUPNsg2V7JdQzyLhn9yFOyXWlYeboa2+rebhrjdf0ctxAhG8Y0NXLxL+YxXuBraGwoytgo7utQPINcw9clC8zgV9YxGaPNnpFxFniSL2mTj1ENYpZBdqct8mXLx95MVfs1kOsZYyfDV9/WyyKeGMSABNyX7bSClEiRNnu9mIHAAg2UgjATQcB+0i4d9AUqIPqrMNGHAa4TzbyghTyjiTYdKdjPRuqoQe81/yXABw7uH8cZIVflD9EAC5bdYTO2jMgMPsh0uCuZ/GDLgT/AKXMMPvAL/QlaapKjq8R0wP2e8KATeDX2Sbuw9R3F0xlk4QcHP4xexopEAVGj0SVZpHIlqAFencFtjSJVLNNHy+5/0EvI/RFGoYgnwMgDjhEtsYWnvEUJiNARAhfGAsGM4KR5gYALHBpXYx1MgYOBAAffMHx0KDL9TOxADoMy+zi6EKhdkAAF3fh2wDaA9sZwIA9GOX2wXQsCUYlg2BBwPQNV1hXxHdQSYAQI90pW0And2tTACADmbENgBfO9sUAb3Hh237I/J18bQA+MDEVXYx1BfOLDBRAD4mcTX3/p9ix43uXIxmc0f1jfujyYw8XFeH727cLMK/V9iTxb6PEGz8D0MniXewF/Ce+hqb1Y7UJ6ODff1RY8AH76Wv5ZxQMaoVzTgKzefaQXU0ddBkh7byCcRIdydtwurriqE49hEsuCKvIyRqnMNQ5Kw5bipylDP3h6sORY5CR/Bp5O2tnrZ7OBUT+6WYcgQrEx0kF5kA+9yq8ncHlXIX2fUEZ4tpVWmjjaY55iPHY+eQo5AVjF8eP4ca2QG0fQMY+XGM9GUQiQANwY1gicaAExDSf5TtZ2pLgh47Ci3mOpixxdEGAB2BDr+4pcd8L2CtkkPsi7q6A/QmQpIzWA3Vma42VB/j7GrRxUTvHoWauCyacKK9yFPZKjC4rJeS++JZMTYgucrmzYRYvSw2Y66yeQvvtkdMUHTq0WgJl09TXjTj9Ae3B5hf4q3ri+f2K5sx024uinycECzF4nPYVT5v5QSlmJzo4qPRMi6dZqxoEWl+rG9um4VMB1zl8jZCqItYXF7mKpe3c2wTFxQ9dDRazrdNM160qEGdveHTGU31u0jnHYRc17LovMlVOu+0QaciKPrZ0WiFPTpxXnQ6fSHzlrMyOxDf7eYeik8QEt3FIvIBV4m8i02kJiKqbEIruRQSXGjkqbO65q1kMr0nrpwTctWz7ybvAWNGTV8i47qRqiATbeIJV6PVe6xR0tXCx5b3ctpyTBtoexNazfeXwq9pf5klinpR2qGoU11U8H2EDD9kUfdjV13kft5oEiMDXdKEmu1xl0qT7jJb504uSyVv3RoXyfskIcXrLPLecpW8B2yQp7CBPteE1nDJKw+FzVsTU1bhhD1IIP8zg7CR6lh6UB7/Ux8PB7D2EOecbaE29HITWstlbLooaj/W7GktYXR10Uw8NzAo5eIxF4n7FAF+8lyGpVXNddPSPs1ZiowNDuWXIsuPQet5S5HKtEugk5x2ga9DfobANp1BiTpDS56AhnPzWbv1KwSEqK//wLufz42JAEb9gJmKz9utvyzEOBMBWHZ82G7l5VupE0HwBccv2K49yKodsNr4iG3itzKuHQWsNH7RduVBRuWA9cVHbVfuZ9AOWFv8Em+XqN7oo1uOQZv5Q3eTLkLzVBQIdTNups5JmUEXe5THCGk6aCq1yL5zLhnZV3QEzVEmeua6Gdc/bo2RrhbesH6ZMwWb1wL6zjHodP4UrEFbWluAwubj3qrd0VjO1WHbE4QECaZyBynllrcHtpvq9lxXdfsVAMTa4iYGu0AB1vAkACj3SkQznIDu+KsQnO3+NplQ8wlYM5yAnvspa5x0tfAu+2lOKKv5H2o8Fvn4+/vV7WQl8uKvEZBvYWmU028k7nDVa5+xDYndR5ggArjn160RaRwNpfdL1NYCgMN9gzPNp9aFNhyLWvnTfEZQeKvBuslTHqymUlLMzWH5NwlJHme55NOuji6/xR2Rq0Ki4WORn7+dgORDC7K0ZHpncb22F9nlfRnfJqT5HrP9/SHV/jb2x7MsvInnXfXg71jDpKuFx1Tf5V21gekDfftYtI0/4WemPk3nPpG7zD0Ny+r2avezhIC/ZvH6tqs+9D02r7S0qGkJErjkshnSyNcYZq5+1/RnxexQdL+b22i+T8j4dxa1k+a5Se0P2NTqUqKLlqAQl1KaES1duTejw9fDOJQ1nBpy10B/SIhTP4/B4gxXWfwRJ+7SZERPLEFn8jnkXi1e7u51cM8RiBexiGpylagfs4nKC4h+vwR1WUanrLVVdTdLLJpMusjU8wTkVSym1rnK1AtWO3zyYqL5x6EevlVxOwvzI0tw0l4k0G+kSSvME/G7s0TrPDcDg5/YxsVtucxQAeKGl8aEytfjM7+9wQwVIPR/2RoVXS180vunnMsuDNaKLjsOnc21fd6BvGrlW0ximLxOScu4O57MSZn8Kpibg91XCNn6WIpOSPOI8DmxZ575Cd0GdWu3OVaAq/zMA6z18VS/dEDMJuMxalQC8J9XAVDjrvrMzwFIzqWRANzoNQCSgzQSwKTU63aROPfXmvZwFztcp440wI+Bv2Gb3Wsodq9jOEe1IgSrG7yRVglgfetND+CXt5vPGZpBB6yOvQWAfr05dDOEgCW0XwAQ3mYfIeD83i8BCO+zjxBwwO9X1ggPGyZKDEE//HDfr+3WX6HUT1YMOM/3G7sVT5H690hKq0a0lhqEKc4h/JZ3ARLWf6POpegc/qwl71OJTj5J7nYmzz6x+DuCwxeZHvYyw59eoTzvVcYvX6N++Qbjl7+k0uFh4u/HVVKmRIBo8g8llIilqbfsSwqIVv84ASRlygWIfd8uoVxM/ICI+U9g/PC2YgwWCIij/zwBJGXKBQiw/6eEcjHxA6Lsv3iG3wV7A8Tm/1tyuZhSAOL3dzyTgokWEMu/a41WjcZq8t/E2Rd1M5D/q/WSrDqR/uxS1Od4MpH34ci6/BF/0y/lKVe67zA/mmA2rNHq8uhzn/9HMBWZzzKq7vmkq/bMZ9xjR/1SpH4JD0H/5gHynYz0XfYlAoSgf/dAIiZOQAD5D85uYczs0ZxlqJ9/Dj3/EbixfU2yYe9+kc4Gd4R/EkIdpsnnAYAv/f3LLgAT1uCbWP7N2Ricn+xA+5ehOO8wDDXfCj8H8x8C1A0sh+A3xexrU3iNKkCV/7WLO3GbuduaXhGp5viEBw3PpHJLvCqsqYopiLF0MinFcjif8C2Hk+1iyPfIovYxcxIAYPhYVs70AGOV6NVlKMXzhIa+4XgyF0+Jyg3DLrpDOYHwCRZFFcqqieunwipsV98aDjOqBxhppd3q6weHZfazuUw8tcdFA62yW3+NPxgMdHSyzuUBTLTaLoTKLcGwj3FGCTBDUWO3/vJwG6N2wKxBre3aW1lHAgFj+zrbtW/zn+X66bB627XTl4fBj4c1sJtGg7OhB5ejg7yWcbYoYr9XvxSwbp2LTWQjG2n17gLKV5aj8/mn2LZ0dkVEZWMe40IKpSjlErcceYdbTT6nn9qpBo9PpxCSVS5gxUKNKvozOQI05gXInmsqQ30hP1MMQCcyla0gnFV04gp0Ac+SZomi/nPtvPp6Fw1pGoHzCJpuMBfT2VwQCkL7V6ALeXTM1ego5NAYOcFFRmYQaJd7wMhMNiNU6IleWIHez+Okrj8eyxEbpOA0zCIgnkTToA3TshKjdgBBs23XvkciN4fBQ7A5dmuvy8/pmVYPiMDm2q2+Jq95kylFQOw1z27l1YreTeoGxF3zbWs9NzyUlMxqB8RdC2zTzprJBYRdCzn9BWZk6MGV6EovdiUolxQVq9EClhNLtZ/gCLbwmH+j11eiEf7ueSezI4mhBcQko2eT0Is4cuqtKJp+PPqwhZytEV/bGFVsKqdZOXA5j+QYM9ZZodbj0VWOBa3eu0+OAeLkvFHppFzMGS3EU6niBmt07vHoav4phvy3p3eE2szPESmfGGdcX8j9XpTZnTFa+0kfJSkOXDDoWnR1kovTz0cRpN3JCu8Tdy8wn+m/l5F+P6n4xAOMXz6E/RIe6R9tWyJ3kaspn6ZlAQQ+TeMkC3yt5hi2M+pREnrmeHSN4wZnhigWStIc42SygzRtkjxrgI4lZP4BU1vPMXTwIqWtl6hfwj1kCRgnExXA1o/jWEwxwEN/Ox5d6zzeYi78eRZKLSWk+j2T67cZXP/FAwtYxgl89FAeLVqFrnMe4KkFmZDtVTi3nJDqP0yuJy8057qSSodzvYIzNVgYsqHWVWjUcUPItGqvGrqVHJEKTS7qX4Vu4M92urW7Gi7Q8YRARy5kHonkXiTizSdcV3G8VVf99eneSfl/0G2r0I2u73/whvjVhGjraeLVFy3YC/h0VjNnQIQ1W+jNVehjzm2YReVE2n6yhmDCz7R8R6JyYQMUuNZb2CYaggc467zCDI/W11tD4+kTPst5AmcThKFKdNdqdDt/56QpREuVV2vZXPStEwmhDrAatwtdbdxO4vXOmpDoh6vRHU6+zMX8SrUn3cPJhChXTKh++RQ20eR5OXR0M7qLz7e/fauf9b0Wh5PI80TRiEObSD6lVKOfUwmGbmPpL3EnIyK/i5F+30JypPxJD2L3Frv4R6pD4XaW+phC3EMJMQaxAD3RabbV8qh3agF0Vxts4/eEeUA/txGMfAw4ASt/mzhz6fkmJT2U7xzQSDO6m7cYXpP/tdyXuLgUvpkA9zIrWqnNV747Q5+ZBrQJp9utvTpfey7t4kK4j9O1F2pDjzaje7gbpn2RSLhHJBcw4HppJdC9zQ5wNQhix1rTLm2+soO1X8TuxVG+DmES0OkFrXN9y1Abb9hdNCz0z2Z0rw26GRtTAXS3E/gmH2FBd9AtuoNe0O3nzP8WGxF0+hp0H7e9URG2BlynewuBb1bJ6PbEurdypkCwe1PRpWvQ/dxN54UfmzWzALq3EfiW0nRrJBUA0C0tgJ6A3errC9Wb9HGAlv4Mzh4948226Etr0Cf5031Cj9juD/qp72ZoEuAduntjN8GGgSnd1c/XoAe4Ht3mVX8VJBBuZXp0fZtFh+VoLps3U4HV6L7vI7uCJzqOMI9CI0eQUehZ1C/h45QQZ1bI0Oyg1WvRg3aMyP1eOExglCyNiNkveGZEnvTXHXYFT6QYRjREGdE+D4zoTM5QBm+70UVr0UM8G6pt8yy2iBAYL5mARuRJS9RpV/DECMOIrqKMaNQDI+ritESG2zvRH9eizzheM+deOzjTOmD0amW9mxD/DqZ9cqXr2tHBnuLkiW47YvbqZO123iFN/EZUtHcd+pxj/bNm13n+6ZXOe9gim1oiunEd+jxXchsGzFmgIXPHc5KbH+86ixD3e4yAP/H8EW4u1uxgs8wxevTqOvSw+5sruAqCU3w2IetrLIrfdJXinfYNOW9T6Kj16Av8AVUqOihrhl4dK3zBkxjGe7I21suZCyys3aHEevQoN6ahJYFHM7vIfVissXONYuFmlQO0fQ5n1k4XFn1kPXqcR0x9dkiKxaNJl6kRCXSNi1izGkKPv7NNDPkQ46uLAIreZxdEBbt6QCwV5Uz0FQ0CfX89epK/YMqLJkzsGu5xfQTwJpo3LVhdsohxe7rpDQ3w8CTGGePghoz+tR49xZ2szp9RoC78hxt+P4HwBJbNNcgIOsKdXRwYAKIkuzAUIiJh6o5puPXvtosg/0mI7g4/Y94LsHy6ZywkdPqDW1y/UGJgLAi2+amdCfCjjXFOQG9wUnTjCejb3KkluR0SlbbIdZ9JEBh3MllSIPhC5OVucHfZaxdBngRPrl9JjglCe4B1AQjAXwbHpIdOPwMBwF9SdhHU5o2xuyPovsekx6SIYKDT/ZtYhsZEA+cuGsDB4HPHZAzMW1EAd7JkxsRC644uP+NGIMDNLFm7GOryLtEVCYS2moMAXEyaI0A8VsEAMU1KSoNSKifuj+cGxP50zMWIftguiGoNhItjnX3WdS+j36gpt2Mag8+P7gcguYdGAmisDxBIUCVrqpIz11QfHxxKZ3LiUDQ34OIA4qBdbIY3asqj5kOKxGM0ewCLOo9AuJtGqDJk8v0VuC+db7d2i6vOAAQcsoawjH6jpnyTUhHcsQ4D8HyPhQfgXhcQeA4z3Yv1hR5vxuYX2sVleKOmvMZwrTdcda2LCIS3MJkrtD6GGW5OmwVn72K72Axv1JS3F5Epf2bZHYC99xMIP17FPAnQ7m8LR1gTQ159gvISu/gMb9SUfzPs77+u2t8HCIRPMRnkXmLhjQFeahec4Y2a0nAkmTLlSPcN8IMEwrpq1oawQWmwT1Lu6hikYj0AQ5dZ17+MfqOmLDzSTUP6EIHk0RqWIdVKqeFBIxGeWtHldpEZ3qgpSykrWu6BFV1BIPz+FCZ36o3m+6Lk7RUecXelXWSGN2rKSRR3p3jA3QiBcP801rg3m4vmTMdaAH4+bF37MvqNmuJ31f+uIu9Fm8Eae0sHYtJQTux3dQnrauvql9Fv1JQzXSXiIwSSARYR0wajudiAGItmJbEvmca+AQ+n4xprEMvoN2rKLlfpuJYM4lhIRqrlcW1OylB9e2uPSN1rBW9ZrrOLy/BGTYlTLcteD1qWUQLh9JkO5gxm5C+pUW/rIvmFk3i9XYiGN2rKAYoyNf08V83vBgLhqY5IzN/o5BWJN9qFaHijplzGIPFyV0n8KIHwl0wSq/P7waLkJcoeRQc32cVleKOm3ED58Ec98OGPEQgXzWJGVqzdOx5xd7NdZIY3asrdFHf3esDdLeQtLLOdDA3pzYtw7j5uF5nhjZryMMXdIx5wdyuB8IU5zGZPMOle1Vf1yfSeeCyaFKOpfhfbu9vsYjO8UVO+xmjvvu5qe3c72a4w2VNu3fRRF8MT9KXSbu5XvMMuOMMbNeU5Bn3Pu0rfnQTCirnMM4nRTDw3MCjl4jHCbck9i3DePmEXleGNmvIG5bRvucrYXQS2/7I+aFH8bIN7Q4W77dZdxVswBQh/j10Ade3hNu6qLWBF415rEMvoN2rKn2lbAKxl3AdA8ldWVwLY5XE/AM+/WHgAOz4+SeBZzLx2P//ljo6An7prEO40D9gFUZsH0ervJG9thvvNg9YYIDeB8+9pBLjaQ3ZxG96oKbMWu794+CkAngUsPACH+zQAz1EUHjW9aTH5y2NZyAGu+RkC+fEsryh+lMcb7/ysXRweeufnrDFMSO/8vF3chjdqyiYPvPNhAJ52D7zzCwA8ZzC8M0h5Z8gD73yEQD7E8grDdwncCzS/aF3/MvqNmjKwmAqxAL75KIHk00zfzH8dgdxprrVh+6PJzHBWVA9aujhQ+ZJddIY3akqOYWH7XOXvMQLh80z+GHfdezSn9bhdXIY3asollA9eyvJBAHNfJhDex7yMyvT+E/WV8Wy3e4b3hF1wiWtJsjy6y/Ir1ohoQPDB4JO2iaDvvaOoSYzSvgfoD7/qKrabaWyAvvEpl7CB+7rh1f8P7nxwRw=='
+)
+MEMO = pickle.loads(zlib.decompress(base64.b64decode(MEMO)))
+Shift = 0
+Reduce = 1
+def Lark_StandAlone(**kwargs):
+  return Lark._load_from_dict(DATA, MEMO, **kwargs)