jaclang 0.6.2__py3-none-any.whl → 0.9.5__py3-none-any.whl

jaclang/pycore/lark_ts_parser.py

@@ -0,0 +1,3444 @@
+# The file was automatically generated by Lark v1.2.2
+__version__ = "1.2.2"
+
+#
+#
+#   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)
+
+
+
+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 = dict()
+        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:
+        #--
+        res = list(self._transform_children([tree]))
+        if not res:
+            return None     ##
+
+        assert len(res) == 1
+        return res[0]
+
+    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 = u'|'.join(u'(?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 self.copy()
+
+    def copy(self, deepcopy_values=True) -> 'ParserState[StateT]':
+        return type(self)(
+            self.parse_conf,
+            self.lexer, ##
+
+            copy(self.state_stack),
+            deepcopy(self.value_stack) if deepcopy_values else copy(self.value_stack),
+        )
+
+    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: ParserState, 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 self.copy()
+
+    def copy(self, deepcopy_values=True):
+        return type(self)(
+            self.parser,
+            self.parser_state.copy(deepcopy_values=deepcopy_values),
+            copy(self.lexer_thread),
+        )
+
+    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 = self.copy(deepcopy_values=False)
+                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 grammar.isascii():
+                    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'eJzsnQlAnPd55gcdvmUrdpTLymFJVqwoTqzYFugWkpAEn8DAMIh7GMMA5r4GRBAgGBhxDEUUaAupWgiHooDS9EpFqxJVbdq62+722B7puT2357bbY9Nu2+1+3/w/5OfnxE5sy4rsut3tqwcjAf//+/ye9x1m4Nz6iThPnMf5n47xJ6J31Qcam4KN486f76sOngk2+kvqasti+t7mYGPNC7WB6qbxwvEnOsajcYfHLU9Tx3jFPVacKWtMWWvKOlPWm3KXKXebco8p95pynyn3m/KAKRtMedCUh0zZaMq7THnYlEdMebcpm0x5jynvNeV9przflA+Y8qgpm035oCkfMuXDpnzElMdM2WLKVlO2mfK4KdtN+agpT5iyw5SPmbLTlI+b8qQpnzDlk6Y8ZcouUz5lytOmPGPKs6bsNiXelART9piy15R9puw35YApB005ZMphUxJNOWLKUVOOmZJkynFTTphy0pRkU1JMsUw5ZUqqKWmmPGdKelMwetcL5bV1jUGni6J3H30uNTUpLWs8el/qKf9Nsea0dzwY3VDubwyWB8/4y6oD5U12s0XvDTUF/c+3NQebxgdWG7S5rT5o/3W7T5uDZ5pDgerx6D3+2Fv9/vHovaecdzrqNHEoer9p75d6en1jqDro9rP92WWYTzLTFK8pWab4TMk25bQpOabkmpJnSr4pBaYUmlJkit+UYlMCpjxvSokppaYETSkzpdyUClNeMKXSlCpTqk2pMaXWlDpT6k1pMKXRlCZTmk0JmdJiSqspZ0xpM+XTprSbctaUDlM6Teky5Zwp3ab0mBI2pdeUPlMippw3pd+UAVMGTRkyJWrKsCnfYcqIKRdMGTXlO00ZM2XclAlTvsuU7zble0yZNGXKlM+Y8r2mXDTl+0z5flOmTZkx5bOmzJoyZ8q8KQumXDLlc6ZcNuXzpiyasmTKFVO+YMoPmPJFU37QlB8y5YdN+RFTftSUL5nyY6ZcNWXZlB835SdMuWbKT5qyYsqXTbluyk+ZcsOUnzblZ0z5iik/a8rPmfLzprxoyi+Y8l9M+UVTfsmU/2rKfzPll035FVN+1ZRfM+W/m/LrpvyGKb9pym+Z8lVTftuU3zHld035PVN+35Q/MOV/mPKHpvyRKX9syp+Y8qem/Jkp/9OUPzflL0z5S1P+ypS/NuVvTPlfpvytKX9nyv825e9N+QdT/tGUfzLl/5jyNVP+2ZR/MeX/mvKvpvybKf9uyv8z5T9iJdVjAjk1zq1r3LrWrevcut6td7n1brfe49Z73XqfW+936wNu3eDWB936kFs3uvVdbn3YrY+49d1u3eTW97j1vW59n1vf79YPuPVRt2526wfd+iG3ftitH3HrY27d4tatbt3m1sfdut2tH3XrE27d4daPuXWnWz/u1ifd+gm3ftKtT7l1l1s/5dan3fqMW5916263xrs1wa173LrXrfvcut+tB9x60K2H3HrYrYluPeLWo2495tYktx536wm3nnRrsltT3OoOeqmn3Jrq1jS3PufWdLdmuDXTrV63ZrnV59Zst552a45bc92a59Z8txa4tdCtRW71u7XYrQG3Pu/WEreWujXo1jK3lru1wq0vuLXSrVVurXZrjVtr3Vrn1nq3Nri10a1Nbm12a8itLW5tdesZt7a59dNubXfrWbd2uLXTrV1uPefWbrf2uDXs1l639rk14tbzbu1364BbB9065NaoW4fd+h1uHXHrBbeOuvU73Trm1nG3Trj1u9z63W79HrdOunXKrZ9x6/e69aJbv8+t3+/WabfOuPWzbp1165xb59264NZLbv2cWy+79fNuXXTrkluvuPULbv0Bt37RrT/o1h9y6w+79Ufc+qNu/ZJbf8ytV9267NYfd+tPuPWaW3/SrStu/bJbr7v1p9x6I86eu9c3NQcam+1ht/K37Y0vcHMaNgP0uupAdeN4xfPR+9JjbzYjc0VcbC1srqsK1jY5I7M9hK/zJqUmj1tx0but0/6knPTMcWtNdE1i1ri1NnrXqfTEzKS0cWudPdAnp/m8sf8zbq2P3p2Uc/RUYnLquHVX9O70pMyjzqBv3R1df/S5U8/Zf+Ge6F1JGc7/jlv3Ru86ctqf85z9D98XXXPKfrf7o2tPZSWNWw9E70r0epNP2O+/IbouzXfq1Lj1YHRtmvO3Hoo+kJWUmn4qMSvJ782y/+7G6D3pp3xe5/+PW++y/2baMfv/jVsPR+/2ZXpPJh+3/+FHouvMx3x3dL37qW6KrsvK9Nkf7D3R9fan4XwW742uey7T+cP7ohtufoysxGT7o78/erfzaSR7T45bH4iuT8zMfO70uPVodO2x5+x/fnPsK0lz/vjB6Lr05HT7n/1QdH2a+Zgfto/L/Tw+Er1r9VN6zD7grET7g22Jrj+eeMpr/5Wt0bvSfKlHkuw3bouuy0zy2u/2eHTNCbtsj95lf7HJaSfGrY9G13tPJTqfiL1XHfEln8pKts9ph/1BjmQmHrX/mY/JCaUm2yexM3pP7L9ZSfa/9HH7E4wd1ZPRtYmp6ePWJ6L3ZPjsj5XsXM8no2tPODfwlJzAyaRE+x/ZZV9EYqr9nz4Vvcf5xM0n/3T0XnNT/ufsf+qZ2DnETv/Z6D2ZNz/mbuf6U1MTx6346D2JR+yvJPGo/eYE+zTcz3lP9P5M+8M8l3Yq12/ZJ7vXPoqk07E/7ove/1x2UmZm8rGkmN4fvdf+2FnJR2PqgH3hR48mee0v6KD9z7lteSh6b3Jq+nOZWbH3ORy9x+5JrzcmEqN3Z+Wmm3/qiH1H5q1How8kp2UlZR63P5vYG45F78pOzIz9MSnmAG9Wqv0pH4/ef9yXdtQ5rNh/OxG917bG6gc6aXeGNzft6LiVbBvBvsvYW1Oi67YlOWdiRd/t9wfP1Nc1Nvubmmuc/xNo9H9q3DoVXWtbb9xKjd5fUh1oavI/X11XYus0e9+N6dpATXDcei663v0P6dH7nw9U+59vDJRUBZvHrYzoPcHaUI2/JlgzbmVGH/b7S4MldX7b+e4H2T1ueaP3On/HfluwdtzKij7i99/U5p12PT1u+cx7Of+y/RGzo/fUNVfY8KhqHbdOR9c5/+q4lRO974Uy+7/HvohxKzd6v3knAx4r7+bHr36hyf34z4xb+dH7Vt/N+VsF0ftiX4w/WO180oXRe2/+lXGrKHpvWai2xH1Xf/R+ObVxqzi6zvylQPSelsDqP/h89N7YowFGlUTvf6FG/k7p6lEaGYw+6Defr/n8nhq3yqL3xs7QvEN59O7a1XeusJs21mMOG16w/+HYF+9eReXND/RCs/M5VUUfEN00blVHN/n9+ib3sMetGqddYi1SG737eOZzpl3q3M/j+brStnGr3vnb7lcvf9u+qYbo++1/13wq9rvG/qv7T9v/dqO5x0BtebV9j03Obb/USubd9oxbze6p18cuLnTznM2X0hJ9QD/yuNUave9Y0vFE3ynT7meiD73s449bbdGH3BZ+6W2fjiWR1e60v/S3+Szix62zq3dj3r3D+WRvHoH7Jdku6YyurakrHbe6ovfY1e2Uc9F3+f2r0rxvwrjVHTvzl67J/UfsW+5Z7V3zscLRDW6vxt7j2fFQ9C77T84jT7EU7Bi3PJYntXhNZLzJckLSinOKmaEidiJCrYVaB7Ue6i6ou6HugboX6j6o+6EegNoA9SDUQ1Abod4F9TDUI1DvhtoE9R6o90K9D+r9UB+AehRqM9QHoT4E9WGoj0A9BrUFaivUNqjHobZDfRTqCagdUB+D2gn1cagnoT4B9Umop6B2QX0K6mmoZ6CehdoN5YGKh0qA2gO1F2of1H6oA1AHVYWsNR3OMXrssdpx4VrXk5+NqXUdzqfgsVYcsV4MarWIP43YomKtikMqDqtYp2K9ikQVCSriVWxVcUTFdhVHVRxTkaTiuIoTKnao2KBip4qNKjapOKkiWcUuFZtVpIgIWXcpHwfAxwHwcQB8HAAfB8DHAfBxAHwcAB8HwMcB8HEAfBwAHwfAxwHwcQB8HAAfB8DHAfBxAHwcAB8HwMcB8HEAfBwAHwfAxwHwcQB8HAAfB8DHAfBxAHwcAB8HwMcB8HEAfBwAHwfAxwHwcQB8HAAfB8DHAfBxAHwcAB8HwMcB8HEAfBwAHwfAxwHwcQB8HAAfB8DHAfBxAHwcAB8HwMcB8HEAfBwAHwfAxwHwccDw8W7Hd4k2EoNxsQv0pFbGxb5ST2pfXMSw88k1sVvxWNudv3GP8zc+Yr95V1zsWj1WR+wL9li1sbbyWJ+OHarH+u3YwXusI7Hj8VijMTt6rCn3A1SviTnEY32X+4G+GhdrPo9lrOqxFmNm86TeFxe7UY/163a17DfUrIkZyGNV2jXOOcRYA3is74s1l8f6mdgFeay/jhnbYz0bs5jHejjWbp7U5LgYUzypB+JiTe2x/iJ2+R7rlF1P2fUPzXlYPx8zkif1/XEx73lSE+NiePCk3hUX6xBP6oNx7gF9MWZIT+qGuJjfPFaCXVPtN3xiTQwUntRjcTF3e1KPxMWM7bG6Yk3usQZiVvNYH4ghzGO9JwYTj3VXDHceKz4GLI/1nTEbeCwrZltP6qa4mO891v0xZnpSPxQXM5/H+nIMXB4rFEOkx/qXWOt7rMMxFHmsEec679XcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG9HcG4n57z7n+J3W6bP/U5p9e1vXGFelTro9n7q4asjENc7fuF+TMoqkjCIpo0jKKJIyiqSMIimjSMookjKKpIwiKaNIyiiSMoqkjCIpo0jKKJIyiqSMIimjSMookjKKpIwiKaNIyiiSMoqkjCIpo0jKKJIyiqSMIimjSMookjKKpIwiKaNIyiiSMoqkjCIpo0jKKJIyiqSMIimjSMookjKKpIwiKaNIyiiSMoqkjCIpo0jKKJIyiqSMIimjSMookjKKpIwiKaNIyiiSMoqkjCIpoyYpH0Du2XFlpURef/6txt4rpt23Gm42GKzfiryUjq897G5JyH19tj1n/5fZyB2QcbE0/z3nCjdo1gU06wKadQHNuoBmXUCzLqBZF9CsC2jWBTTrApp1Ac26gGZdQLMuoFkX0KwLaNYFNOsCmnUBzbqAZl1Asy6gWRfQrAto1gU06wKadQHNuoBmXSDmoAff0OS4267XX4uDHIvueh1OSrf/ge/SgfOOsdQrWelZ+x3WOXODx/7fJ16PtxyLXBaPfTNr3fTgzTnyoVuyFqxeqj3jWyfNF5T61KtuBbePk3YDpu5fPaxbth3cgUvBzWxdj2xdj/xcj/xcj/xcjxRejxReb9J045uSps7+uu5V28Vpg58wDZa647X0zyv1jRNzN76l/lltm7dbu4Ssd+lKsoKVZAUryQpWkhWsJCtothUsKCtYUFawoKxgQVnBgrKCBWUFC8oKFpQVLCgrWFBWsKCsYEFZwYKyggVlBQvKChaUFSwoK1hQVrCgrGBBWcGCsoIFZQULygoWlBUsKCtYUFawoKxgQVnBgrKCBWUFC8oKFpQVLCgrGOdXsK6sYF1ZwbqygnVlBevKCtaVFawrK1hXVrA+rGB5WcHysoLlZQXLywqWlxUsLysGag+rDxrhg0b4oBE+aIQPGtH5jej8RnR+Izq/EZ3fiM5vROc3ovMb0fmN6PxGdH4jOr8Rnd+Izm9E5zei8xvR+Y3o/EZ0fiM6vxGd34jOb0TnN6LzG9H5jej8RnR+Izq/EZ3fiM5vROc3ovMb0fmN6PVG9Hojer0Rvd6IXm9Erzei1xvR643o7kZ0dyO6uxHd3YjubkR3G/Us1G4oD1Q8VALUHqi9UPug9kMdgDqoKmQ9ckuGCTvJU5vjIq9hw3CGiHO3dwh9u8+eIevd+ojo1z8QmmH/4XHnD86Dpf+sD43e7LS9pis2vaGN5KD9F3/wNXWDs6scdP6Qaf/ht29lWzgd/ai2x2pX3GyTly+edpukPhx3+/rD6zxyHfcNGsXZ2v/pzW2Y92jqViN1q5G61UjdaqRuNVK3GqlbjdStRupWI3WrkbrVSN1qpG41UrcaqVuN1K1G6lYjdauRutVI3WqkbjVStxqpW43UrUbqViN1q5G61UjdaqRuNVK3GqlbjdStRupWI3WrkbrVSN1qpG41UrcaqVuN1K1G6lYjdauRutVI3WqkbjVStxqpW43UrUbqViN1q5G61UjdaqRuNVK3GqlbjdStRupWI3WrkbrVSN1qpG41UrcaqVtt+PpefTT1M2I7I7aoWKvikIrDKtapWK8iUUWCingVW1UcUbFdxVEVx1QkqTiu4oSKHSo2qNipYqOKTSpOqkhWsUvFZhUpIkLW+95QvDlhlbMm8lK8ObPMB/Qb8nfAI25v/2Hn/c4lrubT46Dd43D143D143Du42Df40ikx0G0x+Hxx+Hxx0GKx0GKx8Gwx43/P6C5G0LuhpC7IeRuCLkbQu6GkLsh5G4IuRvCVxlC7oaQuyHkbgi5G0LuhpC7IeRuCLkbQu6GkLsh5G4IuRtC7oaQuyHkbgi5G0LuhpC7IeRuCLkbQu6GkLsh5G4IuRtCJ4aQuyHkbgi9F0LuhpC7IeRuCLkbQpeGkLsh5G4IuRtC7oaQuyH0bAi5G0LuhpC7IeRuCLkbQu6G4NAQHBqCm0JwUwjuDcGTIXgyhNwNGd89eku/05Jg/0Njzj+UZf/h177RY+fOLvH5uG+UAM53RF5YXX3udsJjNRNengEvz4jXnwnO88T+PS7yNgwFn/2Of4rvqW12bvqE/ebYmR6y33y3XbPt+hm7nrbrr9g1x65JEWda8Vgb7Zpr17+3a55d/8B8AtZu96Z/zPmHjtlvKLZrvl1zI84s4rGesmuBXXvtWmjXf3VPzW8+0dRHVr95MmfXIvsNH3be4Lff8HcRZ9LypD69+jW+aNdi+w07nTcE7Dc8Y9fn7fpkxJmvPNY+t/1+KuJMYh57X7f/UGL/Ya3zh1L7v+TbNWi/YWX18Zyr5sRTDzlvSLbf8DumH61098o+6DZflts7u90HDaxEu5bZb4hz3lBuv+GHI8406bH+2VyW9bRros9GXhpGv6KD5Vdirvugpl0+0i4faZePtMtH2uUj7fKRdvlIu3ykXT7SLh9pl4+0y0fa5SPt8pF2+Ui7fKRdPtIuH2mXj7TLR9rlI+3ykXb5SLt8pF0+0i4faZePtMtH2uUj7fKRdvlIu3ykXT7SLh9pl4+0y0fa5SPt8pF2+Ui7fKRdPtIuH2mXj7TLR9rlI+3ykT75yL58ZF8+si8f2ZeP7MtH9uWbhPmQ0+sVbvv/krS6EY+p2KNiq4oEFftUxKvYrsKj4qSK/Sp2qdip4oCIkPVh8wqP1N+Jc17i8ZEOw7RjjnhMt9eQfo0h6Q0j1qo4pOKwinUq1qtIVJGgIl7FVhVHVGxXcVTFMRVJKo6rOKFih4oNKnaq2Khik4qTKpJV7FKxWUWKiJC1RY//hh7/DT3+G3r8N/T4b+jx39Djv6HHf0OP/4Ye/w09/ht6/Df0+G/o8d/Q47+hx39Dj/+GHv8NPf4bevw39Phv6PHf0OO/ocd/Q4//hh7/DT3+G3r8N/T4b8SOf6s43PnRApJmXwIpv4Q59ksg5Zcw8X4JU+2XMBt/Cdz8Ejhm1Emo/VC7oHZCHVAVsraZl3tZZxyLP66RPYIvcgSRPYLIHkFkjyCyRxDZI4jsEUT2CCJ7BJE9gsgeQWSPILJHENkjiOwRRPYIInsEkT2CyB5BZI8gskcQ2SOI7BFE9ggiewSRPYLIHkFkjyCyRxDZI4jsETTiCCJ7BI04gsgeQWSPoPVGENkjiOwRRPYIInsErTeCyB5BZI8gskcQ0iMI6RE09whCegQhPYKQNupZqN1QHqh4qASoPVB7ofZB7Yc6AHVQVcjabl5laf2NY8KPOiZMs9UvR8ZvflvP2d3ui7z66xyeUPdOwr2TOIFJeHkSXp6Elyfh5Ul4eRJenoSXJ+HlSXh5El6ehJcn4eVJeHkSXp6Elyfh5Ul4eRJenoSXJ+HlSXh5El6ehJcn4eVJeHkSXp6Elyfh5Ul4eRJenoSXJ+HlSXh5El6ehJcn4eVJdP4knD0JZ0/C2ZNw9iScPQlnT8LZk3D2JJw2CZ9PwueT8PkkfD4Jn0/C55PGTTtcA6Wmrj6S8Y2/Mf6Scz728qdDpOa6Lyp6c16q4Hzr4PudP7zgPC7wWl6Z9863CL75twh23t7XnTjgXr6tV/gmvv7kb++EK3zp9Scfd66y0lZ7I+YxqB90D/ALdq2y/9ls559dXVBqY/Z/UhelXElBI7aoWKvikIrDKtapWK8iUUWCingVW1UcUbFdxVEVx1QkqTiu4oSKHSo2qNipYqOKTSpOqkhWsUvFZhUpIkLWJ9551dctBabzJLuPr7m9tvukuxRudubRpzrMI+XPO2IXbtd5pGjTm5GUb7nvoDjfC7r+Fg7Pr/9WyqcUo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+cVo+djGH1al7lcLHO5WN9ysb7lYn3LxfqWi/UtF+tbLta3XKxvuVjfcrG+5WJ9y8X6lov1LRfrWy7Wt1ysb7lY33KxvuVifcvF+paL9S0X61su1rdcrG+5WN9ysb7lYn3LxfqWi/UtF+tbLta3XKxvuVjfcrG+5WJ9y8X6louFLRcLWy4WtlwsbLlY2HKxsOViYcvFwpaLhS0XC1suFrZcLGy5WNhysbDlYmHLNQvbM4oan6LGp6jxKWp8ihqfosanqPEpanyKGp+ixqeo8SlqfIoan6LGp6jxKWp8ihqfosanqPEpanyKGp+ixqeo8SlqfIoan6LGp6jxKWp8ihpf7PifVdTUAjW1QE0tUFML1NQCNbVATS1QUwvU1AI1tUBNLVBTC9TUAjW1QE0tUFML1NQCNbVATS1QUwvU1AI1tUBNLVBTC9TUAjW1QE0tUFML1NQCNbVATS1QUwvU1AI1tUBNLVBTC9TUAjW1QE0tUFML1NQCNbVATS1QUwvU1AI1tYBLLeBSC7jUAi61gEst4GLUs1C7oTxQ8VAJUHug9kLtg9oPdQDqoKqQtbvDPAYVjP28y3h1YRguDMOFYbgwDBeG4cIwXBiGC8NwYRguDMOFYbgwDBeG4cIwXBiGC8NwYRguDMOFYbgwDBeG4cIwXBiGC8NwYRguDMOFYbgwDBeG4cIwXBiGC8NwYRguDMOFYbgwDBeG4cIwXBiGC8NwYRguDMOFYbgwDBeG4cIwXBiGC8NwYRguDMOFYbgwDBeG4cIwXBiGC8NwYRguDMOFYbgwDBeG4cIwXBg2LkxQ3/XCd73wXS981wvf9cJ3vfBdL3zXC9/1wne98F0vfNcL3/XCd73wXS981wvf9cJ3vfBdL3zXC9/1wne98F0vfNcL3/XCd73wXS981wvf9cJ3vfBdL3zXC9/1wne98F0vfNcL3/XCd73wXS981wvf9cJ3vfBdL3zXC9/1wne98F0vfNcL3/XCd73wXS981wvf9cJ3vfBdL3zXC9/1wne98F0vfNcL3/XCd73wXa/x3R7z3KLUC7FnGu11XBj7eSHOQzrV9h+ekxcoWjWxv7JPrZoOq6bDqumwajqsmg6rpsOq6bBqOqyaDqumw6rpsGo6rJoOq6bDqumwajqsmg6rpsOq6bBqOqyaDqumw6rpsGo6rJoOq6bDqumwajqsmg6rpsOq6bBqOqyaDqumw6rpsGo6rJoOq6bDqumwajqsmg6rpsOq6bBqOqyaDqumwzrpMG46jJsO46bDuOkwbjqMm27ssd+2R41tg5+P2eOAsYd5jy/Aol8w73/Qfci23nn3Q7f0adC34dnPr/9Jz6/4XOdiu56L3NbnPN/cqzNiV3JYcdUJXHUCV53AVSdw1QlcdQJXncBVJ3DVCVx1AledwFUncNUJXHUCV53AVSdw1QlcdQJXncBVJ3DVCVx1AledwFUncNUJXHUCV53AVSdw1QlcdQJXncBVJ3DVCVx1AledwFUncNUJXHUCV53AVSdw1QlcdQJXncBVJ3DVCVx1AlCdAFQnANUJQHUCUJ0AVCcmi05MFp3AYycmi05gqxOTRScmi05MFp2YLDoxWXRisug0KExU3/ngOx9854PvfPCdD77zwXc++M4H3/ngOx9854PvfPCdD77zwXc++M4H3/ngOx9854PvfPCdD77zwXc++M4H3/ngOx9854PvfPCdD77zwXc++M4H3/ngOx9854PvfPCdD77zwXc++M4H3/ngOx9854PvfPCdD77zwQc+uNAHF/rgQh9c6IMLfXChz/T6Ee31CvR6BXq9Ar1egV6vQK9XoNcr0OsV6PUK9HoFer0CvV6BXq9Ar1eg1yvQ6xXo9Qr0egV6vQK9XoFer0CvV6DXK9DrFej1CvR6BXq9Ar1egV6vQK9XoNcr0OsV6PUK9HoFer0CvV6BXq9Ar1eg1yvQ6xXo9Qr0egV6vQK9XoFer0CvV6C7K9DdFejuCnR3Bbq7At1dgYypQMZUwFsVyJgKZEwFMqYCGVOBjKlAxlQgYyqQMRXGd0cd3zk/PDGw+ozBkjjn7cfcZ/LWOGN4kn5fK0e8acQWFWtVHFJxWMU6FetVJKpIUBGvYquKIyq2qziq4piKJBXHVZxQsUPFBhU7VWxUsUnFSRXJKnap2KwiRUTIOq7Hf1mP/7Ie/2U9/st6/Jf1+C/r8V/W47+sx39Zj/+yHv9lPf7LevyX9fgv6/Ff1uO/rMd/WY//sh7/ZT3+y3r8l/X4L+vxX9bjv6zHf1mP/7Ie/2U9/st6/Jdjx3/ilr8WN/Ot81rc1/wSXOfFu741kTfptbgnb+kr4N/0J+M5BP39yB38pDznkco9zjvetifl3Yy4dYi4dYixdYixdYixdQjDdQjDdSbUknWY3I1hcjdGk90YLY06BHUYah3UeqhEqASoeKitUEegtkMdhToGlQR1HOoE1A6oDVA7oTZCbYI6CZUMtQtqM1SKqpCV8lZ7SO/rIOr84rhfiNwWmL4yQ23MWtmRN8RSS13SD5f0wxf96P1+9H4/Vq5+rFz9WLn6sXL1Y+Xqx8rVj5WrH13bj5WrHytXP3q4HytXP1aufqxc/Vi5+tH7/Vi5+rFy9WPl6sfK1Y+Vqx8rVz9c0o+Vqx8rVz9Wrn6sXP1YufrBtX5wph8rVz9Wrn5Qpx8rVz9Wrn6wpB8rVz9Y0o+Vqx8rVz9Wrn6sXP1YufpBln6sXP1YufqxcvVj5erHytWPlasfbO4Ht/uRMv1ImX5kVT+yqh9Z1Y+Vq98Q8JT6rgG+a4DvGuC7BviuAb5rgO8a4LsG+K4BvmuA7xrguwb4rgG+a4DvGuC7BviuAb5rgO8a4LsG+K4BvmuA7xrguwb4rgG+a4DvGuC7BviuAb5rgO8a4LsG+K4BvmuA7xrguwb4rgG+a4DvGuC7BviuAb5rgO8a4LsG+K4BvmuA7xrguwb4rgG+a4DvGuC7BviuAb5rgO8a4LsG+K4BvmuA7xrguwb4rgG+a4DvGozvUs3T1KyDzkMaad/w1T3OFF4Y+dYXC+eVZr8aeeUFw/lwj0TMLzX5ROQWLBxv/OWS3+aXSa5uA6v7xc29YnXReK37Rch67q21E96xu+DtWwFXsXAI1j9kbJqu8ViIeCxEPBYiHgsRj4WIx0LEYyHisRDxWIh4LEQ8FiIeCxGPhYjHQsRjIeKxEPFYiHgsRDwWIh4LEY+FiMdCxGMh4rEQ8ViIeCxEPBYiHgsRj4WIx0LEYyHisRDxWIh4LEQ8FiIeCxGPhYjHQsRjIeKxEPFYiHgsRDwWIh4LEY+FiMdCxFUhwrIQYVmIsCxEWBYiLAsRloWm1zPelNeYOqn0H++g7HagLGRl6oPzi0IrI7aoWKvikIrDKtapWK8iUUWCingVW1UcUbFdxVEVx1QkqTiu4oSKHSo2qNipYqOKTSpOqkhWsUvFZhUpIkKWV48/rMcf1uMP6/GH9fjDevxhPf6wHn9Yjz+sxx/W4w/r8Yf1+MN6/GE9/rAef1iPP6zHH9bjD+vxh/X4w3r8YT3+sB5/WI8/rMcf1uMP6/GH9fjDsePP0rDOQ1jnIazzENZ5COs8hHUewjoPYZ2HsM5DWOchrPMQ1nkI6zyEdR7COg9hnYewzkNY5yGs8xDWeQjrPIR1HsI6D2Gdh7DOQ1jnIazzENZ5COs8hHUewjoPYZ2HsM5DWOchrPMQ1nkI6zyEdR7COg9hnYewzkNY5yGs8xDWeQjrPIR1HsI6D2Gdh7DOQ1jnIazzENZ5COs8E9Y+7fVR9Pooen0UvT6KXh9Fr4+i10fR66Po9VH0+ih6fRS9PopeH0Wvj6LXR9Hro+j1UfT6KHp9FL0+il4fRa+PotdH0euj6PVR9Pooen0UvT6KXh9Fr4+i10fR66Po9VH0+ih6fRS9PopeH0Wvj6LXR9Hro+j1UfT6KHp9FL0+il4fRa+PortH0d2j6O5RdPcounsU3W3Us1C7oTxQ8VAJUHug9kLtg9oPdQDqoKqQlf1W+47Rm/gkcOfZA3nuzxO5fT8B+7T5XRWe1J+Oi30ocz11QGAdoFcH6NWhVeqAwDogsA4IrAMC64DAOiCwDgisAwLrgMA6ILAOCKwDAuuAwDogsA4IrAMC64DAOiCwDgisAwLrgMA6ILAOCKwDAuuAwDogsA4IrAMC64DAOiCwDgisAwLrgMA6AKMOQKwDEOsAxDoAsQ5ArAMQ6wDEOgCxDoCqAx7rgMc64LEOeKwDHuuAxzoDoRz3wePYS5xzdekoFBcYsUXFWhWHVBxWsU7FehWJKhJUxKvYquKIiu0qjqo4piJJxXEVJ1TsULFBxU4VG1VsUnFSRbKKXSo2q0gREbLydBBbBoWWEWbLGMuWQahlEGoZTFoGk5bBpGUwaRlMWgaTlsGkZTBpGUxaBpOWwaRlMGkZTFoGk5bBpGUwaRlMWgaTlsGkZTBpGUxaBpOWwaRlMGkZTFoGk5bBpGUwaRlMWgaTlsGkZTBpGUxaBpOWwaRlMGkZTFoGk5bBpGUwaRlMWgaTlsGkZTBpGUxaBpOWwaRlMGkZTFo2TMpXDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ1WDJ2OHX+Bc/yrJ/430sVGbFWRoGKfingV21XsV7FTxQEVFSr2qPCoOKlil4iQVXh7f9Kh86NCHnGeIer89NiHX8sPjX0zf1is8+MJ//it/8B0yCrqMOfQHnvBrV+z0ous9CIdvUhHL9LRi3T0Ih29SEcv0tGLdPQiHb1IRy/S0Yt09CIdvUhHL9LRi3T0Ih29SEcv0tGLdPQiHb1IRy/S0Yt09CIdvUhHL9LRi3T0Ih29SEcv0tGLdPQiHb1IRy/S0Yt09CIPvchDL/LQizz0Ig+9yEMv8tCLPPQiD73IQy/y0Is89CIPvchDL/LQa/Kw2Ol1Z0gPuKz4DRdnzRGzSXc67xW4PU8XcJ7y8fnXwLY7/gdiO89l/+qdgbjn39TAcs6v/ZWu9Dte25Wmfmb1sZi39LN2bt0dOjGbukYvs0Sn2HM6xZ7TKfacTrHndIo9p1PsOZ1iz+kUe06n2HM6lJ3TOeyczm7ndIo9pxPaOZ1iz+kUe06n2HM6xZ7TKfacTrHndIo9p/PeOZ1iz+kUe06nunM6xZ7TEe+cTrHndIo9F4NmqT0u1NqX8mRsXAjeUjg6Lyf86urI1x8X+Sa/SWDg9j4T7g57bkKq/Q+0xkVuwVPiXvJWmXqrW73Vrd7qVm91q7e61Vvd6q1u9Va3eqtbvdWt3upWb3Wrt7rVW93qrW71Vrd6q1u91a3e6lZvdau3utVb3eqtbvVWt3qrW73Vrd7qVm91q7e6Y94q1+O/oMd/QY//gh7/BT3+C3r8F/T4L+jxX9Djv6DHf0GP/4Ie/wU9/gt6/Bf0+C/o8V/Q47+gx39Bj/+CHv8FPf4LevwX9Pgv6PFf0OO/oMd/QY//gh7/BT3+C7Hjr3CO/7DthXtih+Cxvsd56wvubwY8EwNepe5H3diPurEfdWM/6sZ+1I39qBv7UTf2o27sR93Yj7qxH3VjP+rGftSN/agb+1E39qNu7Efd2I+6sR91Yz/qxn7Ujf2oG/tRN/ajbuxH3diPurEfdWM/6sZ+1I39qBv7UTf2o27sR93Yj7qxH3VjP+rGftSN/agb+1E39qNu7Efd2I+6sR91Yz/qxn7Ujf2oGxtRNzaibmxE3diIurERdWMjMupZqN1QHqh4qASoPVB7ofZB7Yc6AHVQVciq0h8E9mV81C+b96i+bXtaat5b+DcXOb8+ImVN5M6a8m8OIDWagE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE2agE0xD9VqurUh3dqQbm1ItzakWxvSrQ3p1oZ0a0O6tSHd2pBubUi3NqRbG9KtDenWhnRrQ7q1Id3akG5tSLc2pFsb0q0N6daGdGtDurUh3dqQbm1ItzakWxvSrQ3p1oZ0a0O6tSHd2pBubUi3NqRbG9KtDenWhnRrQ7q1Id3akG5tSLc2pFsb0q0N6daGdGtDurUh3dqQbm1ItzakWxvSrQ3p1oZ0a0POtCHd2pBubUi3NqRbG9KtDenWZrKrzjxhxljxP+TDGLFVRbyKBBX7VOxVsV3FThX3qdilYr+KAyJCVr3z6a7+fsGbv1awzv7DP7jZa37jYIb9hz9z/uD8UsJ/Xl3sE+UH3KYeNAfQoOCZBXhmAZ5ZgGcW4JnFdc0CQ7PA0CwwNAsMzQJDs8DQLDA0CwzNAkOzwNAsMDQLDM0CQ7PA0CwwNAsMzQJDs8DQLDA0CwzNAkOzwNAsMDQLDM0CQ7PA0CwwNAsMzQJDs8DQLDA0CwzNAkOzMO0soDQLKM0CSrOA0iygNAsozQJKs4DSLCAxC0TNAlGzQNQsEDULRM0CUbPGB4135msTnQfmfuGNPTJ9hz169nUzqzMXV6yJ3IqX+DQpzDoAsw7ArAMw6wDMOoCvDuCrA/jqAL46gK8O4KsD+OoAvjqArw7gqwP46gC+OoCvDuCrA/jqAL46gK8O4KsD+OoAvjqArw7gqwP46gC+OoCvDuCrA/jqAL46gK8O4KsD+OoAvjqArw4AqwPA6gCwOgCsDgCrA8DqALA6AKwOIKoDiOoAojqAqA4gqgOI6sAU1QEgdwCQHZiiOhDLHZiiOjBFdWCK6sAU1YEpqgNTVIeBZ/PtewTgPavf4Tz+Omh6hzwScEc+ABBSdvaBnX1gZx/Y2Qd29oGdfWBnH9jZB3b2gZ19YGcf2NkHdvaBnX1gZx/Y2Qd29oGdfWBnH9jZB3b2gZ19YGcf2NkHdvaBnX1gZx/Y2Qd29oGdfWBnH9jZB3b2gZ19YGcf2NkHdvaBnX1gZx/Y2Qd29oGdfWBnH9jZB3b2gZ19YGcf2NkHdvaBnX1gZx/Y2Qd29oGdfWBnH9jZB3b2gZ19YGcf2NkHdvaBnX1gZ59hZ4v5Lof1XuebHK1vCkgdXF57BaBaP/kOR28pR898wxX9VTZzZ3vfuybyyit6m/m9NdZvOh3yacV0KTBdCkyXAtOlwHQpMF0KTJcC06XAdCkwXQpMlwLTpcB0KTBdCkyXAtOlwHQpMF0KTJcC06XAdCkwXQpMlwLTpcB0KTBdCkyXAtOlwHQpMF0KTJcC06XAdCkwXQpMlwLTpcB0KTBdCkyXAtOlwHQpMF0KTJcC06XAdCkwXQpMlwLTpcB0KTBdCkyXAtOlwHQpMF0KTJcC06XAdCkwXQpMlwLTpcB0KTBdCkyXGhO2vynPZHMs/+lv+nSbB+6Up17fGWx2npn2428M0mcV0jfZfJPWNputPxcih6wOxa4f2PUDu35g1w/s+oFdP7DrB3b9wK4f2PUDu35g1w/s+oFdP7DrB3b9wK4f2PUDu35g1w/s+oFdP7DrB3b9wK4f2PUDu35g1w/s+oFdP7DrB3b9wK4f2PUDu35g1w/s+oFdP7DrB3b9wK4f2PUDu35g1w/s+oFdP7DrB3b9wK4f2PUDu35g1w/s+oFdP7DrB3b9wK4f2PUDu35g1w/s+oFdP7DrN9jtdF/N+dPO7NOlJgzAhAGYMAATBmDCAEwYgAkDMGEAJgzAhAGYMAATBmDCAEwYgAkDMGEAJgzAhAGYMAATBmDCAEwYgAkDMGEAJgzAhAGYMAATBmDCAEwYgAkDMGEAJgzAhAGYMAATBmDCAEwYgAkDMGEAJgzAhAGYMAATBmDCAEwYgAkDMGEAJgzAhAGYMAATBmDCAEwYgAkDMGEAJgzAhAGYMAATBmDCAEwYgAkDxoTn1Hefg+8+B999Dr77HHxnVCJUAlQ8VBLUcagTUBugNkJtgkqG2gy1BeoQ1GGorVBHoLZDHYU6BrUDaifUSahdUCmqQla33k0y7iYZX1cybioZX2Uyvspk3GIybjEZt5iMW0zGLSbjrJJxVsk4q2ScVTLOKhm9kIxeSEYvJONUk9EZyTjjZPRJMvokGeefjK5Jxm0ko4eScTfJ5m56nLupt2fIU2si5jc41MW9dF7WZ2PvFHZ/ZIe1KfLOT+x4Sb3zEzv+0/zEjl596mGBNL4RW1SsVXFIxWEV61SsV5GoIkFFvIqtKo6o2K7iqIpjKpJUHFdxQsUOFRtU7FSxUcUmFSdVJKvYpWKzihQRIatPj/9revxf0xP/mp7r1/RcvybMMeJuFfeouFfFfSruV/GAig0qHlTxkIqNKt6l4mEVj6h4t4pNKt6j4r0q3qfi/So+oOJRFZtVfFDFh1R8WMVHVDymYouKrSq2qXhcxXYVH1XxhIodKj6mYqeKj6t4UsUnVHhUfFLFUyp2qfiUiqdVPKNit4oEFfEq9qjYq2Kfiv0qDogIWREdsFKQyymgfAoGrBQMWCkYsFKQ5ynI8xQMWClI9xQMWClIlRQMWCnIkRQMWCkYsFIwYKVgwErBgJWCjEnBHJCCjElB8qcgwVMwYKVgwEpBjqQgl1MwYKWY5Dh/e5534DwJa83q98v+MvKf+PtlzncSCyJvyvfN+vWHtLyozHtR4/1FzaQXFYAvqvlfVIu/qAB8Uf3+opLtRTV/TFSo2KPipIpHVewSEbIGlB5VoEcVeFEFJlSBCVWY6qsw1Vdhqq/CVF+Fqb4KU30VpvoquLkKU30VpvoqeLsKU30VpvoqTPVVmOqrwIQqTPVVmOqrMNVXYaqvwlRfham+CvSowlRfham+ClN9Fab6Kkz1VeB9Ffhbham+ClN9FWhchTm+CnN8FRhbhTm+CoytwhxfhTm+CnN8FSb3KkzuVSBuFSb3KkzuVZjcjXoWajeUByoeKgFqD9ReqH1Q+6EOQB1UFbIGb2kyON+E+6dX/Tbdf9pEuHVJ4DwP+M/jIhIJQ7f3x119G3/ZgvOLIP7tbXCHX/eM7Kj73JXvd75/M2xE6nyco77j9t6u813jyLf5mt921zui400LxpsWjDctGG9aMN60YLxpwXjTgvGmBeNNC8abFow3LRhvWjDetGC8acF404LxpgXjTQvGmxaMNy0Yb1ow3rRgvGnBeNOC8aYF400LxpsWjDctGG9aMN60YLxpwXjTgvGmBeNNC8abFow3LRhvWjDetGC8acF404LxpgXjTQvGmxaMNy0Yb1ow3rRgvGnBeNOC8aYF400LxpsWjDctGG9aMN60YLxpwXjTgvGmBeNNC8abFow3LRhvWjDetGC8acF402LGmwvuk0Z/3AHpqJowAhNGYMIITBiBCSMwYQQmjMCEEZgwAhNGYMIITBiBCSMwYQQmjMCEEZgwAhNGYMIITBiBCSMwYQQmjMCEEZgwAhNGYMIITBiBCSMwYQQmjMCEEZgwAhNGYMIITBiBCSOrJpzweOI8zv/Imz+Kd3oCagfUx6B2Qn0c6kmoT0B9EuopqF1Qn4J6GuoZqGehdkN5oOKhEqD2QO2F2ge1H+oA1EFVIes71YDtMGA7DNgOA7bDgO0wYDsM2A4DtsOA7TBgOwzYDgO2w4DtMGA7DNgOA7bDgO0wYDsM2A4DtsOA7TBgOwzYDgO2w4DtMGA7DNgOA7bDgO0wYDsM2A4DtsOA7TBgOwzYDgO2w4DtSMF2+K4dvmuH79rhu3b4rh2+a4fv2uG7dviuHb5rh+/a4bt2+K4dvmuH79rhu3b4rh2+a4fv2uG7dviuHb5rh+/a4bt2+K7d+G5MfZcK36XiFlPhQqMOQR2GWge1HioRKgEqHmor1BGo7VBHoY5BJUEdhzoBtQNqA9ROqI1Qm6BOQiVD7YLaDJWiKmSNf8MHYHbb9f2Rb327cx54yVwTeWnNcx4k2Lwmckdt82/bR2RW173Vtt6Blt8B8+6AeXfAvDuAgB1AwA7TLhOv/qqZOvu/XIi8lp9r8V3Khh6woQc06IHje+D4HmRyDzK5B5ncg0zuQSb3IJN7kMk98GoPMrkHmdwD5/Ygk3uQyT3I5B5kcg8c34NM7kEm9yCTe5DJPcjkHmRyD9jQg0zuQSb3IJN7kMk9yOQe0LwHdO1BJvcgk3vA2h5kcg8yuQcE7UEm94CgPcjkHmRyDzK5B5ncg0zuAU97kMk9yOQeZHIPMrkHmdyDTO5BIvXAuj0wZA8M2QNb98DWPbB1DzK5x/juux3fOSytds35gONS52d6f2/EfCc1I855v+/pGI/9xMegs8FO6lNQnhevGrFFxVoVh1QcVrFOxXoViSoSVMSr2KriiIrtKo6qOKYiScVxFSdU7FCxQcVOFRtVbFJxUkWyil0qNqtIERGyppSV5WBlOVhZDlaWg5XlYGU5WFkOVpaDleVgZTlYWQ5WloOV5WBlOVhZDlaWg5XlYGU5WFkOVpaDleVgZTlYWQ5WloOV5WBlOVhZDlaWg5XlYGU5WFkOVpaDleVgZTlYWQ5WloOV5WBlOVhZDlaWg5XlYGU5WFkOVpaDleVgZTlYWQ5WloOV5WBlOVhZDlaWg5XlYGU5WFkOVpaDleVgZTlYWQ5WloOV5WBlOVhZblj5mTftl4p3R77JSwqT7vwR2Rn1973VZuWQ9b3uK5b+nxNsFzXYrmuwXddgu67Bdl2D7boG23UNtusabNc12K5rsF3XYLuuwXZdg+26Btt1DbbrGmzXNdiua7Bd12C7rsF2XYPtugbbdQ226xps1zXYrmuwXddgu67Bdl2D7XrMYN+nwTaEYBtCsA0h2IYQbEMItiEE2xCCbQjBNoRgG0KwDSHYhhBsQwi2IQTbEIJtCME2hGAbQrANIdiGEGxDCLYhBNsQgm0IwTaEYBtCsA0h2IYQbEMItiEE2xCCbQjBNoRgG0KwDSHYhhBsQwi2IQTbEIJtCME2hGAbQrANIdiGEGxDCLYhBNsQgm0IwTaEYBtCsA0h2IYQbEMItiEE2xCCbQjBNoRgG0KwDSHYhhBsQwi2IQTbkAm27+8wTxX8E4eB02rCBZhwASZcgAkXYMIFfOoLsOQCLLkASy7Akguw5AIsuQBLLsCSC7DkAiy5AEsuwJILsOQCLLkASy7Akguw5AIsuQBLLsCSC7DkAiy5AEsuwJILsOQCLLkASy7Akguw5AIsuQBLLsCSC7DkAhp4AQZdgEEXYNAFGHQBBl2AQRdg0AUYdAGGWYBdF2DXBdh1AXZdgF0XYNcFY4qZd3479s3fjv3afym284sgAs7jfG/gt2N/VkmUCRJlgkSZIFEmSJQJ9mSCPZlgTybYkwn2ZII9mWBPJtiTCfZkgj2ZYE8m2JMJ9mSCPZlgTybYkwn2ZII9mWBPJtiTCfZkgj2ZYE8m2JMJ9mSCPZlgTybYkwn2ZII9mWBPJtiTCfZkgjaZoE0maJMJ2mSCNpmgTSZokwnaZII2maBNJmiTCdpkgjaZoE0maJNpaDOrm8eStLoRW1SsVXFIxWEV61SsV5GoIkFFvIqtKo6o2K7iqIpjKpJUHFdxQsUOFRtU7FSxUcUmFSdVJKvYpWKzihQRIWtOUZMB1GQANRlATQZQkwHUZAA1GUBNBlCTAdRkADUZQE0GUJMB1GQANRlATQZQkwHUZAA1GUBNBlCTAdRkADUZQE0GUJMB1GQANRlATQZQkwHUZAA1GUBNBlCTAdRkADUZQE0GUJMB1GQANRlATQZQkwHUZAA1GUBNBlCTAdRkADUZQE0GUJMB1GQANRlATQZQk2FQMy8/Qz/1Wuw99kBthYqHSoDaB7UXajvUTqj7oHZB7Yc6oCpkLTife409W+wwL9E3Hp5Xjs3H3vGS+9v30mPPXf5chxlyTjjisnr9e+B1o56FWgu1Dmo91F1Qd0PdA3Uv1H1Q90M9ALUB6kGoh6A2Qr0L6mGoR6DeDbUJ6j1Q74V6H9T7oT4A9SjUZqgPQn0I6sNQH4F6DGoL1FaobVCPQ22H2g31UagnoHZAfQxqJ9THoZ6E+gSUB+qTUE9B7YL6FNTTUM+oClmfvzN/hL7zOHJ4dad454n83/iJ/IvKsGYwrBnUaga1mkGtZlCrGdRqBrWaQa1mUKsZ1GoGtZpBrWZQqxnUaga1mkGtZlCrGdRqBrWaQa1mUKsZ1GoGtZpBrWZQqxnUaga1mkGtZlCrGdRqBrWaQa1mUKsZ1GoGtZpBrWZQqxmcaganmsGpZnCqGZxqBqeawalmcKoZZGoGmZpBpmaQqRlkagaZmpG/zeBwM7jYjNmkGbNJM2aaZswmzZhbmjFxNGPiMOqgqpC1pGvaT4rtjNiiYq2KQyoOq1inYr2KRBUJKuJVbFVxRMV2FUdVHFORpOK4ihMqdqjYoGKnio0qNqk4qSJZxS4Vm1WkiAhZV9xnoXzFmeO+sDoLvltnwUY9rMbY3/oBvbRRvbRRvbRRvbRRvbRRvbRRvbRRvbRRvbRR/TxG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJG9dJGY8f/Rc2qYmRVMbKqGFlVjKwqRlYVI6uKkVXFyKpiZFUxsqoYWVWMrCpGVhUjq4qRVcXIqmJkVTGyqhhZVYysKkZWFSOripFVxciqYmRVMbKqGFlVjKwqRlYVI6uKkVXFyKpiZFUxsqoYWVWMrCpGVhUjq4qRVcXIqmJkVTGyqhhZVYysKkZWFSOripFVxciqYmRVMbKqGFlVjKwqRlYVI6uKkVXFyKpiZFUxsqoYWVWMrCpGVhUjq4pNVv2geWZDqj+2Av+Q48IGZ5RdE/n66X51ir85tZ9ynrjt/GF1bL85S98coVcn528+MNsTu3U6IgP76qS8Otc6r42bjry0XKzuDKs7wuoqsDrY35znb07tzrcvGyJfP5M7W/9fRV6arFfXnNV1ZnWNWV1bVleJm7P6y0fxmwvT6qK0uvis7jUv32devr402v/A4bjIS9vKzVXEebb9H0de2i9evj+84trgLhwh64c16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fI16fJjjvuR27NRH7T/sLT6lKuDzh8y7T+U3crftezY5tGI7Nqrvrhp4Zfv2g4wHgYo3tyl22u/w9a4yNdv346L/inypj5n7Ef1d2x/Hjz/vGHvl+Q9rDo1SF3sv/+YzkQnMROdRMKexIRk1CGow1DroNZDJUIlQMVDbYU6ArUd6ijUMagkqONQJ6B2QG2A2gm1EWoT1EmoZKhdUJuhUlSFrKt36Df+g/YbZiKv8gSAYvsNO503vAnPBHC+n/++uMjreSrAG3gGwLLaJA02SYNN0mCTNNgkDTZJg03SYJM02CQNNkmDTdJgkzTYJA02SYNN0mCTNNgkDTZJg03SYJM02CQNNkmDTdJgkzTYJA02SYNN0mCTNNgkzdjkx/VuEnA3CbibBNxNAu4mAXeTgLtJwN0k4G4ScDcJuJsE3E0C7iYBd5OAu0nA3STgbhJwNwm4mwTcTQLuJgF3k4C7ScDdJOBuEnA3CbibBNxNAu4mwdzNT9zen9WzOkU4P29xKPLKU4jzM30+7rzh5WPI6njyzos5v37YuKYz/Rmd6c/oTH9GZ/ozOtOf0Zn+jM70Z3SmP6Mz/RkdWc4omM/oTH9GZ/ozOtOf0Zn+jM70Z3SmP6Mz/Rmd6c/oTH9GZ/ozOtOf0Zn+jM70Z3SmP6Mz/Rmd6c/oTH9GZ/ozMSv95C2d6Z2JfTzu1bz0zo+7unXfJVsxTwKwos4DIF/WvHoeefU8Eup5pNDzSCGj7oK6G+oeqHuh7oO6H+oBqA1QD0I9BLUR6l1QD0M9AvVuqE1Q74F6L9T7oN4P9QGoR6E2Q30Q6kNQH4b6CNRjUFugtkJtg3ocajvUR6GegNoB9TGonVAfh3oS6hNQn4R6CmoX1KegnoZ6BupZqN1QHqh4qASoPVB7ofZB7Yc6AHVQVci6rr6bgu+m8LlPwYVTcOEUXDgFF07BhVNw4RRcOAUXTsGFU3DhFFw4BRdOwYVTcOEUXDgFF07BhVNw4RRcOAUXTsGFU3DhFFw4BRdOwYVTcOEUXDgFF07BhVNw4RRcOAUXTsGFU3DhFFw4BRdOoWen4MkpeHIKnpyCJ6fgySl4cgqenIInp+CRKTh0Cg6dgkOn4NApOHQKDp0yPvgp9UE2fJCNzs9G52ej87PR+dno/Gx0fjY6Pxudn43Oz0bnZ6Pzs9H52ej8bHR+Njo/G52fjc7PRudno/Oz0fnZ6PxsdH42Oj8bnZ+Nzs9G52ej87PR+dno/Gx0fjY6Pxudn43Oz0bnZ6Pzs9H52ej1bPR6Nno9G72ejV7PRq9no9ez0evZ6PVs9Ho2ej0bvZ6NXs9Gr2ej17NNr9/QneUnpNWN2KJirYpDKg6rWKdivYpEFQkq4lVsVXFExXYVR1UcU5Gk4riKEyp2qNigYqeKjSo2qTipIlnFLhWbVaSICFk/7T7ddcKZe39GuTMM7gyDO8PgzjC4MwzuDIM7w+DOMLgzDO4MgzvD4M4wuDMM7gyDO8PgzjC4MwzuDIM7w+DOMLgzDO4MgzvD4M4wuDMM7gyDO8PgzjC4MwzuDIM7w+DOMLgzDO4MgzvD4M4wuDMM7gyDO8PgzjC4MwzuDIM7w+DOMLgzDO4MgzTDIM0wSDMM0gyDNMMgjVHPQu2G8kDFQyVA7YHaC7UPaj/UAaiDqkLWV97QAwfON+4L9CeprT6C4PxInq++6iMIzs+L2P1t/hXUqfYffvRt9JhCyPpZ9wUFz8WeTfFzGnDXNOCuacBd04C7pgF3TQPumgbcNQ24axpw1zTgrmnAXdOAu6YBd00D7poG3DUNuGsacNc04K5pwF3TgLumAXdNA+6aBtw1DbhrGnDXNOCuacBd04C7pgF3Leatn9dMq0SmVSLTKpFplci0SmRaJTKtEplWiUyrRKZVItMqkWmVyLRKZFolMq0SmVaJTKtEplUi0yqRaZXItEpkWiUyrRKZVolMq0SmVSLTKpFplci0SmRaJTKtEplWiUyrRKZVItMqkWmVyLRKZFolMq0SmVaJTKtEplUi0yqRaZXItEpkWiUyrRKZVolMq0SmVSLTKpFplci0SmRaJTKtEplWiUyrRKZVItMqkWmVyLRKZFolMq3SZNqL6rsC+K4AviuA7wrguwL4rgC+K4DvCuC7AviuAL4rgO8K4LsC+K4AviuA7wrguwL4rgC+K4DvCuC7AviuAL4rgO8K4LsC+K4AviuA7wrguwL4rgC+K4DvCuC7AviuAL4rgO8K4LsC+K4AviuA7wrguwL4rgC+K4DvCuC7AviuAD4ogAsL4MICuLAALiyACwvgwgLT67+gvZ6EXk9Cryeh15PQ60lwplGJUPFQSVDHoU5AbYDaCLUJKhlqM1QK1BaoQ1CHobZCHYHaDnUU6hjUDqidUCehdqkKWf/F/TU1/+7MYr/4n+bXDn17hmnnu/adcZE39Tt1v2R+AlHq0dh0/V/dn8lW6oj/ZotfviXfhHU+gEd/GLWzKa1Zcysv29nO3rXmDd362/8ZDb/i3OYqT34AFPwBcNaoCqjHoPZAbYXaB7Ud6iTUfqhdUDuhDqgKWb+qa+B3yKduxBYVa1UcUnFYxToV61UkqkhQEa9iq4ojKrarOKrimIokFcdVnFCxQ8UGFTtVbFSxScVJFckqdqnYrCJFRMj6Nef4naXca14B5kn9zTjn7f/d5cegw49ff0PscJ5NfF0Y0mTXByPfQkw4ObTrdRDk2xwXz9rV95rAkW7XvIh5BcYTrwckDvAuC1C+GUduAucmUH7j9jzv3omLj9zeEeAVw8A57czXecd3ZCj8pjsBJMQmgN/S4bsIoVCE4bsIw3cRhu8iLJpFWDSLsGgWYdEswqJZhEWzCItmEUbxIiyaRVg0izCmF2HRLMKiWYRFswiLZhHG+yIsmkVYNIuwaBZh0SzColmERbMIS0IRFs0iLJpFWDSLsGgWIaqLsFwUIaqLsGgWYdEsQnAXYdEswqJZhHWiCItmEWK8CItmERbNIiyaRVgti7BaFmFQKMJqWYTVsgirpVHPQu2G8kDFQyVA7YHaC7UPaj/UAaiDqkLWV3WguaQDzSUdaC7pQHNJB5pLOtBc0oHmkg40l3SguaQDzSUdaC7pQHNJB5pLOtBc0oHmkg40l3SguaQDzSUdaC7pQHNJB5pLOtBc0oHmkg40l3SguaQDzSUdaC7pQHNJB5pLseP/bcVeENgLAntBYC8I7AWBvSCwFwT2gsBeENgLAntBYC8I7AWBvSCwFwT2gsBeENgLAntBYC8I7AWBvSCwFwT2gsBeENgLAntBYC8I7AWBvSCwFwT2gsBeENgLAntBYC8I7AWBvSCwFwT2gsBeENgLAntBYC8I7AWBvSCwFwT2gsBeENgLAntBYC8I7AWBvSCwFwT2gsBeENgLAntBYC8I7AWBvSCwFzTY+x13YdjmzB6/e3sfT3Kmyvhb+drNbz5VOo/o/OXq6P32fqzh95SoSyDqEoi6BKIugahLIOoSiLoEoi6BqEsg6hKIugSiLoGoSyDqEoi6BKIugahLIOoSiLoEoi6BqEsg6hKIugSiLoGoSyDqEoi6BKIugahLIOoSiLoEoi6BqEsg6hKIugSiLoGoSyDqEoi6BKIugahLIOoSiLoEoi6BqEsg6hKIugSiLoGoSyDqEoi6BKIugZNL4OQSOLkETi6Bk0sg8RKouQRqLoHSS4aav68/SNKD2/Dg8/Pg8/Pgc/DgbjxwjAcn7sHn58Hn58HX7MHX7MEZe8zn/gfO5776Gl3nNb3/GHlpbv0Z+eSNqFDxmIo9Kraq2Kdiu4qTKnaq2KViv4oDIkLW/3B/Yv9jTmD9oTJuEYxbBOMWwbhFMG4RjFsE4xbBuEUwbhE3tgjGLYJxi2DcIhi3CMYtgnGLYNwiGLcIxi2CcYtg3CIYtwjGLYJxi2DcIhi3CMYtgnGLYNwiGLcIxi2CcYtg3CIYtwhXLYJxi2DcIny0CMYtgnGLYNwiGLcIxy2CcYtg3CIYtwjGLYJxi/DfIhi3CMYtgnGLYMgiGLIIvy/C74vgyyIYtwiGLIIhi2DcouHEH2EYdJ6V97Fv9Bij83y3lrjIax8Lv7Wn833ltTzq+M63nl55HPxjReUcUDkHVM4BlXNA5RxacQ7gnAM45wDOOYBzDuCcAzjnAM45gHMO4JwDOOcAzjmAcw7gnAM45wDOOYBzDuCcAzjnAM45gHMO4JwDOOcAzjmAcw7gnAM45wDOOYBzDuCcAzjnAM45gHMO4JwDLuaA0TlgdA4YnQNG54DROWB0DhidA0bngKA5QHUOUJ0DVOcA1TlAdQ5QnTNY+xN9nC8oNjBii4q1Kg6pOKxinYr1KhJVJKiIV7FVxREV21UcVXFMRZKK4ypOqNihYoOKnSo2qtik4qSKZBW7VGxWkSIiZP2pc/x2VKTe7/LY+hG7Njsxs0bO9Wf1jH5Wb+lnpfON2Kpin4rtKvar2KnigIoKFXtUnFSxS0TI+jOF6zTgOg24TgOu08DpNFA7DbhOA67TgOs04DoNuE4DrtOA6zTgOg24TgOu04DrNOA6DbhOA67TgOs04DoNuE4DrtOA6zTgOg24TgOu04DrNOA6DbhOA67TgOs04DoNuE4DrtOA6zTgOg24TgOu04DrNOA6DbhOA67TgOs04DoNuE4DrtOA6zTgOg24TgOu04DrNOA6DbhOG7j+z9vz7eibP/3trf5D35wf5bZ9TeSNjIwv/6Fvzo/I+6M35TlrIevP39D1OrdW8o1e2POqC8DI630y2q/HvcqFv7MRhKy/0NDqQmh1IbS6EFpdiKkuxFQXYqoLMdWFmOpCTHUhproQU12IqS7EVBdiqgsx1YWY6kJMdSGmuhBTXYipLsRUF2KqCzHVhZjqQkx1Iaa6EFNdiKkuxFQXYqoLMdWFmOpCTHUhproQU12IqS7EVBeCqQvB1IVg6kIwdSGYuhBMXQimLgRTF6KoC1HUhSjqQhR1IYq6EEVGPQu1G8oDFQ+VALUHai/UPqj9UAegDqoKWX/5hin6wddEUQeGT9/eb7O9XaH50tO2/0rhOQ94zgOe84DnPOA5j5abB0rngdJ5oHQeKJ0HSueB0nmgdB4onQdK54HSeaB0HiidB0rngdJ5oHQeKJ0HSueB0nmgdB4onQdK54HSeaB0HiidB0rngdJ5oHQeKJ0HSueB0nmgdB4onQdK5wGeeYB1HmCdB1jnAdZ5gHUeYJ0HWOcB1nmAbh6YnQdm54HZeWB2HpidB2bnDcz+Wn1QAx/UwAc18EENfFCDzq9B59eg82vQ+TXo/Bp0fg06vwadX4POr0Hn16Dza9D5Nej8GnR+DTq/Bp1fg86vQefXoPNr0Pk16PwadH4NOr8GnV+Dzq9B59eg82vQ+TXo/Bp0fg06vwadX4POr0Gv16DXa9DrNej1GvR6DXq9Br1eg16vQXfXoLtr0N016O4adHcNursGQ0QNvFwDb9VgiKgB0WswRNRgiKjBEFGDIaIGQ0QNhoga47u/0YcxS8R2RmxRsVbFIRWHVaxTsV5FoooEFfEqtqo4omK7iqMqjqlIUnFcxQkVO1RsULFTxUYVm1ScVJGsYpeKzSpSRISs/6VPANgGo2xDQ2xDQ2zDpW+DbbYBZttghm1oj21oj21osm1osm1o/22mdf5WkX0KyD4FAJwCwI06BHUYah3UeqhEqASoeKitUEegtkMdhToGlQR1HOoE1A6oDVA7oTZCbYI6CZUMtQtqM1SKqpD1d2rrLLV1lto6S22dpbbOUltnqa2z1NZZausstXWW2jpLbZ2lts5SW2eprbPU1llq6yy1dZbaOkttnaW2zlJbZ6mts9TWWWrrLLV1lto6S22dpbbOih3//3afXDLpPLnk77GnOT/heWfkbfUqW2eVPPm2fjLkc3Ydi8hjXv9wSx+g/uZPYXi9l5lq1597XZf6trvDr1u9/1FfRPtFJMgXkWZGVUA9BrUHaivUPqjtUCeh9kPtgtoJdUBVyPonTeIJjHkT+EomkMQTSNsJpO0EVqkJrFITWKUmsEpNYPqYwCo1gVVqAjk5gVVqAqvUBFJzAqvUBFapCaxSE1ilJpC2E1ilJrBKTWCVmsAqNYFVagKr1ARyeQKr1ARWqQmsUhNYpSbQXxOYpCbQXxNYpSawSk2g2yawSk1gDZnAYjWBWWYCi9UEOnECi9UEFqsJLFYTWHQmsGZNYM2aQOdPYM2awJo1gTVrwvjg/+jUU6ZTT5lOPWU69ZTp1FOmU0+ZTj1lOvWU6dRTplNPmU49ZTr1lOnUU6ZTT5lOPWU69ZTp1FOmU0+ZTj1lOvWU6dRTplNPmU49ZTr1lOnUU6ZTT5lOPWU69ZTp1FMWO/6v6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGP6fGPxY7/n92X4LzPGTr/RSOhDCFQhhAoQwiUIQTKEAJlCIEyhEAZQqAMIVCGEChDCJQhBMoQAmUIgTKEQBlCoAwhUIYQKEMIlCEEyhACZQiBMoRAGUKgDCFQhhAoQwiUIQTKEAJlCIEyhEAZQqAMIVCGEChDCJQhBMoQAmUIgTJgvwzYLwP2y4D9MmC/DNgvA/bLAPoygL4MoC8D6MsA+jKA3qhnoXZDeaDioRKg9kDthdoHtR/qANRBVSHr/3bEfqFZ6qOxF+H/q+PCePtzuhIxv3b5j5z3+Tfl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5FXl5NXYFf27+3MS0mJX9P/MT3pOPbDGUf+hV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV9OlV+OIUKonzv15NNaw/d+c30z+TJzz9rg4vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZc8vZe82L2sibtDf6PjLfxNjs7vZ3zMeXrDt/4rHV/pNzkG7Xd835rIm/MrHe3PTc3gVTN41QxeNYNXzeBVM3jVDF41g1fN4FUzePWz8qoZvGoGr5rBq2bwqhm8agavmsGrZvCqGbxqBq+awatm8KoZvGoGr5rBq2bwqhm8agZv7PzXxb0pL293Hhj+xcirPAboNP/vRsxrz1PeeTlT5FY8eTF1Pcx0Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10Rc10JWamu/T8U+uxqNZjUa3HolqPRbUei2o9FtV6LKr1WFTrsajWY1Gtx6Jaj0W1HotqPRbVeiyq9VhU67Go1mNRrceiWo9FtR6Laj0W1XosqvVYVOuxqNZjUa3HolqPRbUei2o9FtV6LKr1WFTrsajWY1Gtx6Jaj0W1HotqPRbVeiyq9VhU67Go1mNRrceiWo9FtR6Laj0W1XosqvVYVOuxqNZjUa3HolqPRbUei2o9FtV6LKr1WFTrsajWY1Gtx6Jaj0W1HotqPRbVmAql3h1nXr9vzPjzcotGHFaxVsVWFfEq9qnYrmK/ip0qDqioULFHxUkVj6rYJSKUeg94flF5flF5flG/rIvK84v61V9Unl9Unl9Unl9Unl/Uc7moJ3ZReX5RD+mi8vyi8vyi8vyi8vyi8vyi8vyi8vyiHvlF5flF5flFPeWLyvOLesoXlecXlecXY+d/b9xb5Dujb5nviDrfwr03cju/M2ofrIZyCUK5BKFcglAuQSiXIJRLEMolCOUShHIJQrkEoVyCUC5BKJcglEsQyiUI5RKEcglCuQShXIJQLkEolyCUSxDKJQjlEoRyCUK5BKFcglAuQSiXIJRLEMolCOUShHIJQrkEoVyCUC5BKJcglEsQyiUI5RKEcglCuQShXIJQLkEolyCUSxDKJQjlEoRyCUK5BKFcglAuQSiXIJRLEMolCOUShHIJQrkEoVyCUC5BKJcglEsQyiUmlO+PM9/DsdM5Mt6U+sCthanzMri0W/rD2t9ym2XsJ+SvidzWFXMDaNoKmraCpq2gaSto2gqatoKmraBpK2jaCpq2gqatoGkraNoKmraCpq2gaSto2gqatoKmraBpK2jaCpq2gqatoGkraNoKmraCpq2gaSto2gqatoKmraBpK2jaCpq2gqatoGkraNoKmraCpq2gaSto2gqatoKmraBpK2jaCpq2gqatoGkraNoKmraCpq2gaSto2gqatoKmraBpK2jaCpq2gqatoGkraNoKmraCpq2Gpg/CeIMw3iCMNwjjDcJ4gzDeIIw3COMNwniDMN4gjDcI4w3CeIMw3iCMNwjjDcJ4gzDeIIw3COMNwniDMN4gjDcI4w3CeIMw3iCMNwjjDcJ4gzDeIIw3COMNwniDMN4gjDcI4w3CeIMw3iCMNwjjDcJ4gzDeIIw3COMNwniDMN4gjDcI4w3CeIMw3iCMNwjjDcJ4gzDeIIw3COMNwniDMN4gjDcI4w3CeIMw3iCMN2iM9xCMNwPjzcB4MzDeDD7BGdhwBjacgQ1nYMMZ2HAGNpyBDWdgwxnYcAY2nIENZ2DDGdhwBjacgQ1nYMMZ2HAGNpyBDWdgwxnYcAY2nIENZ2DDGdhwBjacgQ1nYMMZ2HAGNpyBDWdgwxnYcAY2nEHTzsCUMzDlDEw5A1POwJQzMOUMTDkDU87AJDOw6AwsOgOLzsCiM7DoDCw6Y4ywMWaE1cfVfk0634itKvapiFexXcV9Knaq2K/igIoKFXtU7FVxUsUuEaHUd8W+kpB9aD32f2ux6wsRswcsvGRZazb2vg/D/mMgxBhgMAYYjAEGY7D/GOw/BvuPwf5jsP8Y7D8G+4/B/mOw/xjsPwb7j8H+Y7D/GOw/BvuPwf5jsP8Y7D8G+4/B/mOw/xjsPwb7j8H+Y7D/GOw/BvuPwf5jsP8Y7D8G+4/B/mOw/xjsPwbDjwEGY7D/GOw/BvuPwf5jsP8Y7D8G+4/B/mOw/xjsPwb7j8H+Y7D/GOw/Zuz/CIyQg9bPQevnoPVz0Po5aP0ctH4OWj8HrZ+D1s9B6+eg9XPQ+jlo/Ry0fg5aPwetn4PWz0Hr56D1c9D6OWj9HLR+Dlo/B62fg9bPQevnoPVz0Po5aP0ctH4OWj8HrZ+D1s9B6+eg9XPQ+jlo/Ry0fg6aPQfNnoNmz0Gz56DZc9DsOWj2HDR7Dpo9B82eg2bPQbPnoNlz0Ow5ptnfHec+//hjzkNXm9D6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z9H6Z/9/e2ceGNV5nX2NxCoQiEWsYpNsgRCb2CSxmEUgBMqELEqUzVawTaTxhsMwjTQRRCEwASJSZQrDkskkUVNMSAOBibDBFWREU38tbWxS17FjY+y6gJeUEmynTlj6zb3vFf493mKMhIGQP3L4CVnMPe/znHPe994ZifRrRPo1Iv0akX6NSL9GpF8j0q8R6deI9GtE+jUi/RqRfo1Iv0bEXiNirxGx14jYa0TsNSJ2Q5OEJgslCOUJ5QsVCE0Rmio0TWi60C0kn7uP68p8dt51f9+t7U6GrUPo067AO9x463uFFs/6cL+HXYEbn4D4Xp+A2Aa3AvpJV5wnXXGe1Nh50iMNzRCaKdROqL3QLKF8oTyhTKHZQllChUJzhOYKFQnNE8oWShHKEUoVShMqFpovlCuULrSA5Itrj4tTJYtTJctRJSmvkpRXychSJSNLlYwsVTKyVMnIUiUjS5WMLFWSrCoZWapkZKmS1FXJyFIlI0uVjCxVMrJUScqrZGSpkpGlSkaWKhlZqmRkqZKRpUoWp0pGlioZWapkZKmSkaVKRpYqsVOVyLtKRpYqGVmqROxVMrJUychSJRKukpGlSiRcJSNLlYwsVTKyVMnIUiUjS5UIukpGlioZWapkZKmSkaVKRpYqGVmqpCRUSbmokpGlSkaWKhlZqmRkqZKRpUpGlipjvAGutz5Q7f5sYqCNf2HYnuv6frcn/hfjEgMfyiPVA9+2nK3yfHw8c+4vWD/Qev79pvd8jMFa302XuL7ub7a8T+PyFvi6mVIvrme69MUG6YsN0hcbpC82SF9skGrSIF2yQbpkg3TJBumSDdIlG6RLNkiXbJAu2SBdskG6ZIN0yQbpkg3SJRukSzZIl2yQLtkgXbJBumSDdMkG6ZIN0iUbpEs2SJdskC7ZIF2yQbpkg3TJBumSDdIlG6RLNkiXbJAu2SBdskF6SoP0zAbpmQ3SMxukZzZIz2yQntkgPbNBemaD9LAG6aAN0kEbpIM2SAdtkA7aIB20wfSpQS5+WluqJCtVWmeqiD1V2mOqpC5VBJ0qKUiVRpoqjTRV2nGqtONUucxU8+IHi4uD4uKguDgoLg6Ki4Pi26D4Nii+DYpvg3KZQfFtUHwbFN8GxbdB8W1QfBsU3wbFt0HxbVB8GxTfBsW3QfFtUHwbFN8GxbdB8W1QfBsU3wbFt0HxbVB8GxTfBsW3QZFiUHwbFN8GRXxBcWpQnBoUpwbFqUGRaVCcGhSnBsWpQfFmULwZFNEGxZtB8WZQvGloktBkoQShPKF8oQKhKUJThaYJTRe6heRzD6HxSj4N3xnIICQRZhBmEtoR2hNmEfIJeYRMwmxCFqGQMIcwl1BEmEfIJqQQcgiphDRCMWE+IZeQTlgA8LmHut7xTM06+fIkBm6cjF6FM+ebB6LD3nnxbonHDZewdp+I/4AM16Us4nVzMPr+l9c6Qs10vcM6X4GD0Yx3XWf3E662MOl1s77XxsF3pkyfUemTUZlFozKLRmUWjcosGpVZNCqzaFRm0ajMolGZRaMyi0ZlFo3KLBqVWTQqs2hUZtGozKJRmUWjMotGZRaNyiwalVk0KrNoVGbRqMyiUZlFozKLRmUWjcosGpVZNCqzaFRm0ajMolGZRaMyi0ZlFo3KLBqVWTQqs2hU5rioTKZRmUyjMplGZTKNymQalck0KpNpVCbFqMypUZlTozKnRmVOjcqcGpU5NWqmwZtkGvwjp8E/cgD8I8e8P3LM+yNUb6AjoROhMyGZ0IXQlZBC6EboTkgl9CD0JPQi9CakEfoQ+hL6EfoTBhAGEtIJgwiDCUMIQwnDCBmETMJNhJsJWYThhBGEbMJIQg5hFGE0YQwhgTCWMI6QSxhPmECYSJhMyCfkEQoIUwhTCdMI0wE+9822P1qM/wvZpP3CWCjL5bxJbr3LetJouDhqGR21jMu3jPayYQZhJqEdoT1hFiGfkEfIJMwmZBEKCXMIcwlFhHmEbEIKIYeQSkgjFBPmE3IJ6YQFAJ97hOQ/zPyHmf8w8x9m/sPMf5j5DzP/YeY/zPyHmf8w8x9m/sPMf5j5DzP/YeY/zPyHmf8w8x9m/sPMf5j5DzP/YeY/zPyHmf8w8x9m/sN2/rNdbXK75SrY3lo3esa6An8J+9yRriv8sQnWLbKfXcO3QN3xLxxzXZ3L6nPnsCa6H5ANzgOywXlANjgPyAbH0CyhfKE8oblCRULzhFKEUoXShOYLpQtlCM0QmimUKTRbKEuoUGiOULZQjlCxUK7QApLPPUoa1j42rH1sWPvYsPaxYe1jw9rHhrWPDWsfG9Y+Nqx9bFj72LD2sWHtY8Pax4a1jw1rHxvWPjasfWxY+9iw9rFh7WPD2seGtY8Nax8b1j42rH1sWPvYsPaxYe2z8z/amt8sY/+bNb6NcfGm2lCRy1AR+VAxwFA5lbdpY0KCK8H630VNDZWt/lDRzVA5yB8qB/lD5XbAULkdMFQUNtRoaqxoaj81tZ+a2k9N7aem9lNT+6mp/dTUfmpqPzW1n5raT03tp6b2U1P7qan91NR+amo/NbWfmtpPTe2npvZTU/upqf3U1H5qaj81tZ+a2k9N7aem9tv5HycqcomKXKIil6jIJSpySUFyiXhcIh6XiMcl4nGJeFwiHpeIx2XEkyvdola6Ra10i1rpFrXSLWrlOKxWjsNq5TisVo7DauUya+U4rFaOw2qld9TKcVitHIfVSl+pleOwWjkOq5XjsFo5DquVflQrx2G1chxWK8dhtXIcVivHYbVyHFYrXa1WjsNq5TisVo7DauU4rFaOw2qlN9aKFGvlOKxWjsNqRXy1chxWKwdgtdINa+UArFZkWisHYLVyAFYrB2C1cuRVK0detSLaWjnyqpUjr1o58jI0SWiyUIJQnlC+UIHQFKGpQtOEpgvdQvK5x4vxQvItIbFhSGwYEhuGxIYhsWFIbBgSG4bEhiGxYUhsGBIbhsSGIbFhSGwYEhuGxIYhsWFIbBgSG4bEhiGxYUhsGBIbhsSGIbFhSGwYEhuGxIYhsWFIbBgSG4bEhiGxYUhsGBIbhsSGIbFhSGwYEgmHxJQhMWVITBkSU4bElCExZUhMGRKThMSiIbFoSCwaEouGxKIhsWjIGGGCy3nv3nZrJJvokLuD9Zn47kl0ScnPYQsDGYQkwgzCTEI7QnvCLEI+IY+QSZhNyCIUEuYQ5hKKCPMI2YQUQg4hlZBGKCbMJ+QS0gkLAD73ZKlSpVKXSqUulUpdKpW6VCp1qVTqUqnUpVKpS6VSl0qlLpVKXSqVulQqdalU6lKp1KVSqUulUpdKpS6VSl0qlbpUKnWpVOpSqdSlUqlLpVKXSqUulUpdKpW6VCp1qVTqUqnUpVKpS6VSl0qlLpVKXSqVulQqdalU6lKpVKJSqUSlUolKpRKVSiUqlUpUKpWoVCpRqVSiUqlEpVKJSqUSlUolKpVKVGoqUZ7L+dWZKVbpyZfSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU8HSU2GvRoGL26pEEWuizGyJMrMlylyWKNJNlIKSKIJMlAkuUSa4RJkDE2UOTBTRJRopTXE5bWyAfZ9oqpTREimjJWLKEimqhmYIzRRqJ9ReaJZQvlCeUKbQbKEsoUKhOUJzhYqE5gllC6UI5QilCqUJFQvNF8oVShdaQPK5p4nQkiQhSZKsJElkkggtSZKVJEJLkgtLEqElidCSRGhJIrQkubAk8+Knu1r18P4T8XgycCWfXbIep7s5cOMZtfc+1L9FCsgGWwm3CCUKJQm1E2ov1EGoo1Anoc5CyUJdhLoKpQh1E+oulCrUQ6inUC+h3kJpQn2E+gr1E+ovNEBooFC60CChwUJDhIYKDRPKEMoUuknoZqEsoeFCk4VGCGULjRTKERolNFpojFCC0FihcUK5QuOFJghNJPncM8QIZSL9MpF+mUi/TKRfJtIvE+mXifTLRPplIv0ykX6ZSL9MpF8m0i8T6ZeJ9MtE+mUi/TKRfplIv0ykXybSLxPpl4n0y0T6ZSL9MpF+mUi/TKRfJtIvE+mXifTLRPplIv0ykX6ZSL9MpF8m0i8T6ZeJ2MtE7GUi9jIRe5mIvUzEXiZiLxOxl4nYy0TsZSL2MhF7mYi9TMReZsQ+U8TeJGJvErE3idibROxNMrU0ifSbRPpNIv0mkX6TSL9JpN8k0m8S6TeJ9JtE+k0i/SaRfpNIv0mk3yTSbxLpN4n0m0T6TSL9JpF+k0i/SaTfJNJvEuk3ifSbRPpNIv0mkX6TSL9JpN8k0m8S6TeJ9JukzjeJEZrECE1ihCYxQpMYoUmM0CRGaBIjNIkRmsQITWKEJjFCkxihSYzQJEZoMkaYJUbwixH8YgS/GMEvRvCL9P0ifb9I3y/S94v0/SJ9v0jfL9L3i/T9In2/SN8v0veL9P0ifb9I3y/S94v0/SJ9v0jfL9L3i/T9In2/SN8v0veL9P0ifb9I3y/S94v0/SJ9v0jfL9L3i/T9Ina/iN0vYveL2P0idr+I3S9i94vY/SJvv8jbL/L2i7z9Im+/yNvQJKHJQglCeUL5QgVCU4SmCk0Tmi50C8kX3xDReB4xnkeM5xHjecR4HjGeR4znEeN5xHgeMZ5HjOcR43nEeB4xnkeM5xHjecR4HjGeR4znEeN5xHgeMZ5HjOcR43nEeB4xnkeM5xHjecR4HjGeR4znEeN5xHgeMZ5HjOcR43nEeB4xnkeM5xHjecR4HjGeR4znEeN5xHgeMZ5HjOcR43nEeB4xnkeM5xHjecR4HjGeR4znEeN5xHgeMZ5HjOcR43nEeB4xnkeM5zHGK6TxSu6E7wxkEJIIMwgzCe0I7QmzCPmEPEImYTYhi1BImEOYSygizCNkE1IIOYRUQhqhmDCfkEtIJywA+NxzpPB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5pfB5TeGb67o23lKwMB4fDLTKO+etW46BwHX4zoIiF37Pp3u3WNLQTKEkoUyhPKGpQllC04RyhKYLVQoVCBULDRTKJfnc86RXzJZeMVsqz2y5TEMzhGYKtRNqLzRLKF8oTyhTaLZQllCh0ByhuUJFQvOEsoVShHKEUoXShIqF5gvlCqULLSD53MWyOAtlcRbK4iyUxVkoi7NQFmehLM5CWZyFsjgLZXEWyuIslMVZKIuzUBZnoSzOQlmchbI4C2VxFsriLJTFWSiLs1AWZ6EszkJZnIWyOAtlcRbK4iyUxVkoi7PQLM58WZwlsjhLZDmWSMqXSMoNdRDqKNRJqLNQslAXoa5CKULdhLoLpQr1EOop1Euot1CaUB+hvkL9hPoLDRAaKJQuNEhosNAQoaFCw4QyhDKFbhK6WShLaLjQCKFsoZFCOUKjhEYLjREaKzROKFdovNAEoYlCk4QmCyUI5QnlCxUITRGaKjRNaLrQLSSfewGNV/IgfGcgg5BEmEGYSWhHaE+YRcgn5BEyCbMJWYRCwhzCXEIRYR4hm5BCyCGkEtIIxYT5hFxCOmEBwOcusfNvvVWyh8u+2ISSz9hrkFAy2f4HEkr+FDCfO5pgfcOt8S9UxmNZPB6Jx8/F4zH78hNKNtkXm1Dy0Xj8Sjx+xc5Rgru3y059Qsnj9qtMKHFjxX7J7P/Sfk0fEU2cpSbOUhNnqYmz1MRZauIsNXGWmjhLTZylJs7yVZ2lJs5SE2epibPUxFlq4iw1cZaaOEtNnKUmzlITZ6mJs9TEWWriLDVxlpo4S02cpSbOUhNn7fy7Xa3yKE9JPC4N6PtxH3nP9+O21qM81rNBRYmBq/AjiT+Et+F+VNxUSTdV0k2VdFMl3VRJN1XSTZV0UyXdVEk3VdJNlXRTJd1USTdV0k2VdFMl3VRJN1XSTZV0UyXdVEk3VdJNlXRTJd1USTdV0k2VdFMl3VRpu2mhy3mnZ4L1AObHHHL/zn4e8+OtY7W3Hi5Yb2z3utrSYletsyzvH32nh+Pa0GKfoMXchbJ7KJRZtFD2EoWytSuUrV2h7DMKZZ9RKFu7QpnVCmWOK5TZt1C2doUy7RbK1q5QtnaFsrUrlK1doWztCmUuLpTdSqHMxYWyPymUfUahbO0KZWtXKJNwoeweCmVrV2gmzE9ajsuPL9UDluFKpRquZDVcyWq4ktVwJavhSlbDlayGK1kNV7IarmQ1XMlquJLVcCWr4UpWw5WshitZDVeyGq5kNVzJariS1XAlq+FKVsOVrIYrWQ1XshquZDVcyWq4ktVwJavhSns1PuXiLwP9D2b5P5gKG6YS8ghZhGRCDmEaYTqhklBAmEIoJuQCfO5PO7pyf9Gu5GUirMMU1mFe5WFK4TAVc5haOkz5HOb1H+aCH+aCH+aCH+YaH+ayHuayHuZKHubiHebiHaY3DtMOh2mHw1zCw1TzYa7aYar5MNV8mDI9zPU8zOU4zOU4bC/HZyT/EeY/whcf4WJEeCURXkmEixHhMkW4MhGuZoTLFGEqIkxFhKmIMBURpiLCdY5wnSNc5wgzFuGiR5i+CBUQoQIiTGyEcogwyxFqI0JtROz8f9Z1bdwu+Qv4gGHrI6N+xQHmrYNLy0Dztvskn6OJ4q8XLnIoSaidUHuhfKFZQnlCc4WKhOYJpQilCqUJzRdKF1oglCE0Q2imUKbQbKEsoUKhOULZQjlCxUK5JJ/781Lh1rLCrWWFW8sKt5YVbi0r3FpWuLWscGtZ4daywq1lhVvLCreWFW4tK9xaVri1rHBrWeHWssKtZYVbywq3lhVuLSvcWla4taxwa1nh1rLCrWWFW8sKt5YVbq2d/y+0boWzXFrqej+lznr73qet4wxrW3dz4iUUv2tu93YFN223ip020U6baKdNtNMm2mkT7bSJdtpEO22inTbRTptop0200ybaaRPttIl22kQ7baKdNtFOm2inTbTTJtppE+20iXbaRDttop020U6baKdNtNMm2mmTbafbJP+rmP9VzP8q5n8V87+K+V/F/K9i/lcx/6uY/1XM/yrmfxXzv4r5X8X8r2L+VzH/q5j/Vcz/KuZ/FfO/ivlfxfyvYv5XMf+rmP9VzP8q5n8V87/Kzn+5nf974755xvJNy4fb3s8E3W9/5xfjUHJf3DeHrY3OIous/+ykve+53dWqJ1jW8c2Pr8gh8eT4D0x6f4fE12sRbBn8Ls5jE2Vymyi39ibKrb2JcmtvotwgnCg3CCea6eUOWyd3x1/hJ61XeFf8X54SMLeFdjurtRPKu8/+j+50OWenz1lSW2z/COs7/91JdJKzONMCph+Psv6jL7n4NuqOMrp1lPGzo1xuR7ncjjLWdZQ79B1ldOsoiekoiekoiekoiekoQ15Hk6YK+8XPi6fJFveM+EV1jMdPx+N3A2/edvtMPM4NmNttqfH42Xg8E3jzdlzL/TvrttwX4/Hz8fjZgLmfNy4evxCPqwLmdt5ZJ5nlRijuXs7MUfKjeLwt/oUh1hfK4184bRfFBPeEFo39czx+Mf6FHOsLi+JfmBiPt8fjaLsUJpRMdawdC5hbgVNcAXNokmM57w7LgtZX7ox/y+edNXzIKN49wxUwdwufNu4v+ZhjmUGO+UvjcbH1LvBEx7uTXY7dZ8Xjl+JfcFlfqIh/Ieoo7Q3jmpIJTqVqCLznjchKUdIYUdIYUdIYUdIYUdIYUdIYUdIYUdIYUdIYUdIYUdIYUdIYUdIYoyQP+6v7+7KX+77s5b4ve7nvy6V8X3Z2hjoIdRTqJNRZKFmoi1BXoRShbkLdhVKFegj1FOol1FsoTaiPUF+hfkL9hQYIDRRKFxokNFhoiNBQoWFCGUKZQjcJ3SyUJTRZaLjQCKFsoZFCOUKjhEYLjRFKEBorNE4oV2i80AShiSSf+66WgSXLHljutn1hTQN74t/70Xjs7tSPYS7bUwklt5ny4N5ifaEq/oUlTolcbSqje1aiqTTun7isf+EeqRNdZDm6SJ3oIubqInWiiyxOF7FMF0lyF6kTXaROdJE60UXqRBdJZBeTnntZJ0q+ijJhIIOQRJhBmEloR2hPmEXIJ+QRMgmzCVmEQsIcwlxCEWEeIZuQQsghpBLSCMWE+YRcQjphAcDnvs+FZ5NL/hM2N5BJyCdMJeQRsgjTCDmE6YRKQgEhgVBMyAX43EtcLfPZtvjf+awGnIjX/EP7m+6Xy32Sl/skL/dJXu6TvNwneblP8nKf5OU+yct9kpf7JC/3SV7uk7zcJ3m5T/Jyn7Sv5Mvi+pHi+pHi+pHi+pHi+pHi+pHi+pHi+pHi+pHi+pHi+pHi+pHi+pHG9UtdbfLgQavt1qzd2WZX4P0cXVlbxshf9Latj+irj+irj6imj6imj6imj6imj9GJ9yrXyV/A7Zw/pwpL//e63i4Pn3uZtPY6tvY6tvY6tvY6tvY6tvY6tvY6tvY6tvY6Vu46Fus6Fvg6tvY6lvE6tvY6tvY6tvY6tvY6tvY6tvY6tvY6NoU6tvY6tvY6lv46tvY69oE6tvY6tvY62zw+6RDdpUN0lw7RXRzcXRzcXTpEd+kQ3aVDdBevdxevdxevdxevd5cO0d04/69EPIconkMUzyGK5xDFc4jiOUTxHKJ4DlE8hyieQxTPIYrnEMVziOI5RPEcongOUTyHKJ5DFM8hiucQxXOI4jlE8RyieA5RPIconkMUzyGK5xDFc8jO/1ck/0HmP8j8B5n/IPMfZP6DzH+Q+Q8y/0HmP8j8B5n/IPMfZP6DzH+Q+Q8y/0HmP8j8B5n/IPMfZP6DzH+Q+Q8y/0HmP8j8B5n/IPMftPNfZeffektk+4B9/O2+097sVYupO4mpO4mpO4mpO4mpO4mpO4mpO4mpO4mpO4mpO4mpO4mpO4mpOxlT+13veA/TelS7a+C6aO/X2o1L6zZw+/fT5i/OAxfvYH5VF9P6/c59P8iQZv2C4ZmJl7Kc180vDr42PnSzRlpBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBOVtBuV01l7t4ZvFbb+DNM4vfMhW/ZcZ+i3JvII+QRZhGyCFMJ1QSCggJhGJCLsDnXiFK2ksl7aWS9lJJe6mkvVTSXippL5W0l0ray7zsZSr2Mn17qaS9TNJeKmkvlbSXStpLJe2lkvZSSXuppL1M+V4qaS+VtJeJ3Usl7WWW91JJe6mkvXb+vyZKOkUlnWIqTjFjp6ikU0zfKSbpFJV0ipd1iko6RSWdopJOUUmneMGneI2n7CupfedJ4qqfIKx++z3rB/wFnhS87YDg61IOqlkOqlkOqlkOqlkOqlkOqlkOqlkOqlkOqinuauq5mh6oZjmoptKrWQ6qWQ6qWQ6qWQ6qWQ6qWQ6qWQ6q6ZtqloNqloNquqOa5aCaVqlmOahmOai2TbTS9aHc7bduwIdbVPsBb/u/77v97/8m/xfjsTbw7jf72+Qe/zfEAttogW20wDZaYBstsI0W2EYLbKMFttEC22iBbXxV22iBbbTANlpgGy2wjRbYRgtsowW20QLbaIFttMA2WmAbLbCNFthGC2yjBbbRAttogW20wDY7/6tc3E4ny3Y6WbbTybKdTpbtdLJsp5NlO50s2+lk2U4ny3Y6WbbTybKdTpbtdLLZTq92mV/UnlBSGDCPyBVYXw6IpvZQU3uoqT3U1B5qag81tYea2kNN7aGm9lBTe6ipPdTUHmpqDzW1h5raQ03toab2UFN7qKk91NQeamoPNbWHmtpDTe2hpvZQU3uoqT3U1B5qao+9LN9sndnEetz6D9YPeOuQYs0Qt12RhxSvv/OOS9/9rnG1yi0oazU7uwL6eQTv/fvB/2JX0R2PFVjNi6vYsqwffDXXts5qXrlFtHKx65IW8ypZxDbcN6yTpj1amvZoadqjpWmPlqY9Wpr2aGnao6Vpj5amPVqa9mhp2qOlaY+Wpj3aNO1vubgH/4038OYe/DdslL9hP/0NXriBPEIWYRohhzCdUEkoICQQigm5AJ+7zmWebCv5lfVg23qXeUzffcZl4bddzi+R+4NFf315trNsVvFOrbDVbGcdKf9Dy3B/487+O/uu3llT90/tJf6OvajWI4zftPWUUFJjyy+hZGzA7P6GO2nJjsfqeBwcwJON7/FEY1AMniMGzxGD54jBc8TgOWLwHDF4jhg8RwyeIwbPEYPniMFzxOA5xuB/w/Hbvcn+lluEEoWShNoJtRfqINRRqJNQZ6FkoS5CXYVShLoJdRdKFeoh1FOol1BvoTShPkJ9hfoJ9RcaIDRQKF1okNBgoSFCQ4WGCWUIZQrdJHSzUJbQcKHJQiOEsoVGCuUIjRIaLTRGKEForNA4oVyh8UIThCaSfO4NNELJV6B8AxmEJMIMwkxCO0J7wixCPiGPkEmYTcgiFBLmEOYSigjzCNmEFEIOIZWQRigmzCfkEtIJCwA+90Y7/y1l9mLdbSmzVuV2v+FiBf54/HvvRj2dZhYyJBVtv9QwQ5OEkoTaCbUX6iDUUaiTUGehZKEuQl2FUoS6CXUXShXqIdRTqJdQb6E0oT5CfYX6CfUXGiA0UChdaJDQYKEhQkOFhgllCGUK3SR0s1CW0GSh4UIjhLKFRgrlCI0SGi00RihBaKzQOKFcofFCE4QmknzxwnZl7zpZJz0Zl/KO+xvPp/75KXazi8NlN1F8Nxkuu8lw2U2Gy26i/25SlbqJjrvJcNlNhstuMlx2k+Gym2i1m1HgFumpb7CnvsE2+gab5Rtslm+g7hroSOhE6ExIJnQhdCWkELoRuhNSCT0IPQm9CL0JaYQ+hL6EfoT+hAGEgYR0wiDCYMIQwlDCMEIGIZNwE+FmQhZhOGEEIZswkpBDGEUYTRhDSCCMJYwj5BLGEyYQJhImE/IJeYQCwhTCVMI0wnSAz71VzN1bzN1bzN1bzN1bzN1bzN1bzN1bzN1bzN1bzN1bzN1bzN1bzN3bmPu7bdterCPoz7oC189Js9UeH3UFrsp+43OHXTzoe4J14QmWgifoiSco9idokCdYF56gDZ6g4Z+gJ2yoJBQQEgjFhFyAz/09aTrfYtP5Fivct9iBbJhBmEloR2hPmEXIJ+QRMgmzCVmEQsIcwlxCEWEeIZuQQsghpBLSCMWE+YRcQjphAcDnjkhR6yBFrYMUtQ5S1DpIUesgRa2DFLUOUtQ6SFHrIEWtgxS1DlLUOkhR62CK2vffVtTcn01sxap2FbyXyxP/hltdl1vNrsIi9ubQ/AOWAHezHAE0y6a/WTb9zSLIZjkCaJYjgGY5AmiWI4BmOQJoFuk2yxFAsxwBNMsRQLMcATTLEUCzHAE0yxFAsxwBNMsRQLMcATTLEUCzHAE0yxFAsxwBNMsRQLMcATTLEUCzHAE0yxFAsxwBNMsRQLMcATTLEUCzHAE0S3lpliOAZjkCaJaC0ixHAM1yBNAsRwDNcgTQLEcAzVKImuUIoFmOAJrlCKBZjgCa5QigWY4AmqVINcsRQLMcATTLEUCzKWc/lFrcWZLVWWpxZ5F+Z6nFnSV1nUXQnSUFnaUWd5Za3FlqcWepxZ3lMjubF98gjdzDRu5hI/ewkXvYyD1s5B42cg8buYeN3MNG7mEj97CRe9jIPWzkHjZyDxu5h43cw0buYSP3sJF72Mg9bOQeNnIPG7mHjdzDRu5hI/ewkXvYyD12/v/W1aoPXPrj8dHA2x+8XByPMwJXycctXf6nLH3wBy9bsv8JqvYdnsL8kb0ub/0wMOtDwhoh3bvs7/07l3MTdLh9E3Sbi58o/msa59dU969hfwN5hCxCMiGHMI0wnVBJKCBMIRQTcgE+9wNyJUd4JUd4JUd4JUd4JUd4JUd4JUd4JUd4JUd4JUd4JUd4JUd4JUd4JUd4JUfsK9nuMs9Fmq/9iOXnR/Y3/FiK+Cgp4qOkiI+SIj5KivgoKeKjpIiPkiI+Sor4KCnio6SIj5IiPkqK+ChTxHewiMf3ZqjiDiUJtRPKF2ov1EGoo1Anoc5CyUJdhLoKpQh1E+oulCrUQ6inUC+h3kJpQn2E+gr1E+ovNEBooFC60CChwUJDhIYKDRPKEMoUuknoZqEsoclCw4VGCGULjRTKERolNFpojFCC0FihcUK5QuOFJghNJPncP3Fd1kNF1nPTvwhcwsbSaly5gUvfYHrjP+AIny2aFP/CP7sC18DtmY/F4+cC5kGuEYEPsPO0NpA/Dry5A730txn/vYvHaP8CtxiYSUgiZBLyCFMJWYRphBzCdEIloYBQTBhIyAX43D9lFS/5Ioq4gQxCEmEGYSahHaE9YRYhn5BHyCTMJmQRCglzCHMJRYR5hGxCCiGHkEpIIxQT5hNyCemEBQCfe6frWvuk0w/zLU/WW7bu+0Aj+HtM3btkChsrzW6sTGFjZXQZK1PYWGl9Y2UgGSstbKxMYWNlChsrU9hYmcLGSpsaa5rPzy6v+Vz6g+TWg+DfC9x4FKA1TzV3X94iWjfUxvKTK6xt4Q9dWFbrc+Q+lvhey3qN3nq7Gpe1pVr0l2rRX6pFf6kB/aUG9Jca0F9qQH/j+j2utrmZYd1B+Mh72v+G7VvP9tFrrve/72M3q1F/xvrGtjx/sz72vL8l+9aYAn4u8/1TnO+f4kz6FEfXpzjFP8Uf+hSn1ac40j/F+fIpjvRPcaR/iiP9U9jKGigm5AJ87kYZ6Q9ypD/Ikf4gR/qDHOkPcqQ/yJH+IEf6gxzpDzIvB5mKg0zfQY70B5mkgxzpD3KkP8iR/iBH+oMc6Q9ypD/Ikf4gU36QI/1BjvQHmdiDHOkPMssHOdIf5Eh/0M7/Xpknc2WezJV5Mlc6RK50iFyZJ3NlnsyVeTJXekmu9JJc6SW50ktyZZ7MNZ3lQbHB67TB61zH17ncr9MGr3PtX+cKv04bvM41eZ02eJ02eJ02eJ02eJ2r9ToX6HX7Sh6yr8QX//7pTo3bhpf8fft79snVvsarfY1X+xqv9jVe7Wu82td4ta/xal/j1b7Gq32NV/sar/Y1Xu1rvNrXeLWv2VeyX0y/i6bfRdPvoul30fS7aPpdNP0umn4XTb+LednFVOxi+nbR9LuYpF00/S6afhdNv4um30XT76Lpd9H0u5jyXTT9Lpp+FxO7i6bfxSzvoul30fS77Pw/7GrVfdi7zl/WrP+YK2Bm/OAHmcisvcAuHgPeGOHfdYSfIAV6ghToCVJ2J0jZnSBld4KU3Qmm0P6DlJ4zLD1n6J0ztNgZlp4z9NsZuuoMS88Z+uAMS88Zlp4zLD1nWHrO0CFnaIoz9pU0uXjD7nEWmMd5JY/zxT/OF/84X/zj6HQGcgjTCNMJlYQCwhRCMSEX4HMfcF1rA/k19flD1qZgn/WN7zGGHxRbHKUtjlJMR2mLo1TWUf7Qo1TWUernKJV1lGI6SjEdpZiO0hZHKaajFNNR+0p+0bYdwfrkzx2uAFrDp+J/+AE7glXpPS29omNi4M0e8dae8Nae8cFbg3UUcd4VaKXeYCmm2HrhV2GT8LljLt7f/zIV+WVbAs38BvePpZn82LSBQ5enEuvTbp91vQ+5XFSJ9TG3dycGbnx67RX+9Np/dHFXmCK7whTZFaaITlJk6EiRXWGK7ApTZFeYIuNJiownKTKepMh4kiK7whSj0l9+MJW2JOHD+9iav8DjRusGTUbgHY4b/+kKbVGswjI/0Vne8TfeNtoa9ePNVXzkmptRrSZ+pyWDq+uhTev0+HbrZV3GofH/i4P9sQXzEq2HMP9ZDmH+xEOYP3Fb9CeervyJpys2dCB0JHQidCYkE7oQuhJSCN0I3QmphB6EnoRehN6ENEIfQl9CP0J/wgDCQEI6YRBhMGEIYShhGCGDkEm4iXAzIYswnDCCkE0YScghjCKMJowhJBDGEsYRcgnjCRMIEwmTCfmEPEIBYQphKmEaYTrA5/6Xtq1dlqN3utqmiH0YtcsqnKda2l2rf+TvYRlIh8hAOkQG0iEykA6RgXSIDKRDZCAdIgPpEBlIh8hAOkQG0iEykA6RgXSIGUj/VY4JjtHWx+jkY5T0MWr1GDNyjLY+RhUfo1+PUdLHeExwjAY5Rr8e4zHBMVr0mH0l/ybL8LAk4mFZlIdlUR6WRXlYFuVhSeDDskQPy6I8LAv2sKT6YVmwh2XBHjbL8CtpeD9jw/sZq+vP2P1smEGYSWhHaE+YRcgn5BEyCbMJWYRCwhzCXEIRYR4hm5BCyCGkEtIIxYT5hFxCOmEBwOd+VPK/m/nfzfzvZv53M/+7mf/dzP9u5n8387+b+d/N/O9m/ncz/7uZ/93M/27mfzfzv5v5383872b+dzP/u5n/3cz/buZ/N/O/m/nfzfzvZv53M/+77fw/5rqsLZW1U/ryO53etPxqyxv74rbbUVmno5UuVNTxUlHHS0UdL7VwvNTC8VKzx0vtHW/q5JHL08lb3yJgPbh/kyvQhu8V+Fj8B4RaJo5rQjgf4lsDfi3DyGkOI6dZEE+zbp7mMHKaRfQ0S+VpDiOnWdxOcxg5zWHkNIeR0xxGTrPsnWalO23r9N8vT6c37llckmTfTarW3D/e9V6a/eDH0I/LuDlYBszBMmAOlnI4WMrhYBkpB8sQOVgGzMFSOAdL4RwshXOwFM7BMooONmX0P+wXb6UnxVLGVXwIZm1FU63XeFVsJNtk//hE69YK68GWj7/nI+pWaXjuyg4/bfygi1XjDl8d01CL64eL64eL64eLl4eLl4eLl4eLl4cb9/7GFoxVbNsnmpy661zWXzwpNSlDalKG1KQMeXUZ8uoypCZlSE3KkJqUIdeRIdeRIdeRIdeRITUpw1zVU/aL/2r8Yv7XyndN/A/dE1FbrDX+bxeKjlW++iSaquLum4hyVUmzDSMUEDIJU9/NoBcniF+y5/+SE8QvOQD8koPGLzlbGLv/Vu1u3Uae1Kafn3Td3J+27jpnXd5DDFfg/vTTLuf3JvzeZd3KeMZl7myU7LXoqJwz1PCcoYbnDDU8Z6jhOUMNzxlqeM5Qw3OGGp4z1HBerqHAa+iDGp4z1FD6NTxnqOE5Qw3PGWp4zlDDc4YanjPU8Jyhhkaq4TlDDc8Zami+Gp4z1NB8NTxnqOE5Q41tvmffbr6hN8x3/ZjvmPgrRn/F6K8Y/RWjv2L0V4z+itFfMforRn/F6K8Y/RWjv2L0V4z+itFfMforRn/F6K8Y/RWjv2L0V4z+itFfMforRn/F6K8Y/RWjv2K2v56TCSRTJpBMmUAyZQLJlAkkUyaQTJlAMmUCyZQJJFMmkEyZQDJlAsmUCSTTTCDPy4tPkxefJi8+TV58mrz4NHnxafLi0+TFp8mLT5MXnyYvPk1efJq8+DTz4v+Tynd/2wXpO5Qk1E6ovVAHoY5CnYQ6CyULdRHqKpQi1E2ou1CqUA+hnkK9hHoLpQn1Eeor1E+ov9AAoYFC6UKDhAYLDREaKjRMKEMoU+gmoZuFsoSGC40QyhYaKZQjNEpotNAYobFC44RyhcYLTRCaKDRJaLJQglCeUL5QgdAUoalC04SmC91C8rlfkJazji1nHVvOOracdWw569hy1rHlrGPLWceWs44tZx1bzjq2nHVsOevYctax5axjy1nHlrOOLWcdW846tpx1bDnr2HLWseWsY8tZx5azji1nHVvOOracdWw56+z8/5fryjyN9yHeKbKGyPLEwLV/y8g6edqKI/+L9+daXJsurk0XZ6aLM9PFmeni73Txd7rx6XFpkDFpkDFpkDFpkDF5STFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFplzFpLjFpnjFpnjFpnjFpnjFpnjFpnjFpnjFpnjFpZjFppTFppTFppTFppTFppTFppTFjhBO2EZbHrViR6HhyowsSn26+7aTLObj4J+vg4kXpclvZ5bayy21ll9vKLreVXW4ru9xWdrmt7HJb2eW2ssttZZfbyi63lV1uK7vcVna5rexyW9nltrLLbWWX28out5Vdbiu73FZ2ua3sclvZ5bayy21ll9vKLrfVXo2X2rbL3biheHmdMD/+hROByzm5eFkM1kiDNdJgjTRYIw3WSIM10mCNNFgjDdZIgzXSYI00WCMN1kiDNdJgjTRYIw3WSIM10mCNNFgjDdZIgzXSYI00WCMN1kiDNdJgjTRYIw3WaBvsFcn/TuZ/J/O/k/nfyfzvZP53Mv87mf+dzP9O5n8n87+T+d/J/O9k/ncy/zuZ/53M/07mfyfzv5P538n872T+dzL/O5n/ncz/TuZ/J/O/k/nfyfzvtPP/O5fzMcw19rH5f9vL0XIj51dcjl+h8xsoIGQS8glTCXmELEICoZgwjZBLyCFMB/jcp1x8qOUFvvgX+Hpf4Ot9ga/3Bb7eF/h6X+CreoEv5AW+EBsqCQWEBEIxIRfgc/+P9qA2/215V/ezeQvjcXzgKt9wve1dT6elzG2nr7azzG1nmdvOMredZW47y9x2lrntLHPbqe3tlPN2WmA7y9x2Cn07y9x2lrntLHPbWea2s8xtZ5nbzjK3nbbZzjK3nWVuO82xnWVuO52ynWVuO8vcdttDv7fKnCWh31tV7oxD7jy76L1qoXVbe4SNr8labeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabeFabbHX6nXXdX+y1OaPksZF/OEUuj/caFats4hWn/vkh7OG/+uMTuYBIKswljmPBpVkBt7hiaBr60GgN+yr62plx5zD2H8ZX0kUYEM+9x9liHyOl/Mcr+A5Fu/neDnP8XKe4+U8x9f5HC/nObzoje0fSLD/Z75ayW8pICQQigm5AJ/7T3JJL/KSXuQlvchLepGX9CIv6UVe0ou8pBd5SS9yHV7klbzIK3mRV/Iir+RFXsmL9pWcdWGv4n5QTiYflIPpB+Vk8kE53n5Qbl89KCeThoqFcoRyhaYJTRdKEpoilEzyuc+5WuVtptYzvFP5KN+lPiZsOz8xcM2837RNHhM+37bTyNtPAEvjf3jJOdxyd79xFNhWbc86aT2Om2I+9wUpjSdZGk+yNJ5kaTzJ0niS+jnJ0niSpfEkS+NJlsaTLI0nWRpPsjSeZGk8ydJ40hbt/7VOBbnUwmEptiQRFeR6/0S496gbCYkU0/MU0/MU0/MU0/MU0/P8oc9TTM9TTM9TTM9TTM9TTM9TTM9TTM9TTM9TTM/bV+JK5KeA/VTmpJ+ajpWY+LbPcz93Y+/WmnXPKvl/dLVqAXzb3J+UyAfxxsnQNE7GpHEignEyUI2TEWqcDDjjZIQaJ0PTOBmaxskAN06GpnEyeo0zEmyXyOcM6uU5g3qZwOrlOYN6ebKgXp4sqJcnC+rlyYJ6ebKgXi6zXp4sqJcnC+rlyYJ6ebKgXp4sqJcnC+rlyYJ6ebKgXp4sqJcnC+rlyYJ6ebKgXp4sqJcnC+rlyYJ6ebKgXp4sqJcnC+rlyYJ6ebKgXp4sqJcnC+plfq+XJwvqRYr18mRBvTxZUC/iq5dnCerlWYJ6eZagXp4lqBeZ1suzBPXyLEG9PEtQL08P1MvTA/Ui2np5eqBenh6ol6cHDE0SmiyUIJQnlC9UIDRFaKrQNKHpQreQfO72tvGsX/I5JbDhbb/88+54bPfmCym5z/5vOiSaN2uUDLUOXDuKdSNi3YhYNyLWjcglRsTIETFyRIwcESNHxMgRMXJEjBwRI0fEyBExckSMHBEjR8TIETFyRIwcESNHxMgRMXJEjBwRI0fEyBExckSMHBEjR8TIETFyRIwcESNHxMgRMXJEjBwRI0fEyBExckRkHxFbR8TWEbF1RGwdEVtHxNYRsXVEbB0Rm0XE5BExeURMHhGTR8TkETF5xFipE41QsgE+MJBBSCLMIMwktCO0J8wi5BPyCJmE2YQsQiFhDmEuoYgwj5BNSCHkEFIJaYRiwnxCLiGdsADgc3eWQlQghahAhFwgZcnQDKGZQu2E2gvNEsoXyhPKFJotlCVUKDRHaK5QkdA8oWyhFKEcoVShNKFioflCuULpQgtIPneymGM5zbGc5lhOcyynOZbTHMtpjuU0x3KaYznNsZzmWE5zLKc5ltMcy2mO5TTHcppjOc2xnOZYTnMspzmW0xzLaY7lNMdymmM5zbGc5lhOcyynOZbb+e+S2GqnkqXv51TSOkz4ufUvXeOfgtcmpwtd37bhvl5usy2M/8Ur1+WB49v22ylyRPR7jE0GMgn5hKmEPEIWYRohhzCdUEkoICQQigm5AJ+7m30lBfFMpLrsfzfB/YD1hxXxP4xMtF9jgnuby/6HE9yfctmXkOBucuFff5TX/yiv/1Fe2KN8KY/ywh7l63qUXcCGKYRkgM/dPZF3khql7zfKONso+6hG6cqN0r8bZVfVKN28UTp2o4yXjdIzG2U31ig9s1H6cKPs1BpNz0xtnZp94xeCmAJttaRfuwKXVKl7XDNLYHXmgYmBD7dbWik+2NIgWr1t9rzW26bVHT9/LZxXt2Hb7HWFF9H6ZKf/ea/VtBZlTuI7LOfl3369yn5TWctatKzuxVVtWeZLXV2fu3ei8xH0MZd1FpgmW/CwtOKwHIWGZQselm12WLbZYTkLDMtZYFjOAsNyFhiWs8CwnAWG5SwwLBvksJwFhuUsMCzb5bCcBYblLDAsZ4FhOQsMyzY7LGeBYTkLDMtZYFjOAsNyFhiWs8CwbMjDchYYlrPAsJwFhuUsMCzDU1iOUMIyPIXlLDAsZ4FhGZfCchYYlrPAsJwFhuUQIyxngWEZnsJyFhiWs8CwnAWGZVgLy1lgWM4CwzKsheUsMCxngWE5Cwyb0a2PHHf8K3xgIImQT2hPaEeYRcgjzCUUEeYRUgiphDTCfEI6YQEhgzCDMJOQSZhNyCIUEuYQsgk5hGJCLsDn7qtbGmsnc1b2Nl+L/+E71h9qrcL7Pjc5j3GT8xiv7jFe0GN8cY/xZT/GV/qY/Ur7XTMT5luHfGvY+5P1F1fltH8Jc2X/a3YJrkDmrVXu5GrrJRiQ2KbP6V3/T55YH0A9P/ChTPQDE1s+F/fzV/nn4l5b5xWXYJ90efZnmMxmw+Twapgccw2TY65hMqkNk/l5mExcw+Rga5gcXg2TQzZDU4RyST73IDlI/R177O/YY3/HWel3eOEG8ghZhGmEHMJ0QiWhgJBAKCbkAnzuwVeoisX3tCULr2g1u8p2sm3x+xiMJmeKP2YahQ6RaX4zp/nNHIU3c7TfzLl4M+fizRztN3Po38w5fzP1vpkS30xbbOZgvZni38zBejMH683cNWzmrmEzdw2bOX9v5hZiM620mfuJzdxPbKZhNnNzsZnu2cydxmbuNDbb+R96eb6yjoAKEi/FYNbzmvdc2XnhunWY9b6HEYmBt3/Y90Cx2kBpRQOlwQyUBjNQGsxAaTADjWGHSUt5iS3lJXrnJVrsJbaUl+i3l+iql9hSXqIPXmJLeYkt5SW2lJfYUl6iQ16iKV6yryRDSs9qlp7VLD2rWXpWs/SsZulZzdKzmqVnNUvPauZlNVOxmulbzdKzmklazdKzmqVnNUvPapae1Sw9q1l6VrP0rGbKV7P0rGbpWc3ErmbpWc0sr2bpWc3Ss9rOf2brtHSrBP2T6/2Wnn+9SkqP9U6ALtfDR+hdfJPQTWKnAO0UoJ0CtFOAdgrQTgHaKUA7BWinAO0UoJ0CtFOAdgrQTgHaKUA7BWinAO0UoJ0CtFOAdgrQTgHaKUA7BWinAO0UoJ0CtFOAdgrYdrr5Wr+Fd7Xs96/YPR77rexfCmC/nyU3eX5u999bhBKFkoTaCbUX6iDUUaiTUGehZKEuQl2FUoS6CXUXShXqIdRTqJdQb6E0oT5CfYX6CfUXGiA0UChdaJDQYKEhQkOFhgllCGUK3SR0s1CW0HChyUIjhLKFRgrlCI0SGi00RihBaKzQOKFcofFCE4Qmknzu4dJMLrCZXGD/uMDyf4Fd4gL7xwW2jAvsEhdY5C+wyF9gkb/Aun6BpfwCS/kFVu8LLNgXWLAvsB9eYAu8wBZ4gR3sAjvYBXawC+xgF9jBLrA1XWA3usCec4Ft5oKd/xFy6tVLxNpLTr16yVajl2w1eol0e0lB6SUS7CWbkl6yKeklm5JesinpJTLrZcST3XLnfLt953ykPMT2kJjyIfnZD8l1PiTX8pBc9UNyZYaKhXKEcoWmCU0XShKaIpRM8rlzZCv2P7guA5mEfMJUQh4hizCNkEOYTqgkFBASCMWEXIDPPUrsvp52X0+vrKf319M462mc9fT+elaF9SwE65mX9UzFeqZvPZ23nklaT+etp/PWs6ysZ1lZz7KyngZdzxqznilfz4KzngVnPRO7ntVnPbO8nqVoPUvRejv/o//sW9WGBN76VrUxsmYhrlmIaxbimoW4ZiGuWYhrFuKahbhmIa5ZiGsW4pqFuGYhrlmIaxbimoW4ZiGuWYhrFuKahbhmIa5ZiGsW4pqFuGYhrlmIaxbimoW4ZiE7/2Nb90T8iv1mYuvQapD1A6704G9t/6uvrl3zxX7ST7poP+k8/aRn9JOe0U/6Vz/pGf1MlxgnPj1Hn56jT8/Rp+fo03P06Tn69Bx9eo4+PUefnqNPz9Gn5+jTc/TpOfr0HH16jj49R5+eo0/P0afn6NNz9Ok5+vQcfXqOPj1Hn56jT8/Rp+fo03N2/nPZpd17ZPwwNFMoSShTKE9oqlCW0DShHKHpQpVCBULFQgOFckk+9/hr7kmPD+MpbutR8pUtNU/uVVs3+b9lfaE1blpP+AtYDCuV/+dyMnehdZanTZ4gmChj+n/B/wYyCfmEqYQ8QhZhGiGHMJ1QSSggJBCKCbkAn3vSFboJb40IPuduvHvpVXJi/0FmD2vk+JL1havwxP5iM+krs0dfaS19pZn0lfbRVxpGX5k9+pqmMLl1BWPdNHnK9V7KcVtOT7yigrlKTqfb8Cm0vLa9s2C9S2SS651W88Yitt4i5n8IViz53xuL2KqLWHB5i2j11Vsv6Wmda37xrA686qpaxYt9d4D03QHSdwdI3x0gfXeA9N0B0ncHmL47JdH54P7OidYJ+NRrbjvw53YB1rUtt/6Da+Ux4mn2Erz1ZPWu+E9udr2pgpJ77G+ebn+zlb7V5mW4f+LY3b3F+sPH4384Yf3ho/E/vGH9YUn8e//K/GD3rETI6hYjiFuuOQVYK/y1NtqdfygKmCHncAd4DneA53AHeA53gOdwB3gOd4DncAd4DneA53AHuKk8wFd1gHvPAzyHO8Ad5gGewx3gOdwBnsMd4DncAZ7DHeA53AGewx3gfvUAz+EO8BzuAHelB3gOd4Bb1AM8hzvAc7gDdv5nXrknyN23t2bvtLr2XusHfOhPulrNdN3V0UxbmugkaaKTpIlOkiY6SZroJGmik6SJTjI1c5YY9g807B/o0T/QiX+gE23oQOhI6EToTEgmdCF0JaQQuhG6E1IJPQg9Cb0IvQlphD6EvoR+hP6EAYSBhHTCIMJgwhDCUMIwQgYhk3AT4WZCFmE4YQQhmzCSkEMYRRhNGENIIIwljCPkEsYTJhAmEiYT8gl5hALCFMJUwjTCdIDPPVsLarw6lXyjLQur9RsB0luzsLbKXmRp/Ht7XFoZjRf0khdMOS358vuoptYc8wqqaUt1bf2qav3a0B9Ya1sotc/P2uen0fwshH4OK34OK36WSD9LpJ/Dip+S9VOyfhraz2HFTw/7Oaz4Oaz4Oaz4Oaz4Oaz4aXU/a6yfVvezrPpZIv0cVvwcVvw0tJ+1z89hxW97a47kfw3zv4b5X8P8r2H+1zD/a5j/Ncz/GuZ/DfO/hvlfw/yvYf7XMP9rmP81zP8a5n8N87+G+V/D/K9h/tcw/2uY/zXM/xrmfw3zv4b5X8P8r2H+19j5nyv538j8b2T+NzL/G5n/jcz/RuZ/I/O/kfnfyPxvZP43Mv8bmf+NzP9G5n8j87+R+d/I/G9k/jcy/xuZ/43M/0bmfyPzv5H538j8b2T+NzL/G5n/jXb+i+Se2Sts9K8wFa8wY6+we73C9L3CJL3CvvYKL+sVNjkbKgkFhARCMSEX4HPPa/lE72rrJKZYHvD+rjzSbWiSUJJQO6H2Qh2EOgp1EuoslCzURairUIpQN6HuQqlCPYR6CvUS6i2UJtRHqK9QP6H+QgOEBgqlCw0SGiw0RGio0DChDKFMoZuEbhbKEposNFxohFC20EihHKFRQqOFxgglCI0VGieUKzReaILQRJLPPV8M/iwN/iwN/iwN/iwN/iwN/iwN/iwN/iwN/iwN/iwN/iwN/iwN/iwN/iwN/qx9JQukVaxgq1jBVrGCrWIFW8UKtooVbBUr2CpWsFWsYF5WMBUrmL4VbBUrmKQVbBUr2CpWsFWsYKtYwVaxgq1iBVvFCqZ8BVvFCraKFUzsCraKFczyCraKFWwVK+z8l4iSTlBJJ5iKE8zYCSrpBNN3gkk6QSWd4GWdoJJOUEknqKQTVNIJXvAJXuMJ+0o+4vw+oQT3QzwT/oH9l26RWZQyi1JmUcosSplFKbMoZRalzKKUWZRJizJPUeY2SplFmcEoZRalzKKUWZQyi1JmUcosSplFuR5RyixKmUWZ9ShlFuUSRCmzKGUWtfP/0RsfoxNos1/g9HXrP2zD+6YLLzrrR3TW3fbKfkze69JD+nYPeeyyhxw29pDDxh7SxXvIbNVDunEPOZbsIceSPeRYsoccS/aQjtvD9NGPX3eytPTwuOvq0ee7ytKS05Otekc4S/SVJfrKEtVkiWqyRDVZoposo5NPXKU6sc7CTl1LZcyS5xjXB9FLq8lkhMhkhMhkhMhkhMhkhMhkhMhkhJHJJ63dajxL7m+7rO1q6TV32/hDuFts3am+v0WirX7b+FPX7BJYeZnnurJr0SZL8Okr/7naJR8PXLMPPV9NT9BZn7BwRwCfUlImu8WnuVt8mjuap7nxeZq7xacpkKe513mau8WnuTt5mrvFp7lbfJq7xae5W3ya+5anuVV52lblZ+QoMU+OEvPkKCpPjhINzRCaKdROqL3QLKF8oTyhTKHZQllChUJzhOYKFQnNE8oWShHKEUoVShMqFpovlCuULrSA5HN/9l0+JPnr8T/clhh4y6cl32394eKnJa+M/+HfXIF3+thkq6QOTwzg85Nbdvpv/8jkKQT5/ORkAj8yWT5M2ef+3BWaGa2RKvnGQ/uXVejetuX9vBS6Z1jonqFWnmGhe4aF7hkWumeoomdY6J6hcJ5hoXuGhe4ZFrpnWOieYaF7hpp8xpbhF670k+tW/301YJ5g//srKsvrtg9f7L+3ymFLT+kUPaWL9JQO01N2OT2li/SUw5aeUvF7yn6op+yHesp+qKfsh3pKxe9pqvpt7+ej77WYWxX7rj/zGfjxgl/yd4G2reXlkveukveukveukveukveukveukveukveukveukveukveukveukveuJu9flLPv2zDpGMggJBFmEGYS2hHaE2YR8gl5hEzCbEIWoZAwhzCXUESYR8gmpBByCKmENEIxYT4hl5BOWADwuRfJqFkko2aRjJpFMmoWyahZJKNmkYyaRTJqFsmoWSSCLBKxFomQi2TULBKxFsmoWSSjZpGMmkUyahbJqFkko2aRjJpFYoAiGTWLZNQsklGzSEbNIjFAkYyaRTJqFhlz3H7NHRBYNXGiVROvl0f775BZ61XOWq+yVLzKivIqZ61X+UNfZRF5lbPWq7T9q5y1XuWs9SpnrVc5a73KgvAqa8Cr9pXcKVdynFdynFdynFdynFdynFdynFdynFdynFdynFdynFdynFdynFdynFdynFdy3L6SxfaVxIdDdxdrdb8R/w+Pm/Uv+Xk8Lov/RZELy/oIX/cjbDGPMAuPMAuP8MIf4bU+wmt9hNf6CK/1EV7rI7zWR3h5j/DyHrEv70s6FN8Sv6w1gTbeo93yQQ74320Ythw8MIChuGUWvjgcv3WvZj3/29P6i8uaij8Z/0KWVXw++Hhs3bN4PdCmY3JFyw3Lkt5vGs091VT8SjHpy5Tny5TnyzTpy9TqyxT7yxTuyxTuyxTuyxTuyxTuyxTuyzTpy1Txy1Txy/aVeGSw20HX7eBgt4OD3Q4Odjs42O3gYLeDg90ODnY7mJcdTMUOpm8HB7sdTNIODnY7ONjt4GC3g4PdDg52OzjY7eBgt4Mp38HBbgcHux1M7A4OdjuY5R0c7HZwsNth5/8uyf955v88U36eGTvPxJ5nys8zy+eZ2PPMy3nm5Tzzcp6pOM+rP8+rP88LPs9rPM9rPE8JnadqzlM157no57no57no57no57no57ma57mA57lM57ky5+383906RxtWcf5H1/sp49ab0/6rNcu4dRP8eVfgxuHGm2J3D5INyyDZQQ+SffEg2RcPkn3xINkXDzKl/54P4SzMnX9lz2avMp1YHynTKbEtBONz39tGy2m95rmJ77WuN47aW+2o3VfX1bts0dJl5fH/X7bYu2H5hrt+60pIcP+ty1uXvPi+O9/y9ZJHvb7K2+u6f2zRUq/nvoqipUvuWxb/rg2+yi/dumGE3Rw+7rXDJ0z4pAmlJnzKhE+bUGbCZ0z4rAmfM+HzJnzBhFtNuM2EchO+aMIiE2434Q4T7jRhsQlfMqHChEoTPCbcZcLdJtxjwr0m3GfCEhPuN+HLJiw1wWvCMhN8JvyVCV8xocqEahP8JnzVhBoTlpuwwoSvmVBrwtdNWGnCN0xYZcJqEwImfNOENSasNWGdCd8yoc6E9SZ824S/NqHehO+YEDThb0zYYMJGE0ImbDJhswlbTNhqwndNCJvwPRMiJnzfhB+Y8EMTGkz4WxN+ZMLfmbDNhAdM2G7Cj73OLGiHn5jw9yb81ISdJuwy4Wcm7DZhjwlRE35uQqMJe0140ISHTNhnwn4THjbhH0xoMuGACQdN+IUJMROaTThkwj+a8EsT/smER0z4fyb8swn/YsJhE/7VhH8z4VcmPGrCYyYcMeHXJvy7CY+b8B8mPGHCb0x40oSnTPitCU+b8IwJR0141oRjJjxnwvMm/KcJL5jwXyYcN+GECSdNeNGEl0x42YRXTPidCf9twikT/seE0yb83oQzJrxqwmsmvG7CH0z4XxPeMOGPJvzJhLMmnDPhvAkXTPg/O7gTXCa6nJjoxCQntnNieyd2cGJHJ3ZyYmcnJjuxixO7OjHFid2c2N2JqU7s4cSeTuzlxN5OTHNiHyf2dWI/J/Z34gAnDnRiuhMHOXGwE4c4cagThzkxw4mZTrzJiTc7McuJw504wonZThzpxBwnjnLiaCeOceJYJ45zYq4TxztxghMnOnGSEyc7Mc+J+U4scOIUJ0514jQnTnfiLU6c4cSZTpzlxNlOLHTiHCfOdWKRE+c5sdiJ8524wIklTvyIE91O/KgTFzrxY078uBM/4cRPOrHUiZ9y4qedWObEzzjxs078nBM/78QvOPFWJ97mxHInftGJi5x4uxPvcOKdTlzsxC85scKJlU70OPEuJ97txHuceK8T73PiEife78QvO3GpE71OXOZEnxP/yolfcWKVE6ud6HfiV51Y48TlTlzhxK85sdaJX3fiSid+w4mrnLjaiQEnftOJa5y41onrnPgtJ9Y5cb0Tv+3Ev3ZivRO/48SgE//GiRucuNGJISducuJmJ25x4lYnfteJYSd+z4kRJ37fiT9w4g+d2ODEv3Xij5z4d07c5sQHnLjdiT924g4n/sSJf+/EnzpxpxN3OfFnTtztxD1OjDrx505sdOJeJz7oxIecuM+J+534sBP/wYlNTjzgxINO/IUTY05sdnkX13Vccv8yz5L7rIF4RF37Oxff7qvYsLaug3fZUs8dy+J/6n734sX3ly+6557yZUvuXhz/vrV1ycuWLl5cfsc9i7zeDR+ta3/HojsqF8e/3PH+Jd5l9yyu2vDRStddR+OzdV37OC1euqFyUV2XZUsX3ef90pKl98b5o/bkfasZwBfVdbp/qWfJUs+y6g11He6Lf8eiezbUdV507+2eCp/9xXaLfMuWbKhrv3RxRfyHr63rdf/SJfcvqohP8eXxf9FjXn38hdr/WPkd8Zd6+6I77rYuqK7nvYuqb49/2z2L7lhcueSeOxcvtb6z2+I7PcvKly1eeq/nvkX3xK+h8raShMrytXVdlyyNf8vi+B5h8TLvhjV1XT333r8kvpW4f9GySu+GWzfUdfEu8S29Y7H9hfild4r/ZF+Fx06etYto95FFS+/e4Bvz/wEDONBX'
+)
+DATA = pickle.loads(zlib.decompress(base64.b64decode(DATA)))
+MEMO = (
+b'eJzVXQlgG+WV9n0fhAAhBEJicig2thMCpUAcozhyoo5GdiQ5Ry1HyNY4liJLRkccE4VSegCtoLSI0hYotKWlLb24WtpCS49tt9dm6fbYblu27bZdStttd7tsb9gZzUhz/PNGv+eNFBGIHf2j97/vfe/97//nP2ZuaLyzvqa2RvhzMmdjhB/ZhlhwnstlW53s+JjHF2AO5LLNC8FUikvEcsL1xmPBaJr/QlN4fiGeSOWyjbPR4JFkbiqXrU8EF3PZlh7xSg//z0AgtbTABQK5bNu4WIc3lcilsy0LiXA8EU4t5Zi2uY5su49LzIdjwehubjaXZmp5PXN12WbfoXGHAGCuQShoyjYIleXmWqZyc23Zph7hU09urmOuMz3XJdQz151m6iTZUc8Yq5KdTcTnZVnhEyFbL8o22r1KybpgsiDX0BNMElINolSr42CBsIJkE3c8T5Ek3dIjfiZqaBRraNvtGLVPuFRVNIe42WA6WqyjtUcqICppEitp2m/3KCtYYRu+ciYeS6Yyx4KJTJRLbZGqcmebAovhUGqO95yNqWcaOd4RrZKXPI6courmIi+H3CPFmhuDyaXYTAFYc0/+IwGrRZRtH51wj/icY24ltpbZdGwmFY7HCpW09RRKiHpaxXpa7Lu8Po99xCdXEpxOphLBmZRcSaGEqKRNqmTEZfeqfNw4Ew0mk7It+Y+EeLsoXmeXtddeXRCq77laFqgRBTqk0PD67D7niCo0kqlgKjwjh4b4mVDZKdHncdh3j7ldh1T0JbhgKB6LLsmWF0qIerqkesb2Ozwe525Vs2qJH+MSiXCIk+splBD1dEtRZh8ZcXi9xSrO56NsIRFPcTMpLpThG/exYIrLLKSno+GZYsDNbRcirYlp5SNt7jJFpWcUfJuvdMxTrLadr/YIl8okFWEr1lLP1GtrWSHW0uF0+xyeUfuIysbWcIyP69ngTNHI9p5iEWHlmZKVbscBZSX1MW6xIN7Yw38gBFdK2cfhnlBnHy6WVmQf4RMhe5bUytyqyDyLp0DIyMkFHmhmPh5KR7nSjJ4t4WAOBLw+Vg7Xa8RskArH0lwmxE2njxzhEplZIfVGlzLJxXBqZi6T4FLpRCyzOBeOcpnUXCK+mJnmA+toZiYoXOa/NJfhokmO/8z/mI0nMqnEUiY8mwnFNcjqmJYiskYR2TkyMj5hyq6e55GF+TQVjM1w8dkM34VEuXkulkpmCjGd4Y6nuFgomRHyPv+VEMdnMy6TTC/wJgQXg+FUZinMRUOZo9ySUENsli9PzYWTmWPxcCjDu4svy/BXgkkCZpsW5ioJ5q4Jp8vndBdhjvEw0zE+B4djfKCnY0dj8cVYZjoej3LBWIZPO+HYkQzv3Wled3JpfjoezUyHj/CRlolPR/jWwcPgm5aIKBhbIqK6VQvkXBFIg88z4VB0hIm0siPkP8nhVCsKrpbCadTu8sqSjbNB3nNyost/JGTPk5S6J1wuWWksHY3KSoVPhOCagqCdlXWeOxnsv87e/+rAhinpX1v7r+A/9BYqO28Q+sZgTiSm9k2tNdKf2iJDUpI9v9BYJ9hdDjmgZnlPbZ08fnBqkq8r2D9r7x8NTPXFhjNbJ+NjQuHlhY/Tu/iP28RPNn9o0h8KTPX6B4bFf2T8A/l/9G2xTXKOqcm+/qlhqWA4NqxxoBHOCyScfP/ldO8p4ryIx9ljmzzc4/dPZfz+gS29PZnN/OfNxc+bteFqoGStlAR9DnbcZfc5+OYvU7L6Gr7ea/z+DfmKM/4NtuH1/hNbtvReU/DEmkHwKwVXGGm/UNTeWdS+l++25E4Cqtu/wX+igGAtiED4VgFEvQGIdVoKWKeM4QL/SQoQFw4afo0GxXotFT67U25L54H1F11xPoyByhc9Uqc67prwCn/l8Wxfnzye7esjBi0XSaNR1ume8OZ/yKL9/bJofz8hukHSyY93PMJfWbC3Vxbs7SUEN0ptw7FP+E/ucIeGhuQOl/9ACG4qdJpqufVKufU6cpulRKUSq5OlGnp0hGyiUL1bKbNeIbOelNkiybh8ckKs26GQ2UHK9Eoye5QyOxUyO0mZPolBl3evc9SnULVDoWoHIXaxJObRiO3cqdC2kxDrl7rHCY1c/U5ZsJEXJCUHJEmha3F698oah4dljcPDhNxgYeDp3s3/L4tt2iSLbdpEiG2V/DzmUQwr6zIZWSiTIYS2Fe53PJ4xxX3gkIKTIdKySyRVHodXQcjAwIBMCP+BENsu3SPwdyTOPe7A2HhRdpTvGXgKhzL+Xn/vUGbHjqFM/tMm/yb+J/8f/3PYP8z/7OP/9gvfG8oMDmU2Ct8ZEq8fHiLGOg3aTHGpBFyVJWqLSaK+h8wRl0kMqdNDbb8sQyaHV0hqVImhtlcWIdPC5ZIaL3+/JodK7aAsM0jIvFIKsHGHZ8ThVtypbZSlNhJSV0i3di6FwA5ZgGw4V0oCexQCO2UBMjyuKgRw3s+y0JAsRLbqHZLQrgOBg4oArj0sCx0mhIZkIfeYAt71stD1hNDOQhA4x+WkU5uRRchmMiylKTsrx2ztJlmCbI1Xy8gUjThyW21NjYGUXYoCXkrmIHKzUogEt0sCt1vJwIAMjmyII5KakTHXmMI/V8oyVxIyuwsx7WCdsshVsshVhIijqIZl7bLMxbLMxYTMqNSv7pvgc4tTiW5YFiNz5p7C3ejBEZfdycpS62Wp9YTU3kJPssvD30TLQidkoROEkLPQj2iETspCJwmhVxU0jds9DoVRNlnIRggxBU0aoS2y0BZCyCURmLeJcShCYlIWmyTEWEnMQ4hNyWJThJhb4l1wsTIFtfoH/YOTh9vkO5+OQbHIH5PvdYwGdWOFsZkroK28m6+p1zaQadvSO8x3GMUceeagdMEfk64UFDUYKBqX0tsBObu3TK5r7ehsmyp2DF2Dk+v8Kf+sP8HD76O5VdvH15RtiieEO+KcZEo0mDg6EOWOc4lcttEXP8rFcncI09CeCZeDL0mmgolUjrmWaWBqUzm++Xdk293xWGHCOJfOtnLHF4KxpDCNOCVV2hUI5OXyPwNbeaFIXV1NTTqYbYwnQrwmpibbGIyGg8mcO9scXxBmHJP52e3uoxy3EAhGo4GUACWZuyXbnK8/tC13y1yXO9ud4uYXosEUF0jG04kZjq+gky9JLQXCsVB4hkvmtggQPekoNybVm+YLGoSCXJrx8Eoif67Nz7fP1UVqeVQFcJF6/udULtLM/2JqIy38L3ektS7/1Ug7//uWSIfwk0cR6cxf7OJ/8toi3YI4//sM4TfjVav4O/8vW+RF/me2gYty8znmNUxTgUuVZpG7dnH2nqduPiUTJ6KqMY/Kp0a1mjRcUi/OkeuqR5AyQam+5RgfMHq668zr3k+pu1WY/NZVXm9e+QFK5W35KW9d7Q3mtR+k1R4W5mF1tTea136Ilvj8IpWe8ibzyl9Nq1yYDNZV3mxe+SSl8uaYvstbzKv207p8OhqfORrIpySN9lbz2qdotcdTc5x+S28zr/0wmHpVWZX9di1zjm4KlmYYlIuvbbPhaIqHGk+n+B6oI9sid33S4DM/2RqZzgPsiMwI1anGmHqXxLswXSFx9VNXCNRUXG7Vu1iY8dTHIYyc1Vc4dGcTUPvhMBkFJNHLM9iA2sLAWe9ahxQGYX4UkSw6Xz12rhS/iN70mrLzWw6DEV140CqDq7/ZIcYa0xax9HJpQYiB0YxVVJlDjhhUhSxCXtzdY1nifRk0LsR4kqta3l8uzRUxnp49veSXgw3EEP9IRdio/taMuE+ZqwSFL5eGibjjCleER3NmtZs3K3ISupFU+43d1MjYjO4k2xVf13j57EBAWZc4V7pN8yXdtI+/QTuqtm+4HnBbZJfiiliyW1GCv5OJmgcyypdYfZ8xXxIOiQY/RxgrqRU93o2DAa2KUPZoI9NnFM9mRy/L6zLwAb6gtjcIxdXyDcLH/LW02KzmE9EwEiUxw9rxDSQJR69yuYJdbGIuNZzXk88IvEyHPIgmkVKTeDMYdqZZqrJZsrRFBhsO46T4q4ZhHKJ5H6tiqsozV7ZokcXKQ0N6188KBBQpShzkXaKxvjxTXMcpLYx8gxhIieXfAsqfgQZeiFmtJasCUDp+taxMHTmlHVyWaQ7pOlqXPAtQ/xOg/GdA+S8gVyHmYk5UwFUGeWR5zkLMsmRonfUHgPwXgPI/AuV/gZyFmOc4WQFnybu60O5CzERcT+uulgZ9+tuA8g6gvJsox887vMYid0lHRfUuqU6CLm98t5wE2pjfXlDs6CRqOsxTcwOtfy8A/HUhUL4eKL8IKN8IlNsaiImRTvPmvrZazCVcq2dol3lDb6wWQ3XM6jZv1usqbRYUllT+O8O8oa+vFkN1zFph3qw3VNosKj+dad6gN1baIB34K83Dv8minvG0dn9nmbf/Zlr3xQF3XAuUJ4HyNFB+nHTr2ebNuqXSZpHNTMegc8wb9KZKG6QDf5V5+G8uF3wonKj8ca55g7KVNkgH/mrz8G8tF3wq3s8zD/y2cgHXgbnGPMy3WNSttIa4mXggGk6mNHN78gNzdG+di0/CwXY47eL5Ad1u53zz/NxO68YnAHd9pkEbZ08C3/wcUP40UP4lMhAuMG/oW0+/oWST1DFxrXkT33b6TdQx6ELzBt1R9sZbkea5zjwDOVqX/hJwyHOES58HvvkboPx3pEvXmzfozsoZRDY3HVN6zJvy9sqZogP8IvPA77KoWamfBIZuQeIRNd0WtMG8se+g9VJ3oz73K4DylUD5OY2Erzaah/9Oi3xlbl/P8ib3N5k38120XtoAsL4JKLcB5X1EuWTEZvNG3G2Rr4zWYopPvluWHw3X7cUDktPx0BLVor3Ek808T/dYFdPVwsUW81zcaxEX0lMNLWMi0lSnbfmGFPSap+DdtG1/EmjLU0B5ACgPAuUhKCf0mTfuPrVxyo3Gqu0ybLSNcRpuNFZ8ndxorKxL3IOyvTIbje9X25dshJx3rFE72DlOdpSIzWDvMQ/kOsjviA1X7y0Jh0SD30f5vpJa0buOHgADWhWh7MNtjMsonqtoL/H71SbdCfjKaO8rInA/ABIqPyuDvaGd8RqxWYFtUQiCH1Sb+EGwbT4EZOaPAuWfgFouwh8fpARbmf1NiBT0IVrWnwLY/TxQ/kWIdUTm+rAVrFu4UQmRIR+i5f0UwO8zQPl3IN4R+zI/AmYfxdNy2A93MFNG6adatyMhctZH1cT8FPTizwFv/RIofw4ofx4o/62lw6SPVdoschZOxyBElvt4pQ3SgY/Ie58oF3wonKj8gch+D1faIB34iHz4SLngU/GO2Hr+aLmA68BsNg/zMUqYp7ffQOwqf5zWD/1N+nwPAuXbgPJLmwj/IPaTf7Jc8Mn41wGO2B7+qXIB14GJ2AD+BBYmFAZU/CK2Z3+6XMB1YCK2VX8GC5OKR8R26M9iAerAQWxjfhIc/ysfWMl+v5M5Ynjwtpq3xyDuAp5S0zPfBHlroUkbNgnAfymg/BhQvkT6GzH+/1zlDCJbko4piJH/5ytnig5wxJj/aUrgp3vfCuIu4Au0vnkn4Zu7AR/cC5TfT/oGMf7/ovXAyXagAxkx8v+S9ZB1ACLG/F8G+xhFgLMnuph5g8dmnxkIFL8srnBdauHTs/9BDfEpkkN05v0KyEKDYFiOvbWLiRv1scJrEZe3vtspcZan6zILu8Wvqm35Ohhy34LaBFGO79r+sUSYLQgPumcf7GKuNWI5/0KLyq09fU0N+sdgX1B4iYMetELbWCg+kv8VxPYFPWk851+nhB95DgiE30CBgBgYfAMMBFVvx/6qizlmuKhmsFHkrEBAUZdI+uXL2TOCiJlvqu37E0j6XwHSXypD6/tWqRsJcVl4RTdz3NyNxHw8pFfeLbkhHlpS743A8/xPapPam6F1YZ1lJPy68CmQUJkK1tPNnDDoNFcEAoXviiH6Sgv7zH9WA1xL0oPm4BmQg3rerhw73c2cNDBf8V5gXe8gjP+2GlkfFBvQ/S8+Pv6FEoHq1ca6IBCp9ju0IJTvRdYFgbif+i4liMJLlXX1I252vgdGKZGc2LVnMK83uZIKT3hLGTb/Ynn1AJ+84bNwzx+i+XxfTZmLdJnUhY0163dh+4Byb7P2Hoe8/doPyB4iyvHd4r9WzlDILMKrsKGITPCD028oaBYit/wb1ixMQC7Dc4j09cPTaSJoEGIO50fWG2SBhxAzPD+unEEgfMT8z7OU8Mvf+ZXnQWL/Tuue+wHS3wuUP0C47UHIPYgl359g4ZMwyfYPAkcs+f7UeuAgTMSS789ow7/qBniI5eL/oPXNlwHffIUiqL4GyH4T8iJiYfnn1hsEwSc7FdAgxEL0LypnEAgfsXD9S1r4mEBahicQT9j6z0qYAgJHPEPrOfPALWAc8aysX1kPHISJeCbW85XtOQxGR4gHW/2aluuOFn1mu1q0PlhBfBP/oKrf0MIk4ZCNEASIePDUb80DBOEgHiT1X7Sx2SLOuo1V1cgG8cCp39H6oQ+I536KANoKyG6HPIl4BNXvrTcIgk9md9AgxKOp/rtyBoHwEY+s+p/KtyyDzI94ttQfaP3gBdidIPxwEOIb8WSo/6XlG1xOsjw9IR4C9QIt6RxA+hGgPAJRj3jA0/+pwZKLxvnoZR9ewdxmsMxncC4XsUTxRzW2xRaCSMmRui/zwK/v/YlWv3uC3eXQ5gD80t6fS+ovpCGjU5fZlYWNEoIrxUXoK7RL+x79CvCz93+htCGSBYL+dijoEfPtf4WDXnwEkrjl+rEzmbuMVgor9/QlRCP6m9rWe0AH3Ac44D1A+QOKmvCrdH8HXaLiha1bydxtdseQ8DpAuS7pbYBbK7Rl6EW1gQ+DfngM4PsJqCEgWH+pVEMQl8x7VzL3GpEO7gyS6LZ+ZxBbUwtCJ7Sy4yuZ+4zwWzRQQ5hTqzHnFBge3yZGZN+1PjDYOlo8y+LO6Ak45vtJtp6avJ8S5P0cIs98n8c2WEweusNjG0sjEi/8XnEhiF0GZpuoiahz6Y9dVhdTdqE1S2lb+xbXuj36FRhs2o08r92ND2zSNZEKzC81s83U0fw3oKd4kYjymlb9b9YB5QQzkUbgmy1EOXq1mm2pAgYge8mJIpAB8+vZbGsVMwDaa34BnG1D21u+CF+Gx82vpLPtVcwAaK/5JXm2o+L2WuBf86vxbGfV2AtaZ35pnu3CdvRkvjotPbrRANX8Qj/bTe38/YDTyHR+CPjmJHVzPwx8MwgFiPm9AuwZVcAAZC+ZAEAGzG8xYFdUMQOgveZ3JrBnou0tX4Qvw+PmtziwK6uYAdBe83sl2LMqbq8F/jW/rYI9u2rsBa0zvxuDPedl36WjN3ywq6g9/HHqnP0I8M3HqNv0pyBvm99Lwp5bBZaSdoE+Nb95hF1dlZai95Cw56HtKkdkgh40v7mEXVOVlqJ3nbDnV9yuZfjL/CYU9oIqsAu9R4VdS90fnqYpZ/M7VtgLqT30EnULqWsDpiWIcvQmFnYdGj+ElhxJgvjNv2OMXV82/CBa8y8QY3uqoiUYTdX0mDfuImpX9ACUk01hI/BNG+Qc828WYzeg8UNodd6eDeE3/7IwdmPZ8INozb8bjN10mpsC+rVf7GZqvh3U8b4XYnqzeZw2NE4SFcin+TdrsVvKgBP9jiu2lz5O3Y4D8Pba0zKwMf9iK7aP2hszgDc46qifA755FPKn+XdasReXzS7ICjL7g3ZdbN6u/orbBVrRb96KgapvbUaDpwHzhg9Su+/NgDtupW5utwPfvANy6KB5u7aWzS7ICrK5gXZtNW/XtorbBVqxzbwVl1Rxc5Osu8S8ddupffQowPnj1G3qCcg7283jv7Rs+Em0IP+Xmsd/WQXxS2gvM4/2FfC26NbU0kLhZMON5zCPGG2IrsS7ihG7pS/XWPm9NsgnPwC4/yFQ/izkE8Re6lca+CT/slvRJ1evYp4w+4LBqnkPL8KpV2ho+jXk1OqxFhEUV5YKijwW9slVzFOGJy/y350nXki7MhAo1iLtmL6kIq+jZa/SGNbRDrXN7nZt/7OincjcCIp3IJCsbAfyAOKYwlBpPCQc9LM52Z2l1aLPFwzD0SxHKPvCKuZpU8dwsk12r9e5h3q4hQjfqzWWDIBBs40Imu1Q0CCC2F4aD0we+ggquwt2bHOs8Gqab57LfNXwiaqn+c3oiHAY0dg/CoaDk3C+WM4A5SxQPl6GINoNe1F6+xr76GrmlMlzlRV0h0NjyGHQHUGA3lAZ6B2F6W0Tj5pyUSH/nVrNPFP9HO/RWLMAcpwEOD5WBo73GnAcT81xhdd0v+M85vuGAybxy0cXSx9WtPgkNuvUmHAjSOwbiK7lZktHRq+iRbIMusryBm2WoeYsR3B2FxSGiMGUi5q59kJUCu88MRdriAEZS83b+wjePkDGGuIMqLs8jJXn7OUYNW2PELQ9DoVbs3k84wbj6mLLZC9Yw/zI4OEszcyBgNfHAu8/QCS0fTA6lS/ZrWuYZyv99BjWo0H3dWjkbPj4FkSW9VIDMHp+DSJ5+qgB6M594289J2gBQA+wQb8Zgt1PDWHcNeEV/upDQGTAA7QQ2line8Kb/6EPApHZDtKCaHYcHHHZnaw+AkQuO0QdjbsOBNzEK8CC6EPVr6amgE+YjoPjQEZAHHOepEXQ4PNMABkRccbYT6u+cdTu8gL6EWd+p6jNd0+4XPrqEUdwD8PdVX0qzt8DX7yWeaHi3VRAg2pNR4W7qWuoAZSpmwrSAjBoFYhOappWvVGrQPRQM9Tmw60C0TuFaNXrvJYR3y1xtNpb9k04vD7nGDBIQfRLs7QQjHtGRMd0hDoCR8ZcEAOIbmmOOgLh8RGiWwpTm28wNEJ0SxFq83We8Y3vlo5Sm+912b179fUjnt0QpY7/cYdnxOEGkgDi8Qjz1ElAcADsBMTzCWK0EMjDrkH0owHi1MqJ87NB9Dn9Ber87/IBnR/ijPy11Nr3QNoRJ9YT1C3fsc+xT1894gB5ktp4N6QdccA7RT3uE4yHACBOV6epE58b1o8483yMmgC7ezf/vz4AxFHkRerwG/MQjxgPok8MH6dO/MLA0wl1PYiTvEvUHth1IAB6AHHk9jrqEOQBQC5AHI09sRwCDkIAEKdaM8sBAE7KII6enqQfezrHgR4AcXL0euoUbGfH9bUjzn2+hpp9l3evcxRgH3GU8wZqAB4DAIjjlq+lzkETRggQByZvpB58Gk8QI848vo4WQskJYsRRxtdTp0K7xzMGvEIacRDxDfS9sd5esCD6hOEbaQG0igACY0BCQJwevIm6ORhOUSNOCt5MjWDXhNPlcwJ+QJzZu4UWQYfPwY677D5HwOsDiEAcsXsTLYzOIoy9DjswREEciXvz8ulgnQAMxJm27PLp8NmdwHQl4ojZrdTjBY/DC/QWiJNgt5VWb+GBb/wJr7fQ4o3s7NTfzGUnyvEntm6nZhFaGBblbiOeMNZi/CITxDmst1IzyQJMjkNMIk5XvY166sgONAbE0ag74AW11ulgNLAQTHCxHJtexzbVGqyr5RffClfwC2o5DarpTpmSO29aXZP/o5nXJfcS4dfV7jTAoZ3VJw9i4JfV3l5aP8U7U1YGAkVXSgdJti/niAxiYe4uWgMii0CLOwG1OMRy3TvgoG8XmJpOBGeOcqkc+7F1bHMFw/6dGlw3QeFWnmh/F636MkX73aX1U+yyXuokO+byBPc9tHgj9wDBfV8ZgvveEhldCG4ux/5qHdtSwdB+twbVQ5UN7fto1ZcptO8vrb+qQvs9tHgjTwOh/aUyhPZ7S4R2MHYkyof2RevZtgqG9vs0qE5VNrQfoFVfptB+P61+/cjGb/75ADUA3caC3/3zoAaA8pyPOgDyZ4isi7wPllZsI6+IJb9XsIQ/jfIhDZLd9VB+041C8VJ7eH4hnkhZ/Zq5D9NiU10RS/4GZLcXLWXvIW0EkwjLkrk+UlqvjbwilrR3WcnARzVIjjeaiR/ueDni52O02FRXxJJVXfrxs9pS9j6uQfh0E5SAQtxM3MIA+kRpxTbyiliyyVIKHtYgeQaioFWgQLgXTlnIwyOltdvIK2LJJZby8KgGyfMgD/LsjnU8PFZau428IpbstJSHx7VDRYgH6cy9KmfgifhkafU28opY8ipLifiUBsl68lXmUt8yHw9ZyMATpfXayCtiyX5LGfi0Bslt5NOfpP5DOfdjHROfKa3fRl4RS6YtZeKzGiSfhJhQvjnYOiKeLK3eRl4RS2KWEvGUBsmLEBGK20rrePhcae028opYcp2lPHxeg2QFeLDXYNhFPr8IP+Z6mhaY6opY8kZgzHWzpdR9QYNwCbrrVEy6WRdCXyyt3UZeEUvutJKH9MD/A3m5Q+U='
+)
+MEMO = pickle.loads(zlib.decompress(base64.b64decode(MEMO)))
+Shift = 0
+Reduce = 1
+def Lark_StandAlone(**kwargs):
+  return Lark._load_from_dict(DATA, MEMO, **kwargs)