jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/compiler/larkparse/jac_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'eJzsnXl8k9eVv71IYY/ZwhYISQgEMGGTJWSxyRZG2LJssA1GQsYY2xAStoCdOErJ0iTOgkI2ZV+dpNN2pq2mC+2047aqaDrdptN9X6cdl3WmC5ru7e/e916b8zSZNNNlPumvyR/53keSpXe57/ece3T0crP7ocKCwgL936H03NR5+9sOHOw8kNbjkbs7ezoPtLbv27vD4RFdnQf27NrbtvtguiU991A6VRhMRwoOHkpfOTxSaKTISLERlxG3kfOMDDMy3MgIIyONjDIy2sgYI+cbKTEy1sg4I+ONTDAy0cgFRiYZmWxkipGpRqYZudDIdCMzjFxkZKaRi41cYuRSI7OMXGZktpE5Ri43MtfIPCPzjZQaWWDkCiMLjSwystjIEiNLjXiMlBnxGvEZWWbEb6TcSMDIciMrjKw0ssrIaiNBIxVGKo2EjKwxUmVkrZGwkXVGqo3UGIkYqTUSNVJnpN7IeiMbjDQYaTTSZGSjkU1Gmo1sNhIzEjeyxUjCSIuRrUZajWwz0mZku5F2Ix1GOo3sMLLTyJVGdhm5ysjVRnYb2WNkr5F9RvYbucbIASMHjXQZ6TZyrZHrjPQYud5I0sgNRt5g5JCRG43cZORmI7cYeaORW43cZuR2I71G7jByp5G7jNxt5LCRlJF7jBwxcq+R+4zcb+QBIw8aSRt5yMjDRh4x8qiRx4w8buQJI08aecrI00aeMfKskT4jzxl53sgLRt5k5O+MvNnIW4y81cjfG/kHI28z8vaDnanzdu3cu+9Apza01LBQfTRaVdeUThU1N6Y7U2N2th7o3NnZ07pjd9vOg8rqUiO6D3a2br++q/Ng+q5Be+y6fn9nOjVSuWRXZ09Xd9vudGp4q/Noa2s6NaJWvyikLbQ7NcqY6zlHdR/o3t1p3VRt0DvMdmWM/KORdxp5l5F3G3mPkaNG3mvkfUb+ycj7jXzAyD8b6TfyQSMfMvJhI1kjHzGSM3LMyEeNvGjkY0b+xcjHjXzCyCeNfMrIp438q5HPGPk3I5818jkjnzfyBSNfNPIlI1828hUjXzXyNSNfN/INI9808i0j3zbyHSPfNfI9I/9u5PtGfmDkP4wMGPmhkeNGThg5aeSUkdNGzhj5TyP/ZeRHRn5s5CdGfmrkrJG8kf828jMjPzfyCyO/NPIrI7828hsjvzXyO0eiBSYGRwutFlkttuqy6rZ6ntVhVodbHWF1pNVRVkdbHWP1fKslVsdaHWd1vNUJVidavcDqJKuTrU6xOtXqNKsXWp1udYbVi6zOtHqx1UusXmp1ltXLrM62Osfq5VbnWp1ndb7VUqsLrF5hdaHVRVYXW11idalVj9Uyq16rPqvLrPqtllsNWF1udYXVlVZXWV1tNWi1wmql1ZDVNVarrK61Gra6zmq11RqrNreL1lqNWq2zWm91vdUNVhusNlptsrrR6iarzVY3W41ZjVvdYjVhtcXqVqutVrdZbbO63Wq71Q6rnVZ3WN1p9Uqru6xeZfVqq7ut7rG61+o+q/utXmP1gNWDVrusdlu91up1VnusXm81afUGq2+wesjqjVZvsnqz1VusvtHqrVZvs3q71V6rd1i90+pdVu+2ethqyuo9Vo9YvdfqfVbvt/qA1Qetpq0+ZPVhq49YfdTqY1Yft/qE1SetPmX1aavPWH3Wap/V56w+b/UFq2+y+ndW32z1LVbfavXvrf6D1bdZfbvVd1jNWP1Hq++0+i6r77b6HqtHrb7X6vus/pPV91v9gNV/ttpv9YNWP2T1w1azVj9iNWf1mNWPWn3R6ses/ovVj1v9hNVPWv2U1U9b/Vern7H6b1Y/a/VzVj9v9QtWv2j1S1a/bPUrVr9q9WtWv271G1a/afVbVr9t9TtWv2v1e1b/3er3rf7A6n9YHbD6Q6vHrZ6wetLqKaunrZ6x+p9W/8vqj6z+2OpPrP7U6lmreav/bfVnVn9u9RdWf2n1V1Z/bfU3Vn9r9XdWC8ziO1potchqsVWXVbfV86wOszrc6girI62Osjra6hir51stsTrW6jir461OsDrR6gVWJ1mdbHWK1alWp1m90Op0qzOsXmR1ptWLrV5i9VKrs6xeZnW21TlWL7c61+o8q/OtllpdYPUKqwutLrK62OoSq0uteqyWWfVa9VldZtVvtdxqwOpyqyusrrS6yupqq0GrFVYrrYasrrFaZXWt1bDVdVarrdZYtUWdaK3VqNU6q/VW11vdYLXBaqPVJqsbrW6y2mx1s9WY1bjVLVYTVlusbrXaanWb1Tar2622W+2w2ml1h9WdVq+0usvqVVavtrrb6h6re63us7rf6jVWD1g9aLXLarfVa61eZ7XH6vVWk1ZvsPoGq4es3mj1Jqs3W73F6hut3mr1Nqu3W+21eofVO63eZfVuq4etpqzeY/WI1Xut3mf1fqsPWH3QatrqQ1YftvqI1UetPmb1catPWH3S6lNWn7b6jNVnrfZZfc7q81ZfsPomq39n9c1W32L1rVb/3uo/WH2b1bdbfYfVjNV/tPpOq++y+m6r77F61Op7rb7P6j9Zfb/VD1j9Z6v9Vj9o9UNWP2w1a/UjVnNWj1n9qNUXrX7M6r9Y/bjVT1j9pNVPWf201X+1+hmr/2b1s1Y/Z/XzVr9g9YtWv2T1y1a/YvWrVr9m9etWv2H1m1a/ZfXbVr9j9btWv2f1361+3+oPrP6H1QGrP7R63OoJqyetnrJ62uoZq/9p9b+s/sjqj63+xOpPrZ61mrf631Z/ZvXnVn9h9ZdWf2X111Z/Y/W3Vn9ntcBU3aOFVousFlt1WXVbPc/qMKvDrY6wOtLqKKujrY6xer7VEqtjrY6zOt7qBKsTrV5gdZLVyVanWJ1qdZrVC61OtzrD6kVWZ1q92OolVi+1OsvqZVZnW51j9XKrc63OszrfaqnVBVavsLrQ6iKri60usbrUqsdqmVWvVZ/VZVb9VsutBqwut7rC6kqrq6yuthq0WmG10mrI6hqrVVbXWg1bXWe12mqNVfttTrTWatRqndV6q+utbrDaYLXRapPVjVY3WW22utlqzGrc6harCastVrdabbW6zWqb1e1W2612WO20usPqTqtXWt1l9SqrV1vdbXWP1b1W91ndb/UaqwesHrTaZbXb6rVWr7PaY/V6q0mrN1h9g9VDVm+0epPVm63eYvWNVm+1epvV2632Wr3D6p1W77J6t9XDVlNW77F6xOq9Vu+zer/VB4oPdqbcB7vaDnSlW9JXvbW4oKBtqARuquau3W27D6Sv/FBq5HrnYVMnv7LQ+Saya9/VnXsP6jp5pCA1rKKhob65tTYdKUyN6OzY2dm648C+PelIUWqUQ/v2tx7o3JGOFKdGmlc2tK5fko64UsOcp7v2pSPu1LCGxg0bKxqq0pHzUsOdx9v2Xp+ODBv8m1rnb4anhhusrE5HRgx+ckM6MjI1ItLc2lxRG6lSNCo1TFF1dL3aptGpUWpcv6mqoaF6jXr7ManzFIcq6tKR852XNVU1NqUjJalh62N1tdV16iVjUyP1n9eFajfqvxjnvKyuXo/HO+OqNWE1nuC805qqtenIxNTwNVWh+obW+vXpyAXOtoRr6ysr1OdPSg3Xn1db0diYjkxOndfY1FBdF05Hpph3qtsYTUemOu9UW6W2Y5rzcHN107p05MKU67KqujXpyHTnPSoaY3WhdGSG8/b1lTVVIfX6ixxSu1rfoGimQ41NFU3V6pUXp4Y1xda3VtTF0pFLzCGpq1avutT5uHUVaoNm6V2tagy11lVE1S5d5nxQ87rqWgWzUy7z6Bzn0Vh1Va3alsudj2ioMh8413nbdVX6xM1LjVyr9k5/vH5qfuq8SrXRevtLU67K+np1MBaYg7GuKhRJR65Ijaqrr6utD1XUOsdtYcqtN1EdzkWp4nq9c4tTw/UOrKnWsCTlWl+7UW3zUuczG+rr1YOe1Hm169W0UWezLDVCv7hp43q98d7UaH1yqhur6sIV+mz51CsrGypCarjMHJdGfbz9qWG1gzOv3Jkqofq6puq6jYoDzgc1VtWqTVrujNfW1jenIytSbjWoUH+9MuVqrIqqubjKOSq1FdHKNRXpyGpnNysbqirUbgbNdtm/qHCOSp3e9spU8bqqzelIyDkdTQ3qLK1JDV9fvb6qdW2zOmpV5g8rY2qGpiNrU8Oramur1zdWKwibPaiuU2+zzkyO5gp9aqvNJkeq1fGsSQ3Xp6I1ulEd+YiZV86Lap35vam6sbqpXl0tUecNHExH6pwdWVOlJqM6AvWp8xrsQVtvz3vTxgZ1sDc4bxeqaFTPNDh/37i+olk90WhOWW21vqiaUqPMH7SuczZ1o3nlxvX6It3kQENFtX6PZvNnZpZsdj5KXTBVeh7FUsXO4Yqnip032ZJyR9X5UUchocyh9dzxakkVV1arTdiaGmPm4YbBqdiaGumccHvpbXOOXpUz6dqcg79WH4ftqRHmonWeaDcXVriuXk+NDrN9+s/SkU51YWysVRu6w9mFaEVTSF2tO50Zt76+scleZlea+aw2dFdqVEha31WpEWo6KLtYU70pHbk6VRytV9u/25kam/Wm7EkVVakP2utsnHMJ7UsNW1PfZHZ0v/PGlWq+XJMqdt7igFJ9jA6misP6vHXZU79eT9dusx3qyFybKgqrV12XGh4a8uwe5zOqG9XT16eKatXTyVSRdsEbUsP0XrbWqzn8hqEdMD58SF1Mjeuq16pX3+j8fZ1++5tSI5yzURnRW3lzqrhWb8styhvVlpsH3zj00Wovb1Wzy77Lbc426l2/PTXKnlTzF72pEaFznn9Hyl1pXnenc7FWVKqTWqHt4a6UW39HrK6+u1Mj1ClRs761akM6clg/XluvNi+VGj101J2n7kmdNzg8kho1eMAcvjc1wlymDt3nkDozDt2vTo6SB1LDnU1xHnswdd7gB6ZTI8xeOfSQeqJ+jTN82HkXdTYdeiR1XsUaM3w0NaL23F88pmLExkpn+Lg6QNbdnnAOkLbsJ40TNdSrwPGU82hTfTrytDxDS9ORZ+SUU/ysCKQK+5yZW1XnuM5zIjCr5543kWmznsMvmHGtvkbflJrS2uqEZhXOW9uvbNu1t3X/7u6DrZ7F6cjfpYbv3nWwq/Xatt3pyJtTo9sOHty1c29r+749+w+kI29Jjd6xa3eX8/2688BbU6N27e3o7Gk9uHtXe2c68vfqL7r27dnVbt43HfmH1JjrVAKi3t28UzryttSoPd27u9SHHNi1d2c68vaUa/8ulalE3pE6b0dbe9c+9baZ1PCOXe12K/4x5dJdUenIO1OjDu7vbN/VttskIu9Kuffvu65Tvf7dqVHbd3Vdt+ugTjc60pH3pEbZzTBvfVS938HWg/vbrlMb8N7UsPZ9e/d2tnelI+9Ljdq9b+eudvWWzh/+U+q87r3729qvTkfef+49e/Q2fSA1Ym/bns4O89n/nBq9vVsdCnXsnDwr0p8adrDTbvEHUxe0toqdNId3aVk68qHUiJ2dQ4fzw6nzeR7SkWyqRG1ce/eBA517u1o7e/TLPpIa7vQ6OB+cS41rdf6+7UBnq878Wpeqc33s3H7s3af266MqK7xy1w41ejE1Qh+DVvWU2rKPmfPTunuXOqR6U/8lNVJ/SKc6OfvUx39cvU/bnu0dbfajP5Ea2XZgV9eVezq7drWnI5/Uh8756HTkU6mx4hi3bncO2qdTxc5W/mtq5OD26GP3GbsR5kX/lhqhD5U9CJ9NjXTOtcXPpYbtGJwan0+NHDwF+l2+kHLpT0xHvqjeXU9S+ydfGjrbZie/nBrR1b1/d6c5GV9JlTi73L5v9251zp3d/GpqxI4Dneqg7OtQe/K11Jj91zvj1u279+kt/HpqxK49+3e3drXtUu/wDbUZ+nGL39SdKOde+y11BPd27xnEb9uT1dWmduA7KpFWx7FVb2068t3UBHXhDb3WnD1/OvK91MRWe3ns0WfdmS1LytORf1dHf+jhdOT7+nVqu/Yd6FJ/u6fLvIGy8R+o17W3q3NoPvU/UiPaDrRfaSfmgL589Mf/MDWsbfsudeZVPn5cbZjekI7OdrVHJ9Qp6Gzfd0AdpwMH05GT6qI+9ynpyCm93edeYLbPm46cTo3Z0b3XOaT2jc6kxnbtNtt2nZo1rR371KT5z9Rw52B26InxX2bbOs22/Sg1cufufdvVLLm2TZ3IH6fOH3rSvuNP1IQ1G20f+GnKpbc8HTmbGtO1T53lazt32+3Mp0YrUgewfXdb90H19v+dGqnmatsee/x/lhp99XWt4oT8PDXMPpCO/CJVcmXboEvZ53+pdkdtSkerfmbwTX81dHT2t3VdmY78OjW+1VkpOWwvyXTkN6lRHfu6utQfa9dIR36rp5x9UTryOyd1W1tdV1FbG0tHCwqdLKVqc6hqfVM6WliofXavmszXm12LFhWmRg0mQ3opES0uPJcdra+uUpld1KXexHmoUi0E0lG3XsXtPthp3+G8QhsCVGIeHeY8t2uHfW54oXaB9s79Xc5Jio4oTJWoA6M2VbmEPRjRkerBPW379zt+Zp5JR0epLeXLRhemxh7svKa7c29757nXjSnUy1LzOvVsOnp+oZ7M+w4MfYiZy550tER9jrWnc38/Vm3huReno+PU3gzBeHUs1NlR03/ooQmF+tI5xxPVm7a37e/qPiA26oLC1LiDand2d3apGTz08KTC1AQR5bTPqs3Zk45OLtS+LuKdPdlqo6cU6lkwGLPs4+Xp6FS1nVdfq95714F0dNpL39gcswvV6dBXkpni0emFTi62fmNlOjrDnLb1DSo9jF40CCpHjM4sTE1VE2/wz1qdmX7QfLT65IvVefj9J9PRS9QnmUtCX3DRSwuHJrPZxVnqOO3ae2Wn8nw1c/XFqP7oskKnshCdrbZrz76O7t2d6egcdeL3dO7ZrvbFGF/0cvVsW/fO1n3709G56mPUIr5hY6POf6Lz1FPte/Y7T81XR8o5TrtUCBZntFQ97pj67z2+QJ3J63d17u4w12n0CrXJ6lR3DrpTdKF6gfIMx081L1Iv6OhU53Rw5i9Wm7p33161lTZxiC4pTA3Xl7R5fqk+CE6Lon3Ao+ZThwo6e9t2Dj5Upj7kuit37R5kr3pPlU507Wqz5hP1qV1Wx14dRe3V0WXqI7oODF6+fvURBzrPWWq0vHDI+ZwtCqgzO3Q5LldPXrvr4K7BF69Q77VDzX5DK9Wze9q62q+0vEp9sGO2BlerM2hMq72rZ/DcBNVr2rsODG5rhbM56mLYax+oVO95oG3XkFmEnKvzXJSzV+fidHSN2hbHZBwXqiq0tQJrQWvVpDPb1t52cDBCRsPq46y9mPm+zrmQxEM25C1JR6v1yXBmgAnu0RpnU86Fe5tLLUtHI4U6Lml3NU+bbfSno7WFJlWznxZVb2mnqtm7OnWIRLg1r6ovTE1qNcFBzQzxhuqT1quzY59JRzeoUy9flo42OJso3N78ZVk62ujsqLxOzFPqPZvMJLOZqHNpbCx0elwd7tqXjm5SnzTITiku2ixeof9is9q1QdZ1tmisUCf3v3cFm8/0paNxZ3NEwmuNSh33LeqdTdJk9ilhDvtQDmdfqWZAS6FNjnQuno5uLUxNbm2F/doDpz6w1XkXnc9pB+qyW7LUm45uU5937vF0tM15G+eRg9fgxepttqtjhafS0Xblfmaav6yjdjgffO4ysRNsaTraWZia1tr6+xHKbrI6ZTvU5FB/6diceVTt807j/Oec0m6ccv4r1UmST6Sju2yYGJrEdkfUzLzK8ezfi6L2s73p7tR5joPYgqzzv0hBdE9xbzpSqAafK1KDIjXIutSgWA0O66dcanC1HrjVyzcrPU89cL9+YJga3K4Hw9XgVj0YoQYBNeiO6AJwZKSWK51+RfXkKNBo0BjQ+aAS0FjQONB40ATQRNAFoEmgyaApoKmgaaALQdNBM0AXgWaCLgZdAroUNAt0GWg2aA7octBc0DzQfFApaAHoCtBC0CLQYtAS0FKQB1QG8oJ8oGUgP6gcFAAtB60ArQStAq0GBUEVoEpQCLQGVAVaCwqD1oGqQTWgCKgWFAXVgepB60EbQA2gRlATaCNoE6gZtBkUA8VBW0AJUAtoK6gVtA3UBtoOagd1gDpBO0A7JXVHiqRTuuCULjilC07pglO64JQuOKULTumCU7rglC44pQtO6YJTuuCULjilC07pglO64JQuOKULTumCU7rglC44pQtO6YJTuuCULjilC07pglO64JQuOKULTumCU7rglC44pQtO6YJTuuCULjilC07pglO64JQuOKULTumCU7rglC44pQtO6YJTuuCULjilC07pglO64JQuOKULTumCU7rglC44pQtO6YJTuuCULjilC07pglO64JQuOKULTumCU7rglC44pQtO6YJTuuCULjilC07pglO64JQuOKULTumCU7rglC44pQtO6YJTuuCULjilC07pglO64JQuOKULTumCU7rglC7jlMXaKa+0j32wSL9iF+gq0NWg3aAa0B7QXtA+UB1oImg/6BrQAdBB0HxQF6gb1AC6FnQdqAe0EHQ9KAlaAvKAbgC9AeQHHQLdCLoJtAWUAN0MugX0RtCtoNtAt4PWgHpBd4B8oJWgO0HDQdNBI0BuUDHoLlAbqAA0DHQ36DAoBboHdAR0L+g+0P2gB0APgtKgh0APgx4BPQp6DPQ46AlQE+hJ0DTQU6CnQc+AngXVg/pAz4GeB5WAXgCNBI0CjQaNAY0DjQdNAE0CTQHNAM2U1B1xvXxRYKgWoKsDB/XgTWrgK+wV1YFXVRVwH9KHrSB6ofrTg5Hz9KcNZnHLi/X2hEGXgNaCakGzQLNBk0FzQfNAjaCNoEWgxaClIA+oGVQG8oHiID9oGSgAagGtAG0FtYKCoErQNlAHqBNUCtoJqpLUHRmmz7dfnf536lnxd2qiLXYOV0EkqPTN6omrCp04UxDdrQcH9EQsdLy/IJrSg7eowTv0YJ8afFAP3qoGb9aDwbygB3lBD/KCHkSEHmQJPcgSepAX9CAv6EEm0INMoAeZQA+ifQ+ifQ+ifQ+ifQ+ifQ+ifQ+ifQ+ifQ+ifQ+ifQ+ifQ+ifQ8ieg9ieA9ieA9ieA9ieA9ieA8ibA8ieg9ieA9ieA9ieA9yqR7EcEM1oDtAPtBK0J2g4aDpIDdoGKgYdBeoDVQAGgF6HPQEqAl0GPQkaBroKdDToGdAz4LqQfeD+kDPgZ4HlYBekNQdGa594LA6IneIT59YLN/T0OOSuiMjXm3JWleqr/tfB6eR+u2bFE4oFPOjE+tmQ/tBKyV1R0bJeo4b9Rw36jlu1HPcqOe4Uc9xo57jRj3HjXqOG/UcN+o5btRz3KjnuFHPcaOe40Y9x416jhv1HDfqOW7Uc9yo57hRz3GjnuNGPceNeo4b9Rw36jlu1HPcqOe4Uc9xo57jRj3HjXqOG/UcN+o5btRz3KjnuFHPcaOe40Y9x416jhv1HDfqOW7Uc9yYl27Uc9yo57hRz3GjnuNGPceNeo4bs9uNeo4b9Rw36jlu1HPcqOe4Uc9xo57jRj3HjXqOG/UcN+o5btRz3KjnuFHPcaOe40Y9x416jhv1HDfqOW7Uc9yo57hRz3GjnuNGPceNeo4b9Rw36jlu1HPcqOe4Uc9xo57jRj3HjXqOG/UcN+o5btRz3KjnuFHPcaOe40Y9x416jhv1HLdxytHaKWuU4a7URvz3avBQsXMUCqKn9eAf1ODBImeWF0RucWZ0QeRypW9TepnSt6sXfFy/8h1q8AH9yoy2dT34RzXYV+gc74LozfqRd6o/+o7Sd6kHPqQfeLca/LTIOV0F0QN68B41eH+xM80Lou8tdq7EgmixHhxVg279fu9Vg6/pF79PDZbop/5JDaqKnQNREN2gB+/XUabQMaqCaLLIuYYLokuLHXsqiP5KP/IBNXiu0Dl5BdHP6Ef+WQ2uKXZOhPqrYsePC6KH9KBfDXqLHc8qiG7WL/6gGlTrRz6kBm/Vj3xYBzs9yKrBw4WObRVE31fkzP+CaFi/+CNq8P0i5ywVRAf0IKcGPyhyrt6C6C+LHCsqiH5JD46pwYki51IuiO7Vb/hRNThb5EycguhP9OBF/RGFjrkVRAuKndlXEG3Qg4+pwc+LHFcqiB7Xg3/Rf6Wf+rjeCz34hBrU6qc+qQZb9SOfUoOj+g0/rQbvKXTMSZ2vQsdDCqK/KXIu4ILoMT24WA1mFjuXg1pT6sG/qsHFevAZNZilB/+mBvP14LNqcEWxcyUVRC8pdqymIDqn2HG8gmhQDz6nBiv04PN6oVvkmExB9NEix4kKoqFi54IqiK7Sgy+oQY0efFEN6oudq6sgulMP5qlBa7HjbQXRK/Vgvn6Nfp9FavCMXf9E+/TgS2rweLFzeRREXyxy3KRA5Upq8GU1uFEPLlGD7+jBV9TghiLHCwui1+pBQA1+qAdL1GCZk8mMOaR9uyC63qWX2efry+yreu/1Ufya3lc9KFGDuiLH5dQVqB+ZpgaPufQblNg3mO6s08fqN9DL9jt1lvWsuo4S+kXjZKITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITR6ITN4nO+D+28HWXGozVg8fVYN2rLIV1RybozxssaRxxltLFoAKQGzQMNEJSd2Sifme1eZGa3qFCReTT4gI1cJeElRI8EqZJaJKwX0B35AL9qferT+3pFcWSQvFJlppAhyV1Rybpd1FHNNLde67sMAFlhwkoO0ww+zxZ/93gYz9GoefHKPf9GMWVH6Pw8mNT+pjylyyBqiMUfbczAaYeMmE96sTvaWbHzYZMQa1oCqo1U1ABmoKq2RRUlaagvjbF7NyF+nOeUB/7jWIxIV6UE+JFOSFedP5qukwjjiCNOII04gjSiCNII44gjTiCNOII0ogjSCOOII04gjTiCNKII0gjjiCNOII04gjSiCNII44gjTiCNOII0ogjSCOOII04Yib0DHleJ+O8TsZ5nYzzOhnndTLO62Sc18nmvF4kz1ACZyiBM5TAGUrgDCVwhhI4QwmcoQTOUAJnKIEzlMAZSuAMJXCGEjhDCZyhBM5QAmcogTOUwBlK4AwlcIYSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSSPQSCLMJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJJHoJ48gz/0BFS1dAxutQ/Xpp6/+v0tbrFa3ev2hF6+LB7+Ya5Hdz7YgYhvaDVkrqjlwiM5kkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkkMpkk5mUSmUwSmUwSmUwSmUwSmUwSmUwSszuJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCaJTCZpnPJSW0EIOBWEWfb7gCudLxQuk33YR9FvdRT9VkfRYXUUHVZH0b1zFP1WR9FvZWgfqA40EbQfdA3oAOggaD6oC9QNagBdC7oO1ANaCLoelAQtAXlAN4DeAPKDDoFuBN0E2gJKgG4G3QJ6I+hW0G2g20FrQL2gO0A+0ErQnaDhoOmgESA3qBh0F6gNVAAaBrobdBiUAt0DOgK6F3Qf6H7QA6AHQWnQQ6CHQY+AHgU9Bnoc9ASoCfQkaBroKdDToGdAz4LqQX2g50DPg0pAL4BGgkaBRoPGgMaBxoMmgCaBpoBmgGZK6o7M1g77dWW4awsdQyuIXq7T6W/o1ZyprRZEv6oz5G+qwdv04FtqsMhJlefov/22Xn0UOhOxIPp2pyZ8+cuvTfWS9H79yqF+ulfff+FWL/imfsFLV6vfUYOTr51l6zg1OKNf83+wfh3sKDy3kB2vBhUvv6IdalH8P1jaDrVODq1x0c9/HRokX2H5O9Rn+dJ18FBb5WttQTzUAfr/28p4rr6s1dUc+aKduU+65DX8Xb2Xha9wDX9PvSCGC/Ul1+fQ1Th07Q1dV69wFQ1dM0OXytDFM1UfqaKXvXheofgzdGG89Hp46WUw2Mtybq4PzeOXztpXmHY6B64slPPvpbNtqJPmFcov/6sp9VV14BfJqTU0kb6mnil95Qk1NI/+XQ0+4Xp1E6o7Mk+WRgIojQRQGgmgNBJAaSSA0kgApZEASiMBlEYCKI0EUBoJoDQSQGkkgNJIAKWRAEojAZRGAiiNBFAaCaA0EkBpJIDSSAClkQBKIwGURgIojQRQGgmgNBJAaSSA0kgApZEASiMBlEYCKI0EUBoJoDQSQGkkgNJIAKWRAEojAZRGAiiNBFAaCaA0EkBpJIDSSAClkQBKIwGURgIojQRQGgmgNBJAaSSA0kgApZEASiMBlEYCKI0EUBoJoDQSQGkkgNJIAKWRAEojAZRGAiiNBFAaCaA0EkBpJIDSSAClkQBKIwGURgIojQRQGgmgNBJAaSSA0kgApZEASiMBlEYCKI0EUBoJoDQSQGkkgNJIAKWRAEojAZRGAiiNBFAaCaA0EkBpJIDSSMCURuYfMlFuS5EuhpRq3xx0vNXF0mUM1UvqjizQr/+++vO3FPeaosq79UB3+rzNCehXyF9FlsBUSmAqJTCVEphKCQy1BBZTAospgcWUwDRLYDglMJwSGE4J7LUE9lMC+ymB/ZTAXktgRiUwoxKYUQnMqARmVAIzKoEZlcCMDI0E+UDLQH7QGFA5KAAaBxoPWg5aAVoJWgW6ALQaFARVgCpBM0Ah0BpQFWgtKAxaB6oG1YDOB0VAtaCxoCioDlQPmgiaDJoCWg/aAGoATQc1gppAG0EzQZtAzaDNoFGg0aAYKA4qAW0BJUAtoK2gVtAk0DZQG2g7qB3UAeoEXQjaAdopqTuyUDulXvJ8SDvoD9SgH2uJlyxk9G8O39MrVglD+f5Q9jy0oBlaxwxlz+dy5UXS84Pw/CA8P2g8f7EsmPehYN6HEnkfSuR9KIr3objWh6J4H4rbfShu96G43YeiXB8K2H0oYPehgN2HAnYfCth9KFn3oWTdh5J1H0q6fShg96GA3YcCdh+Kh30osfahlNiHAm8fisZ9KBr3oYDdh1JwH8q9fShP9qE82YcvGfpQ3O5DmbgPpe4+lKUNXQXaC6oD1YMmgvaD7gf1gYaDukDdoAbQdFAT6DlQEvQ86EbQTaAtoASoBHQz6BbQC6C7QG2gW0FPgB4H3Qa6HVQDugM0EjQKNBo0BjQONB40ATQJNAU0AzQTlALdAzoCuheUBj0Eegx0N+g+0AOgB0EPgx4BPSqpO7LE9nZHpxX1mqw64RS9l+rHB70ogtuBRHCDjAhuyBHBzUEiuNFFBDfriOBmHRHcICOCm5FEcHuOiIkMnsEQNhWRS8eyh/6iIaxMhqR+hKR+mFE/AlQ/AlQ/pn0/wlU/TKwf4aofltYPE+uHifXDXvsR5voR5voR5vphaf2wtH5YWj9CYD9CYD9CYD9CYD9CYD/srh8BsR8BsR8BsR8hsB8hsB8hsB+m2Q/T7Idp9sM0+2GT/bDJfoTAflhhP+yuH3bXjzDXj8DWD/PrR8DvRzjuRzjuR0jqR6DpR7DsR4jvR+Duh9X3w+r7EdT7EZz7YVSGDoNSoHtAR0D3gu4D3Q96APQgKA16CPQw6BHQo6DHQI+DngA1gZ4ETQM9BXoa9AzoWVA9qA/0HOh5UAnoBdBI0CjQaNAY0DjQeNAE0CTQFNAM0ExJ3RGv7ZkZ5XTQ+GR5vRnrumas65pRW2jGOrkZ67pmrIybUWloRqWhGdWgZqyMm1FNaMYqrxmr5masmptRKWpG/acZK7lmrJqbUXdoRv2nGetkQxeDLgFdCpoFugw0GzQHdDloLmgeaD6oFLQAdAVoIWgRaDFoCWgpyAMqA3lBPtAykB9UDgqAloNWgFaCVoFWg4KgClAlKARaA6oCrQWFQetA1aAaUARUC4qC6kD1oPWgDaAGUCOoCbQRtAnUDNoMioHioC2gBKgFtBXUCtoGagNtB7WDOkCdoB2gnZK6I8ukU8bglDE4ZQxOGYNTxuCUMThlDE4Zg1PG4JQxOGUMThmDU8bglDE4ZQxOGYNTxuCUMThlDE4Zg1PG4JQxOGUMThmDU8bglDE4ZQxOGYNTxuCUMThlDE4Zg1PG4JQxOGUMThmDU8bglDE4ZQxOGYNTxuCUMThlDE4Zg1PG4JQxOGUMThmDU8bglDE4ZQxOGYNTxuCUMThlDE4Zg1PG4JQxOGUMThmDU8bglDE4ZQxOGYNTxuCUMThlDE4Zg1PG4JQxOGUMThmDU8bglDE4ZQxOGYNTxuCUMThlDE4Zg1PG4JQxOGUMThmDU8bglDE4ZQxOGYNTxuCUMThlDE4Zg1PG4JQx45R+7ZRDzYG6JzCCnkDdLhgr7DVp6Gbzw5kCZbP6b8vlt4ybiuTsMHQJaC1oHSgCqgXNAs0GTQbNBc0DzQc1gBpBG0GLQItBS0BLQR5QM6gMFAP5QHGQH7QMtAWUAAVAy0EtoBWgVaBW0FZQELQTVAGqBG0DdYA6QWtApaAaUJWk7khA5gIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIh5AIhkwss1045RoX3jxc5dlMQva3YccuC6E+LHXsoiLpcji8VRG5U+h/qga/qZwZ0H6rL8cuCaMDlmGpBtEkP9E3jNrgcqymILnQ5blgQfdHlWF9B9Jc6pfihGvj1Zx5Xg7F6cEINKop6TZvvHJfjYgXRa/TgpBrcoQen1KDW5VhaQfTtrl7RsHtaDZ7WgzNqkNJb+J9q8Cn9yH+pwQddvaad/w168CM1+Jwe/FgNvqwH+v52R/TgJ2rwJpfjywXRj7gc8y6IfhgNuz9Vg016cFbvhX5qpD5yRb2mZ39HkRMqCqJ7i845c+RdzgFfYct7W5zy3koZqHwIVD4EKh8ClQ+ByodA5UOg8iFQ+RCofAhUPgQqHwKVD4HKh0DlQ6DyIVD5EKh8CFQ+BCofApUPgcqHQOVDoPIhUPkQqHwIVD4EKh8ClQ+ByodA5UOg8iFQ+RCofAhUPgQqHwKVD4HKh0DlQ6DyIVD5EKh8CFQ+BCofApUPgcqHQOVDoPIhUPkQqHwIVD4EKh8ClQ+ByodA5UOg8iFQ+RCofAhUPgQqHwKVD4HKh0DlQ6DyIVD5EKh8CFQ+BCofApUPgcqHQOVDoPIhUPkQqHwIVD4EKh8ClQ+ByodA5UOg8iFQ+RCofAhUPgQqHwKVD4HKh0DlQ6DyIVD5EKh8CFQ+BCofApUPgcqHQOUzgWqVdEo/nNIPp/TDKf1wSj+c0g+n9MMp/XBKP5zSD6f0wyn9cEo/nNIPp/TDKf1wSj+c0g+n9MMp/XBKP5zSD6f0wyn9cEo/nNIPp/TDKf1wSj+c0g+n9MMp/XBKP5zSD6f0wyn9cEo/nNIPp/TDKf1wSj+c0g+n9MMp/XBKP5zSD6f0wyn9cEo/nNIPp/TDKf1wSj+c0g+n9MMp/XBKP5zSD6f0wyn9cEo/nNIPp/TDKf1wSj+c0g+n9MMp/XBKP5zSD6f0wyn9cEo/nNIPp/TDKf1wSj+c0g+n9MMp/XBKP5zSD6f0wyn9cEo/nNIPp/TDKf1wSj+c0g+n9MMp/XBKP5zSb5xytXbKvEoxbxr8Qds9TutO8DVy2/T/1r9b03m17l96trj35X62+zM1uEu/Rv8e+G5X75/8Q179c+XD+n1ezQ95X/73uym7DHpN3X+qSw0+qh8Z+rWuvuXrQ/gF4594Ryp9U9GH9Rv+ib/E1bcZfcLV+8f+JPfnavC9P/BrSV3UfkZ/xF/3b3MrZK7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jQa7jMblOpXZK/X1lE2548tLvNPU3mFWD32lucL7KDB0yMelxpxK3xtbl4g5VSQf2woG9cGAvHNgLB/bCgb1wYC8c2AsH9sKBvXBgLxzYCwf2woG9cGAvHNgLB/bCgb1wYC8c2AsH9sKBvXBgLxzYCwf2woG9cGAvHNgLB/bCgb1wYC8c2AsH9sKBvXBgLxzYCwf2woG9cGAvHNgLB/bCgb1wYC8c2AsH9sKBvXBgLxzYCwf2woG9cGAvHNgLB/bCgb1wYC8c2AsH9sKBvXBgLxzYCwf2woG9cGAvHNgLB/bCgb1wYC8c2AsH9sKBvXBgLxzYCwf2woG9cGAvHNgLB/bCgb1wYC8c2AsH9sKBvXBgLxzYCwf2woG9cGAvHNgLB/bCgb1wYC8c2AsH9sKBvcaB12qnHFpL/UINLnjZdaBe7H1be/Mv1WD2y//MZCiBfumvVIay5MHlVnck/JLf7mx0fH2d+bcmzFZuwD+tu8H8eqZauHvki8LcDYyWMEbC+RJKJIyVME7CeAkTJEyUcIGESRImS5giYaqEaRIulDBdwgwJF0mYKeFiCZdIuFTCLAmXSZgtYY6EyyXMlTBPwnwJpRIWSLhCwkIJiyQslrBEwlIJHgllErwSfBKWSfBLKJcQkLBcwgoJKyWskrBaQlBChYRKCSEJayRUSVgrISxhnYRqCTUSIhJqJUQl1Emol7BewgYJDRIaJTRJ2Chhk4RmCZslxCTEJWyRkJDQImGrhFYJ2yS0SdguoV1Ch4ROCTsk7BTQHamB/77Edl9qsq/CWx2zHiYduTsSkZ55RhrBGWmgZ6SBnpEGekZ65hlpk2ekTZ6RNnlGzpMz0jPPSJs8I23yjLTJM9Imz0ibPCOd8Yx0xjPSDM84B7lW7vwJufMn5M6fkDt/Qu78CbnzJ+TOn5A7f0Lu/Am58yfkzp+QO39C7vwJufMn5M6fkDt/Qu78CbnzJ+TOn3B2Pip3/rTc+dNy50/LnT8td/603PnTcudPy50/LXf+tNz503LnT8udPy13/rTc+dNy50/LnT8td/603PnTcudPOztfp3de5xbb9eWgs41fOyW6enlQTsmDckoelFPyoJySB+WUPCin5EE5JQ/KKXlQTsmDckoelFPyoJySB+WUPCin5EE5JQ/KKXlQTsmDckoelFPOQVkvd/6k3PmTcudPyp0/KXf+pNz5k3LnT8qdPyl3/qTc+ZNy50/KnT8pd/6k3PmTcudPyp0/KXf+pNz5k3LnTzo7v0Hu/HG588flzh+XO39c7vxxufPH5c4flzt/XO78cbnzx+XOH5c7f1zu/HG588flzh+XO39c7vxxufPH5c4fd3a+Qe78F+T+fkHu7xfk/jpwvoQSCWMljJMwXsIECRMlXCBhkoTJEqZImCphmoQLJUyXMEPCRRJmSrhYwiUSLpUwS8JlEmZLmCPhcglzJcyTMF9CqYQFEq6QsFDCIgmLJSyRsFSCR0KZBK8En4RlEvwSyiUEJCyXsELCSgmrJKyWEJRQIaFSQkjCGglVEtZKCEtYJ6FaQo2EiIRaCVEJdRLqJayXsEFCg4RGCU0SNkrYJKFZwmYJMQlxCVskJCS0SNgqoVXCNgltErZLaJfQIaFTwg4JOwV0Rxq1lw1ekwPy+hqQFjEgL7YBebENyAtnQF44A/LCGZBTfUBO6AFpeQNydg/I2T0gZ/eAnMMD0pcG5EwdkDN1QM7UATk5B+TkHJCTc0C69oCcnAPStQfk5ByQ3jwgHXhAOvCAnKkDcj4OSDcdkFNwQMaaARlEBuSsG5CzbkBOpwE5gwbkPBmQ82RAWviAtPAB6doD0rUdmCBhtoQ5EuZLmCZhgYQrJFwkYYmEpRI8EsokjJTgleCT4JcwRkK5hPESVkm4QMJqCRUSKiWEJIQlRCREJdRLWC+hQcJ0CY0SNkrYJGGzhNESYhLiElokbJXQKmGShDYJF0pol9AhoVTCTgHdkSbhZdFVxWJCWqoHTQRNBk0BTQVNA00HzQSNBI0CjQaNAZWAxoHGgyaBZkjqjmx8SVW6/v+oKr1J/kCysVjMakuXgNaC1oEioFrQLNBs0GTQXNA80HxQA6gRtBG0CLQYtAS0FOQBNYPKQDGQDxQH+UHLQFtACVAAtBzUAloBWgVqBW0FBUE7QRWgStA2UAeoE7QGVAqqAVVJ6o40y1naglnaglnaglnaglnagnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgnnZgpnYgpnYgpnYgpnYgpnYgpnYgpnYgrnXgrnXgvnVgrnXgtnWgtnWgtnWgtnWgtnWgtnWgtnWgtnWgtnWgtnWgtnWYmbbZnnTuLzzg91doKtAV4N2g2pAe0B7QftAdaCJoP2ga0AHQAdB80FdoG5QA+ha0HWgHtBC0PWgJGgJyAO6AfQGkB90CHQj6CbQFlACdDPoFtAbQbeCbgPdDloD6gXdAfKBVoLuBA0HTQeNALlBxaC7QG2gAtAw0N2gw6AU6B7QEdC9oPtA94MeAD0ISoMeAj0MegT0KOgx0OOgJ0BNoCdB00BPgZ4GPQN6FlQP6gM9B3oeVAJ6ATQSNAo0GjQGNA40HjQBNAk0BTQDNFNSdyQm+9XC6FcLo18tjH61MPrVwuhXC6NfLYx+tTD61cLoVwujXy2MfrUw+tXC6FcLo18tjH61MPrVwuhXC6NfLYx+tTD61cLoVwujXy2MfrUw+tXC6FcLo18tjH61MPrVwuhXC6NfLYx+tTD61cLoVwujXy2MfrUw+tXC6FcLo18tjH61MPrVwuhXC6NfLYx+tTD61cLoVwujXy2MfrUw+tXC6FcLo18tjH61MPrVwuhXC6NfLYx+tTD61cLoVwujXy2MfrUw+tXC6FcLo18tjH61MPrVwuhXC6NfLYx+tTD61cLoVwujXy2MfrUw+tXC6FcLo18tjH61MPrVwuhXC6NfLYx+tTD61cLoVwujXy2MfrUw+tXC6FcLo18tjH61MPrVwuhXC6NfLYx+tTD61cLoVwubfrW4dspfqeX63XrZ/2s12KEHv1Gx+sLel/tHAHSJ4D5ZM3hpGeCAGjSiVKB/bbIR/9DZb9VgLX5l9DJ3V94il2XHYEnHYEnHYEnHYEnHYMfHYFDHYFDHYFDHYLnHYFfHYFfHYFfHYM7HYF7HYF7HYF7HYM7HYGXHYGXHYGXHYGXHYGXHYGXHYGXHYGWGRoJ8oGUgP2gMqBwUAI0DjQctB60ArQStAq0GBUEVoErQDFAItAZUBVoLCoPWgapBNaAIqBY0FhQF1YHqQRNBk0FTQOtBG0ANoOmgRlATaCNoJmgTqBm0GTQKNBoUA8VBJaAtoASoBbQV1AqaBNoGagNtB7WDOkCdoB2gnZK6Iwnpf78tkrPN0CWgtaB1oAioFjQLNBs0GTQcNBc0DzQf1ABqBG0ELQItBi0BLQV5QM2gMlAM5APFQX7QMtAWUAIUAC0HtYDcoBWgVaBW0FZQELQTNAxUAaoEbQMVgzpAnaAC0BpQKagGVAUaIak70qJn/tA/tDv0byrrf2g36+oV/3bu0D/8q/8R5c/r1wz9E7VD/wbv0L+mO/hPCndHtsorK4wSr6FLQbNAl4EmgGaD5oAuB00FzQXNA80HTQOVghaArgBdBFoIWgRaDFoCWgrygMpAXtBIkA+0DOQHjQGVgwKgcaDxoOWgFaCVoFWg1aAgaCeoAlQJmgH6HSgEWgOqAq0FhSVFCwrx5DpQNSgCqgWNBUVBdaB60ETQZNAU0HrQBlADaDqoEdQE2giaCdoEagZtBo0CjQbFQHFQCWgLKAFqAW0FtYJeAE0CbQO1gbaD2kEdoE7QDlCNpO5Iq7bK3ykz7lQTrVBbcYv+7njQPHNYluWwLMthWZbDsiyHZVkOy7IclmU5LMtyWJblsCzLYVmWw7Ish2VZDsuyHJZlOSzLcliW5bAsy2FZlsOyLIdlWQ7LshyWZTksy3JYluWwLMthWZbDsiyHZVkOy7IclmU5LMtyWJblsCzLYVmWw7Ish2VZDsuyHJZlOSzLcliW5bAsy2FZlsOyLIdlWQ7LshyWZTksy3JYluWwLMthWZbDsiyHZVkOy7IclmU5LMtyWJblsCzLYVmWw7Ish2VZDsuyHJZlOSzLcliW5bAsy2FZlsOyLIdlWQ7LshyWZTksy3JYluWwLMthWZbDsiyHZVkOy7IclmU5LMtyWJblsCzLYVmWw7Ish2VZDsuyHJZlOSzLcliW5bAsy5ll2bbBX1p+S+ebOvE85ZSr2tTj0aLBUNyLTMehaDGejLqA3ZHt+g3c2mKXKouNnqdHq/RomB4tL3RCQ0Fkr7DfDOw3A/vNwH4zsN8M7DcD+83AfjOw3wzsNwP7zcB+M7DfDOw3A/vNwH4zsN8M7DcD+83AfjOw3wzsNwP7zcB+M7DfDOw3A/vNwH4zsN8M7DcD+83AfjOw3wzsNwP7zcB+M7DfDOw3A/vNwH4zsN8M7DcD+83AfjOw3wzsNwP7zcB+M7DfDOw3A/vNwH4zsN8M7DcD+83AfjOw3wzsNwP7zcB+M7DfDOw3A/vNwH4zsN8M7DcD+83AfjOw3wzsNwP7zcB+M7DfDOw3A/vNwH4zsN8M7DcD+83AfjOw3wzsNwP7zcB+M7DfDOw3A/vNwH4zsN8M7DcD+80Y+23X9nuTMsRFRWJKBoqkNRjaD7oT5AOtBA0DDQcVg+4CtYGmgwpAbtAI0OOgJ0CHQU2gJ0H1oPtBfaBpoOdAT4GeB5WAnga9AHoG9Kyk7kjHa+Q+fC+9696feI+9V3NrPf1t2nOFvf/TPfaSxb1/7D329B3+2v6yN9sbusfen+vWen/iHfX+uBvpvcL98/66b5vXqS+sb6r5/tHec7eA6o7skKXPs0gfzyJ9PIv08SzSx7NIH88ifTyL9PEs0sezSB/PIn08i/TxLNLHs0gfzyJ9PIv08SzSx7NIH88ifTyL9PGsTB8fKigoLND/2YeX4EVLQR5QGcgLGgnygZaB/KAxoHJQADQONB60HLQCtBK0CrQaFARVgCpBM0Ah0BpQFWgtKAxaB6oG1YAioFrQWFAUVAeqB00ETQZNAa0HbQA1gKaDGkFNoI2gmaBNoGbQZtAo0GhQDBQHlYC2gBKgFtBWUCtoEmgbqA20HdQO6gB1gnaAdkrqjuzUq+0CtbKOdKgl9nC9xN5ZKPzvRTjXi3CuF+FcL8K5XoTLvAiXeVG6jKVloABoHGg5aAVoJSgImgFaA6oCrQWtA1WDakC1oLGgOtBE0GTQFNAGUBNoJqgZNApUAtoCSoBeAG0DbQd1gnaALgZdApoFugw0ATQbNAc0HzQNtAB0Begi0BLQUpAHVAbygkaCfCA/aAyoHDQetAq0GlQBqgT9DhQChUERUBRUD1oPagBNBzWCNoI2gTaDRoNioDioBbQV1AqaBGoDtYM6QKWgnZK6I1e+/k8j/V/900gZ54Dvkk3sw2FtwzF1huMCM3Q+qAQ0FjQONB40ATQRdAFoEmgyaApoKmga6ELQdNAM0EWgmaCLQZeALgXNAl0Gmg2aA7ocNBc0DzQfVApaALoCtBC0CLQYtAS0FOQBlYG8IB9oGcgPKgcFQMtBK0ArQatAq0FBUAWoEhQCrQFVgdaCwqB1oGpQDSgCqgVFQXWgetB60AZQA6gR1ATaCNoEagZtBsVAcdAWUALUAtoKagVtA7WBtoPaQR2gTtAO0E5J3ZGrZEnjKK76o7jqj+KqP4qr/igc7yg84Cg84Cg84Chc7Sgc4Sgc4Sgc4Sj87yj84Sj84Sj84Sj87yjc4ijc4ijc4ijc4ijc4ijc4ijc4ijcwtBIkA+0DOQHjQGVgwKgcaDxoOWgFaCVoFWg1aAgqAJUCZoBCoHWgKpAa0Fh0DpQNagGFAHVgsaCoqA6UD1oImgyaApoPWgDqAE0HdQIagJtBM0EbQI1gzaDRoFGg2KgOKgEtAWUALWAtoJaQZNA20BtoO2gdlAHqBO0A7RTUnfkanOz/siT+l79uw/pr4kKom917ty/R1ujX+H+wX8IoG7wC4jbVcYaHaHLHjk9GqlHvsFC+LqX/55hqDT+NjVIF/e+9JuV6Cj9Ph919ZqvTR6RFfHoaP3ck7I2Hh2jH/qY3oDz9ehp/ViJHn1Gj8bq0WeLe81XFJ8v7n2Z3xtFx+kXfUk/p/+xn48P/ltKn3T1nqumR8frF31F/gYpOkE/9PXiXlFY19+RfFN/8ET93LeKe89V1qMX6Ie+g29k9DcO33WK7Xv1cca/s1Du3H173+vfbvX+sd9u6a+wNv6Br7le/3ar92/z2639+sIaXOUuQPvyAvTlL0CL8gK0KC9Ai/IC9OUvQLf9AjQlL0BH/QI0Hi9Av/sCNBcvQHPxAnS4L0A78QL0tC9AT7uhC0CTQBeCZkjqjlyjj9xga0Q5WiPK0RpRjtaIcjRDlKMZohzNEOVohihHM0Q5miHK0QxRjuaLcrRGlKM1ohytEeVojShHa0Q5WiPK0RpRjtaIcrRGlKM1ohytEeVojShHa0Q5WiPK0RpRjtaIcrRGlKM1oty0RhyQt5f9rJhIBkZLGCPhfAklEsZKGCdhvIQJEiZKuEDCJAmTJUyRMFXCNAkXSpguYYaEiyTMlHCxhEskXCphloTLJMyWMEfC5RLmSpgnYb6EUgkLJFwhYaGERRIWS1giYakEj4QyCV4JPgnLJPgllEsISFguYYWElRJWSVgtISihQkKlhJCENRKqJKyVEJawTkK1hBoJEQm1EqIS6iTUS1gvYYOEBgmNEpokbJSwSUKzhM0SYhLiErZISEhokbBVQquEbRLaJGyX0C6hQ0KnhB0Sdgrojhwc6m3epBMd+4OSwX5m88OSNfKHJVnUcbKo42RRx8mijpNFHSeLOk4WdZws6jhZ1HGyqONkUcfJoo6TRR0nizpOFnWcLOo4WdRxsqjjZFHHyaKOk0UdJ4s6ThZ1nCzqOFnUcbKo42RRx8mijpNFHSeLOk4WdZws6jhZ1HGyqONkUcfJoo6TRR0nizpOFnWcLOo4WdRxsqjjZFHHyaKOk0UdJ4s6ThZ1nCzqOFnUcbKo42RRx8mijpNFHSeLOk4WdZws6jhZ1HGyqONkUcfJoo6TRR0nizpOFnWcLOo4WdRxsqjjZFHHyaKOk0UdJ4s6ThZ1nCzqOFnUcbKo42RRx8mijpNFHSeLOk4WdZws6jhZ1HGyqONkUcfJoo6TRR0nizpOFnWcLOo4WdRxsqjjZE0dp0vne4eVI6Z7nRpC5M5e2bnX/Yr/tk10krbQisLeP/ZfuRlamqlle+S7+gOv1R+4W6+w9cODd7xbhR96r0Lf9Sr0XRu6A3QnyAdaCRoGGgEaDioG3QVqA00HFYDcoMdBT4AOg5pAT4LqQfeD+kDTQM+BngI9DyoBPQ16AfQM6FlJ3ZHr5D0pf+q8YhfoKtDVoN2gGtAe0F7QPlAdaCJoP+ga0AHQQdB8UBeoG9QAuhZ0HagHtBB0PSgJWgLygG4AvQHkBx0C3Qi6CbQFlADdDLoF9EbQraDbQLeD1oB6QXeAfKCVoDtBw0HTQSNAblAx6C5QG6gANAx0N+gwKAW6B3QEdC/oPtD9oAdAD4LSoIdAD4MeAT0Kegz0OOgJUBPoSdA00FOgp0HPgJ4F1YP6QM+BngeVgF4AjQSNAo0GjQGNA40HTQBNAk0BzQDNlNQd6flr/CZAl+D36kdeI18JvP5NQO/r3wT83jcB1+sLS3/0I/q4DcbjMuQNZYgtZYhCZYhCZYg7ZYgmZYgmZYgmZYhQZYgtZYhQZYg0ZYhlZfDlMvhyGaJQGVy6DP5aBl8ug4eWwUPL4Nll8PoyuHQZ4lUZPLsMTlyGGFGGOFAGdy8zzpgU7TuRXxzsPVfIdeBSCbMkXCZhgoTZEuZIuFzCVAlzJcyTMF/CNAmlEhZIuELCRRIWSlgkYbGEJRKWSvBIKJPglTBSgk/CMgl+CWMklEsISBgnYbyE5RJWSFgpYZWE1RKCEiokVEqYISEkYY2EKglrJYQlrJNQLaFGQkRCrYSxEqIS6iTUS5goYbKEKRLWS9ggoUHCdAmNEpokbJQwU8ImCc0SNksYJWG0hJiEuIQSCVskJCS0SNgqoVXCJAnbJLRJ2C6hXUKHhE4JOyTsFNAdueGQzWKKdVvNG17yj613OO0eh14jSZ7atMjZ3pdJ9qKTdZXo7GuxAUTnmhN1z87raV/v33bap2+p49Uz4VXlfze+2h+mvPZ/kPJn/x2K/tXJeD146Q9S/uffoXRHbnqN2NhfY9fan92rtC/+TL/mddPqfQ2b1qvyqptfsxeWnmVFrr/NK+z1C+uv/sK65c9+YUWnOM0qxX++S+w7avCjoj/9EtOXauX/0bXWpQbPvoYuuno1SMirLzpVn6aOotevw9fEdfjGQ7rwWBAZrVfJt+qLUuei39QHUV+dH9eDq/TJ0IOr1aBE//01+srQjwx+Ax3Dt4YxfMscw/egMXzLHMO3ojF8DxrDd6SG9oJuBu0HJUEHQfNB3aBbQdeCekC3gdaAFoKuBy0B+UArQXeCRoDcoGGg4aBi0F2gNtB0UAHocdAToMOgJtCToHrQ/aA+0DTQc6CnQM+DSkBPg14APQN6VlJ35LZDptfxJn1d3K6vi8GevU341wc24V8D2IR/fWAT7nq/CTdw34RboW/Cv0WwCfer32R+BdArfzObR69lHr2WefRa5tFrmUevZR69lnn0WubRa5lHr2UevZZ59Frm0WuZR69lHr2WefRa5tFrmUevZR69lnn0WubRa5lHr2UevZZ59Frm0WuZR69lHr2WefRa5tFrmUevZR69lnn0WubRa5lHr2UevZZ59Frm0WuZR69lHr2WefRa5tFrmUevZR69lnn0WubRa5lHr2UevZZ59Frm0WuZR69lHr2WefRa5tFrmUevZR69lnn0WubRa5lHr2UevZZ59Frm0WuZR69lHr2WefRa5tFrmUevZR69lnn0WubRa5lHr2UevZZ59Frm0WuZR69lHr2WefRa5tFrmUevZR69lnn0WubRa5lHr2UevZZ59Frm0WuZR69lHr2WefRa5tFrmUevZR69lnnTa3nHH26mjPxIDabpwaTeP19T5Z36gwcP6GEY2mFMu8OwjcM4gYdxAg/DKAydDxoLGgcaD5oAmgi6ADQJNBk0BTQVdCFoOmgG6CLQTNClkrojd71mCyuv11N6X6+n/GXWcboQ8IB+5C+4oLtb5okTimSeaOhS0CzQZaAJoNmgOaDLQVNBc0HzQPNB00CloAWgK0AXgRaCFoEWg5aAloI8oDKQFzQS5AMtA/lBY0DloABoHGg8aDloBWglaBVoNSgIqgBVgmaAQqA1oCrQWlAYtA5UDaoBRUC1oLGgKKgOVA+aCJoMmgJaD9oAagBNBzWCmkAbQTNBm0DNoM2gUaDRoBgoDioBbQElQC2graBW0CTQNlAbaDuoHdQB6gTtAO2U1B05rP1PW+/XdAAZrB4FMUGDMApDu0H7QXeA7gT5QCtBw0HFoLtAbaDpoAKQGzQMNAL0OOgJ0GFQE+hJUD3oflAfaBroOdBToOdBJaCnQS+AngE9K6k7kvoDGeX/lEj+UfnjS9PGV8gWX5ok/oHc8Jai3r9AbjiUEv6vMsGhBPAV8j6dLa4v7H3FBPDV5H2vJt3745K7v8ra/D3Gyswsr4JLGboVdAh0E2gNaCFoP+gO0J0gH2glyA0aDioG3QVqA00HFYCGgUaAHgc9AToMagI9CaoH3Q/qA00DPQd6CvQ8qAT0NOgF0DOgZyV1R478La+e9SrqydeX0X+7y+i/oOXeK1fPE51L7xLQpaBZoMtAE0CzQXNAl4OmguaC5oHmg6aBSkELQFeALgItBC0CLQYtAS0FeUBlIC9oJMgHWgbyg8aAykEB0DjQeNBy0ArQStAq0GpQEFQBqgTNAIVAa0BVoLWgMGgdqBpUA4qAakFjQVFQHageNBE0GTQFtB60AdQAmg5qBDWBNoJmgjaBmkGbQaNAo0ExUBxUAtoCSoBaQFtBraBJoG2gNtB2UDuoA9QJ2gHaKak7cp+8rcB25xVXge4AXQ3aDToEqgHtAd0I2gK6CbQXdDNoImg/6CBoPqgL1A26FXQt6HpQD+g20DWgNaCFoCRoCcgHWgm6EzQcNB3kBg0DFYPuArWBCkAjQI+DngA1gQ6DngTVg+4H9YGmgZ4DPQV6HlQCehr0AugZ0LOSuiP3//6NZCM79MMPyNtdluJ2l6W43WUpbndZittdluJ2l6W43WUpbndZittdluJ2l6W43WUpbndZittdluJ2l6W43WUpbndZittdluJ2l6W43WUpbndZittdluJ2l6Wm0eXB1+s4vX+BOs5LlyJ/3Ark1Sw89AJvp37N6wWdXrm6SNvfJEZcuqvsIfnvxdSgXaAG7QI1aBeoQbtADfo9atA8UIPmgRo0D9SgeaAGzQM1aB6oQfNADZoHatA8UIPmgRq0StSglaAGrQQ1aCWoQStBDVoJDF0MugR0KWgW6DLQbNAc0OWguaB5oPmgUtAC0BWghaBFoMWgJaClIA+oDOQF+UDLQH5QOSgAWg5aAVoJWgVaDQqCKkCVoBBoDagKtBYUBq0DVYNqQBFQLSgKqgPVg9aDNoAaQI2gJtBG0CZQM2gzKAaKg7aAEqAW0FZQK2gbqA20HdQO6gB1gnaAdkrqjjw8+I8ivNMadGSxM/kLIkGlb1ZPXKXDzg1qsFsPDqjBHj24RQ1SevAWNXiHHuxTgw/qwVvV4M2FwtnKkWyVI00qR5pUjjSpHGlSORKxciQ45UiaypE0lSMpLEfKVo4UsdykSY/I6BFE9AgiegQRPYKIHkFEjyCiRxDRI4joEUT0CCJ6BBE9gogeQUSPIKJHENEjiOgRRPQIInoEET2CiB5BRI8gokcQ0SOI6BFE9AgiegQRPYKIHkFEjyCiRxDRI4joEUT0CCJ6BBE9gogeQUSPIKJHENEjiOgRRPQIInoEET2CiB5BRI8gokcQ0SOI6BFE9AgiegQRPYKIHkFEjyCiRxDRI4joEUT0CCJ6BBE9gogeQUSPIKJHENEjiOgRRPQIInoEET2CiB5BRI8gokcQ0SOI6BFE9AgiegQRPYKIHkFEjyCiRxDRI4joEUT0CCJ6BBE9gogeQUSPIKJHENEjiOgRRPQIInoEET2CiB5BRI+giR6P/i1/Wfb6d2S95hvD21//suzPvZx9TF9Y+l46XfrxwbvrdEcel1+iuYqlpbrw4ylDa0HrQLWgWaDZoMmguaB5oPmgBlAjaCNoEWgxaCnIA2oGlYF8oDjID1oGCoASoBbQCtBWUCsoCNoJqgRtA3WAOkFrQKWgGlCVpO7IE/Iec78Sk8bApRJmSbhMwgQJsyXMkXC5hKkS5kqYJ2G+hGkSSiUskHCFhIskLJSwSMJiCUskLJXgkVAmwSthpASfhGUS/BLGSCiXEJAwTsJ4CcslrJCwUsIqCaslBCVUSKiUMENCSMIaCVUS1koIS1gnoVpCjYSIhFoJYyVEJdRJqJcwUcJkCVMkrJewQUKDhOkSGiU0SdgoYaaETRKaJWyWMErCaAkxCXEJJRK2SEhIaJGwVUKrhEkStklok7BdQruEDgmdEnZI2CmgO/Kk/PeesvJIZOWRyMqryIHzJZRIGCthnITxEiZImCjhAgmTJEyWMEXCVAnTJFwoYbqEGRIukjBTwsUSLpFwqYRZEi6TMFvCHAmXS5grYZ6E+RJKJSyQcIWEhRIWSVgsYYmEpRI8EsokeCX4/h979x4fd3nnh16yTQHjC2MmZiA2k/EAYkZiGA/CMiADFuZmeWzGM8bY4yvYuCFASIJIyAaBBBFMIAnEJE64Dpdqd9tdtXvco54tLSo9Pa26Obpk2+5uvZuqdM+23bZJ9tJquz3t2aPfDFKe94ts9t7Ndp1/Mm9ZviD95vP9Pt/n+f0UoivExhBXh7gmxLUhukNsCnFdiOtD3BBic4ieEDeG2BLiphA3h7glxK0hbguxNURviG0hiiG2h9gR4vYQpRA7Q5RDVELsCnFHiN0h7gyxJ8TeENUQ+0LsD3EgxMEQh0IcDnFXiLtDHAlxNMQ9IY4F6Ot9pfmzQxofKu5ptGQvoyy6EOXQBvQoegU9g15FZ6BN6Gm0GL2GWlAdnYm2oLPRDvQgeh69js5Ca1AFvYHeRI+hlegtVEOH0RPoJfQiehI9Faqv99XoOnl0bq135aLGH9pS/JeLg39jDydsejjx0sOJlx7ODPVwaqeHs0Y9nHHp4TRMD6dhejjV0sPplB7OxvRw4qWHEy89nHjp4RRND+dfejhT08P5lx7Ov/Rw4qWH0zA9nH/p4fxLD+dfejj/0sP5lx7Ov/Rw/qWH8y89nH/p4fxLD+dfejj/0sP5l57m+ZfXwn2IHPsQOfYhcuxD5NiHyLEPkWMfIsc+RI59iBz7EDn2IXLsQ+TYh8ixD5FjHyLHPkSOfYgc+xA59iFy7EPk2IfIsQ+RYx8ixz5Ejn2IHPsQOfYhcuxD5NiHyLEPkWMfIsc+RI59iBz7EDn2IXLsQ+TYh8ixD5FjHyLHPkSOfYgc+xA59iFy7EPk2IfIsQ+RYx8ixz5Ejn2IHPsQOfYhcuxD5NiHyLEPkWMfIsc+RI59iBz7EDn2IXLsQ+TYh8ixD5FjHyLHPkSOfYgc+xA59iFy7EPk2IfIsQ+RYx8ixz5Ejn2IHPsQOfYhcuxD5NiHyLEPkWMfIsc+RI59iBz7EDn2IXLsQ+TYh8ixD5FjHyLHPkSOfYgc+xA59iFy7EPk2IfIsQ+Ra+5D1MOkjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRkjKWMkZYykjJGUMZIyRlLGSMoYSRlrJuXr4QbShxaF7/qm1qE0uhidhy5Bl6I2dAG6DGVQFl2I2lEHuhxdhHLoCpRH61EBXYk60VVoKdqAutBGtBxdja5BMbQKXYu60SZ0Hboe3YA2ox60Ft2ItqCb0M3oFnQrug1tRb1oGzoXFdF2tAPF0fkogW5HJbQTrUFlVEG7UBLdgXajO9E5aBnag/ailaiK9qH96AA6iFajQ+gwugvdjY6go+gedCxUX+8bYacYp1OM0ynG6RTjdIpxOsU4nWKcTjFOpxinU4zTKcbpFON0inE6xTidYpxOMU6nGKdTjNMpxukU43SKcTrFOJ1inE4xTqcYp1OM0ynG6RTjdIpxOsU4nWKcTjFOpxinU4zTKcbpFON0inE6xTidYpxOMU6nGKdTjNMpxukU43SKcTrFOJ1inE4xTqcYp1OM0ynG6RTjdIpxOsU4nWKcTjFOpxinU4zTKcbpFON0inE6xTidYpxOMU6nGKdTjNMpxukU43SKcTrFOJ1inE4xTqcYp1OM0ynG6RTjdIpxOsU4nWKcTjFOpxinU4zTKcbpFON0inE6xTidYpxOMU6nGKdTjNMpxukU43SKcTrFeLNTfPPR5k/zKi2K7qh5K3xgyhbmy009gR5Fj6EtKIceRE+hp9EGtAmdgc5Ci1ENHUZrUAs6E52NXkQvoWdQBb2MdqDn0evoQvQGegW9iVaiV9Fb6DVUD9XX+9fCFcUBjqQd4EjaAY6kHeBI2gGOpB3gSNoBjqQd4EjaAY6kHeBI2gH21g5wJO0AR9IOcCTtAEfSDnAkran1qICuRLtRJ9qA9qKNqAtV0T50DdqPutEBdBDdgI6hzagHHUJH0FG0BbWjreimUH29w9HVFp1Q/bloa2z+dvq/2rgwP4ruRR9D96Gt6H70ANqO4uhB9CmURQ+hPvQw+jT6DMqhR9Bn0Xr0OfQo6kePoSp6HA2iJ9CT6BNoCxpCT6ENaBN6Gp2F1qCz0RloMaqhw6gFnYleRC+hCnoGvYwuRK+gV9FrqI52oOfR6+gN9CZaid4K1df7449G/yEtvY9HPcJPRO/N6Naxn238x7YUR6J97F+ee3F0UeMN0lJsm3vXFj8c/ZiawUWN71xL8f73b+4v/tT7Nwo0b/ePWo97G2eef/L9RuTHG43IX5//caNLW4PLYrbZs/yN6Bdfm/vFFxY1vlItxS8vanypW4pfaPxZPxX+uIktxNsWitUWCktTD6Fr0DZ0CdqF0mgrmr96Pt4aXiEfp1H9ePM/9aej/5L5LylPSWh+IaMv+yPzX8jX57/YDza+CiNzv7f5XfjH798i0fiWLfwhC9+7hT9/4Y+d+0N6lzf/1N49zb+mt/HjXv9muLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOsLBOkFcJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtYJFtaJZnL/rSgpo6I5O/RCo1jVGqH8M6fvpRv6y30v3f/MW+ii+/b2LBn6y3Av3f/2fv94oNE/ngzHFasWhTW3qXUojS5G56FL0KWoDV2ALkMZlEUXonbUgS5HF6EcugLl0XpUQFeiTnQVWoo2oC60ES1HV6NrUAytQteibrQJXYeuRzegzagHrUU3oi3oJnQzugXdim5DW1Ev2obORUW0He1AcXQ+SqDbUQntRGtQGVXQLpREd6Dd6E50DlqG9qC9aCWqon1oPzqADqLV6BA6jO5Cd6Mj6Ci6Bx0L1df7t6O135po7VeL1uJro1eFuUJQvCh6tbXRivzv4aMqX2n8KR9FH0P3ofvRy+jj6JPoUyiLLkQPo0+jz6AcegStR1eiH0Mb0OfQRvQoegU9g15FZ6BN6Gk0iBajFvQaqqNPoC3oTDSEzkb3ogfQdrQDxdGD6Hn0OjoLPYT60E60BlXQG+iz6E3Ujx5DVbQPrUSPowH0Fqqhw+gJ9BJ6ET2JPo+2oqfQUnQOWoaWoxhahc5Dq1ECrUVJ9Cz6IvoS+jJ6AX0VfQN9AT2HvoKOo6+hE+jrofp6R6OEfWoucJ9fFFxM3bwdu4mwbt4s3URDNzHVTYh089bpJja6udC6udC6eet0EzDdhFY3sdFNUHRzSXZzuXYTi928ObspHt2ESDdB0U1QdFMuunmLdxPK3bzFu3mrdhPR3bw5uwnXbsK1u/nN/TvNh3c0P9bK17iV71Qr/9pW/n2t/Ita+Qq08lVtbf6t/0c4gE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE0zgE03B7A/Oz9pbZkrvsVktO55hXHiB6akD0VTt9a5T/5I9Mm/09pI35biovnR5dXRH5SKfq2VoeHCkG5hmLUwA/3gz1CeH1319f7dMMpTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp4jyFFGeIspTRHmKKE8R5SmiPEWUp5pR/vb7s/3rW6PZ/t8Lc7ON3GwjN9vIzTZys43cbCM328jNNnKzjdxsIzfbyM02crON3GwjN9vIzTZys43cbCM328jNNnKzjdxsIzfbyM02crON3GwjN9vIzTZys43cbCM328jNNnKzjdxsIzfbyM02crON3GwjN9vIzTZys43cbCM328jNNnKzjdxsIzfbyM02crON3GwjN9vIzTZys43cbCM328jNNnKzjdxsIzfbyM02crON3GwjN9vIzTZys43cbCM328jNNnKzjdxsIzfbyM02crON3GwjN9vIzTZys43cbCM328jNNnKzjdxsIzfbyM02crON3GwjN9vIzTZys43cbCM328jNNnKzjdxsa+bm3w+TMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWGpMyQlBmSMkNSZkjKDEmZISkzJGWmmZTvhEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMktSZknKLEmZJSmzJGWWpMySlFmSMttMyrHmnRnNj+V5tGS+efPWP3h/tf5q4yTeu2GylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC2RrCWStUSylkjWEslaIllLJGuJZC01k/UfhklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSskxSlknKMklZJinLJGWZpCyTlGWSstxMyv8zSsro1tcvcfvqB2+PjW6GfWv+9ti/1th1/0fR751PhXHe3ePk1Tjv9XHe6+O8Z8d5z47znh3n/TXOe2icPB7nHTXOO2qcd9Q475px0nKcd8Y474xx3hnjvBfGeS+Mc72PU0XGud7HqRTjVINxqsE4V/84V/g4qT7ONT1OJRynvo1zFY9zFY9zbY5zNY5zxY1zxY1TU8apKeNUkXGqyDgVdJyaMk5NGadSjFMXx6kU41SKcSrhONVgnGowTjUYpxqMUw2aWoo2oI1oOboarULXoevRMbQZ9aAb0S2oFxXRDnQ72onWoDLahe5Ad6JlaA/ai/ajA+ggWo0Oo7vREdSOtobq6/2/wi6zm/dWN/8l3Xy/m1qBVqJzUQytQuehOPoQWo3ORwl0AboQfRitQWvRRSiJPoJSaB1Ko4vRJehS1IYuQxmURe2oA12OcugKlEfrUQFdiTrRVWgD6kIb0dXoGnQt6kab0HXoenQD2ox60I1oC7oJ3YxuQbei29BW1Iu2oSLajnag21EJ7URlVEG70B1oN7oT7UF7URXtQ/vRAXQQHUKH0V3obnQEHUX3oGOh+nr/cZSU8yc5i+uic5/DP/Dc6N+d+/9vDv2gw54fPCK6cOfywjHU+UOjfb3/5P3B6ceXRIPT8fmn3HwsuoE7esrN/dGL6KE4bY1nsfzTMMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ0nyJEmeJMmTJHmSJE+S5EmSPEmSJ5tJ/nNRUn47mgXMP9/kl+eHAm/ODw5ao/uk01HI/7XG8yS+Gf2el6JnWjR/NnPjD+z9ZvDdaqCv9/9+NPpIS/G1xnbXRPTbls9xfFEj2VqKTy5uBHNL8bcXN5KopbgkyvFfm3vxS9FH/m10Q/aSRiS3FK9Z0sjtlmIlevFLcy9KSxpp1lLMLRlqPh3lJ5c0kneuaixpxGxL8b9Ftyr8u7kXG6O/9N/PvTg3evHrcy82Ry/+c/SRJY1sbSleuqQRnS3FT0Qv/sPci6eiF/8xej7JkkaOthR/ekkjeluK34he/KdoMy+6efzi6MtzT/Sh7869+Gb0oUuiD/2d6EPfm3vx95c0CkZL8XPRi9+Ye/Gt6MVvzr34hejFv4xmNtGL34q+zksadaGl+O6SRvFoKY4tbtSiluL26F/923Mv7oheLI2+iosaxWfur49enDv34oFF3y8IvT/T+FZMzj817icWBd+mf9r4tano1/5L9G9c/P5/2xcbRXc6rPIfrO1/mJoe1f8bh35QbY/uKPlH3BnyX6MZVfPOkuYl+u+a9/V9K7wZ//HGnX8fRfeij6H70FZ0P3oAfRxtR3H0IPoE+iT6FMqih1Af2okeRp9Gn0E59Aj6LFqPrkQ/hj6HNqJHUT96DFXRPvQ4GkCD6An0JPo82oKG0FNoA9qEnkZnoTXobHQGWoxq6DBqQWeiZ9EX0ZfQl9Hz6AX0VfQN9AX0DHoOfQUdR19DJ9DX0YvoJVRBL6ML0SvoVfQaqqMd6P17q7/a0tLaEv3v/Q+/wSe9iVait9BSdA5ahpajGFqFzkOrUQKtRclQfb0///4DTBtNQLPkH5pvB56afzrpm9GvXRr92lONduCfRb9p4xx/5v3nWPXmh5rP1Lxh7v9/fO4X7m1t5EhL8b7WRijOrddaG+/tluKz0YufmHsx0tpI3bki1NoIwJbi9VHt+8m5Fz/eWNP98z/cX/Pc3IuHWhvvgrn1IX/xF6KHZfEv+PLci59tHWo+IPWnoxf/KiqRrY231Nx/aWvjfdBS/Bv8c7829+Lv/uB/91ejUt3aeBfMfXlag/+AuXdeS/FkdAtlW/Sle7C1ccm3FB9pbbybW4pDrY23S0vxk62N98ZcF9LaeIu2FP9e4wvwL8I6OEUdnKIOTlEHp6iDU9TBKergFHVwijo4RR2cog5OUQenqINT1MEp6uAUdXCKOjhFHZyiDk5RB6eog1PUwSnq4BR1cIo6OEUdnKIOTlEHp6iDU9TBKergFHVwijo4RR2cog5OUQenqINT1MEp6uAUdXCKOjhFHZyiDk5RB6eog1PUwSnq4BR1cIo6OEUdnKIOTlEHp6iDU9TBKergFHVwiro0RV2aokZOUSOnqJFT1Mgp6tkUFXOK6jZFdZuimk5RTaeofFNUvikq3xR1d4o6OEUdnKIOTlEHp6iDU9TBKergFHVwijo4RR2cCuvg+3oDvYlWorfQUnQOWoaWoxhahc5Dq1ECrUXJUH29vxAm7CAJO0jCDpKwgyTsIAk7SMIOkrCDJOwgCTtIwg6SsIMk7CAJO0jCDpKwgyTsIAk7SMIOkrCDJOwgCTtIwg6SsIMk7CAJO0jCDpKwgyTsIAk7SMIOkrCDJOwgCTtIwg6SsIMk7CAJO0jCDpKwgyTsIAk7SMIOkrCDJOwgCTtIwg6SsIMk7CAJO0jCDpKwgyTsIAk7SMIOkrCDpOggKTpIig6SooPk5iDZOEg2DpJ4gyT6IIk+SDIPksWDZPEgeTtI3g6St4Mk7CAJO0jCDpKwgyTsIAk7SMIOkrCDJOwgCTtIwg6SsIMk7CAJO0jCDpKwgyTsIAk7SMIOkrCDJOwgCTtIwg6SsIMk7CAJO9hM2F9sjg6bH/v11vDr31QNPYXOQM+gHNoRqq/3l+YHXB9fNBQOuP5l9PH5P/XpxeG7q6nDaAd6MVRf76noz4qeiTK4uPGf0dL7u9GHf3n+w+v48K+ElWaASjNApRmg0gxQaQaoNANUmgEqzQCVZoBKM0ClGaDSDFBpBqg0A1SaASrNAJVmgEozQKUZoNIMUGkGqDQDVJoBKs0AlWaASjNApRmg0gxQaQaoNANUmgEqzQCVZoBKM0ClGaDSDFBpBqg0A1SaASrNAJVmgEozQKUZoNIMUGkGqDQDVJoBKs0AlWaASjNApRmg0gxQaQaoNANUmgEqzQCVZoBKM0ClGaDSDFBpBqg0A1SaASrNAJVmgEozQKUZoNIMUGkGqDQDVJoBKs0AlWaASjNApRmg0gxQaQaoNANUmgEqzQCVZoBKM0ClGaDSDFBpBqg0A1SaASrNAJVmgEozQKUZoNIMUGkGqDQDVJoBKs0AlWaASjPQrDTfDhP2BAl7gkw9QaaeIEVP8N04QYqeIA1PkIYnSMMTfBdPkHgnSLwTJN4JEu8EiXeCjDtBxp0g406QASdIvBMk3gkS7wRX2wneIye49k6QCCdImROkzAkS7wTZcYJ8OMH1fILr+QRV6QRpeIJcOUE2niDHmroXPYC2ox0ojh5Ez6PX0VnoIdSHdqI1qILeQJ9Fb6J+9Biqon1oJXocDaC3UA0dRk+gl9CL6En0ebQVPYWWonPQMrQcxdAqdB5ajRJoLUqiZ9EX0ZfQl9EL6KvoG+gL6Dn0FXQcfQ2dQF8P1df7r+a3lFfOPw4w0ZhTz4TJuzrqjouXtYZcCOKm7kWfRx9D96H70QPo42g7iqMH0SfRp1AWPYT60E70MPo0+gzKoUfQZ9F6dCX6MfQ5tBE9ivrRY6iK9qEh9DgaQIPoCfQk+gTagraip9AGtAk9jc5Ca9AZ6Ey0GNXQYdSCzkZfQM+glehZ9EX0JfRltAM9h55HX0HH0Qvoq+hr6AS6EH0dfQNV0IvoJfQyegW9il5DdfQ6egO9id5CMbQWJVASnYPOQ0vRcrQKLUOrQ/X1/utm4LYUX2ltxE1L79WNN2JL8R+2NnKkpdi+qBGYLcXcoqHm7urSRY1QaSleEG3nZqI9yYkljRRoKX6ztRFNLcUzFjVSsKX4841kf29+mLF7SZCVQzSfQzSfQ7QIQ7SbQ7TTQ82i8m/mi0rbfFH5Z41Rza+GP7XobU6nvs3p1Lc5nfo2p1Pf5mTu25xVfZuzqm9zVvVtTt++zcnVtzm5+jYnV9/mnO7bnGN9m3Osb3OO9W3O6b7NgOttTrW+zanWtznV+janWt/mVOvbnGp9m1OtTS1FG1AX2oiWo6vRNSiGVqFrUTfahK5D16Mb0GbUg9aiG9EWdBO6Gd2CbkW3oa2oF21D56Ii2o52oDg6HyXQ7aiEdqI1qIwqaBdKojvQbnQnOgctQ3vQXrQSVdE+tB8dQAfRanQIHUZ3obvREXQU3YOOherr/X/e/5mJxbVRLs43KPfThNzfLAe/1kzp5seKfEaR9qbY/Px/G/1ApJVRAfixKNYXfpRg9GPwbo1eREc190cnWrPRJ7W3DgU/0W7hZ9wt/HDChR+aF/04vn8dvfipuRcvNI4K/bvonzb/1arRedWo/zX+oTW64xr9Ta35H/Hvw42FGTYWZthYmGFjYYaNhRk2FmbI3RneYzPN78qvz9+I8lHvP/kP4cbCQ3wLHmr+e/9j9BnRzdhTS4a+f3t2X+9/+nM+c/sTzDN+olmUvxN+cb/NF/fbfHG/zRf323xxv80X99t8cb/NF/fbzS/ud+d/REw8+gfO//WT/PWT/PWT/IWT/IWT/IWT/IWTzb/we+HCtcbIsMbIsMbIsMbIsMbIsEaPU2NkWGNkWGNkWGNkWGNkWGNkWGNkWGNkWGNkWGNkWKNrq9G11RgZ1hgZ1ujhaowMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa7zFaowMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa6wHaowMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa4wMa81C8htha7KK1fkq1uOrqJmrmjXzN8OqepTPONr8jN96f/XY2zfUXDz+w0ZR/e0/gxPKC+d6o8X0Tzf+mv/8I/sDrKPG8Rejj/yRfpJ19COSvxt95PSPtB76i/Ajrf/X/0nW/yV6h833TzuZfe9sJsDsD++ff2fu/399qNn3vveDfwrRn6ih7uv9nUebb7euxg/k+K9h5/weret7tK7v0Tm/RyP7Ho3sezSy79HIvtdsZH/3T76I+P1vxm+8rzONZc5/CwP51/jv+TX+W3+t+e/6f8MHpO5gGbej+e377/NJ/eD8zafb5zPl89EKdGm0At3A6vSDgbFwsc8vPBf+yxe+FFH8nQiv7OKy6E9+ObzGiyuiD70avWqsjiejV+dGr6YXvx8wP7/4B33xirHok/7F4ve/Vj8X/cOXRx9a3hp8HYurog/94uIgRIvnRR86tfj9ZPuVxcH3aG4VNPfq29G/4ey5V72/HHyTih+Kfm2GQJ1ffff1/o/wGvwe35fv8T37Htfg97gGv8c1+D2uwe9xDX6v+b3+//6cF7LDdNnDzf7j98IL8N/yz26or9jS+iNbxP9Itfsvc8mO+pZLol86XbuHflRq90KQfJy+vaG+YmvjXZeb+9y9S4LP/Rbr2G+xIvwWK+xvsQZsqK+4KPpTm8kba22+U39AXdm9+AfXlR9STv4Uq8f3a8X368EPKANB+v+wrC8ubm2W5Jbiv1o01JxIfjtqS4pLWsNafRffhLua34QzGl+u86Picqj5e3v/81Cjmel9tPFNmVv5NP6sv9L6+1fpP8ZXMwrbZUv+zL6s7dGr1a1/ki9w8xpqXcKX+swflUoRxd0Zi4Pv2AdKR+ObWoz/aRaR6Go4P+xd/petJqeLyNCPShHpK57VeNNF77V/sjh4Z0WPjvlHi8O31ML7Jioqfz36yNXRVRS9WHiGzMJ74ca5F38rep90RO+Tvx19aOEhMguX9UIftvB4moXr+64oklrDq/me6PqOPjL/oJni5dEf/fXoQ9GTZgZbf+Alv3ClRw+h+XRreKVH7/JvtAYpsnDJzr+Bi7nor3g8+tBVcy8ei150RF/m1jBQKnMv6jRHC0/QiR5B81r0B13ReKBb9GsLD6xZeOMvXMYLV+/C9Rw95uZvtobZ8m/mXjwXfeRw9F2IXlw89+Kl6MXCY24Wngh0x9yLgeiXFh5z80Mu2oVr9fboD1wUXqsLl+jCI4YW3owL1+rClblwQRbnXjzN5bcQ5LdF/8nRRxYSfT7B35v7wJ7oAwsJHt1c9Hb0YiGn75x78Q/o6Nuiyze6JvLR1/mfRh9aSNGFhJzPzOL66JP+efRr808vKhaiD/1C9KGFzP5DhFzxyui3/Vr0oevnXnxvUZBpxc7o134z+tDCE4kWHnu0UGkWwnHh0UTzGVS8Kvr9s9GvrZt78buLwuxZCJjL514sosBviH5b96IgNIpd0YeWkBrb5178lcU/KCyKG6PPXhb9vqujVyuiz5ovldGTmM4NK1LxmkYvGH32tdGr86JX3Y3+IPq06CkXCZqVhYJz6dyLC+cbjEZVWXgW1PwjoL5fDT6Y4gvh/cGEXojzhdC9e+7FxdGL6AFUHdGL+WQtbor+rfnoQws1+oOd9kJLsvBkrYW2YqGOL1T2hUL8+1fS4nXR33p79KGForhQAj9Q+YrXR5+9J3p1Q/Rqb/RZC0VwodJFj+Q6FH3S5uiT7gpLXbEn+tBRKtvCI7D+ME++WihNC0Vm/lDLN1nyf7O55D/7R6WR+19syR9VrEr0S6e7taG/nN3a0tbw1Galsei8BaXQzehW1Iu2oTS6BJ2PLkMZlEU7URntQlegPFqPCuhKtBt1oj1oA9qLNqIuVEX70DXoWrQfdaPr0EF0AN2AjqHNqAcdQkfQUbQFtaOt6KZQfcVzWsPHBd/J0cM7OXp4J0dcm1qBVqJzUQytQuehOPoQWo3ORwl0AboQfRitQWvRRSiJPoJSaB1Ko4vRJehS1IYuQxmURe2oA12OcugKlEfrUQFdiTrRVWgD6kIb0dXoGnQt6kab0HXoenQD2ox60I1oC7oJ3YxuQbei29BW1Iu2oSLajnag21EJ7URlVEG70B1oN7oT7UF7URXtQ/vRAXQQHUKH0V3obnQEHUX3oGOh+orLWsMzknXOSNY5I1nnjGSdM5J1zkjWOSNZ54xknTOSdc5I1jkjWeeMZJ0zknXOSNY5I1nnjGSdM5J1zkjWOSNZ54xknTOSdc5I1jkjWeeMZJ0zknXOSNY5I1nnjGSdM5J1zkjWOSNZ54xknTOSdc5I1jkjWeeMZJ0zknXOSNY5I1nnjGSdM5J1zkjW2cGpc0ayzu5tnTOSdc5I1jkjWeeMZJ0zknXOSNbZW6pzRrLOGck6ZyTrnJGsc0ayzhnJOmck65yRrHNGss4ZyTpnJOuckaxzRrLOjlidM5J1zkjW2R+rc0ayzhnJOmck65yRrHNGss4ZyTpnJOuckaxzRrLOGck6ZyTrnJGsc0ayzhnJOmck65yRrHNGss4ZyTpnJOuckaxzRrLOGck6ZyTrnJGsc0ayzhnJOmck65yRrHNGst7ctVzeGh6S/A1OaPxGM4VXtIabeb/KNfGrfKd/lffRr/KO+9Xm37ey9X/OmZvGsZXixvn58F/U0zd/uEM3c//ScOnbzdK3m6VvN0vfbpa33Sxvu1nedrO87WZ5283ytpslbDdL2G6WsN0sYbtZtHazaO1m0drNorWbZWo3y9RulqndLFO7WYp2s/jsZvHZzQKzm8VnN8vNbpaU3Swpu1lSdrOk7GYR2c2itZtFZHdzERnjbfvbvG1/u/m2XdX4lPmi/VdZDTT1INoUqm/u8jw9pxw6vZn8ZzyejKa2V/8lm1PGW5vPPW++3bYRrNuImm1E2zZidhuRsY3Y20bsbSNqthHr2wi6bc1w+VDjHxjtT31m8VDzWM+Fi6JfWE3qbOdYz3buodze/JPOb/yG+Xb5+canLEYt6Ax0Jjo7VF8x0RoeNP0OB02/Qx5+h4Om3+Gg6Xc4aPodRjTfYYn/nWYsXkAz9DG+BB9r/ssu5Kv0W/xbfqv5p3yYev3fF4X1uqkUuhndinrRNpRGl6Dz0VnoMpRBWbQTldEudAXKo/WogK5Eu1En2oM2oL1oI+pCVbQPXYOuRfvRGagbXYcOogPoBnQMnYk2ox50CC1GR9BR1IK2oHa0Fd2Ezg7VV1zTGo6/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q4y/q2RrlfF3lfF3lfF3lfF3lfF3lfF3lfF3lYa3yvi7yvi7yvi7yvi7yvi7yvi7SttcZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdZfxdpTZWGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9XGX9Xm13C2tbTS7Ch00uwP2gJFq2hLjh9VOSPcXfIfbTv9zXb94tawzXLc6xZnmPN8hxrludYszzHmuW55h+dbA3vCPvworBT+DAz+g8zO21qE3oFbQjVV/xIa7hK+QT/mZ9o/ltSrQx+mer+BnPcpl5Dr4bqK65rDR+184XFYZvT1IvoDJRDO0L1FdOt4RjrHqr6PYyx7qEe39PM0Isbvz36saCjzTdE81efZUT6LCPSZxmRPsvpoGc5HfQs49NnGZ8+yzr7WVb5zzI+fZZ1/bOcDmrqIbQTldEudAXKo/WogK5Eu1En2oM2oL1oI+pCVbQPXYOuRftRN7oOHUQH0A3oGNqMetAhdAQdRVtQO9qKbgrVV7yE9/EDvI8faH7Kpa3hHvkvNN6dH0X3oo+h+9BWdD96AH0cbUdx9CD6BPok+hTKoodQH9qJHkafRp9BOfQI+ixaj65EP4Y+hzaiR1E/egxV0T70OBpAg+gJ9CT6PNqChtBTaAPahJ5GZ6E16Gx0BlqMaugwakFnoi+gZ9Cz6IvoS+jL6Dn0PPoKOo5eQF9FX0Mn0NfRN9CL6CVUQS+jC9Er6FX0GqqjHeh19AZ6E61Eb6Gl6By0DC1HMbQKnYdWowRai5Kh+optrX8+TxfoK17WGjaMa/gWruFLuoZvzBrenmv4Zq/hjbym+Z+YmVPjZ4YenuuPP1XMUlRmKCozFJUZisoMRWWGojJDUZmhqMxQVGYoKjMUlRmKygxFZYaiMkNRmaGozFBUZigqMxSVGYrKDEVlhqIyQ1GZoajMUFRmKCozFJUZisoMRWWGojJDUZmhqMxQVGYoKjMUlRmKygxFZYaiMkNRmaGozFBUZigqMxSVGYrKDNfiDFftDEVlhqIyQ1GZoajMUFRmKCozFJUZisoMRWWGojJDUZmhqMxQVGYoKjMUlRmKygxFZYaiMkNRmaGozFBUZigqMxSVGYrKDEVlhqIyQ1GZoajMUFRmKCozJNIMOTNDUZmhqMxQVGbIrhmKygxFZYaiMkMCzlBUZigqMxSVGYrKDEVlhqIyQ1GZoajMUFRmKCozFJUZispMM3HbifbbWfre3mztOxqfMv/f9wU2Fr7AALappegctAwtRyvQuSiGVqHzUBx9CK1G56MEugB9GK1Ba9FFKInWheorXs6XtWdx+GXt4fvQ0/w+5FrDVdhBVmEHm59yReNT5v+B7xEz7xEz73Gxv9e8GPLRby+eET0M497GRdzS+8DQ96cVo+z4jPIfNcqOzyg7PqN8m0bZ/xll/2eU/Z9RvhWj7AaNshs0ym7QKJfoKHtDo+wNjbI3NMq3cJSdolF2ikbZKRplp2iUnaJRdopG2SkaZadolDfPKBOmUfaNRtk3GuWtNMou0ii7SKO8lUZ5K42ywzTKDtMoE61RdphG2WEaZYdplB2mUXaYRnnzjLLfNMp+0yj7TaPsN42y3zTKftMo+02j7DeNst80yn7TKPEzyu7TKLtPo4TfKPEzSsSMEjGj7FONsk81yj7VKIEzyq7VKLtWo+xajRI/o+xhjbKHNcoe1iiRPUpkj7K/Ncr+VlMrURXtQ/vRAXQQrUaH0GF0F7obHUFH0T3oWKi+4vrWcAUywQpkghXIBCuQCVYgE6xAJliBTLACmWAFMsEKZIIVyAQrkAlWIBOsQCZYgUywAplgBTLBCmSCFcgEK5AJViATrEAmWIFMsAKZYAUywQpkghXIBCuQCVYgE6xAJliBTLACmWAFMsEKZIIVyAQrkAlWIBOsQCZYgUywAplgBTLBCmSCFcgEK5AJViATrEAmWIFMsAKZYAUywQpkghXIBCuQCVqDCVqDCVYgE6xAJliBTLACmWAFMsEKZIIVyAQrkAlWIBOsQCZYgUywAplgBTLBCmSCFcgEK5AJViATrEAmWIFMsAKZYAUywQpkghXIBCuQCVYgE6xAJliBTNCUTbACmWAFMsEKZIIVyAQrkAlWIBOsQCZYgUywAplgBTLBCmSCFcgEK5AJViATrEAmWIFMNJvOQmt4CHGEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOEHnOk2WNe2Rr2mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNP0mNPNHrOTiJ0lYmeJ2FkidpaInSViZ4nYWSJ2loidJWJnidhZInaWiJ0lYmeJ2FkidpaInSViZ4nYWSJ2loidJWJnidhZInaWiJ0lYmeJ2FkidpaInSViZ4nYWSJ2loidJWJnidhZInaWiJ0lYmeJ2FkidpaInSViZ4nYWSJ2loidJWJnidhZInaWiJ0lYmeJ2FkidpaInSViZ4nYWSJ2loidJWJnidhZInaWiJ0lYmeJ2FkidpaInSViZ4nYWSJ2loidJWJnidhZInaWiJ0lYmeJ2FkidpaInSViZ4nYWSJ2loidJWJnidhZInaWiJ0lYmeJ2FkidpaInSViZ4nYWSJ2loidJWJnidhZInaWiJ0lYmebEXsVEXuKiD1FqJ4iVE8Ro6f4dpwiRk8Rh6eIw1PE4Sm+jaeIvFNE3iki7xSRd4rIO0XInSLkThFypwiBU0TeKSLvFJF3isvtFG/KU1x8p4iEU8TMKWLmFJF3ivA4RUCc4oI+xQV9irJ0ijg8RbCcIhxPEWRN3YseQNvRDhRHD6Ln0evoLPQQ6kM70RpUQW+gz6I3UT96DFXRPrQSPY4G0Fuohg6jJ9BL6EX0JPo82oqeQl9Az6Ivoi+hL6Pn0FfQcfQC+ir6GjqBvo6+gZaic9AytBzF0Cp0HlqNEmgtSobqK25oRGxLb0vx/uj2kehJLN+KDuotmnvxD5Y03tktxWeiX1oS3WPUvMWkpfiz0ef8lbkXzy9uvFNbip9f3HhjtBSfWNx4f7YUr2k8EqCr9fSD5n9UHzRfvDH6bdtOP3L+9CPn/+iPnD/9oPk/4YPmm8/svyr60OlHzvf+fo+c75u7YOZ/GO3vDjV/GG25cYL86sbH5zfyTrIFd5ItuJNswZ1kC+4k22Un2S47yXbZSTazTrJFdZItqpNsSp1kU+okm1In2Xg6yebSSbaTTrKddJLtpJNsIJ1kA+kkm0Qn2SQ6ybbQSTaCTrIRdJKNoJNs/ZxkQ+ckWzgn2bQ5yTbNSTZfTrL5cpLNl5Nsopxk2+QkWyMn2Rpp6iMohdLoYnQeugRdirLoQtSBLkcXofWogK5EnegqtBRtQBvRcnQ1WoWuQ9ejY2gz6kE3oltQLyqiHeh2tBOtQWW0C92B7kTL0B60F+1HB9BBtBodRnejI6gdbUW/F6pvrlJGB223tL7/0Ue5bbWh4k38YnEJ7JursOGpiZ/m7dLUOpRGF6Pz0CXoUtSGLkCXoQzKogtRO+pAl6OLUA5dgfJoPSqgK1EnugotRRtQF9qIlqOr0TUohlaha1E32oSuQ9ejG9Bm1IPWohvRFnQTuhndgm5Ft6GtqBdtQ+eiItqOdqA4Oh8l0O2ohHaiNaiMKmgXSqI70G50JzoHLUN70F60ElXRPrQfHUAH0Wp0CB1Gd6G70RF0FN2DjoXqm1tYRAH4S1HjGq1lo9X1Da2Nb3pL8ezFQ8HqNloqfmNJ9Hs2EZorCM0VhOYKQnMFobmC0FxBaK4gNFcQmisIzRWE5gpCcwWhuYLQXEForiA0VxCaKwjNFYTmCkJzBaG5gtBcQWiuIDRXEJorCM0VhOYKQnMFobmC0FxBaK4gNFcQmisIzRWE5gpCcwWhuYLQXEFoNvUhdD26AW1GPWgtuhFtQTehm9Et6FZ0G9qKVqBetA2di4poO9qB4uh8lEC3oxLaidagMqqgXSiJ7kC70Z3oHLQM7UF70UpURfvQfnQAHUSr0SF0GN2F7kZH0FH0YXQPOhaqr3hd6+mHfg0158KPhWPC00//Ov3z4f5kz12+vjV88ug6YmgdMbSOUriOWF9HDK0jyNdRGNdRGNfRvKwjyNdR/NYRSusI+XWE/Doam3W0K+sInnWE/DrK5DralXXEelMfQSm0DqXRxegSdClqQ5ehDMqidtSBLkc5dAXKo/WogK5EnegqtAF1oY3oanQNuhZ1o03oOnQ9ugFtRj3oRrQF3YRuRregW9FtaCvqRdtQEW1HO9DtqIR2ojKqoF3oDrQb3Yn2oL2oivah/egAOogOocPoLnQ3OoKOonvQsVB9cwu68Bb5zdwiv5lb5Dc3p2KbW8OnCcYan1JHb6BaqL5iT2u4PlxOzCwnZpYTM8uJmeVE7HJCZzmhs5zQWU6MLieClhNBy4mg5QTucgJpOYG0nEBaTuAuJ56WE0/LiaflxNNy4mk58bSceFpOPDW1FG1AXWgjWo6uRtegGFqFrkXdaBO6Dn0IXY9uQJtRD1qLbkRb0E3oZnQLuhXdhraiFagXbUPnoiLajnagODofJdDtqIR2ojWojCpoF0qiO9BudCc6By1De9BetBJV0T60Hx1AB9FqdAgdRnehu9ERdBR9GN2DjoXqK944p8as7b8vip7UtYXkHCM5x0jOMZJzjOQcIznHSM4xknOM5BwjOcdIzjGSc4zkHCM5x0jOMZJzjOQcIznHSM4xknOM5BwjOcdIzjGSc4zkHCM5x0jOMZJzjOQcIznHSM4xknOM5BwjOcdIzjGSc4zkHCM5x0jOMbJyjKwcIyvHyMoxsnKMrBwjK8fIyjGycoysHCMrx8jKMbJyjHQcIx3HSMcx0nGMdBwjHcdIxzHScYx0HCMdx0jHMdJxjHQcIx3HSMcx0nGMdBwjHcdIxzHScYx0HCMdx0jHMdJxjHQcIx3HSMcx0nGMdBwjHcdIxzHScYx0HCMdx0jHMdJxjHQcIw/HyMOxZh7eFOVhdMTpkcaTC29uDRf5j/DVeoSv1iO8K5tagVaic1EMrULnoTj6EFqNzkcJdAG6EH0YrUFr0UUoiT6CUmgdSqOL0SXoUtSGLkMZlEXtqANdjnLoCpRH61EBXYk60VVoA+pCG9HV6Bp0LepGm9B16Hp0A9qMetCNaAu6Cd2MbkG3otvQVtSLtqEi2o52oNtRCe1EZVRBu9AdaDe6E+1Be1EV7UP70QF0EB1Ch9Fd6G50BB1F96BjofqKt7Q2O8new1Fw3toIzvcv6N6Z4Npr4sEAfcXbWt8/blj8m9GQdX7h/x+a5+W3toa3JE1yS9IkN6NMcoPSJDcoTXLbwyS3K01yE8sktytNckvLJDexTHITyyS310xym9MktzlNcpvTJLe0THJLyyS3tExyC9Qkt0BNcgvUJLdATXIL1CS3u0xyQ9QkN0RNckPUJLdATXIL1CS3QE1y08wkN81MctPMJDfNTHKbzCS3yUxyC9Qkt8JMcrvLJLe7THKb0yQ3Nk1y88skN3xNcjvWJLdjTXJL0iQ3Gk1ys9Qkt3hNcuPWJLf6THKrzyQ3dU1yc9YkN+k09Qx6Fn0RfQl9GT2HnkdfQcfRC+ir6GvoBPo6+gZ6Eb2EKuhldCF6Bb2KXkN1tAO9jt5Ab6KV6C20FJ2DlqHlKIZWofPQapRAa1EyVF+jbH5/4PpdLszvEnLf5Uv3Xb6s323+YdtaT99+9KN6+9Hpm46GTt909Ee76ah5z0x39Nmnbz/q/RPdfnT6pqPf/6ajhTXYz7Fa+7nm6qIY1ZTiovnT809w0r6h4mJ+8fsn7Z9obgpun19j9E4Pfb+7+PfNkrWjdf5nVD8c/Zu+/zOqb2/8wvwaYt/isN/Yx8/W2se25j5+FNk+/rlNPYpeQc+gV9EZaBN6Gi1GLeg1VEdnoi3obPQA2oEeRM+j19FZaA2qoDfQm+gxtBK9hWroMHoCvYReRE+ip0L1FUut4dywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywwNywQCUqMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsMDcsNCv7ztbTJ5SHfoQPJkdr2ruj33X6hPLQX6wTyuXGO2u+h/lPrWEP01QNPYXOQM+gHNoRqq9YoffJ0/vk6X3y9D55ep88vU+e3idP75On98nT++TpffL0Pnl6nzy9T57eJ0/vk6f3ydP75Ol98vQ+eXqfPL1Pnt4nT++Tp/fJ0/vk6X3y9D55ep88vU+e3idP75On98nT++TpffL0PnkujTy9T57eJ0/vk6f3ydP75Ol98vQ+eXqfPL1Pnt4nT++Tp/fJ0/vk6X3y9D55ep88vU+e3idP75On98nT++TpffL0Pnl6nzy9T57eJ0/vk6f3ydP75Ol98vQ+eXqfPG/tPL1Pnt4nT++Tp/fJ0/vk6X3y9D55ep88vU+e3idP75On98nT++TpffL0Pnl6nzy9T57eJ0/vk6f3ydP75Ol98vQ+eXqffDMqd7UGx+16/0vwrm9iXYh0iItDnBfikhCXhmgLcUGIy0JkQmRDXBiiPURHiMtDXBQiF+KKEPkQ60MUQlwZojPEVSGWhtgQoivExhDLQ1wd4poQsRCrQlwbojvEphDXhbg+xA0hNofoCbE2xI0htoS4KcTNIW4JcWuI20JsDdEbYluIc0MUQ2wPsSNEPMT5IRIhbg9RCrEzxJoQ5RCVELtCJEPcEWJ3iDtDnBNiWYg9IfaGWBmiGmJfiP0hDoQ4GGJ1iEMhDoe4K8TdIY6EOBrinhDHAvQV72ik1O/NLZyODr1QbI0Gv8ejRnW+XXmHduUd2pV3aFfeoV15h1btHZqXd2he3qF5eYd27B1amXdoZd6hlXmHxu0dGpt3aGzeobF5h8btHdqcd2hz3qHNeYc25x3anHdoc96hzXmHNqeppWgD6kIb0XJ0NboGxdAqdC3qRpvQdeh6dAPajHrQWnQj2oJuQjejW9Ct6Da0FfWibehcVETb0Q4UR+ejBLodldBOtAaVUQXtQkl0B9qN7kTnoGVoD9qLVqIq2of2owPoIFqNDqHD6C50NzqCjqJ70LFQfcXdre8fE/5c45jwna3hkvcOvlp38NW6g3dlUyvQSnQuiqFV6DwURx9Cq9H5KIEuQBeiD6M1aC26CCXRR1AKrUNpdDG6BF2K2tBlKIOyqB11oMtRDl2B8mg9KqArUSe6Cm1AXWgjuhpdg65F3WgTug5dj25Am1EPuhFtQTehm9Et6FZ0G9qKetE2VETb0Q50OyqhnaiMKmgXugPtRneiPWgvqqJ9aD86gA6iQ+gwugvdjY6go+gedCxUX3EPUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKyQlRWiMoKUVkhKitEZYWorBCVFaKy0ozKvURlJ1HZSVR2EpWdRGUnUdlJVHYSlZ1EZSdR2UlUdhKVnURlJ1HZSVR2EpWdRGUnUdlJVHYSlZ1EZSdR2UlUdhKVnURlJ1HZSVR2EpWdRGUnUdlJVHYSlZ1EZSdR2UlUdhKVnURlJ1HZSVR2EpWdRGUnUdk5H5VfbW1pbYn+F3z4Kj5pA+pCG9HV6Bp0LepGm9B16Hp0A9qMetCNaAu6Cd2MbkG3otvQVtSLtqEi2o52oNtRCe1EZVRBu9AdaDe6E+1Be1EV7UP70QF0EB1Ch9Fd6G50BB1F96BjofqKVTKzi8zsIjO7yMwuMrOLzOwiM7vIzC4ys4vM7CIzu8jMLjKzi8zsIjO7yMwuMrOLzOwiM7vIzC4ys4vM7CIzu8jMLjKzi8zsIjO7yMwuMrOLzOwiM7vIzC4ys4vM7CIzu8jMLjKzi8zsIjO7yMwuMrOLzOyaz8xAV6ENqAttRFeja9C1qBttQteh69ENaDPqQTeiLegmdDO6Bd2KbkNbUS/ahopoO9qBbkcltBOVUQXtQneg3ehOtAftRVW0D+1HB9BBdAgdRnehu9ERdBTdg46F6ivuaw03n38neNc3sS5EOsTFIc4LcUmIS0O0hbggxGUhMiGyIS4M0R6iI8TlIS4KkQtxRYh8iPUhCiGuDNEZ4qoQS0NsCNEVYmOI5SGuDnFNiFiIVSGuDdEdYlOI60JcH+KGEJtD9IRYG+LGEFtC3BTi5hC3hLg1xG0htoboDbEtxLkhiiG2h9gRIh7i/BCJELeHKIXYGWJNiHKISohdIZIh7gixO8SdIc4JsSzEnhB7Q6wMUQ2xL8T+EAdCHAyxOsShEIdD3BXi7hBHQhwNcU+IYwH6ivvDlCq+S3PyLs3JuzQn79KcvEtj9i6tyru0Ku/SqrxL8/Uujcu7NC7v0ri8S5v2Lm3Mu7Qx79LGvEub9i5Nzbs0Ne/S1LxLU/MuTc27NDXv0tS8S1PT1FK0AXWhjWg5uhpdg2JoFboWdaNN6Dp0PboBbUY9aC26EW1BN6Gb0S3oVnQb2op60TZ0Liqi7WgHiqPzUQLdjkpoJ1qDyqiCdqEkugPtRneic9AytAftRStRFe1D+9EBdBCtRofQYXQXuhsdQUfRPehYqL7igUYAPt/b0vszQ98/v/1Q41NrqIKeCdVXPNj4Y+ZvELyP93ZTD6JNofqKhxq/ff4SuY37/W5r3vN2eP4fWrxvcfAvfZh/6cP8Sx/mX/pw86+6q/HnbJz7cx58//EBxe3z90zsjm49XRqdQNowf2L/Vm4GXji6/1NzL16Yv3fjBPczL4t+/8vhAf3iiuhDr0avVkavJqNX50avpufvJ/756EPLG7d5R69i0at/Eb1aFb36xejVedGrU/P36f5K9KF49KFvR68+FL2a4XaO6HaFf904qX/3+1/dlrn/+LnPvTn63P+xeKj5ZMazGj/z5EhYB3v/a1AGm1gXIh3i4hDnhbgkxKUh2kJcEOKyEJkQ2RAXhmgP0RHi8hAXhciFuCJEPsT6EIUQV4boDHFViKUhNoToCrExxPIQV4e4JkQsxKoQ14boDrEpxHUhrg9xQ4jNIXpCrA1xY4gtIW4KcXOIW0LcGuK2EFtD9IbYFuLcEMUQ20PsCBEPcX6IRIjbQ5RC7AyxJkQ5RCXErhDJEHeE2B3izhDnhFgWYk+IvSFWhqiG2Bdif4gDIQ6GWB3iUIjDIe4KcXeIIyGOhrgnxLEAfcWjrfMP8vp2dC9S9GOrv9xIuHvmfqFxZ9NHW6MDU8fCNJuL8CDO3tc6lEYXo/PQJehS1IYuQJehDMqiC1E76kCXo4tQDl2B8mg9KqArUSe6Ci1FG1AX2oiWo6vRNSiGVqFrUTfahK5D16Mb0DG0GfWgtej30I1oC7oJ3YxuCVVsaeUXb0W3oV60DZ2Limg72oHi6HyUQLejEtqJ1qAyqqBdKInuQLvRnegctAztQXvRSlRF+9B+dAAdRG+h1egQOozuQnejI+gougdtDdVX/Kut4eMPj/P4w+M88PA4Dzw8ziMOj/OotOM84vA4jyo8zqMKj/OowuM8Yu04jyM8zuMIj/M4wuM8jvA4jyM8zgMIj/MAwuM8gPA4D+g7zuMIj/M4wuM8jvA4j4I7zgPzjvMEs+M8ru84jwA8ziMAj/M4wuM82O84D+87zhPTjvOwueM8MvI4jyo8zkP/jvPgwuM8ZLCpe9EDaDvageLoQfQ8eh2dhR5CfWgnWoMq6A30WfQm6kePoSrah1aix9EAegvV0GH0BHoJvYieRJ9HW9FTaCk6By1Dy1EMrULnodUogdaiJHoWfRF9CX0ZvYC+ir6BvoCeQ19Bx9HX0An09VB9c01ps21tfLD394J3fQN9xXvJ4H4yuJ93Xz+J3E8i9/N97ief+3nX9pPP/byH+3nX9vOu7SdP+sn1fnK9n1zv5z3cz3u4n/dwP5nfT+b3k/n9ZH4/md/P+7ufCtBPBeinAvST+f1kfj+Z309K9JMS/aREPynRTy70kwv9ZH4/7/1+3t/9vL/7yfV+kryfd3s/Fa6f+tNP/ekng/tJ1n6qQz81rZ9K1U+29ZNt/VSxfqpRP+/9ft77/bz3+3nv91NV+kmCfpKgnyToJwmaegY9h76CjqOvoRPo6+hF9BKqoJfRhegV9Cp6DdXRDvQ6egO9iVait9BSdA5ahpajGFqFzkOrUQKtRclQfcWPtYYjgcsbn3ILSqGb0a2oF21DaXQJuhSdjy5DGZRFO1EZ7UJXoDxajwroSrQbdaI9aAPaizaiLlRF+9A16Fq0H3Wj69BBdADdgI6hzagHHUJH0FG0BbWjreimUH3F+1rn9yp+5v2H+fTmh5p7Du9GDyv6ybkX/yx68fHoQUTRSOwn5l7cu6RRVFqKO6MXPx49Bil68cm5F7saw/77G3/swmOjPvDwqoXHRy08EGjhcU0LT0VaeCDQwsOiomdNfXTR0PefMNRXfKD1D3j41u/3zK2FJ2x94N8WPYSr8wc/T+uHPEbrg0/P+gMemjXwAx/E+yd9aNbCs7I++IisDz4Za+E5WH+8x1998BlXf5hHW33wQVY/5PlVfyEfW/XxxjUZPUz2V1qHmk/KHY9e3Bt94aIXH5t7sTL6PZ+Ye/Eb0UfmG/MqzVRT96FH0f2oH1XRY+gB9Dh6EH0WfQplUR96Aj2MPoOeRFtQDj2C1qMNaBN6Gp2NzkBnorPQYlRDh9Ea1IJeRC+hZ1AFvYx2oOfR6+hC9AZ6Bb2JVqJX0VvoNVQP1Vd88A/K59MPR/xj5Xz0qPAXeHT/D3lKYvQExJ+ICvTpn+M+9Kf/lMTmz3P4qejr++dceD7BCqSdFUg7K5B2ViDtrEDaWYG0swJpZwXSzgqknRVIOyuQdlYg7axA2qkl7axA2lmBtLMCaWcF0s4KpJ0K0c4KpJ0VSDsrkHZWIO2sQNqpM+2sQNpZgbSzAmmnGrezAmlnBdLOCqSdFUg7K5B2ViDtrEDaWYG0swJpZwXSzgqknRVIOyuQdlYg7axA2qnb7axA2lmBtLMCaW9WiE9y0Wa4aDNctBku2gwXbYaLNsNFm+GizXDRZrhoM1y0GS7aDBdthos2w0Wb4aLNcNFmuGgzXLQZLtoMF22GizbDRZvhos1w0Wa4aDNctBku2gwXbYaLNsNFm+GizXDRZrhoM1y0GS7aDBdthos2w0Wb4aLNcNFmuGgzXLQZLtoMF22GizbDRZvhos1w0WaaF+2nWvlpDoOcSWjo+z/NocklsK/4EJd9mss+zWWf5rJPc9mnuezTXPZpLvs0l32ayz7NZZ/msk9z2ae57NNc9mku+zSXfZrLPs1ln+ayT3PZp7ns01z2aS77NJd9mss+zWWf5rJPc9mnuezTXPZpLvs0l32ayz7NZZ/msk9z2ae57NNc9mku+zSXfZrLPs1ln+ayT3PZp7ns01z2aS77NJd9unnZ9zUu2qhNaYs6j/lV6wONz/0ouhd9DN2HtqL70QNoO4qjB9En0KdQFj2E+tDD6NPoMyiHHkGfRevR59CjqB89hqpoH3ocDaIn0JPo82gLGkJPoQ1oE3oanYXWoLPRGWgxqqHDqAWdiV5EL6EKega9jC5Er6BX0Wuojnag59Hr6A30JlqJ3grVV3yYAjPMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zL0Jw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMvRDD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcRDLMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTMfUfD3Hc0zH1Hw9x3NMx9R8PcdzTcvA3n040AXPjBj9FP0Dt/yVDzx3guiV4s/IjNhZ/VGf0AydSioeAHcy78AL7fmqstbwwFP6ty4acTfvBnxP3m3Od+cqj5YxovbWxTfaY1PH7zSGO58FF0L/o8+hi6D92PHkAfR9tRHD2IPonOR59CWZRBD6E+tBM9jD6NPoNy6BH0WbQeXYl+DH0ObUSPon70GKqifWgIPY4OoAE0iJ5AT6JPoC1oK3oKbUCb0NPoLLQGnYHORItRDR1GLehs9AX0DHoWfRF9CX0ZPYeeR19Bx9EL6Kvoa+gE+jr6BnoRvYQq6GV0IXoFvYpeQ3W0A72O3kBvopXoLbQUnYOWoeUohlah89BqlEBrUTJUX/GR1rAzTjF6STF6STF6STF6STF6STF6STF6STF6STF6STF6STF6STF6SbF4TTF6STF6STF6STF6STF6SbEkTTF6STF6STF6STF6STF6SbEoTDF6STF6STF6SbGwTbGwTTF6STF6STF6STF6STF6STF6STF6STF6STF6STF6STF6STF6STF6STF6SbGsTjF6STEISTF6STWXc59tPb2ROvQj/FPmTm+bDv1ZntKJtrBXR7/0p79r+mOUgw7KQQfloINy0EE56KAcdFAOOigHHZSDDspBB+Wgg3LQQTnooBx0UA46KAcdlIMOykEH5aCDctBBOeigHHRQDjooBx2Ugw7KQQfloINy0EE56KAcdFAOOigHHZSDDspBB+Wgg3LQQTnooBx0UA46KAcdlIMOykEH5aCDctBBOeigHHRQDjooBx2Ug45mOfhc46J9aO4ifiY8P3ao8bn3oo+h+9Cj6H7Uj6roMfQAehzF0YPos+hTKIv60BPoYfQIWo8+g55En0BbUA5tRU+hDWgTehqdhdags9EZaDGqocOoBZ2JXkQvoWdQBb2MdqDn0evoQvQGegW9iVaiV9Fb6DVUD9VXfLQ1HL98qvEpH0X3os+jj6H70P3oAbQdxdGD6FMoix5CfWgnehh9Gn0G5dAj6LNoPfocehT1o8dQFe1DQ+hxNIieQE+iT6AtaCt6Cm1Am9DT6Cy0Bp2BzkSLUQ0dRi3obPQieglV0DPoZXQhegW9il5DdbQDPY9eR2+gN9FK9Fao/5+9ew9s8swPfG/JeDAYYi4OF8syBmwDBgzCYFuAMRdzsV9eG+uCwDYYgcCbWBAQCAclBBIjIUIIIVFuIMDIpu3SNO22c7q3dqfb1e502909Z2Z7RtPObM92dnra7rQMA9tup5fT8z4SVn7fIRcgJCEzzj95P8ZcbD/P7/n9nsv7BPUXTF/qakdlq99QHxkpeyIjZc9jdTjhhOnuxV9PmtV7bE4O8076tTYvflK/Uy17sfmx74Aj/W6k3z1O/S6bWeRlxreX0v3M6F7atMh9HFZT7bEMXeiennPW+P9Xjf//sfELL5tkx8l2k485mfZ946HcLLtAtsFn23m25T+qA2l/azxUfHjzzrbhH6umYpZt+N6m+8hPnT1cu7qfVvQgjSeo96tWom80GT/aw3cvrtU6jYc89dCdeWtTjuaLxIbvtjXSqBztgPELm9Qv9BgP+ephZ+SD2xGS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagJDYCJbERKImNQElsBEpiI1ASG4GS2AiUxEagZGYj0CmTnOD3IgB6EQC9CIBeBEAvAqAXAdCLAOhFAPQiAHoRAL0IgF4EQC8CoBcB0IsA6EUA9CIAehEAvQiAXgRALwKgFwHQiwDoRQD0IgB6EQC9CIBeBEAvAqAXAdCLAOhFAPQiAHoRAL0IgF4EQC8CoBcBMKMnoUZoNbQGWgtZoXVQE7Qe2gBthDZBzVAL9ASkQZuhCZAOtUJtUBE0FZoGbYHaIQdUAjkhF+SGZkBbIQ+0DSqAxkHboQ6oEOqEuqAd0E6oG5oC7YK80G5oD+SD9kIWaB/UIxU0CmMVKv2qSFWp6PAsbiNmVRsxh9yI+exGzLE2Yh61ETOujZhxbcTMaSNmQBsx/9qIWdVGzKo2Yla1ETO1jZhjbcS8bSPmWBsxx9qIWdVGzLg2Yo61EbOjjZgdbcTsaCNmYxsxV9qIudlGzJw2Yua0EfO2jZhHbcQsbiNmcRszNWjEJIfFuWYZdjKaCW2ANkEatBmaDVVAldBUaC40D6qCHJATckOLoMWQDVoC1UAeaCm0HaqFOqB6qA7qhLqg5dAKaAe0EloFdUM7odVQD7QGWgvtgnzQXqgJmg+1QOulgvppNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNpyNNryTKONmr7Uq1kPNJmuFgg8I7PqI7Pqn8tq1hmTvC23BMl9CZL7EhSYJSiWSpDcl6A8KkG5WYJyswRTAiUoj0pQUpYg1S9B6VSC0qkE0wUlmAQoQTpfgtKpBMVnCSYBSlAsZVQGzYRmQbOhcqgCqoTmQHOheVAVNB9aAC2EqqFF0GLIBi2BaqCl0DKoFqqD6iE7tBxaAa2EGqBVUCO0GloDrYXWQU3QemgDtBHaBDVDLZAGbYZ0qBVqg7ZA7ZADckIuyA1thTzQNmg71AF1Ql3QDmgn1A3tgrzQbmgP5IP2QvugHqmg/vK9ScgbpshPZxLyOL+JTSuO/CwmI+m3pGnWyM9CVnL2k/L9B38p7ad8F63RY7XXPrmHjLyTVvspfSftK6ZP/0Jm1UIW4s/P/vQ/eCHzOZPcah3CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuIZx0D+Gkewgn3UM46R7CSfcQTrqHcNI9hJPuocxJ91dNcrZ8AKX+AEr9AZT6Ayj1BzDNMYDCfwCF/wAK/wFMZQxgGmAA0wADmAYYwKTHACYFBjApMIBJgQFMegxgimAAUwQDmCIYwBTBAKYIBjBFMIApggFMEWQ0FqqF6qB6aDxkh5ZDE6FJ0ApoJdQArYIaodXQGmgtZIXWQU3QemgDtBHaBDVDLZAGbYYmQDrUCrVBRdBUaBq0BWqHHFAJ5IRckBuaAW2FPNA2qAAaB22HOqBCqBPqgnZAO6FuaAq0C/JCu6E9kA/aC+2DeqSC+nlD6jWtRj1kVucbXjPdPe7gSvNCOj6qX/6GymJzjYezqlZtVh9qVS93+orxcEFl4qONh7B6uG48/Kr6pXxVrKmPjDEelqsHs6pa1cMoVfrkRjIvlPpr9Se2qD/xxKh0a8jRb6iHHONhv/qk4aTi+9jL8P3M2tHrJjnDPQE/4An4AU9AIMnoCagQmgBNhCZBk6Ei6EloCjQVmgZNh4ohC1QCWaFSaAZUBs2EZkGzoXKoAqqE5kBzoXlQFTQfWgAthKqhRdBiyAYtgWqgpdAyqBaqg+ohO7QcWgGthBqgVVAjtBpaA62F1kFN0HpoA7QR2gQ1Qy2QBm2GdKgVaoO2QO2QA3JCLsgNbYU80DZoO9QBdUJd0A5oJ9QN7YK80G5oD+SD9kL7oB6poP6G6aPustJWRzLXVD2tZoSeMx786kHdV7VfPVxQ8y1qBFB3Wr2iPqJuuXp/+N6r3xy+Cevn5bsWjqXD9VPQ01AY6oX80H7oANQKtUFF0GGoCiqGjkBByAEdhfqgZ6FqKAQdg2xQLfQ8dBy6DL0AnYA6oS6oEIpAJ6EG6CXoDNQPnYIOQU1QC3RaKqjHTD8720ZGdotEvujdImrnzhyVmN7PAk3ceJinPvnLvVLzpupi6m6GHP3rozKXNhhjw6hMl9J3qQ9lL3n4d5le+Va6V1Ybv/zL6p8yPJ+8KN2Do1At1ADlQ7nQGcgLlUA5UB40GhoDXYQuQWchFxSH2qAL0DWoGEpAl6FBqBC6Ag1BV6EBqaD+9idF0o8KoI86bn624TK9fPfIw+XHLN99nsHxfmLiA4XCz26/nBFktT2Pddx7x3R3HqQ0PQ/y7jCfT/PiT23ioca4maYH6FIjGchH97aR/aoP3O8ufZl6luost00P2sVGetZIz/oCelbc9KEvxOzGtEw3JmK6MRHTjQmHbkzLdGPCoRtTDN2YfujGBE43JhW6MWWT0UEoBB2GqqAg1A8dhY5BNuhZ6BR0CGqCqqEW6DRUCzVAUSgfKoHGQHlQLnQG8kI50GjoInQJOgu5oDjUBl2ArkHFUAK6DA1ChdAVaAi6Cg1IBfXLJrkxYEv6UzZCM6EN0CZIgzZDs6EKaCo0F5oHVUEOyAm5oUXQYsgGLYFqIA+0FNoO1UIdUD1UB3VCXdByaAW0A1oJrYK6oZ3QaqgHWgOthXZBPmgv1ATNh1qg9VJB/Yrpw3ctqvzhr1SYv5vg6Ok13GXmyH1tZNQ3q89egoHkQ3YyXkUfuYFVxBtYRbyBVcQbWEW8gRXUG1hTvIE1xRtYU7yBVdIbWGG8gRXGG1hhvIH11BtYb7yB9cYbWG+8gfXUG1h9vIHVxxtYfbyB1ccbWH28gdXHG1h9vIHVx4zGQrVQHVQPjYfs0HJoIjQJWgGthBqgVVAjtBpaA62FrNA6qAlaD22ANkKboGaoBdKgzdAESIdaoTaoCJoKTYO2QO2QAyqBnJALckMzoK2QB9oGFUDjoO1QB1QIdUJd0A5oJ9QNTYF2QV5oN7QH8kF7oX1Qj1RQHzB9iYrVD38J738beQnvSLH6+BWr19I9y2V4jPrGDRdCvRj3MjoINUgFjWaplq/mqnTmOfUPHK5630snU09BT0O9kB9qgfZDB6BnoFaoCDoIHYIC0GGoCjoCBSEHdBTqg56FqqFjUAiyQTXQc9DzUD10HHoBOgF1Ql3QSehF6CWoHzoFhaEmKAKdhmqhBigK5UMl0BgoD8qFzkBeKAcaDV2CXNBZ6CIUh4qhy9AV6Co0ALVBF6BrUAIahAqhIegV6Bz0KnQeikFvQu9CL0OvQa9Db0BvQW9D70gF9UGTrLrmpD9lIzQT2gBtgjRoMzQbqoAqoanQXGgeVAU5ICfkhhZBiyEbtASqgTzQUmg7VAt1QPVQHdQJdUHLoRXQDmgltArqhnZCq6EeaA20FtoF+aC9UBM0H2qB1ksF9aF0o1WJ4h8h9/vIt3R/3/j/hoh4Bfa9py2zyUY2Nf2x8Zs2Rj5siuODV0ZfT/9Lzhj++9xIZk33tVHqF37OdHeJ92j6Rf8/b5LHNE+kv6inoKehXsgPtUD7oQPQM1ArVAQdhA5BAegwVAUdgYKQAzoK9UHPQtXQMSgE2aAa6DnoeageOg69AJ2AOqEu6CT0IvQS1A+dgsJQExSBTkO1UAMUhfKhEmgMlAflQmcgL5QDjYZegc5Br0LnoQtQDHoTehd6GToLvQa9Dr0BvQW9Db0DXYQuQS4oDhVDl6Er0FVoAGqDrkEJaBAqhIagsVABNA4aD02EJkGToSnQNMgKzZAK6r+QDrFqa3lolGiTVnxHrfgKrfg+WdFbrPjeW9GvrJm/8Z+avtQTNl/IPI2aJaoZmbAZmbD52AmbG6a797XoRebIfewbVbewbEf3+eg3utzP/SzfUz8OLG/d+7qWey9qma6+V+bIZ/m6lmxz/Vm8n+UXTbJWrUqH5I3QTGgDtAnSoM3QbKgCqoSmQnOheVAV5ICckBtaBC2GbNASqAbyQEuh7VAt1AHVQ3VQJ9QFLYdWQDugldAqqBvaCa2GeqA10FpoF+SD9kJN0HyoBVovFdTfGw5l2u9/EZHsCwlgRvjUfjASyD4ykP3SSOJ4v4mjyhePjXrQJjmSOH5o1/jpTxzfN8l5tuPpgPwU9DTUC/mhFmg/dAB6BmqFiqCD0CEoAB2GqqAjUBByQEehPuhZqBo6BoUgG1QDPQc9D9VDx6EXoBNQJ9QFnYRehF6C+qFTUBhqgiLQaagWaoCiUD5UAo2B8qBc6AzkhXKg0dAr0DnoVeg8dAGKQW9C70IvQ2eh16DXoTegt6C3oXegi9AlyAXFoWLoMnQFugoNQG3QNSgBDUKF0BA0FiqAxkHjoYnQJGgyNAWaBlmhGVJB/ZdNsgqLYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9ivEsM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2x8SwTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y9inGcM+zRj2acawTzOGfZox7NOMYZ9mDPs0Y5ldYL9ietj33jzI6276kLv2IXftQ9bSh0y2D5lsH3LXPuSufchW+5Ct9iFb7UNG2oeMtA8ZaR8y0j5kpH3ISPuQkfYhI+1DRtqHjLQPGWkfMtI+ZJ19yDP7kGf2Ic/sQ57ZhzyzD1lgH7LOPuSZfcgz+5Bn9iHf70OemVELdBqqhRqgKJQPlUB50GgoFzoDeaEcaAx0EboEuaCzUBwqhi5DV6Cr0ADUBl2ArkEJaBAqhIakgvo/M8lMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKIFMKJHJhH7VhPOCf2cMDl+L/MS5wdfkDPT9XHvwD8bnWiIff1bw1xB5PbmynWc0E9oAbYI0aDM0G6qAKqGp0FxoHlQFOSAn5IYWQYshG7QEqoE80FJoO1QLdUD1UB3UCXVBy6EV0A5oJbQK6oZ2QquhHmgNtBbaBfmgvVATNB9qgdZLBfWvmuTcdAD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fQD5fSCT3/8f6Q4bNkadBWr4Ge65fvRcP3quH33Vj77qR1/1o6/60Vf96Kt+9FU/+qoffdWPvupHX/Wjd/rRO/3onX70Tj96px+904/e6Ufv9KN3+tE7/eidfvROP3qnH73Tj97pR+/0o3f60Tv96J1+9E4/eqcfvdOP3ulH7/Sjd/rRO/3onX70Tj96px+904/e6Ufv9KN3+tE7/eidfvROP3qnH73Tj97pR+/0o3f60Tv96J1+9E4/eqcfvdOP3ulH7/Sjd/rRO/3onf5M7/x1U+boReaD0/GPn47fPh3/pOn4MU7HlzkdP/Dpmb/on5vkuH0Evf8Ien9GYagX8kP7oQNQK1QEHYQOQ1XQESgIOaCjUB/0LFQNHYNCkA16HjoOvQCdgDqhLigCnYRegvqhU9AhqAlqgU5DtVADFIXyoRIoDxoN5UJnIC+UA42BLkKXIBd0FopDxdBl6Ap0FRqA2qAL0DUoAQ1ChdCQVFD/F6b7m6C/qLa6qL1FDzdTf8b4876i/r5/aZLV6Kz0P2kjNBPaAG2CNGgzNBuqgCqhqdBcaB5UBTkgJ+SGFkGLIRu0BKqBPNBSaDtUC3VA9VAd1Al1QcuhFdAOaCW0CuqGdkKroR5oDbQW2gX5oL1QEzQfaoHWSwX1f4VGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW4FGW5FptP9aNdoPXhH/Iiaq0lKvlJccBQb130CzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL0OzL8s0+980DZ93f3tUJPYprxX+uHn1f2O6j43p3zZFvoCN6Y/JfvSf4Vf5v2nKMeWo/0b2mqf3mn8NQ0klhpJKDCWVGEoqMZRUYiipxFBSiaGkEkNJJYaSSgwllRhKKjGUVGIoqcRQUomhpBJDSSWGkkoMJZUYSioxlFRiKKnEUFKJoaQSQ0klhpJKDCWVGEoqMZRUYiipxFBSiaGkEkNJJYaSSgwllRhKKjGUVGIoqcRQUomhpBJDSSWGkkoMJZUYSioxlFRiKKnEUFKJoaQSQ0llZij5rXSjHf7xa+lP8UP90HHoBHQKOgA1QdXQQeg0FIVqoQYoD8qHcqEzkBcqgXKg0dAY6CJ0CToLuaA41AZdgK5BxVACugwNQoXQFWgIugoNSAX1f5tuNmqe5K1RkcwFfpdGRTID5NH0C29+G9HQjWjoRjR0Ixq6EQ3diIZuREM3oqEb0dCN+OdG/HMj/rkR/9yIf27EPzfinxvxz43450b8cyP+uRH/3Ih/bsQ/N+KfGx3AjfjnRvxzI/65Ef/ciH9uxD834p8b8c+N+OdG/HMj/rkR/9yIf27EPzfinxvxz43450b8cyP+uRFe3Ih/bsQ/N+KfO9OQ/53pp/7opToy+cTIS1bvZsF5xsMyU2TkDObnlhcnTcc/GKv/Tu0UO6z/+3S3G46J67A5Zx02bK3DBqqMjkDLoc1QBeSGZkMt0PBwfsgkB/BD2ER4KLPp7T88LhHkrPHwh+pBLUT8rw8LKfpU9araisfxXLfqlnMfOLio0DYv9zGMMiPB5XMKLl83Db9OY1LkPl6n8UW8RWPk7T/32RYe7KUZv/NJcff+LxX90OAaN0UecN7x3jD5QC0nGyY/u1nGe5tQNs49XHh7uDtAH6i9fSnD0n/M5Dw52jyV7fyu6e775rUZkQ+mNJ7CoZWMDkINUkH991BSt6OkbkdJ3Y6Suh0ldTtK6naU1O0oqdtRUrejpG5HSd2OkrodJXU7Sup2lNTtKKnbUVK3o6RuR0ndjpK6HSV1O0rqdpTU7Sip21FSt6OkbkdJ3Y6Suh0ldTtK6naU1O0oqdtRUrejpG5HSd2OkrodJXU7Sup2lNTtKKnbUVK3o6RuR0ndjpK6HSV1O0rqdpTU7Sip2zMl9X8abu36+6NEc+9Bc+9Bc+9Bc+/JNPf/nP5zBo1eUxZR01852lj14f9i+vBLqR5kzcsIvtq6yIetfakbDJNmGQr+xnjQMtuDMv+8v8h8mf+n+nfoFiOj1n4pktlN9C8jsczXbU5/3Tnar6a/xhx9jgou3zE+8BvG/79rfOC9u/WArpkjmUDxm+rP/L9Md18frb0jvh+jM3/hN2QdlW9O11HfREhwISS4EBJcCAkuhAQXQoILIcGFkOBCSHAhJLgQElwICS6EBBdCggshwYWQ4EJIcCEkuBASXAgJLoQEF0KCCyHBhZDgQkhwISS4EBJcCAkuhAQXQoILIcGFkOBCSHAhJLgQElwICS6EBBdCggshwYWQ4EJIcCEkuBASXAgJLoQEF0KCCyHBhZDgyjTd/2qSW2afT3/KU9DTUC/kh1qg/dAB6BmoFSqCDkKHoAB0GKqCjkBByAEdhfqgZ6Fq6BgUgmxQDfQc9DxUDx2HXoBOQJ1QF3QSehF6CeqHTkFhqAmKQKehWqgBikL5UAk0BsqDcqEzkBfKgUZDr0DnoFeh89AFKAa9Cb0LvQydhV6DXofegN6C3obegS5ClyAXFIeKocvQFegqNAC1QdegBDQIFUJD0FioABoHjYcmQpOgydAUaBpkhWZIBfXfNz0m05CP/zskv9TrFyMzi5EPK+G/brTHX4l8FqX8/53uWEbSru2OfJCzB/VvfVKHu//5J6N7af0f27tG5qE+vjOMzEN9eONNmWR9aMaLEcxYZzPjxQhmvBjBjJU1M1bPzFhnM+PlB2as3Znx8gMzXn5gxssPzHj5gRlrd2a8/MCMlx+Y8boDM153YMbrDsx43YEZ+8bNeMGBGS84MOMFB2asP5rxggMzXmJgxksMzHhRgRkvMTDjtQVmrIya8aICM15UYMaLCsx4UYEZLyow40UFZqx+mvGiAnNmj/y3041ouBKxoWKyIau2If+2If+2IeO2IY+2IY+2IY+2ITe3Iau2ITe3Ice2IYu3ISO1ISO1IR+2IT+1IbO0ISO1IXu0IXu0IVu1Icu1IT+1Iae3IVu1IQe1ITu2IQO2Ia+1ZXLCP3ikQ9QnZYCPao+2kRdpVyL3N2g9tlu0v9Cd2R9kcA+XuH0ph7o//BkqgNS+h1dGKqGRSuhz6VnfeXyHkYcrdR6TUeMxGSzubdKqh9pG3Wfb/lI26e8+uib9oS35+ZHNIyNF+8M2zv+WbpzZ1WG1Xnwhfabij9K/MPwS2YZcOX2cURtUBE2FpkHToWKoBJoBjYUKoHHQeKgQmghNgqZAVqmg/v+kvyF3/xHaj9RnzJIokBgnMV6iUGKixCSJyRJtEkUSUySmSkyTmC5RLFEiYZWYIRDU/zu++pvyq78pv/qb8qu/Kb/6m/Krvym/+pvyq78pv/qb8qu/Kb/6m/Krvym/+pvyq78pv/qb8qu/Kb/6m/Krvym/+pvpr/6PZWfQ/lR9whyJ6RJzJeZJVEssklgsUSexXGKixAqJlRINEqslrBJNEuslNkhskmiWaJF4QmKzxASJVokiiakS0yTaJVwSMyQ8EgUShRKdEl0SuyR2S+yV2CdRJjFTYrZEucRkiQqJSokqiWKJBRILJUolbBJLJGoklkqMlVgmUStRLzFewi4xSWKVxJMSjRJrJNZKrJPYKKFJ6BJtElskHBIlEk4Jt8RWiW0S4yS2S3RI7JDYKdEtMUXCK2GR2CPhk5gv0SMQ1L+HUH5HhvI7sufckV/WHflzviP71B0ZmO7IH/od2dbvyB/GHdn578gv+I6MBHdkJLgjA+0d2SXuyB/gHRnm7sgYcSf91f+P9Fc/3shzfsec/tNz9FO56a86R7+TG8lcRDnGnP59OXoyN/3dydF/rD7yJ8bDt3PT35Uc3aWKlj81HkaZ01+mkZCNimRS4XzjI7pNnX/5vso0v208fE89/JnxMEF99p8bD2vM6X+1kVOr3/YDVWCNSv/Tc/RfGpX+6nL0d9XDHxgP/1399r8wHq6oj9xUKZ4p/f3M0ZzG36WrnYGu9M/BqAfUp/zIePiWerhtPFwflf4O5+j/dlT6+56jfy03/RPM0VvVv+KO8bDVnO78xndDPfzQeLhpSv8sc/R9ZvWN+z6azW3ZbG7LZnNbNpvbstncls3mtmw2t2WzuS2bzW3ZbG7LZnNbNpvbstncls3mtmw2t2WzuS2bzW3ZbG7LZnM73Wz+xCQXt+K4byGO+xbiuG8hjvsW4rhvIY77FuK4byGO+xbiuG8hjvsW4rhvIY77FuK4byGO+xbiuG8hjvsW4rhvIY77FuK4byGO+xbiuG8hjvsW4rhvIY77FuK4byGO+xbi2Msbx30Lcdy3EMd9C3HctxDHfQtx3LcQx30Lcdy3EMd9C3HsHY7jvoU47luI476FOO5biOO+hTjuW4jjvoU47luI476FOO5biOO+hTjuW4jjvoU47luI476FOO5biOO+hTjuW4jjvoU47luI476FOO5biOO+hTjuW4jjvoU47luI476FOO5biOOoZBz3LcRx30Ic9y3Ecd9CHPctxHHfQhz3LcRx30Ic9y3Ecd9CHPctxHHfQhz3LcRx30Ic9y3Ecd9CHPctxHHfQhz3LcRx30Ic9y3Ecd9CHPctxHHfQjyzQ/7/TQdANSidUwPEXxkPJelx4U9NYqv4P2aO3P6Z6bOd8vqz3MjIlNfIlNfDTXn9ebpxDm8jOIDh5QCOihxAuD+Q6Qj/U+ZB+grEiRWIEyswHmX0BFQITYAmQpOgyVAR9CQ0BZoKTYOmQ8WQBSqBrFApNAMqg2ZCs6DZUDlUAVVCc6C50DyoCpoPLYAWQtXQImgxZIOWQDXQUmgZVAvVQfWQHVoOrYBWQg3QKqgRWg2tgdZC66AmaD20AdoIbYKaoRZIgzZDOtQKtUFboHbIATkhF+SGtkIeaBu0HeqAOqEuaAe0E+qGdkFeaDe0B/JBe6F9UI9UUP+BDJVaSkTKDMZJjJd4QqJQYoLERIlJEpMliiSelJgiMVVimsR0iWIJi0SJhFWiVGKGRJnETIlZErMlyiUqJCol5kjMlZgnUSUxX2KBxEKJaolFEoslbBJLJGoklkosk6iVqJOol7BLLJdYIbFSokFilUSjxGqJNRJrJdZJNEmsl9ggsVFik0SzRIuEJrFZQpdolWiT2CLRLuGQcEq4JNwSWyU8Etsktkt0SHRKdEnskNgp0S2xS8IrsVtij4RPYq/EPokegaD+F6bhF+H+kUpHf2yUI7aIyPrvKVTOGv//qvH/7xv/dxv//1vjEyqQ4GfT8Gxumy1K7j1Z/MHbKP4y/S/JnvVVh39XRjJnfhsiMS7mpg//qjO/q9TvvImAfEtGmVsyOt+S0fmWjM63ZEC+JWPwLRmDb8kYfEs2wlsyIN+SMfiWjMG3ZAy+JWPwLRmDb8mwe0uG3Vsy0t5K/wR/aPrZ2bX3KTfrqU1/P3rg6nZk117kZ3PX3q1P6lmfcr7nwKgP7TUj8z2RkfmeT2ycP5KDnm7HhI0dEzZ2TNjYMWFjx4SNHRM2dkzY2DFhY8eEjR0TNnZM2NgxYWPHhI0dEzZ2TNjYMWFjx4SNHRM2dkzY2DFhY8eEjR0TNnZM2NgxYWPHhI0dEzZ2TNjYMWFjx4SNHRM2dkzY2DFhY8eEjR0TNnZM2NgxYWPHhI0dEzZ2TNjYMWFjx4SNHRM2dkzY2DFhY8eEjR0TNnZM2NgxYWPHhI0dEzZ2TNjYMWFjx4SNHRM2dkzY2DFhY8eEjR0TNnZM2NgxYWPHhI0dEzZ2TNjYMWFjx4SNHRM2dkzY2DFhY8eEjR0TNnZM2NgxYWPHhI0dEzZ2TNjYMWFjx4SNHRM2dkzY2DFhY8eEjR0TNnZM2NgxYWPHhI0dEzZ2TNjYMWFjx4SNHRM2dkzY2DFhY8eEjT0zYXPbdPf8sb5zVEQeQL5jksvfQ4gHQ4gHQ4gHQ4gHQ4iFQ4gOQ4gOQ4gOQ4h3Q4gVQ4gVQ4gVQ4iMQ4gcQ4gcQ4gcQ4iMQ4gjQ4gjQ4gjQ4gjQ4gjQ4gjQ4gjQ4gjGY2FaqE6qB4aD9mh5dBEaBK0AloJNUCroEZoNbQGWgtZoXVQE7Qe2gBthDZBzVALpEGboQmQDrVCbVARNBWaBm2B2iEHVAI5IRfkhmZAWyEPtA0qgMZB26EOqBDqhLqgHdBOqBuaAu2CvNBuaA/kg/ZC+6AeqaD+v9IB8IBRk7wiAkwz3hnVjLcMNeMdR814q1Ez3kDUjHcONeNdTM04Ad2MNxA14zx0M85DN+M8dDPOJzfjJHMzTjI34+R0M05ON+PkdDNOTjfj5HQzTk434zx0M85DN+M8dDPOQzfjJHMzTjI34yRzM04yN+PscjNOKzfjVHUzTlU341R1M05VN+N0dDPOQzfj3HZz5jz0X5nuvl5PrxolfhL/kGlOf53+1QbjV8+qYuU7qoI0R2KY1NOP352K4mxeUP/fxm9OXyB6zaQ2W/yNSb7wbDD9j3kKehrqhfxQC7QfOgA9A7VCRdBB6BAUgA5DVdARKAg5oKNQH/QsVA0dg0KQDaqBnoOeh+qh49AL0AmoE+qCTkIvQi9B/dApKAw1QRHoNFQLNUBRKB8qgcZAeVAudAbyQjnQaOhl6Cz0CnQOehU6D70GXYBeh96AYtCb0FvQ29A70LvQRegS5ILiUDF0GboCXYUGoDboGpSABqFCaAgaCxVA46Dx0ERoEjQZmgJNg6zQDKmg/uO7ITZHv2xKR5gczZ7uiTn6b5vSoSNHn29OR8wcvVrt/p6ndmRfT0eqHH2sOR1QcvTpwzNTM8yRzCTjt0zpSJCj/54pHZ5y9DxzOhLm6N80iSCoI1jr6N46gouOcKKj6+sI5Dq6vo6QqCN06wgEOjq7jrCgIyzo6N46woKOzq6js+vo7DoCiI6ur6Pr6wguOjqKjo6iIyzo6DY6uo2OBq+j6+to/jo6mI7OoKO76egaOrqGjq6oo6Po6Jg6Oqaeaap/axq+pOD3I/cxAf/Hxids//gJ+OF1zIe/teCI+shH31qgt6qjEjuGD1/8E/XbHpOLDL5vPIxXn/P432jwPePh59RHHuxqg79Ltxd1n8svqXjzR8YP+8nIB4nZe0h43kPC8x4SkPfQg99D+vMeemJGz0gF9b9P/zvU8sbvqi9iOJ19Kv25T0FPQ72QH2qB9kMHoFaoCDoIHYaqoCNQEDoK9UHPQtXQMSgE2aDnoePQC9AJqBM6Cb0E9UOnoENQExSBTkO1UAMUhfKhEmgMlAflQmcgL5QDjYYuQpcgF3QWikPF0GXoCnQVGoDaoAvQNSgBDUKF0JBU0ChU72530Sojn+W1z/+fSc4sm/DWQBPeGmjCWwNNeGugCW8NNOGtgSa8NdCE9xOY8NZAE94aaMJbA014a6AJbw004a2BJrw10IS3Bprw1kAT3hpowlsDTXhroAlvDTThrYEmvDXQhLcGmvDWQBPeGmjCWwNNeGugCW8NNOGtgSa8NdCEtwaa8NZAE94aaMJbA014a6AJbw004a2BJrw10IS3Bpoy72b4x3QjChuNaoFZDB69GDx6MXj0YvDoxeDRi+GiF8NFL4aLXgwXvRguejFc9GK46MVw0YvhohfDRS+Gi14MF70YLnoxXPRiuOjFcNGL4aIXw0UvhoteDBe9GC4y6oIi0EnoJagfOgUdgpqgFug0VAs1QFEoHyqB8qDRUC50BvJCOdAY6CJ0CXJBZ6E4VAxdhq5AV6EBqA26AF2DEtAgVAgNSQX1HPMjuUVFn/VJY4nJPDzn+u/lJSoBk/xWBrBcEsjMx5rNw/fI5JpFY9mPxbeMDkINUkHjd49sMYyMvA/wU+wsVDsvu9XnjGwxjMhdXKPMcuvyD1XfmyVRIDFOYrxEocREiUkSkyXaJIokpkhMlZgmMV2iWKJEwioxQyCo55llltyWjrIboZnQBmgTpEGbodlQBTQVmgvNg6ogB+SE3NAiaDFkg5ZANZAHWgpth2qhDqgeqoM6oS5oObQC2gGthFZB3dBOaDXUA62B1kK7IB+0F2qC5kMt0HqpoP6VTxr+HsVdqdlh64H2+Kpx8O/V73pMrlEd2dobechBIaiPTjez4SnKelTR9aiUMzoDFUOXIBfUAB2UCur55kf5IqHs+4M+5h1B3za6hBZJv3RI2xz5uHcGpV8+pOkR8c6ge98MdNP4lLaIeDFQ9lVBH/OGoB8av2lLJP1SIq09It4Y9MGLgsaYcVDqkw9IPdDBqB+rRj08NV9ujnz8UamxGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdGDcdmXGzAMntt2U++22Zz35b5rNpPCFRKDFBYqLEJInJEkUST0pMkZgqMU1iukSxhEWiRMIqUSoxQ6JMYqbELInZEuUSFRKVEnMk5krMk6iSmC+xQGKhRLXEIonFEjaJJRI1EksllknUStRJ1EvYJZZLrJBYKdEgsUqiUWK1xBqJtRLrJJok1ktskNgosUmiWaJFQpPYLKFLtEq0SWyRaJdwSDglXBJuia0SHoltEtslOiQ6JbokdkjslOiW2CXhldgtsUfCJ7FXYp9Ej0BQH6eCmT5Xrek/l/tBVNLPpCfMzkDFUBs0PIufWS5+Cnoa6oX8UAu0HzoAvQJheTq7RyyjV6HzUCvEZfQi6AJ0CIpBb0KHoSroCBSEHNBRqA96FqqGjkEh6F3IBn3cFoKXIW4aeB46Dp2FXoBOQJ1QF3QSaoBeg16H3oC4DeIt6CXobegdqB86BYWhJigCnZYK6uPNw5uNXWbRH6Poj1H0xyj6YzQzuf2EWW40fh/d8n10y/fRLd9Ht3wf3fJ9dMv30S3fR0d8H93rfXSojA5Ch6AAdBiqgo5AQcgBHYX6oGehaugYFIJsUA30HPQ8VA8dh16ATkCdUBd0EnoRegnqh05BYagJikCnoVqoAYpC+VAJNAbKg3KhM5AXyoFGQy9DZ6FXoHPQq9B56DXoAvQ69AYUg96E3oLeht6B3oUuQpcgFxSHiqHL0BXoKjQAtUHXoAQ0CBVCQ9BYqAAaB42HJkKToMnQFGgaZIVmSAX1woedQL3PFyn0jLxIYWS29WGX4CbIWQo9F0cEc3FEMBdHUTN6AiqEJkAToUnQZKgIehKaAk2FpkHToWLIApVAVqgUmgGVQTOhWdBsqByqgCqhOdBcaB5UBc2HFkALoWpoEbQYskFLoBpoKbQMqoXqoHrIDi2HVkAroQZoFdQIrYbWQGuhdVATtB7aAG2ENkHNUAukQZshHWqF2qAtUDvkgJyQC3JDWyEPtA3aDnVAnVAXtAPaCXVDuyAvtBvaA/mgvdA+qEcqqE98NFuetMbIx+94moSSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLIWSLJUpySY/Lls6VXE1oP6Yz25vp9p8+MQnbPJ8oL2d/9t4+EeMXV/IJs8jxkNSfeRx2+35cJs8/8Z4+GP15/yU7vbMBrgbSCJuZDpkUbpDBo1+cibT2fR/dvdfoy3OdAFttfH/nzd+4Wn17X/NeDiiHl5VDU09PGc8+NXDy+rfoh4CxsN+9XBedSn1IE9E6r+gHs4ZD4Pq4V3j4RfVw4vGwyvq4S3VsdXDLxgP76uHZ4yH31QPbxoPX1MPrxsPp9XDPzUefl49XDAefs140OeotbKD6kPvGA/H1MMrqgephzdUZ1cPb6vuph6MsU//DZP6TjyJ3S1T0t+smdAsaDZUDk2GKqBKaA40HZoLzYOqoGJoPrQAWgiVQtXQImgxZIOWQDXQUmgZNBaqheqgemg8ZIeWQxOhSdAKaCXUAK2CGqHV0BpoLWSF1kFN0HpoA7QR2gQ1Qy2QBm2GJkA61Aq1QUXQVGgatAVqhxxQCeSEXJAbmgFthTzQNqgAGgdthzqgQqgT6oJ2QDuhbmgKtAvyQruhPZAP2gvtg3qkgsb/jmfekPSNXPUmpKkfUXWrzOk1mVz9gxqskdU85OnVaeZ7rs8+mL4+ezpCsxMdwYlA7USXcaKTONERnOgIToR0J8K2E83bidDsRGh2IjQ70bydaNBONGEnAq4TAdeJgOtEwHUi4DrR2J0Iv040aCcCrhPN24mA60QwdqKxO9HYnQi/ToRYJzqCEwHXiRDrRLdwoss4EXCdaMJOhF8nwq8T3cmJTuJEJ3EiGDsxmDoRVJ0I1M5MByr+hHmq7C7eeztKNte7nx6jtvjuSfcYi+qyl40//hnVY0vMuMpAvQfNf7eU+ok7DNQL0SLm9ECXo19O/1HW4eN+2nuRD3LGgzjtdxDzlAczs3Ol6JyDmJQfxKT8ICblBzEpP4gFiUFM0Q9iin4QU/SDWHQYxIT9ICbsBzFhP4jliUFM3w9i+n4Q0/eDWJ4YxGT+ICbzBzGZP4jJ/EFM5g9iMn8Qk/mDmMzPaCxUC9VB9dB4yA4thyZCk6AV0EqoAVoFNUKroTXQWsgKrYOaoPXQBmgjtAlqhlogDdoMTYB0qBVqg4qgqdA0aAvUDjmgEsgJuSA3NAPaCnmgbVABNA7aDnVAhVAn1AXtgHZC3dAUaBfkhXZDeyAftBfaB/VIBfUZj26bgZrBmvuR+w3SM1gj+w0iI/sNHmK/QZn5J19NpW8wR35yg+j9v6mKG265YfMn3kY103z3LWr6r5nvp1/cx2vUHv71aZ90WvHzfGna94yv5qXI/b087fF/Z9qDHTuclW4Uqhl65QxhUJ/9CFZ7782Z1frvdyOy2izn36OuIHv+w/6+bNaePVn36dL3oPGHZFLtdCfR/kEkTmkE9crPdZVEb1Mzpt/KjTyyV2ColY+/VB/5zN6FoW9R/+Yf5kZG3orxwOskers6z3ohMvJWjJ8YIud8Hgfu72ecUp3kP+VGvpzH60fyLtWW5qbbkjr7/V31vVCN6nfUw9Pq26Qeeo2HQvV7DhkPt9RHhjcedaRzqNOQHzoO7YdegDqhE9AB6CR0EApBh6EqKAj1Q0ehZ6FTUBNUDR2DbFAt1ABFoTFQHjQayodyoTOQFyqBcqCL0CXoLOSC4lAbdAG6BhVDCegyNAgVQlegIegqNCAV1Odhq/MqzB+swvzBKsxTZfQEVAhNgCZCk6DJUBH0JDQFmgpNg6ZDxZAFKoGsUCk0AyqDZkKzoNlQOVQBVUJzoLnQPKgKmg8tgBZC1dAiaDFkg5ZANdBSaBlUC9VB9ZAdWg6tgFZCDdAqqBFaDa2B1kLroCZoPbQB2ghtgpqhFkiDNkM61Aq1QVugdsgBOSEX5Ia2Qh5oG7Qd6oA6oS5oB7QT6oZ2QV5oN7QH8kF7oX1Qj1RQr8q+dLHYHMncNR1SH5+PRRYPVkA9WAH1YAXUgxVQD1ZAPVgB9WAF1IMVUA9WQD1YAfVgBdSDnMCDFVAPVkA9WAH1YAXUgxVQD0Z6D1ZAPZin8mAF1IMVUA9WQD3IFzxYAfVgBdSDFVAPsioPVkA9WAH1YAXUgxVQD1ZAPVgB9WAF1IMVUA9WQD1YAfVgBdSDFVAPVkA9WAH1YAXUg/zLgxVQD1ZAPVgB9WRG+gWf1yvLTqmjd59ydnuklIp8KUqphTiW0Z9ud09BT0O9kB9qgfZDB6BnoFaoCDoIHYIC0GGoCjoCBSEHdBTqg56FqqFjUAiyQTXQc9DzUD10HHoBOgF1Ql3QSehF6CWoHzoFhaEmKAKdhmqhBigK5UMl0BgoD8qFzkBeKAcaDb0CnYNehc5DF6AY9Cb0LvQydBZ6DXodegN6C3obege6CF2CXFAcKoYuQ1egq9AA1AZdgxLQIFQIDUFjoQJoHDQemghNgiZDU6BpkBWaIRXUq5Febkt/ykZoJrQB2gRp0GZoNlQBTYXmQvOgKsgBOSE3tAhaDNmgJVAN5IGWQtuhWqgDqofqoE6oC1oOrYB2QCuhVVA3tBNaDfVAa6C10C7IB+2FmqD5UAu0XiqoL3q0Oy0e/vXvn+1b39Np6iN/6/vH5Kuf52rW/SxiPdAZn4dbqfo8E+BvGi3r1yOPcKFqcbofxA3/ofp2DScpozK9xIZ8eW+6Iz0NnYZ6IT90HGqB9kMvQJ3QCegAdBIqgg5Ch6Eq6AgUhPqho9Ax6FnoFHQIaoKqoRBkg2qhBigK5UMlUB40GsqFzkBeKAcaA12ELkEu6CwUh9qgC9A1qBhKQJehQagQugINQVehAamgvkTtox7+afytmoo7rNd8roPNoxpjvtRDyxc7ojzQQGIMP9q5yJdyRkUMJEsxVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgwVPgyQ8Wyz2p7ov7NURG5P7FWjkljzekxqQ51eh7ud8zD/Y55uN8xD/c75uF+xzzc75iH+x3zcL9jHu53zMP9jnm43zEP9zvm4X7HPNzvmIf7HfNwv2Me7nfMw80UebjfMQ/3O+bh1oo83O+Yh/sd83C/Yx7ud8zD/Y55uN8xD/c75uF+xzzc75iH+x3zcL9jHu53zMP9jnm43zEP9zvm4X7HPNzvmIf7HfNwv2Ne5q6Nerwf/1+ozyiQGCcxXuIJiUKJCRITJSZJTJYoknhSYorEVIlpEtMliiUsEiUSVolSiRkCQd0+vD05fYHzB7uTlz8uLzAZuZMu8qnnK75ufHcPRb5Ubyv5qd18uyJ7aWR0+DzA2vQ4uDL9C8O7nTakI9ocaDo0F5oHVUOLoMVQHbQcmgitgFZCDdBqyAo1QeuhDdAmqBnaDE2AWqEiaCo0DWqHXNAMyAMVQIVQJ9QF7YJ2Q3uhfVAZNBOaDZVDk6EKqBKqgoqhBdBCqBSyQUugGmgptAwaC9VC9dB4yA5NglZBjVAPtAZaC62DNkIapENt0BbIAZVATsgNbYW2QeOg7VAHtAPaCXVDUyAvtAfyQfOhFqmg3oDts+ewffYcts+ew/bZc9g+ew7bZ89h++w5bJ89h+2z57B99hy2z57D9tlz2D57Dttnz2H77Dlsnz2H7bPnsH32HLbPnsP22XPYPnsO22fPZbbTrUK9dB67aM9jF+157KI9j1205/EtOI89teexp/Y89tSex5d5Hjtsz2OH7XnssD2Pb8h57Lc9j/2257Hf9jy+Ieex+/Y8dt+ex+7b89h9ex67b89j9+157L49j923GY2FaqE6qB4aD9mh5dBEaBK0AloJNUCroCehRmg1tAZaC1mhdVATtB7aAG2ENkHNUAv0BKRBm6EJkA61Qm1QETQVmgZtgdohB1QCOSEX5IZmQFshD7QNKoDGQduhDqgQ6oS6oB3QTqgbmgLtgrzQbmgP5IP2QhZoH9QD/SM0JKV/xQTmgEG9MR1kc4yEfb+qCMzG40Xj/+qA5jdUjp9rPJxVvzJKFXvq4SvGwwX1MFrVnOohX5XA6mGM8bA8XRCsRuzORzaRjxwvH1lyPrLkfOTF+cgG85Hx5SMTzkctkY9aIh/ZYD4ylHzkJPnISfJRdeSj6shHNpiPbDAf2XU+csN85H/5yF7ykQ3mo67JR12Tjzw8H1lPPuqafORA+ciB8lHl5CNvzEemmI9MPx8ZUT4y/XxUR/nIlvKRLeWjcsrP5E5rPuJeWXUN7H8dFclcJztqVCRz0+xU9Tn3Xierrn3V1Edwr2x1bkRcFquuex2dGxFXw2Zvgr3nVtf0rbHvpovbtV/sdNKbOTmmHPXfyLzS570P5lPOJ6kj9ptGJpbuY2Jp3WN9jbr2c5Ev59mEkffsROQhhSZkKwXIVgqQrRQgWylAtlKAbKUA2UoBspUCZCsFyFYKkK0UIFspQLZSgGylANlKAbKVAmQrBchWCpCtFCBbKUC2UoBspQDZSgGylQJkKwXIVgqQrRQgWylAtlKAbKUA2UoBspUCZCsFyFYKkK0UIFspQLZSgGylANlKAbKVAmQrBZlsZT22Y/xWevn5KehpKAz1Qn5oP3QAegZqhYqgg1AAmgodhqqgedARKAg5oKNQH/QsVA0dg0KQDaqBnoOeh+qh49AL0AmoE+qCItBJaCf0IvQS1A+dgg5BTVALdBqqhRqgKJQPlUB50GgoFzoDeaEcaAz0MnQWegU6B70KnYdegy5Ar0NvQDHoTegt6G3oHehd6CJ0CXJBcagYugxdga5CA1AbdA1KQINQITQETYSs0DRoBlQATYbGQuOhSdA4aIpUUN+QDsbqWoEfmtKxzyjeTKJx5mBWMSczF7Ix/ZvUuvIvRmIj2wRGyrnIyPaAR1LFbbr7butMb6vD0FOHQaoOg1QdhqU6DDZ1GGzqMNjUYQCrw9BTh+GsDsNZHYalOoTtOoTtOgxSdQjidQjidQi/dRiI6hCM6xDu6xCa6xD86xCo6xCo6zAw1CFs12GYqMMwUZcJnM1YryzFtHsppt1LsfRTimWMUky7l2LhohQLQaVYCCrFYl0pFi5KsdhTikn4UixqlGJRoxQLeaVYnivFRHspFjVKsSxUiuW5UixjZFQGzYRmQbOhcqgCqoTmQHOheVAVNB9aAC2EqqFF0GLIBi2BaqCl0DKoFqqD6iE7tBxaAa2EGqBVUCO0GloDrYXWQU3QemgDtBHaBDVDLZAGbYZ0qBVqg7ZA7ZADckIuyA1thTzQNmg71AF1Ql3QDmgn1A3tgrzQbmgP5IP2QvugHqmg3pIOlXebvvZd0eszmCsxW2K5xGYJt0SFRI9EmcRGiQ0SUyWmS8yTcEosklgsUSPhkVgqUSvRIVEvUSexQ2KlxE6JbonVEmsldkn4JPZKzJdYLxDUtexLr78uJ5nVelNSfSCb32eT+Grj4UZuOlAZaa/xoK9Ta6i/h7WobPa+znj4FfVJC9QnfRXLU9mMPJv0Zxe1sqn5buPhiikiEvF9KjVXH/lz42GN8S/SF6o/+h1TJPNW7JfUw73ZejZJV2tqfepzskm6WqR41xT5oLjJZtvDJYderf6Kk6Z0WM/RT5jSo4uRIaqHbJ2jdoUOqIdsSl5qPFSrL/UPVO6p/qBF6g/6OfVr2RW4bKmSzcCziXc2Ff+h8fDLpoiohr5nPLxmSvd/4+ehHsqNh0vqQS3yXVd/cnZBcavx8KL6pULjoVV95GPy7WyavUX9geoj2TQ7m11nVyizdUQ2zc4m1dlcWjceosics/Vls/qS1UeyheY9b1fPFpbFxsO/Vg/Z8nGb8fBbKB/nqIas2sRi9X3+j+aIKADbjIf/jCov+5pmm/rs31e/ppZMJ6gPLUm/bVp9KFtu3kehpteo3/Yn6kONxsMPzZEP6jJ9qfq1H6kPqZXVb6mf0A/Ut089ZCvhbIGXXZgdrqP0Zer3/7X6tVnGw4/NEVE/ZYukhcaDGSXRcLmj16nfPwr1Tqvx8BX1kXvKHL1effY49fvs6ukJ9VnDBfxN9V2StbS+XH3ORPXZK9TTZPW0Uj1NUZ+m7u+Zph6yNXO2VK40HopzI6Iezi5WqwXtK+ohW8feW39my857a8tsIZotF/cYD+Xq4X8aDwvUw3BNqDeof+ti9aHspMJweafXql9bpj6UvawyO2Wi1uPvqIfstEd2CiI7KZGdTPjo2QB9lfo7tqgPZQv7bBl/T/WuN6rP3q6eVqunDvVZ2UI+W63/qfGwS33SGvVJu2W5rq9VH9qL6ly9Bfhr6uGO8bBV/QH3bgmYYDwcUA/Z8nq4UA4aYSCzLJCjX1ah5qjRVuzG3zRPvcbbE1FTxTn6b6tfOWY8zFd/yH7joVo9BI2HseohZDxMHy6pZ5jv9tFvqd/1gvHwe+rhWeMhT/3SYePhm6bIB0VAK5YUWjHR3Iop8FZMerdiEjqjA1ATVA0dhE5DUagWaoDyoHwoFzoDeaESKAcaDY2BLkKXoLOQC4pDbdAF6BpUDCWgy9AgVAhdgYagq9CAVFDXs++v/C8m8dX/ZeZXW9O/OvxXvYI6+hXUGxmNhQqgcdB46AloAjQRmgRNhoqgJ6Ep0FRoGjQdskAlkBUqhWZAZdBMaBY0GyqHKqBKaA40F5oHVUHzoQXQQqgaWgQthmzQEqgGWgotg2qhOqgeskPLoRXQSqgBWgU1QquhNdBaaB3UBK2HNkAboU1QM9QCadBmSIdaoS1QO+SAnJALckNbIQ+0DdoOdUCdUBe0A9oJdUO7IC+0G9oD+aC90D6oRypoZPzD5eMXcwXFw21JUvXZcRX4H/nepPtZg3lsNyB9hvuOtuAw97fEOJnBOInxEk9IFEpMkJgoMUliskSRxJMSUySmSkyTmC5RLGGRKJGwSpRKzJAok5gpMUtitkS5RIVEpcQcibkS8ySqJOZLLJBYKFEtsUhisYRNYolEjcRSiWUStRJ1EvUSdonlEiskVko0SKySaJRYLbFGYq3EOokmifUSGyQ2SmySaJZokdAkNkvoEq0SbRJbJNolHBJOCZeEW2KrhEdim8R2iQ6JTokuiR0SOyW6JXZJeCV2S+yR8Ensldgn0SMQ1NuxcjgfWf98ZP3zkfXPR9afUSE0AZoITYImQ0XQk9AUaCo0DZoOFUMWqASyQqXQDKgMmgnNgmZD5VAFVAnNgeZC86AqaD60AFoIVUOLoMWQDVoC1UBLoWVQLVQH1UN2aDm0AloJNUCroEZoNbQGWgutg5qg9dAGaCO0CWqGWiAN2gzpUCvUBm2B2iEH5IRckBvaCnmgbdB2qAPqhLqgHdBOqBvaBXmh3dAeyAfthfZBPVJB3fEIXkOl7sRcF/mw11EdMR6S5ohIT//GeNDklM6fZKZ0nOl/x/BWYBv2hduw792GPeo27AS3Yae7Dbu9bdgTb8MedRv2xNuwh9uGffa2zA5rF7bpX0e0vI5oeR3R8jqi5XWMFNcRO68jdl5H7LyO0eA6Iul1RNLriKTXMW5cR1y9jrh6HXH1OsaN64iy1xFlryPKXkeUvY4oex1R9jqi7HVE2YzGQrVQHVQPjYfs0HJoIjQJWgGthBqgVVAjtBpaA62FrNA6qAlaD22ANkKboGaoBdKgzdAESIdaoTaoCJoKTYO2QO2QAyqBnJALckMzoK2QB9oGFUDjoO1QB1QIdUJd0A5oJ9QNTYF2QV5oN7QH8kF7oX1Qj1RQd6u3Cqq9zO+Z1AsFt2L64Jvim5XBOInxEk9IFEpMkJgoMUliskSRxJMSUySmSkyTmC5RLGGRKJGwSpRKzJAok5gpMUtitkS5RIVEpcQcibkS8ySqJOZLLJBYKFEtsUhisYRNYolEjcRSiWUStRJ1EvUSdonlEiskVko0SKySaJRYLbFGYq3EOokmifUSGyQ2SmySaJZokdAkNkvoEq0SbRJbJNolHBJOCZeEW2KrhEdim8R2iQ6JTokuiR0SOyW6JXZJeCV2S+yR8Ensldgn0SMQ1D0qtqkXx/2GWcW2bThNV6oSQH2uSTJ7uC6jp6Ew1Av5of3QAegZqBUqgg5CAegwVAUdgYKQAzoK9UHPQtXQMSgE2aAa6DnoeageOg69AJ2AOqEuKAKdhF6EXoL6oVPQIagJaoFOQ7VQAxSF8qESKA8aDeVCZyAvlAONgV6GzkKF0CvQOehV6DzUBr0GXYBeh96AYtCb0FvQ21Ax9A70LuSCLkKXoDh0GboCXYUGoGtQAhqEhqDJ0FhoPDQRmgRZoWnQDKgAGgdNkQrq2+991cIbpsjIqbdPe+pNbeWLmYb3+v469th+Dgfh1Dbevxpe3h05EffR67yf64m4DpXtGI1P+yuV7HSmu55q3N9Rn6b2hW5R2x9nqxbz+t2dA/qg+lCl+tAvpv+MLqRIf2CWOVFGT0O9kB9qgfZDB6BnoFaoCDoIHYIC0GGoCjoCBSEHdBTqg56FqqFjUAiyQTXQc9DzUD10HHoBOgF1Ql3QSehF6CWoHzoFhaEmKAKdhmqhBigK5UMl0BgoD8qFzkBeKAcaDb0MnYVegc5Br0LnodegC9Dr0BtQDHoTegt6G3oHehe6CF2CXFAcKoYuQ1egq9AA1AZdgxLQIFQIDUFjoQJoHDQemghNgiZDU6BpkBWaIRXUd4xcGPDwOZHKPG7ieMPIKwEiIwlQJgHaid0iczHTPxcz/XOxopTRE1AhNAGaCE2CJkNF0JPQFGgqNA2aDhVDFqgEskKl0AyoDJoJzYJmQ+VQBVQJzYHmQvOgKmg+tABaCFVDi6DFkA1aAtVAS6FlUC1UB9VDdmg5tAJaCTVAq6BGaDW0BloLrYOaoPXQBmgjtAlqhlogDdoM6VAr1AZtgdohB+SEXJAb2gp5oG3QdqgD6oS6oB3QTqgb2gV5od3QHsgH7YX2QT1SQb37bq2o541SxeKudOQcLgjTxWJBtjL8QfqeI2/6U75reMVw8aipz71kPDjT4Xc3wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm8/wm9/5sex5+4pqfQHtb8XnT+NoO7LHqP6N6MimZPIf60OF7aoH9C/Mj6kN6un1lGRzLHrG6MimWO4Xx2lfvte/Ggs+NFY8KOx4EdjwY/Ggh+NBT8aC340FvxoLPjRWPCjseBHY8GPxoIfjQU/Ggt+NBb8aCz40Vjwo7HgR2PBj8aCH40FI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MFI6MlE4r3pUPl3Tke7X+I3ptGUO9Jf8LwVGcHFoA6sBzbgQWnDiykdmBRsAOLnh1YRurAQlwHFpU6sCjYgaXFDiwtdmCJsAOLUR1YFOzA0lQHFho7sOjZgeXDDizudWAJuwOLex1Y7urAomcHFj07sBDXgYWxDiyMdWBpuAPLlR1YNOvA8mgHlkc7sPzbgaW+DiwDdmBpuAMLvh2Zxa9/MnxiT5sW+VQH9tQLOl42RT7fk3uf3YG9z+Gc3sPNWtzPHMWDHcZ7CsspYSynhLGcEsZyShjLKWEsp4SxnBLGckoYyylhLKeEsZwSxnJKGMspYSynhLGcEsZyShjLKWEsp4SxnBLGckoYyylhLKeEsZwSxnJKGMspYSynhLGcEsZyShjLKWEsp4SxnBLGckoYyylhLKeEsZwSxnJKGMspYSynhLGcEsZyShjLKWEsp4SxnBLGckoYyylhLKeEsZwSxnJKGMspYSynhLGcEsZyShjLKWEsp4SxnBLGckoYSyZhLJmEsWQSxpJJGIskYSyEhLEQEsbyRhjLN2Es34SxDBPGwksYCy9hLK6EsbgSxuJKGMspYSynhLGcEsZyShjLKWEsp4SxnBLGckoYyylhLKeEsZwSxnJKGMspYSynhLGcEsZyShjLKWEsp4SxnBLGckoYyylhLKeEsZwSxnJKGMspYSynhDPLKU+jtLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLWitLVmStteZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKNRZKPRTDbqRzaqIRvVkI1qyEY1ZKMaslEN2aiGbFRDNqohG9WQjWrIRjVkoxqyUQ3ZqIZsVEM2qiEb1ZCNashGNWSjGrJRDdmohmxUQzaqIRvVkI1qyEY1ZKMaslEN2aiGbFRDNqohG9WQjWrIRjVkoxqyUQ3ZqIZsVEM2qiEb1ZCNashGNWSjGrJRDdmohmxUQzaqIRvVkI1qyEY1ZKMaslEN2aiGbFRDNqohG9WQjWrIRjVkoxqyUQ3ZqIZsVEM2qiEb1ZCNashGNWSjGrJRDdmohmxUQzaqIRvVkI1qyEY1ZKMaslEN2aiGbFRDNqohG9WQjWrIRjVkoxqyUQ3ZqIZsVEM2qiEb1ZCNashGNWSjGrJRLZON7ldbENROgzPpg8cH0pHz74yhujcS+5D3WKhZ7Nce9IUW/2B8riXyYS+0GJ7QDerPpP/i7xj+LTXTq45Cz8mNZP5p72Crg9r88J56iBoP76b3PBwc/iKezlVfxKHhLfi/qxRAvl2ZXiN4Cnoa6oX8UAu0HzoAPQO1QkXQQegQFIAOQ1XQESgIOaCjUB/0LFQNHYNCkA2qgZ6DnofqoePQC9AJqBPqgk5CL0IvQf3QKSgMNUER6DRUCzVAUSgfKoHGQHlQLnQG8kI50GjoZej/Z+/e4+Os7zvR2xgKyBKWL7Gk0UyUxIOkTIi5CIy5DGBsbrKfsRjM1QYsxOUVkhASUEgId7C4mIvNMDdkPGDTFir3orM6Z7vq7qu7Z3tWq9X2dC/VbrcXbdPTvnbb3W222l73nNM980ho8nsfaEqTNKVZ5588b1m2sT3zeb7f7++rR/vRi+gl9DJ6BR1AB9GrqIBeQ0VUQmVUQVX0OhpFu9AhlEBvoMOoht5EO9Fb6Ag6ilaht9FqlELtqAutRGtRE2pBa1AzWh9qOHpgIWKfrQfwwROC92qWXjVLD59l1pClH83SuWbpXLP0qlk60CwdaJYONEtXm6UfzdLVZulOs/S/WXq5LL1clk4yS2eXpbPL0pNl6WOzdGhZesAs/VqWjjBL95ale8vSLWbp5bL0jll6x+xiN/Vg+HCm7f89/oxPhvhUiA0h0iHWhjg9RHeInhAdIXpDfDpEJkQixGdCnBHisyE+HmJjiDNDnBXi7BDnhOgLcW6I80I0hdgU4vwQm0O0hLggxIUhVodYE+KiEBeHyIa4JMSlIS4LsSXE5SFSIbaG2BbiihBXhrgqxNUhrgnRH2J7iB0hWkNEIXIhdoZYF6ItRHuIgRDXhsiHSIa4LsSuENeH6ApxQ4gbQ9wUYmWI5hA3h7glxKoQu0PsCXFriNtC3B5ifYi9IQZD3BFiKMSdIe4KcXeIewIMR8N8pe3iF9j+7NIa9balDmJ5fPEbcTez0Dh8ld6gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gl96gd7E3eGghYn87TmM2G+NJ0j9eMfIBi5b76/8/MfJBg6TG/l9jMPX+8dO31/6+1vheDT/D004+2t+r4fjG58j3vvH5dQ6A0hwApTkASnMAlOYAKM0BUJoDoDQHQGkOgNIcAKU5AEpzAJTmACjNAVCaA6A0B0BpDoDSHAClOQBKcwCU5gAozQFQmgOgNAdAaQ6A0hwApTkASnMAlOYAKM0BUJoDoDQHQGkOgNIcAKU5AEpzAJTmACjNAVCaA6A0B0BpDoDSHAClOQBKcwCU5gAozQFQmgOgNAdAaQ6A0hwApTkASnMAlOYAKM0BUJoDoDQHQGkOgNIcAKU5AEpzAJTmACjNAVCaA6A0B0BpDoDSHAClOQBKcwCU5gAozQFQmgOgNAdAaQ6A0hwApTkASnMAlOYAKM0BUJoDoDQHQGkOgNIcAKU5AEpzAJTmACjNAVCaA6A0B0BpDoDSHAClOQBKcwCU5gAozQFQevEA6GFaoLb4pv3txzG20RG10RG1UQu30R+10R+10RG10RG10RG10RG10RG10RG10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10QO10aG00RG10RG10RG10RG10RG10Zm20REtqh89izahLHoOnYKS6CR0MlqBnkeDaBk6Fb2A9qNV6EX0EnoZvYJ2ogPoIHoVFdBrqIhKqIwSqIKqaBd6HY2iQ+gNdBjV0JvoLXQEHUVvo9UohdpRF1qJ1qIm1ILWoGa0PtRwvWgNE/enTwgjdlH3os+jL6B+9EV0H/oSyqF16H70ZfQV9ADKoAfRMMqjr6KH0NfQRvR19DA6G/Whb6BH0Gb0KHoMPY52oz3oCfQkego9jZ5B+9A2NIKeRZtQFj2HTkFJdCo6Ca1Az6NBtAydjF5A+9GL6CX0MnoFHUAH0auogF5DRVRCZVRBVfQ6GkW70CGUQG+gw6iG3kQ70VvoCDqKVqG3URNaiZpRC1qN1qC1aD1qRynUFWo4eoTvJ/MOvew79LLv0Mu+Qy/7Dn38O3S279DZvkNn+w69+jv0ue/Q575Dn/sOXf07dL3v0PW+Q9f7Dl39O/TA79ADv0MP/A498Dv0wO/QA79DD/wOPfCimtAmdD7ajFrQBehCtBqtQRehi1EWXYIuRZehLehylEJb0TZ0BboSXYWuRtegfrQd7UCtKEI5tBOtQ22oHQ2ga1EeJdF1aBe6HnWhG9CN6Ca0EjWjm9EtaBXajfagW9Ft6Ha0Hu1Fg+gONITuRHehu9E9oYajR9/biNw+Ha9APkbFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFOUPFObNYcT7e2F/fzf76B66tb98wspjOxfinPkE6J53AJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpnAJpmdJpmdJpmdJpnVJpmkJpncJpncJpncJpncJpnAJpnAJhcnsE+SuMeoh49RAR+jAj5GzXuMe+cxat5j1K7HqF2PUbse4557jPr0GPXpMerTY9Snx6hPj1GRHqMiPUZFeoyK7Rj16THq02PUp8eoDY5RQR2jUjhG/XaMmvAYNeEx6tNjVHrHqOaOUX0co/o4Rg9xjLrvGJXsMSrZY1Sdi7oX3YdyaCdah+5HB9Fb6BT0IBpGeZREu9AR9DA6ih5Dj6PdaA9ahZ5AT6K30fNoED2NRtHr6Bm0D/WjZ9EL6CX0MnoRvYIOoFdRAb2GiqiEyqiCqqgJrUTNqAWtRmvQWrQetaMU6go1HD21VA9v/+mRoByOi9+pkQ8qi+M17TsXlrKfJp2nSedp3pfTZPU0WT3NK2Ca5J7m/TxNck/z7p7m/TzN+3mapJkm8adJ/GkSf5p39zTv7mne3dPcDaa5G0xzN5jmbjDN3WCad/4094Zp7g3T3BumuRtMczeY5m4wTX5Mkx/T5Mc0+TFNYkyTGNPcDaZJhWne+dO886fJ+GkyfpocmObeN82daZo70zTpPE3mTnPfmOZuN809bJrUmyb1prm/TXPXmiavFrUfvYheQi+jV9ABdBC9igroNVREJVRGFVRFr6NRtAsdQgn0BjqMauhNtBO9hY6go2gVehs1oZWoGbWg1WgNWovWo3aUQl2hhqNneLzyN+PPOD3AcLRvcX68+JN+JP5JD0QjS19lP3FCzGf5HuW/GvwZF9EcoiXEaSFWhWgNsTrEmhBrQ6wL8bEQ60O0hWgP0REiEaIzRDJEKsTHQ3SF+ESIT4b4VIgNIdIhTg/RHaInRG+IT4fIhPhMiDNCfDbExhBnhjgrxNkhzgnRF+LcEOeF2BTi/BCbQ1wQ4sIQF4W4OEQ2xCUhLg1xWYgtIS4PsTXEthBXhLgyxFUhrg5xTYj+ENtD7AgRhciF2BliIMS1IfIhrguxK8T1IW4IcWOIm0LcHOKWELtD7Alxa4jbQtweYm+IwRB3hBgKcWeIu0LcHeKeAMPRcx+VbwcXf2u1f71i5G/n94X7Hr8dXPw94r+5YuT494X7ofy+cM+zk3PyiiAk39Mn0ZXoarQDbUCnozbUiz6NMiiPrkPXozPRWegc1IduROeiTegWtBmdjy5Ee9Ct6GJ0G7odXYbuQZejvehOdBfahj6D+tEVoYajFxZeRO9/LtVSoP5pHCEf/IWB7/9ywnrabd8avlj/pP6BfxoG2oP1i1/wQVX7+dKyT7B48gkWTz7BgtOiTkOrUCtajdagtWgd+hhaj9pQO+pACdSJkiiFPo660CfQJ9Gn0AaURqejbtSDetGnUQZ9Bp2BPos2ojPRWehsdA7qQ+ei89AmdD7ajC5AF6KL0MUoiy5Bl6LL0BZ0OdqKtqEr0JXoKnQ1ugb1o+1oB4pQDu1EA+halEfXoV3oenQDuhHdhG5Gt6DdaA+6Fd2Gbkd70SC6Aw2hO9Fd6G50T6jh6MVwiLBicYjw0kel0P7o19dv1S/+WfzJ3/dC+/319dH6xT9fPvLdFtpx1/KL8Q8dr7hHPjoV98uUKjlKlRylSo5SJUepkqNUyVGq5ChVcpQqOUqVHKVKjlIlR6mSo1TJUarkKFVylCo5SpUcpUqOUiVHqZKjVMlRquQoVXKUKjlKlRylSo5SJUepkqNUyVGq5ChVcpQqOUqVHKVKjlIlR6mSo1TJUarkKFVylCo5SpUcpUqOUiVHqZKjVMlRquQoVXKUKjlKlRylSo5SJUepkqNUyVGq5ChVcpQqOUqVHKVKjlIlR6mSo1TJUarkKFVylCo5SpUcpUqOUiVHqZKjVMlRquQoVXKUKjlKlRylSo5SJUepkqNUyVGq5ChVcpQqOUqVHKVKjlIlR6mSo1TJUarkKFVylCo5SpUcpUqOUiVHqZKjVMktliqvMJxoYjjRxHCiieFEE8OJJoYTTQwnmhhONDGcaGI40cRwoonhRBPDiSaGE00MJ5oYTjQxnGhiONHEcKKJ4UQTw4kmhhNNDCeaGE40MZxoYjjRxHCiieFEE8OJJoYTTQwnmhhONDGcaGI40cRwoonhRBPDiSaGE00MJ5oYTjQxnGhaHE4ciF9EUX55veZcNxLvAiyLhuLvAP3eYeb2Xwz+9hbxfIhsiL4QiRC7QtwfYDg6+JcV139RTV2vXbd/deT7X1J/d5X0h3mm0vd9QP0dHq70g5xCf5hS+K9UAX93he/fynr31YWXP6tF/2PhBwoLP7BUEPWxxdPHpkcfOyF97IT0sQXSx25HH7sdfex29LEv0semRx/7In3sffSxWdLHlkQfWxJ97IT0sTPRx7ZDH1sSfWw09LHR0McGRR+bF33sTPSxPdLHBkUfexF9bGz0sZXRx65F3+Kewmvcllu4LbdwW27httzCbbmF23ILt+UWbsst3JZbuC23cFtu4bbcwm25hdtyC7flFm7LLdyWW7gtt3BbbuG23MJtuYXbcgu35RZuyy3cllu4LbdwW27httzCbbmF23ILt+UWbsst3JZbuC23cFtu4bbcwm25hdtyC7flFm7LLdyWWxZvy0XPDOJbyG9+4OHBhzkz+E7fw6L03d5+v9vb7vb9I8fvusfvun+zd93ywqt+6Vb0e8vD29SinkfPopPQfrQR7Qw1XP97Wvq+7id/mLfY8Yd7/tA83LPK4uEvxa+NlSGaQ7SEOC3EqhCtIVaHWBNibYh1IT4WYn2IthDtITpCJEJ0hkiGSIX4eIiuEJ8I8ckQnwqxIUQ6xOkhukP0hOgN8ekQmRCfCXFGiM+G2BjizBBnhTg7xDkh+kKcG+K8EJtCnB9ic4gLQlwY4qIQF4fIhrgkxKUhLguxJcTlIbaG2BbiihBXhrgqxNUhrgnRH2J7iB0hohC5EDtDDIS4NkQ+xHUhdoW4PsQNIW4McVOIm0PcEmJ3iD0hbg1xW4jbQ+wNMRjijhBDIe4McVeIu0PcE2A4ep0O5yY6nJvocG6iw7mJDmdR29EOtAGdjrpRG+pFn0YZlEfXoevRmegsdDY6B/WhG9G56Ga0Cd2CNqPz0W60B12ILkK3oovRJeh2dBu6DN2DtqDL0V50J7oLbUOfQf3oilDD0ejxQ/y/sSXZH0B/FJ/m/4f4h44f2Y/8QJupxqhx2eL469DC+2ypffpTjln/dLENeoMz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogz/ogOOeKMP+KMP+KMP+KMP+KMP+KMP+KMP+LFF3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGH3HGHzHhiDjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjzjjjxaj8jBRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojJPVOaJyjxRmScq80RlnqjME5V5ojK/GJU1Rqz/IEjKRTSHaAlxWohVIVpDrA6xJsTaEOtCfCzE+hBtIdpDdIRIhOgMkQyRCvHxEF0hPhHikyE+FWJDiHSI00N0h+gJ0Rvi0yEyIT4T4owQnw2xMcSZIc4KcXaIc0L0hTg3xHkhNoU4P8TmEBeEuDDERSEuDpENcUmIS0NcFmJLiMtDbA2xLcQVIa4McVWIq0NcE6I/xPYQO0JEIXIhdoYYCHFtiHyI60LsCnF9iBtC3BjiphA3h7glxO4Qe0LcGuK2ELeH2BtiMMQdIYZC3BnirhB3h7gnwHD05vFp1Q/ztOoHMKSKB2J//8SR49Oq/9/R/1t0VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN10VN3f7qiKy5ctXxb/r/Hhq/mka1A/2o52oAjl0E40gK5FeXQd2oWuRzegG9FN6GZ0C9qN9qBb0W3odrQXDaI70BC6E92F7kb3hBqOjvB0wyMLW6+fQ/eiz6MvoH70RXQf+hLKoXXofvRl9BX0AMqgB9EwyqOvoofQ19BG9HX0MDob9aFvoEfQZvQoegw9jnajPegJ9CR6Cj2NnkH70DY0gp5Fm1AWPYdOQUl0KjoJrUDPo0G0DJ2MXkD70YvoJfQyegUdQAfRq6iAXkNFVEJlVEFV9DoaRbvQIZRAb6DDqIbeRDvRW+gIOopWobdRE1qJmlELWo3WoLVoPWpHKdQVajg6uhCxLXHTdsLCz1wWPbNi4T+y3ojFFx31i1NPWPiJy6JfiD/yqfrFn8Uf+Z36xa+sWPgzLIt2xTX/f6hfnHjCwn9dvWyOPxK3S6fUPxJdtzzuc+rNQ3R2fPXbcRvxK/WL34ov/mP9ojX+eb9bv9hywsI/w7Lom8sX3l31Diz+lf5T3KCcuPDnWRb95IkL/+DLomp88e/qF78Zf/J/rl8cjj/y+3Ftvnzhr3BZ9Ej8kT+oX/yb+GK+fvGjJy78nS2L/tGJC6G+LPr5FQv/hsuiXPy7/7f6xQ0nLPzL1f8+4otv1S9+f/nCv8Ky6O74DxTFf4y55fFf4ttLT3s8+cT4uQ0/Sqk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/QKk/8O1Sv6Gr0TWoH21HO1CEcmgnGkDXojy6Du1C16Mb0I3oJnQzugXtRnvQreg2dDvaiwbRHWgI3YnuQneje0INRz/23tbOsmjFid/+294+tfCDP06OZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM2So1lyNEuOZsnRLDmaJUez5GiWHM0u5ug7C1G59NI/j2X481hOP48V9/NY0D6PZfjzWEc/j2X481i0XtRSeP/Thf+id5ndTDG7mWJ2M8XsZorZzRSzmylmN1PMbqaY3Uwxu5lidjPF7GaK2c0Us5spZjdTzG6mmN1MMbuZYnYzxexmitnNFLObKWY3U8xuppjdTDG7mWJ2M8XsZorZzRSzmylmN1PMbqaY3Uwxu5lidjPF7GaK2c0Us5spZjdTzG6mmN1MMbuZYnYzxexmitnNFLObKWY3U8xuppjdTDG7mWJ2M8XsZorZzRSzmylmN1PMbqaY3Uwxu5lidjPF7GaK2c0Us5spZjdTzG6mmN1MMbuZYnYzxexmitnNFLObKWY3U8xuppjdTDG7mWJ2M8XsZorZzRSzmylmN1PMbqaY3Uwxu5lidjPF7GaK2c0Us5spZjdTzG6mmN1MMbuZYnYzxexmitnNFLObKWY3U8xuppjdTDG7mVqc3fzEQsTGo5aHTlz4/ZdFP7dw1jj23sM9Fj/70eVh3j26eMM4xtdS7aVO3EuduJc6cS914l5q5L1UjXupGvdSNe6lDt5LDbmXGnIvNeReKua9VJR7qSj3UlHupWLeS325l/pyL/XlXurLvdSXe6kv91Jf7qW+XFQT2oTOR5tRC7oAXYhWozXoInQxyqJL0MfQpegytAVdjlJoK9qGrkBXoqvQ1ega1I9OQ9vRDtSKIpRDO9E61Iba0QC6FuVREl2HdqHrURe6Ad2IbkIrUTO6Gd2CVqHdaA+6Fd2Gbkfr0V40iO5AQ+hOdBfqRHeje0INRz+59PSED/mEkh+uxyfE20RXnzjyQc9R+A5rRd/3Byp8v3Z+/tpWfYajnzq+O3d8d+693bl4C+5341/n+Fd6frdvqGB37qc/Ku+sP6lf3HDie6/2N1f8tb7X4pfQaX/Jm+5v0Xut8e1BPmoLq9/je63xXVR+uN50jU7+dxd7zZ/5S76ZTPz9YX5p5Ht/Ltz4wu/zet0/G7/P4pOhn69fRP3xafu/jT80WL/44/p/YXRN/KFc/KF4R+AnTox/+v/SqNWmwhKtsbvQyIHGH2Bj/HPjj1wQvxnYZmi8k7fWL34m/i3PiH/LifhDjQWHxpuyEQCNtYjGLfGO+sXh5eGb8u74LzL+yNLCQ/TZ+JeuxB+KNy6e+uDvZdB4w8Z/4oeWh2/YOC6q8cVS9DXeeUvxE22Mf4sn4g+dV794PL44I35txBeNFNxVv3iTb0/w8frFxqU1i1r8C50Z/0I/xnpFI7Yab8LGe6/xbox3KH46vmgk42/VLw4sf+8f9Sfii3T9YjS+aKxpNHZTbqhfPBn/UGNN4zu80xpvsIH4FzwhfIM13leNZZdGlDTeYI23U+NdFNUvnuM907j7XBP/keOPNG5DS7edb9Y/cHP8gcZtJ95Z+bn4onFzual+8Q8p23ril2/8mjgr/nuejj/UeOM1gn4p+hfXaX45/rGlLZronPhD/yb+UOOO8yGyOuqLf9rvxB+6tH7xrfhiKZGjc+Mf+4P4Q41FmsZCTuP22Ij2xmrNUoJGW+Off0r84jkvvvrj+LMai0SN6Gzk42frFyeQhktJF50f//wTibpc/eJHVnxQwkWb489ujn/eBfHVaSuCzIqXhFrD+2l0Yfw5q+PPvii+WhtfXRxfrY8/Ld7waY8vGjfQxn2zu36RiD/SuDk2tpQaO0mNe9n770GNW8/77y+Nm1HjTjFUv0jHF79Xvzgjvli6HUTZ+L/1rPhDjQpjKWyjTfGPnRd/qJHxjYqqse3VqIoa9UijQmlUFn9xaRBdEv8eA/GHGjf3xq38fXfw6NL4s2+Ory6Lr26JP6txM2/cseOdsr3xJ22JP+mO8JYdXR5/6C7u0I1lrvfvcC2tbm1vrV/cF1807qxL98jh6O8s3EHqIRqNv/ey237WYmRtv6z+/z9e/4F74xA6UL94ML54OX4NxBffqF98Ib54IX7xxRfxU82/GF+8Ur/4e/FF/G0bfzK+mKtfvBNfvFS/OBpfVOsXY/HFk/WLF+OLUhwa8cVw/eLW+L/3S/WLfxB/5J36xU/FF8X4jxtfvFq/eDa+eLd+8ePxxcH6xd+J33E98d/S/fGHKvWLr8cXL9YvRuKLQhw68UU5Dpb44rX6xd9fWGubYP9iB1OiHUyJdjCp3MHUbQdToh3M2XYwt9zB3HIHs+UdzNl2MJvcwcxoBzO4HczgdjB33sE0eQdzoR3M4HYwxdzBNHkHU7dFfQJ9En0KbUBpdDrqRj2oF30aZdBn0Bnos2gjOhOdhc5G56A+dC46D21C56PN6AJ0IboIXYyy6BJ0KboMbUGXo61oG7oCXYmuQleja1A/2o52oAjl0E40gK5FeXQd2oWuRzegG9FN6GZ0C9qN9qBb0W3odrQXDaI70BC6E92F7kb3hBqul3/Bt29bGbdMD0T/GxsQs2xAzLIBMcsGxCwbELNsQMyyATHLBsQsGxCzbEDMsgExywbELBsQs2xAzLIBMcsGxCwbELNsQMyyATHLBsQsGxCzbEDMsgExywbELBsQs2xAzLIBMcsGxCwbELNsQMyyATHLBsQsGxCzbEDMsgExywbELBsQs2xAzLIBMcsGxCwbELNsQMyyATHLBsQsGxCzbEDMsgExywbELBsQs2xAzLIBMcsGxCwbELNsQMyyATHLBsQsGxCzbEDMsgExywbELBsQs2xAzLIBMcsGxCwbELNsQMyyATHLBsQsGxCzbEDMsgExywbELBsQs2xAzLIBMcsGxCwbELNsQMyyATHLBsQsGxCzbEDMsgExywbELBsQs2xAzLIBMcsGxCwbELNsQMyyATHLBsQsGxCzbEDMsgExywbELBsQs2xAzC5Opf4uETtBxE4QsRNE7AQRO0HEThCxE0TsBBE7QcROELETROwEETtBxE4QsRNE7AQRO0HEThCxE0TsBBE7QcROELETROwEETtBxE4QsRNE7AQRO0HEThCxE0TsBBE7QcROELETROwEETtBxE4QsRNE7AQRO0HEThCxE0TsBBE7QcROELETROwEETtBxE4QsRNE7AQRO0HEThCxE0TsBBE7QcROELETROwEETtBxE4QsRNE7AQRO0HEThCxE0TsBBE7QcROELETROwEETtBxE4QsRNE7AQRO0HEThCxE0TsBBE7QcROELETROwEETtBxE4QsRNE7AQRO0HEThCxE0TsBBE7QcROELETROwEETtBxE4sRuzPNr5R1PKlGVgUX/xG/SX4ufgT/h4ZPE8Gz5PB82TwPBk8TwbPk8HzZPA8GTxPBs+TwfNk8DwZPE8Gz5PB82TwPBk8TwbPk8HzZPA8GTxPBs+TwfNk8DwZPE8Gz5PB82TwPBk8TwbPk8HzZPA8GTxPBs+TwfNk8DwZPE8Gz5PB82TwPBk8TwbPk8HzZPA8GTxPBs+TwfNk8DwZPE8Gz5PB82TwPBk8TwbPk8HzZPA8GTxPBs+TwfNk8DwZPE8Gz5PB82TwPBk8TwbPk8HzZPA8GTxPBs+TwfNk8DwZPE8Gz5PB82TwPBk8TwbPk8HzZPA8GTxPBs+TwfNk8DwZPE8Gz5PB82TwPBk8TwbPk8HzZPA8GTxPBs+TwfNk8DwZPE8Gzy9m8CQRO0SoDvEmGSJih4jYIUJgiMAdInCHCIghImGIuBgimocIiCHCeIgwHiJwhwjcIQJ3iMAdIliGCNwhYnSIwB0igoa4FQwRQUNE8xBhPEQYDxFIQwTSEIE0RCANEUhDRNAQUTJEIA0RSEME0hCBNETIDfGGHeINO8QbdoiwGuLtO8Qbb4gIGuJtOMQbfYg35RBv+yHeokO8RYeIhCHesEMExBABMbT4lvm5H+jKULRz4cQ1PFz8Htfy4uP8/xJ/5K9tPy8aiP+bvxV/0kd/e+hv89JQdG38F/1fP/h494dra2g4+vsflVW9j/4SbPwWP/XE4++x40uwH+qd9Q8oAl9fuOl9Dn0efQF9ER1CX0JfQQ+gDEqgr6KH0NfQRvR1dDbqQ99Am9AjaDN6FL2B9qPD6CSURc+hp9AKtAzV0Jvoy2gbOhmNoFPRveg+lEM70Tp0PzqI3kKnoAfRMMqjJNqFjqCH0VH0GHoc7UZ70Cr0BHoSvY2eR4PoaTSKXkfPoH2oHz2LmtBK1Ixa0Gq0Bq1F61E7SqEu9CJ6Cb2MXkGvoSKqohfQAfQqKqASKqNKqOF6BRFHbLypvj++Ny1l7SDvq0GydpCsHSRvBkneQV6vg7xCB3n1DvLOHeQVOsh7dZD36iDvlkHye5D8HuTdOcird5A0HySjB8noQbJ9kFf2IIk2SKINchcY5FU/yKt+kKQfJIcHyeFBsmiQhBkkJQfJ9kESe5D3+CDv8UHSfJBUHuQ9Psj7f5D7zCBpt6hDaCc6iN5CCXQEvYGOolXoMHob1dCboYajn4/fLdHKenOzfW5koY6P7l+x8M+1LMotlcX74uX9prgB2rRUlF39waVuo0yrNwLRa3HfdGr8S//qyLer/EbZH1fw5bA4i5rj3+JQWKZFLfGH/kn8+58WXx2OP7Yqvvo/46vW+OpfxD8hrpb/VXzxvq9UiFbHnzQb/1hc2f+zuFhfqueiNQtfkRD/2FJDEK2NP/SrSzuyvx5fLNV40br4x34j/lCjtnu9/sf6t/Uf+lj8Q/+e3iCufX9zoez7h8cbqh/CryqMe79/EX/keEM18jfVUP0j1pv3sd68j/Xmfaw372O9eR/rzftYb97HevM+1pv3sd68j/Xmfaw372O9eR/rzftYb97HevM+1pv3sd68j/Xmfaw372O9eR/rzfsW1x3/d3rR0xYe//Q59Hn0BfRFdAh9CX0FPYAyKIG+ih5CX0Mb0dfR2agPfQNtQo+gzehR9Abajw6jk1AWPYeeQivQMlRDb6Ivo23oZDSCTkX3ovtQDu1E69D96CB6C52CHkTDKI+SaBc6gh5GR9Fj6HG0G+1Bq9AT6En0NnoeDaKn0Sh6HT2D9qF+9CxqQitRM2pBq9EatBatR+0ohbrQi+gl9DJ6Bb2GiqiKXkAH0KuogEqojCqhhuu37jBiu+IPRr3LQzYSt4v3Whf/jl2kcRdp3EUad/Ee7SKNu3jHdvEe7eI92kVud5HbXeR2F+/RLt6jXbxHu8j0LjK9i0zvItO7yPQu3r9dJHwXCd9FwneR6V1keheZ3kUKdJECXaRAFynQRY52kQJdpEAXCd/FO72Ld3MXKd5Finfx3u7ivd3F/ayLu00Xd5suEreLHO3intXFXaOL+1IXSdZFknVxz+ri/tLF+3BR+9Eq9CJ6Cb2MXkE70QF0EL2KCug1VEQlVEYJVEFVtAu9jkbRIfQGOoxq6E30FjqCjqK30VrUhFrQarQGpVA76kIrUTNaH2o4+oWPbqddbxe3t40c77iPn1z+bWy0/w9KmYSlTIJSJkEpk6CUSVDKJChlEpQyCUqZBKVMglImQSmToJRJUMokKGUSlDIJSpkEpUyCUiZBKZOglElQyiQoZRKUMglKmQSlTIJSJkEpk6CUSVDKJChlEpQyCUqZBKVMglImQSmToJRJUMokKGUSlDIJSpkEpUyCUiZBKZOglElQyiQoZRKUMglKmQSlTIJSJkEpk6CUSVDKJChlEpQyCUqZBKVMglImQSmToJRJUMokKGUSlDIJSpkEpUyCUiZBKZOglElQyiQoZRKUMglKmQSlTIJSJkEpk6CUSVDKJChlEpQyCUqZBKVMglImQSmToJRJUMokKGUSlDIJSpkEpUyCUiZBKZOglElQyiQoZRKUMglKmQSlTIJSJrFYyvwTEvfQCWHEHuL88hDnl4c4sTzE6dSivoS+gh5AGZRAX0UPoa+hjejr6GzUh76BNqFH0Gb0KHoD7UeH0Ukoi55DT6EVaBmqoTfRl9E2dDIaQaeie9F9KId2onXofnQQvYVOQQ+iYZRHSbQLHUEPo6PoMfQ42o32oFXoCfQkehs9jwbR02gUvY6eQftQP3oWNaGVqBm1oNVoDVqL1qN2lEJd6EX0EnoZvYJeQ0VURS+gA+hVVEAlVEaVUMPR1Ee3WzzeJY58z11ifEC7Kf6c4+3iyA+4XfynC++s3677Z04IXzTvey/sr///xOKLcfuvjHzQkyYb/02Nl/L7n0/57Qc4Ty99G8cvrYif3/LPfmjf4fE4qeP4O/34POhv5g0+s/DGil9YK3mtxG/5j634Tu/07/Ud/s/jd3j8cNk7Fr5R6y/yTVAO8LC2Azys7QAPazvAw9oOsMlxgEe3HeDRbQd4dNsBtjUO8CC3AzzI7QAPcjvAXscBHut2gMe6HeCxbgfY6zjAQ94O8JC3Azzk7QAPeTvAQ94O8JC3Azzk7QAPeVtUE9qEzkebUQu6AF2IVqM16CJ0McqiS9DH0KXoMrQFXY5SaCvahq5AV6Kr0NXoGtSPTkPb0Q7UiiKUQzvROtSG2tEAuhblURJdh3ah61EXugHdiG5CK1Ezuhndglah3WgPuhXdhm5H69FeNIjuQEPoTnQX6kR3o3vQ/0Bvh4p+ZDlcBofrNcNfUkZ9D99HpVEQfYc66P3lz1/pe600yp7vsdr5K33TlUYl890VMO+vUj6y34/l/YVHXCufHX/kr7EC+aXGU+aPxD+wNMYcYZA4wiBxhHHPCKPDEUajI4sDgn/hE/PjV9bf/cDi5nt9ZP6/pIr5sxPCu8SiPomuRFej7WgH2oBOR23oFNSLPo0yKI+uQ9ejM9FZ6Gx0DupDN6Jz0c1oE7oFbUbno91oD7oQXYRuRSehi9El6HZ0G7oM3YNORlvQ5WgvWoHuRHehZWgb+gzqR1egU0MNR/+Kc44/XPiUz6F70efRF1A/+iK6D30J5dA6dD/6MvoKegBl0INoGOXRV9FD6GtoI/o6ehidjfrQN9AjaDN6FD2GHke70R70BHoSPYWeRs+gfWgbGkHPok0oi55Dp6AkOhWdhFag59EgWoZORi+g/ehF9BJ6Gb2CDqCD6FVUQK+hIiqhMqqgKnodjaJd6BBKoDfQYVRDb6Kd6C10BB1Fq9DbqAmtRM2oBa1Ga9BatB61oxTqCjUc/WsitpVtnVY2clrZyGllI6eV8/pWNnJa2bNpZc+mlT2bVjYJWtmlaWWXppVdmlZ2aVrZpWlle6aV7ZlWtmda2SdpZZemlV2aVnZpWtlOaGW/o5VdhVZ2TVrZWGllY6WV7ZlW9lBa2TVpZf+hlf2HVjZrWtmsaWXTpZW9nlb2VxZ1L7oP5dBOtA7djw6it9Ap6EE0jPIoiXahI+hhdBQ9hh5Hu9EetAo9gZ5Eb6Pn0SB6Go2i19EzaB/qR8+iJrQSNaMWtBqtQWvRetSOUqgLvYheQi+jV9BrqIiq6AV0AL2KCqiEyqgSajj6ZRq4AmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAmPoAoPnAoPnAoPnAoPnAoPnAoPnAoPnAoPnAoPnAoPnAoPnAoPnAoPnAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAqPmAsPlAsPlwuKIeJYaszNOxW8viHdScnZSbHRyI+ukHO2kHO2kHO2kSOmkHO2kZOmkSOmkSOmkcO2kcO2kcO2kSOmkSOmkSOmkqO2kqO2kqO2kqO2kqO2kgOmkxO2kxO2kxO2kqO2kqO2kqO2kDOqkDOqkDOqkDOqkkOykDOqkDOqkxO2k1OmknOmkjO2kjO2kuOmkuOmkoO+k3O6k3O6k5OykkOykaO+kbO6kMO+klOuklOukaO+kwO6kEFnUfrQKvYheQi+jV9BOdAAdRK+iAnoNFVEJlVECVVAV7UKvo1F0CL2BDqMaehO9hY6go+httBY1oRa0Gq1BKdSOutBK1IzWhxqO/g0l56qFxv+T6FNoA0qjteh01I16UAfqRZ9GGZRAn0FnoM+ij6ON6Ex0FjobnYP60LnoPNSENqHz0WbUgi5AF6LVaA26CF2MsugSdCm6DG1Bl6MU2oq2oSvQlegqdDW6BvWj7WgHakURyqGdaB1qQ+1oAF2L8iiJrkO70PWoC92AbkQ3oZWoGd2MbkGr0G60B92KbkO3o/VoLxpEd6AhdCe6C92N7gk1HP3bH+xyZ7xOvD5+fNjxPe7j251ud8bfEjh14sgP25pnoyK+l6r33sX641cW3n7xu24qXAHqqn/gF1aEb67GO2hj/eIn4o9cEL/UVix9S/GZFQtJtizadWLwjoly8Y/9ePxjW+sXPxN/6Iz4QxPxh9bGf8ITw/dD4y33O/WLX1nx3huj+YSF9FkWHV4evg3ujt8Y8Ud+t36xJf6cjvrFU/F3Wv5s/HtUln/ge6XxFknWLx5aHr5F4nSoLg8ypvFaX3rDRxvjX/mJ+EPn1S8ejy/OiP9Zlodxs6t+8eby8A3x8frFxviP+u/if/D4Fzoz/oV+LP6x1fWLR04Mg6Lx+m+87BtvhG/VL356eZhFv1W/aIn/PIPxv0z8Q+n6xWh8MV+/+NH4V26J/xnjz7mhfvFk/EOr6he5E77zi7zx2h6If8ETwtd24yXdXr94hndx47XdeCU3XsBR/eI5Xq6NmL8m/iPHH2nk/VK+f7P+gZvjDzTyPVG/+Ln4ohHeN9Uv/iHh3RO/pOsX0Vnx3/M0m8k76xe/+IHLZdHZ8Wf/cvxj/7F+0Rp/6JyFbykRf6gR9h8iJqO++Kf9TvyhS+sX34ovllIxOjf+sT+IP/QH8a8d/wv9p/ivL75o3Ica8bq+fvGPTgxSLDov/vl/HP/Yp+oXf3ZCGFqNZPps/eIEcmgpY6Lz459/IiGTq1/8yIoPypZoc/zZzfHPuyC+Oi3+rKXb5+/Hf0vhnSy6MP6c1fFnXxRfrY2vLo6v1sefFn9VR3t80bhjNW5U3fWLRPyRxt0oVb/4yfgP/p/j93580biLvD/9G6H//mRv3AYaGT1Uv0jHF438/b36xRnxf2s2/m89K/5Q45a+lKnRpvjHzlsRpmujclkZ/7vFF43qo1EANEqCxq38L74XR5fEv8dA/KHGbbVxE33fvTO6NP7sm+Ory+KrW+LPatxGG/fK/1C/2Bt/0pb4k+7gZtn47hiXxz92V/yhdfWLn48v/lv94ob4F2iK3+XxxZr6xd3xRWv94r74onFPW7o7DdffI/FN5XPxOymOmkfiP2P8qU/Ff2nxn3FX/Fv9yNLL7tL4Q9cvPMU1DsYb4qs/j3/iSP1iW/yDN8Yf2hp//kPxyzz+0E3xh34p/n2XxpX3LJSX96Jn0efRF9CjqB99ET2GdqPH0X3oCbQO3Y8eQBn0IBpGT6Ovoq+jr6Fn0JfRNrQRPYzORptQFj2HTkFJdBI6Ga1Az6NBtAydil5Ho2gX2o8OoZ3oIHoLJdAR9AY6ilahw+htVENvhhqOfvWj8rV0z9d/5A9HPqDbitrid3ZvWEV+r31XXNZdEP+CfyMN2En1i0vi3/14JzbyP+fX2f1ao8n62eUj358vuGi8I767L6ZovJIbr+2ll3R0c/z2m1r+IV/cf6Wvpmi8Ohsvyve/Fr/vXyDx3b1QPszL4q/yahiOfp2z1V9fCOfPoc+jL6AvokPoS+gr6AGUQQn0VfQQ+hraiL6OzkZ96BtoE3oEbUaPojfQfnQYnYSy6Dn0FFqBlqEaehN9GW1DJ6MRdCq6F92HcmgnWofuRwfRW+gU9CAaRnmURLvQEfQwOooeQ4+j3WgPWoWeQE+it9HzaBA9jUbR6+gZtA/1o2fRC+hF9BJ6Gb2CDqBXUQG9hoqohMqogqqoCa1EzagFrUZr0Fq0HrWjFOoKNRz9xl9DcRvXjum4evs+PTEinjJ/5vtZ3B4/VBg5Xsr+wErZOaqYGlVMjSqmRhVTo4qpUcXUqGJqVDE1qpgaVUyNKqZGFVOjiqlRxdSoYmpUMTWqmBpVTI0qpkYVU6OKqVHF1KhialQxNaqYGlVMjSqmRhVTo4qpUcXUqGJqVDE1qpgaVUyNKqZGFVOjiqlRxdSoYmpUMTWqmBpVTI0qpkYVU6OKqVHF1KhialQxNaqYGlVMjSqmRhVTo4qpUcXUqGJqVDE1qpgaVUyNKqZGFVOjiqlRxdSoYmpUMTWqmBpVTI0qpkYVU6OKqVHF1KhialQxNaqYGhVAjQqgRgVQowKoUQHUqABqVAA1KoAaFUCNCqBGBVCjoqpRUdWoqGpUVDXqpBp1Uo3qp0YFV6MSq1GJ1ajEalRbNaqtGtVWbbGK+fdEbIdLuB0s4XawhNvBEm4HS7gdLOF2sITbwRJuB0u4HSzhdrCE28ESbgdLuB0s4XawhNvBEm4HS7gdLOF2sITbwRJuB0u4HSzhdrCE28ESbgdLuB0s4XawhNvBEm4HS7gdLOF2sITbwRJuB0u4HSzhdrCE28ESbgdLuB0s4XawhNvBEm4HS7gdLOF2sITbwRJuB0u4HSzhdrCE28ESbgdLuB0s4XawhNvBEm4H6wgdLOF2sITbwRJuB0u4HSzhdrCE28ESbgdLuB0s4XawhNvBEm4HS7gdLOF2sITbwRJuB0u4HSzhdrCE28ESbgdLuB0s4XawhNvBEm4HS7gdLOF2sITbwRJuB0u4HSzhdrCE28ESbgdLuB0s4XawhNvBEm4HS7gdLOF2sITbwRJuB0u4HSzhdrCE28ESbgdLuB0s4XYsLsH85kLi1vuw7X+v/oO/Vv//LSOLSxw/dcJCwi2Let6b10bb44/8ev3iWHwK2Rl/Z8zLF94by7ZvW3jHLNt+RfxrfvO9J5ss/kbf4rb9LYqbb1GSfYsS8FuLt4TfWvjFnq//rr+xdKLQtFCO/1/cK8Ypx8cpxMYpzscpzse55Y9Tqo9TwI1Tqo9Tzo1TwI3zZxyntBynxB+nxB+nxB+nnBunnBunnBun/B+n/B+n/B+n/B+n/B+n1BunGRinGRinGRin/B+n/B+n/B+nYBynYBynYBynYBynRBynRByn/B+nDByn1Bun1BunxB+nqB+n8Bun2RmnFRmnFRmnHB+nyB6nURinvRmnaRnn/TJOmTtOQzNOYzJOkbao/ehF9BJ6Gb2CDqCD6FVUQK+hIiqhMqqgKnodjaJd6BBKoDfQYVRDb6Kd6C10BB1Fq9DbqAmtRM2oBa1Ga9BatB61oxTqCjUc/fZ3+9i07+p8/IfsiWrxFO7P4v/m449WG/nBDOh+hy8oal14RX8SfQptQGm0Fp2OulEP6kC96NMogxLoM+gM9Fn0cbQRnYnOQmejc1AfOhedh5rQJnQ+2oxa0AXoQrQarUEXoYtRFl2CLkWXoS3ocpRCW9E2dAW6El2FrkbXoH60He1ArShCObQTrUNtqB0NoGtRHiXRdWgXuh51oRvQjegmtBI1o5vRLWgV2o32oFvRbeh2tB7tRYPoDjSE7kR3obvRPaGG6/edsCX6Owuf8jl0L/o8+gLqR19E96EvoRxah+5HX0ZfQQ+gDHoQDaM8+ip6CH0NbURfRw+js1Ef+gZ6BG1Gj6LH0ONoN9qDnkBPoqfQ0+gZtA9tQyPoWbQJZdFz6BSURKeik9AK9DwaRMvQyegFtB+9iF5CL6NX0AF0EL2KCug1VEQlVEYVVEWvo1G0Cx1CCfQGOoxq6E20E72FjqCjaBV6GzWhlagZtaDVaA1ai9ajdpRCXaGG6yVnGLEpTyhSnFCkOKFIcUKR4oQixQlFihOKFCcUKU4oUpxQpDihSHFCkeKEIsUJRYoTihQnFClOKFKcUKQ4oUhxQpHihCLFCUWKE4oUJxQpTihSnFCkOKFIcUKR4oQixQlFihOKFCcUKU4oUpxQpDihSHFCkeKEIsUJRYoTihQnFClOKFKcUKQ4oUhxQpHihCLFCUWKE4oUJxQpTihSnFCkOKFIcUKR4oQixQlFihOKFCcUKU4oUpxQpDihSHFCkeKEIsUJRYoTihQnFClOKFKcUKQ4oUhxQpHihCLFCUWKE4oUJxQpTihSnFCkOKFIcUKR4oQixQlFihOKFCcUKU4oUpxQpDihSHFCkeKEIsUJRYoTihQnFClOKFKcUKQ4oUhxQpHihCLFCUWKE4oUJxQpTihSnFCkFk8o/iOJmyZi00RsmlBNE6pp3lxpIjZNxKaJ2DQRmyZi00Rsmrd2msBNE7hpAjdN4KYJ3DSBmyZw0wRumsBNE7hpAjdN4KYJ3DSBmyZw0wRumsBNE7hpAjdN4KYJ3DSBmyZi00RsmohNE7FpInZR+9A2NIKeRZtQFj2HTkFJdCo6Ca1Az6NBtAydjF5A+9GL6CX0MnoFHUAH0auogF5DRVRCZVRBVfQ6GkW70CGUQG+gw6iG3kQ70VvoCDqKVqG30WqUQu2oC61Ea1ETakFrUDNaH2o4+t04YqNb4q9++cPlC1G4LPq15UFG9TMg6Kel7Keh7aeF7afd7KfB7Kfx7mdA0E+72U9L2U/z2U/z2U9L2U9L2U9r2E9j2k+72U+72U+72U8L20/z2U871k871k/z2U9z1k9z1k9b1U+D2U+T1U8b10/L1U9T108D1k8D1k/D10871k/710/717/YEP1e43z+Hy8fWTyf//OFafx/4r5dXfi5n0OfR19AX0SH0JfQV9ADKIMS6KvoIfQ1tBF9HZ2N+tA30Cb0CNqMHkVvoP3oMDoJZdFz6Cm0Ai1DNfQm+jLahk5GI+hUdC+6D+XQTrQO3Y8OorfQKehBNIzyKIl2oSPoYXQUPYYeR7vRHrQKPYGeRG+j59EgehqNotfRM2gf6kfPoia0EjWjFrQarUFr0XrUjlKoC72IXkIvo1fQa6iIqugFdAC9igqohMqoEmo4+s8LEbsULI8tD98Ijy0+1va//AVH+PG9/l/Gx6cfye8kG39z2PgLhT5qXxZ0av3iwvgj32El4MT4Iv6hH8AXCi2rX3wx/gUbiwQn1C8eiD/yo/UfPHUhiOt/K/EHvsOKwYr6xf4P3jU4Jf4njn/oo/bVRT9Svzj4w/hlRr8ff3/Y+EvlOha+P+y3Fr8h9OKbujl+3z8Q/ddGzXVZ/C6Jn+n06Inxz/0DNiDKPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLPMW/zFP8yzzFv8xT/Ms8xb/MU/zLi+XOPE1nhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxhmFxZnFY/N8WIjYuif/d8uC9uoUh0BYGZ1sY8G1hYLOFscEWhlVbGJxtYay1hWHOFgZZWxh9bGH0sYVhzhZGXlsYo21hkLWF0dUWhiRbGKAsqHjCsuXL4v813m5bmBttYa65hfnWFmZYW5hhbWGSuYXp0xbmhVuYPm1hirSF6eEW5kZbmPttYe63ZXHu8IcLL4FH6y+BvhMWorX+WlgRvBa2MnzdyitjK6+MrbwytvLK2MorYyuvjK28MrbyytjKv9tW/t228qrZyqtmK6+arbxqtvKq2cqrZiuvmq28MrbyyljUfrQLHUI70UH0FkqgI+gNdBStQofR26iG3gw1HP3Rew3p4gcT/Ccl+I0S/MES/MMl+M9N8E+cWPyN/pgGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd4wGd2yxwf2TeBz4ev2Gm1wRTwL/lH73ZxYi83PoXvR59AXUj76I7kNfQjm0Dt2Pvoy+gh5AGfQgGkZ59FX0EPoa2oi+jh5GZ6M+9A30CNqMHkWPocfRbrQHPYGeRE+hp9EzaB/ahkbQs2gTyqLn0CkoiU5FJ6EV6Hk0iJahk9ELaD96Eb2EXkavoAPoIHoVFdBrqIhKqIwqqIpeR6NoFzqEEugNdBjV0JtoJ3oLHUFH0Sr0NmpCK1EzakGr0Rq0Fq1H7SiFukINR3+2ELHxweEcZ4HvO+rcX///ifr///f6D5zOCV7j8KtxSNQ4ovyz+sWfcUTZOC1qnA39dv3ijxbOhv47cd/DeLOH8WYP480exps9jDd7GG/2MN7sYbzZw3izh/FmD+PNHsabPYw3exhv9jDe7GG82cN4s4fxZg/jzR7Gmz2MN3sYb/Yw3uxhvNnDeLOH8WYP480exps9jDd7GG/2MN7sYbzZw3izh/FmD+PNHsabPYw3exhv9jDe7GG82cN4s4fxZg/jzR7Gmz2MN3sYb/Yw3uxhvNnDeLOH8WYP480exps9jDd7GG/2MN7sYbzZw3izh/FmD+PNHsabPYw3exhv9jDe7GG82cN4s4fxZg/jzR7Gmz2MN3sYb/Yw3uxhvNnDeLOH8WYP480exps9jDd7GG/2MN7sYbzZw3izh/FmD+PNHsabPYw3exhv9jDe7GG82cN4s4fxZg/jzR7Gmz2MN3sYb/Yw3uxhvNnDeLNncbz5fxOx7fEHv/0FXu0kbjuJ2857rZ38bSd/20ncdhK3ncRtJ3HbSdx2EredjG0nY9vJ2HYytp2MbSdj28nYdjK2nYxtJ2Pbydh2MradjG0nY9vJ2HYytp2MbSdj28nYdjK2nYxtJ2PbScB2EredxG0ncdtJ3HYSt507XzuJu6h+9CzahLLoOXQKSqKT0MloBXoeDaJl6FT0AtqPVqEX0UvoZfQK2okOoIPoVVRAr6EiKqEySqAKqqJd6HU0ig6hN9BhVENvorfQEXQUvY1WoxRqR11oJVqLmlALWoOa0fpQw9H/s/DVB9uWMvYJ3gkLiq7gB6MT4XD0/5LZk0xBJpmCTDIFmWQKMskUZJIpyCRTkEmmIJNMQSaZgkwyBZlkCjLJFGSSKcgkU5BJpiCTTEEmmYJMMgWZZAoyyRRkkinIJFOQSaYgk0xBJpmCTDIFmWQKMskUZJIpyCRTkEmmIJNMQSaZgkwyBZlkCjLJFGSSKcgkU5BJpiCTTEEmmYJMMgWZZAoyyRRkkinIJFOQSaYgk0xBJpmCTDIFmWQKMskUZJIpyCRTkEmmIJNMQSaZgkwyBZlkCjLJFGSSKcgkU5BJpiCTTEEmmYJMMgWZZAoyyRRkkinIJFOQSaYgk0xBJpmCTDIFmWQKMskUZJIpyCRTkEmmIJNMQSaZgkwyBZlkCjLJFGSSKcgkU5BJpiCTTEEmmYJMMgWZZAoyyRRkkinIJFOQSaYgk0xBJhenIH9OxM4RsXNE7BwRO0fEzhGxc0TsHBE7R8TOEbFzROwcETtHxM4RsXNE7BwRO0fEzhGxc0TsHBE7R8TOEbFzROwcETtHxM4RsXNE7BwRO0fEzhGxc0TsHBE7R8TOEbFzROwcETtHxM4RsXNE7BwRO0fEzhGxc0TsHBE7R8TOEbFzROwcETtHxM4RsXNE7BwRO0fEzhGxc0TsHBE7R8TOEbFzROwcETtHxM4RsXNE7BwRO0fEzhGxc0TsHBE7R8TOEbFzROwcETtHxM4RsXNE7BwRO0fEzhGxc0TsHBE7R8TOEbFzROwcETtHxM4RsXNE7BwRO0fEzhGxc0TsHBE7R8TOEbFzROwcETtHxM4RsXOLEfs/lrb6t/958Ff/48Tbjy9+6rIVYRpvYCqxganEBuYQG5hDbKAf3cBUYgNTiQ1MJTYwldjAVGIDU4kNdMMbmFFsYEaxgRnFBmYUG5hRbGBGsYEZxQZmFBuYUWxgRrGBGcUGZhQbmFFsYEaxgRnFBmYUG5hRbGBGsYEZxQZmFBuYUWxgRrGBqcQGphIbmEpsYCqxganEovahbWgEPYs2oSx6Dp2CkuhUdBJagZ5Hg2gZOhm9gPajF9FL6GX0CjqADqJXUQG9hoqohMqogqrodTSKdqFDKIHeQIdRDb2JdqK30BF0FK1Cb6PVKIXaURdaidaiJtSC1qBmtD7UcLR8xXvfuHT7L498iCcef7P+CTfzNZF/+TcwjXLxV2H++F/lKcYPxh/5Dt/KtCP+krX4k79fTzH+of9Opr9Vv/ix+CN/tW9pesLCy6Pxr9X4x47/kf5o+bf/1aOFr7Q9L/6GCTviq19YPvJBZ73vPypunP42/gGX/pOH6y+ej8h3so7/tG+uGPlwX9T7ff9i3sbX8MbfqHD8w34x75/ULyL+Yr/DO6O7fvFa/J/xIb6YNzoj/gc+sGLku/2y3gfj10f8kb/4GwFGu+Pf45/z9vtBfkvA93+t7nd4Pze+aPdP6xffPOED3+HxKtufnzDyQ/PVuyeuCBeUqywoV1lQrrKgXGVBucqCcpUF5SoLylUWlKssKFdZUK6yoFxlQbnKgnKVBeUqC8pVFpSrLChXWVCusqBcZUG5yoJylQXlKgvKVRaUqywoV1lQrrKgXGVBucqCcpUF5SoLylUWlKssKFdZUK6yoFxlQbnKgnKVBeUqC8pVFpSrLChXWVCusqBcZUG5yoJylQXlKgvKVRaUqywoV1lQrrKgXGVBucqCcpUF5SoLylUWlKssKFdZUK6yoFxlQbnKgnKVBeUqC8pVFpSrLChXWVCusqBcZUG5yoJylQXlKgvKVRaUqywoV1lQrrKgXGVBucqCcpUF5SoLylUWlKssKFdZUK6yoFxlQbnKgnKVBeUqC8pVFpSrLChXWVCuLi4onxQHYNQW36Z+K47GeJ7xhyOLD4b6JwvVy498VKqXv5Gi5a/vGxPHVVAifh7E8e9QPPI/53coPnnhnbV0Q1xDNK0hmtZwC1zUaWgVakWr0Rq0Fq1DH0PrURtqRx0ogTpREqXQx1EX+gT6JPoU2oDS6HTUjXpQL/o0yqDPoDPQZ9FGdCY6C52NzkF96Fx0HtqEzkeb0QXoQnQRuhhl0SXoUnQZ2oIuR1vRNnQFuhJdha5G16B+tB3tQBHKoZ1oAF2L8ug6tAtdj25AN6Kb0M3oFrQb7UG3otvQ7WgvGkR3oCF0J7oL3Y3uCTUcnUKf9i5v+3d527/L2/5d3vbvEnnvEgLvEgLvEgLvEmvvEgnvEgnvEgnvEoDvEhDvEhDvEhDvEoDvEhfvEhfvEhfvEhfvEhfvEhfvEhfvEheLakKb0PloM2pBF6AL0Wq0Bl2ELkZZdAm6FF2GtqDLUQptRdvQFehKdBW6Gl2D+tF2tAO1ogjl0E60DrWhdjSArkV5lETXoV3oetSFbkA3opvQStSMbka3oFVoN9qDbkW3odvRerQXDaI70BC6E92F7kb3hBqOTiUAmwnAZgKwmQBsJgCbCcBmArCZAGwmAJsJwGYCsJkAbCYAmwnAZgKwmQBsJgCbCcBmArCZAGwmAJsJwGYCsJkAbCYAmwnAZgKwmQBsJgCbCcBmArCZAGwmAJsJwGYCsJkAbCYAmwnAZgJwUR9Dl6LL0BZ0OUqhrWgbugJdia5CV6NrUD86DW1HO1ArilAO7UTrUBtqRwPoWpRHSXQd2oWuR13oBnQjugmtRM3oZnQLWoV2oz3oVnQbuh2tR3vRILoDDaE70V2oE92N7gk1HDWxbTPK7uMo246jbDuOst84yp7UKPuNo+wpjrKnOMqe4ij7VaPsIo6yizjKLuIou4ij7CKOsn04yvbhKNuHo2znjbKLOMou4ii7iKPsgY2yLTfKVtgou3qj7P+Nsv83yi7iKFt9o2zujbJpNsqm2Sj7oqPsKY6y8TfK1uIoG4aLuhfdh3JoJ1qH7kcH0VvoFPQgGkZ5lES70BH0MDqKHkOPo91oD1qFnkBPorfR82gQPY1G0evoGbQP9aNnURNaiZpRC1qN1qC1aD1qRynUhV5EL6GX0SvoNVREVfQCOoBeRQVUQmVUCTUcrVyI2D/avix6ecVCvi2LXlo4LGhesfD442XR6MLzTlr++rdyfgC7OIuLPx+PZ/XHt3JGvo9bOactvVp+Z3n8alm18Gq5v+6e+Nf6tfif+r2XS/Qr8c/89frFsfjiN+oXZ8Y/9Kvxf8HCML2VBqlIg1SkQSrSIBVpkIo0SEUapCINUpEGqUiDVKRBKtIgFWmQijRIRRqkIg1SkQapSINUpEEq0iAVaZCKNEhFGqQiDVKRBqlIg1SkQSrSIBVpkIo0SEUapCINUpEGqUiDVKRBKtIgFWmQijRIRRqkIi1RkZaoSEtUpCUq0hIVaYmKtERFWqIiLVGRlqhIS1SkJSrSEhVpgoo0QUWaoCJNUJEmqEgTVKQJKtIEFWmCijRBRZqgIk1QkSaoSBNUpAkq0gQVaYKKNEFFmqAiTVCRJqhIE1SkCSrSBBVpgoo0QUWaoCJNUJEmqEgTVKQJKtIEFWmCijRBRZqgIk1QkSaoSNtTpO0pLrY9qwnAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLBGCJACwRgCUCsEQAlgjAEgFYIgBLiwG4Jlyn2D4R/O0sojlES4jTQqwK0RpidYg1IdaGWBfiYyHWh2gL0R6iI0QiRGeIZIhUiI+H6AowHK3lLnHaCeFdYlGfQhtQGq1Fp6Nu1IM6UC/6NMqgBPoMOgN9Fn0cbURnorPQ2egc1IfOReehJrQJnY82oxZ0AboQrUZr0EXoYpRFl6BL0WVoC7ocpdBWtA1dga5EV6Gr0TWoH21HO1ArilAO7UTrUBtqRwPoWpRHSXQd2oWuR13oBnQjugmtRM3oZnQLWoV2oz3oVnQbuh2tR3vRILoDDaE70V3obnRPqOFo3Yqlb8b1G/Ek4aTty7b/r/HHP/YXfIXQ0uDpw3wRUDxmGl4x8p2/Gmg9CVyhTq9Qp1eo0yvU6RXq9Ap1eoU6vUKdXqFOr1CnV6jTK9TpFer0CnV6hTq9Qp1eoU6vUKdXqNMr1OkV6vQKdXqFOr1CnV6hTq9Qp1eo0yvU6RXq9Ap1eoU6vUKdXqFOr1CnV6jTK9TpFer0CnV6hTq9Qp1eoU6vUKdXqNMr1OkV6vQKdXqFOr1CnV6hTq9Qp1eo0yvU6RXq9Ap1eoU6vUKdXqFOr1CnV6jTK9TpFer0CnV6hTq9Qp1eoU6vUKdXqNMr1OkV6vQKdXqFOr1CnV6hTq9Qp1eo0yvU6RXq9Ap1eoU6vUKdXqFOr1CnV6jTK9TpFer0CnV6hTq9Qp1eoU6vUKdXFuv0Ns5nDy+E9OfQ59EX0BfRIfQl9BX0AMqgBPoqegh9DW1EX0dnoz70DbQJPYI2o0fRG2g/OoxOQln0HHoKrUDLUA29ib6MtqGT0Qg6Fd2L7kM5tBOtQ/ejg+gtdAp6EA2jPEqiXegIehgdRY+h/4+9e4+Ps87vQ++rxIzsFbaMbYyNLWCAMWBsjG1hYS7GFsLW2GA8gC/jC9i4q+yuvAtaYMUu8gIajLmNYcTFWOLWuk0maZvmSEpUVklayUrqo216kjS7TU739JXe0tur56g9PcdHr555ZvDs713ILtnCht2w//C85ZvWfubzfL/f5zvPPIF2od2oFnWiI+g9dBTtR0+iE+gN9BR6Gm1CWRRHNWgGmolmodmoDs1F89EitBg9h55HL6AX0Ssoj15Hz6KX0HH0MupGr6LXQrWn5lNjFqgxC9SYBWrMAjVmgRqzQI1ZoMYsUGMWqDEL1JgFaswCNWaBGrNAjVmgxixQYxaoMQvUmAVqzAI1ZoEas0CNWaDGLFBjFqgxC9SYBWrMAjVmgRqzQI1ZoMYsUGMWqDEL1JgFaswCNWaBGrNAjVmgxixQYxaoMQvUmAVqzAI1ZoEas0CNWaDGLFBjFqgxC9SYBWrMAjVmgRqzQI1ZoMYsUGMWqDEL1JgFaswCNWaBGrNAjVmgxixQYxaoMQvUmAVqzAI1ZoEas0CNWaDGLFBjFqgxC9SYBWrMAjVmgRqzQI1ZoMYsUGMWqDEL1JgFaswCNWaBGrNAjVmgxixQYxaoMQvUmIVyjXlhKQBXFmuWXy/9ZU9K/UrUhbNb8J+jdys+Uzz4ncld5SWDzeGSQeqiaOvjP0zuKq8o/Nnk6Pdd8HP7Ztjo/2N9tOLyl/uu2M/fDNv1UVs90ZuFr5jW9fHeFftm8SAZ/eSf7bfHXkSfOEifOEiHMEjXOEjXOEgtOkgPOUhnMUgPOUifMUhnMUhnMUjPM0jvOUjvOUjvOUifMUifMUifMUhfOkhfOkhfOkhfOkhfOkgPMkiXOkiXOkiXOkhfOkhfOkhfOkgnM0gnM0gnM0gnM0jvMkjvMkhfOkh/MkgPMkgPMkjvOUi3OUhHMkgXPkiPPEiPPEifOEj3N0gHO0jfPUg3PUj/NUj/NUinPUjHPEj3UNYx9Bx6Hr2AXkQvoRw6jl5Gr6A86kavotfQ6+gNdAJtR2+iBegk6kG96C20Fb2N3kHvolr0HoqjGjQDzUSz0GxUh+ai+WgRWhyqPbWQiK3lwaS1PIq0lkeR1vLw0VoeYljLw0dreYhoLQ8RreUhorU8/LCWB4XW8qDQWh4UWsuDQmt5UGgtjwat5dGgtTwatJZHZ9byoNBaHhRay4NCa3lIYy2PsqzlkY21PEizlodz1vJwzloeFFrLIzdreaxmLY+BrOUxkLU8zLWWh4jW8jjOWh4pWsvjP8tqRV9BW9BWNAcdRjn0NjoPPYza0Ta0EG1H76BvoHfRt9ATaBfajWpRJzqC3kNH0X70JDqB3kBPoafRJpRFcVSDZqCZaBaajerQXDQfLUKL0XPoefQCehG9gvLodfQsegkdRy+jbvQqei1Ue2pR6QFLG6Ne8p9NK38YyqTUP57WVe44342+VPksld8qp/LFTO96md71Mr3rZXrXy/Sul+ldL9O7XqZ3vUzvepne9TK962V618v0rpfpXS/Tu16md71M73qZ3vUyvetletfL9K6X6V0v07tepne9TO96md71Mr3rZXrXy/Sul+ldL9O7XqZ3vUzvepne9TK962V618v0rpfpXS/Tu16md71M73qZ3vUyvetletfL9K6X6V0v07tepne9TO96md71Mr3rZXrXy/Sul+ldL9O7XqZ3vUzvepne9TK962V618v0rpfpXS/Tu16md71M73qZ3vUyvetletfL9K6X6V0v07tepne9TO96md71Mr3rZXrXy/Sul+ldL9O7XqZ3vUzvepne9TK962V618v0rpfpXS/Tu16md71M73qZ3vUyvestT+8WU5bWU5bWU5DUU6TWU6TWc+mrp2Stp5Cpp2Stp6ypp5Cpp5Cpp8Sqp9Stp9Stp9Stp6ypp6ypp6yppwyupwyupwyupwyupwyup+Sppyiupyiupyiupwyupwyupwyup3Cqp3Cqp3Cqp3Cqp1Sqp1Sqpwyupxyqp+Spp+Spp9Stp7itpwCqp+ivpySvpySvpyytp9isp2Cup8yvp3ivp9yrp9yrp7Cvp0Cvp1gp6xh6Dj2PXkAvopdQDh1HL6NXUB51o1fRa+h19AY6gbajN9ECdBL1oF70FtqK3kbvoHdRLXoPzUKL0Hy0GNWgOhRHM9FsNAPNDdWeWlKK2HOB1MTItIkhWxMjviaGek0M2ZoYPjYxJG1i5NbEWK2JAVwTA7gmBmlNDOCaGKs1MVZrYqzWxKiuiSFbE0O2JsZ4TYykmhhJNTGAa2JA1cSAqonRUhNDtiYGTU2MspoYOzUx2GpiCNXEEKqJoVcTI6kmRmBNjMCayu1H/Y+7x/Xn3dr6ie5offhG1o+4f/Xh21Y/5ibVkSldn8JNqh/xVu8fcUuqcicqujf1m9HBT3Yn6uPcgPrJ3jv+cW4u/UzeSrqkdEqfe+X+x8nhq7qsoyiLpqNjaBnaGqo9dWnpj32i+G1cOyXIyUZyspGcbCQZG0nGRpKxkdxqJBkbScZGkrGRZGwkGRtJxkayt5FkbCQZG0nGRpKxkWRsJBkbScZGkrGRZGwkGRtJxkaSsZFkbCQZG0nGRpKxkWRsJBkby8l42c/t3f/Pb/qHURvdbV88reszc/f/5/9R2IkPvSsn9ddKCzeXMwpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIMgpIlkcBV5x7SFfqWx+rzYvS/zein/BpPKXrCHXFh5/S9fkH5XV91BW5ciH+iz2A60qurq9MCa+uZf0C+hL6MnoTtaGvoYfQUrQAfR09gh5Fy9BjaAVaiTrQavQ4akDfRCfRMdSDpqN16Bn0bTQVTUK96C30VbQBVaMuFEOt6CtoC9qK5qDDKIfeRuehh1E72oYWou3oHfQN9C76FnoC7UK7US3qREfQe+go2o+eRCfQG+gp9DTahLIojmrQDDQTzUKzUR2ai+ajRWgxeg49j15AL6JXUB69jp5FL6Hj6GXUjV5Fr4VqL15ko4g9FnU60a5H6ZO2LpnW5Sdt/ctSE7SUNB4hjUd4HY6QzSNk8wj/4iMk9Qiv3xGSeoRX8wiv3xFevyMkywgJP0LCj5DwI7yaR3g1j/BqHiH9R0j/EdJ/hPQfIf1HeKWPcC0Y4VowwrVghPQfIf1HSP8R8mKEvBghL0bIixESYoSEGCH9R0iBEV7pI7zSR0j4ETJ9hNf9CNe6Ea5EI1yJRkjjETJ2hOvECFe3Ea5ZI6TcCCk3wvVshOvSCK/Rso6h59Dz6AX0InoJ5dBx9DJ6BeVRN3oVvYZeR2+gE2g7ehMtQCdRD+pFb6Gt6G30DnoX1aL3UBzVoBloJpqFZqM6NBfNR4vQ4lDtqau4EfADbgT8gBsBP+BGwA+4EfADbgT8gBsBP+BGwA/KNwKuZqMvx0Zfjo2+HBt9OTb6cmz05djoy7HRl2OjL8dGX46NvhwbfTk2+nJs9OXY6Mux0Zdjoy/HRl+Ov54cG305NvpybPTl2OjLsdGXY6Mvx0Zfjo2+HBt9OTb6cmz05djoy7HRl2OjL8dGX46NvhwbfTk2+nJs9OXY6Mux0Zdjoy/HRl+Ojb4cG305NvpybPTl2OjLsdGXY6Mvx0Zfjo2+HBt9OTb6cmz05djoy7HRl2OjL8dLJsdGX46NvhwbfTk2+nJs9OXY6Mux0Zdjoy/HRl+Ojb4cG305NvpybPTl2OjLsdGXY6Mvx0Zfjo2+HBt9OTb6cmz05djoy7HRl2OjL8dGX46NvhwbfTk2+nJs9OXY6Mux0Zdjoy/HRl+uHIDXUNoOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOU9oOl0vbZXya8BSuQFO4Ak2h0inrC6gWnY9modmoDs1BF6C5aB6ajy5EC9BFaCFahC5Gi9ESVI8uQZeiy1ACXY6uQFeiJFqKrkJXo2vQMnQtWo5WoOvQSnQ9WoVWozWoAd2A1qJGdCNah25CN6Nb0K1oPboNbUAbURO6HTWjO9AmtBm1oBTagraiO9FdaBu6G21HaXQPuhfdh3agnWgX2o0yaA/ai/ah/eh+9AA6gA6iB9GhUO2pa0tRee6l3clLtJPQ6eQF28kLtpMXXicvvE5eeJ28SDp5IXQSqp28LDp5WXTysujk1O8k8jo5vTs5vTs5vTs5oTs5oTu5MHRyCndyYejkFO4k/DsJ+E4CvpMTupOTtpOg7uQ07eTi1sklq5MTs5MTs5PTrZMTrJOTqJOTqJPLRCeXiU4uDJ1cGMqqQwl0OVqKFqCr0TXoYrQCXYdWouvRKhRHq1EDmoluQLPRTegCdDM6hG5F69Ft6Ha0GaXQVnQn2oYWortRGt2D7kMz0A60E2XQHrQXzUX70QPoALoIXYU2hWpPLWdy+QanflmXoEvRZagOJdDl6Ap0IboSJdFStABdha5G16CL0TJ0LVqOVqDr0Ep0PVqF4mg1WoMa0Ex0A1qLZqHZqBHdiNahm9DN6BZ0K1qPFqHb0Aa0ETWh21EzugNtQptRCzofpdAWtBXNQfPQfHQnugttQwvR3Wg7SqPF6B50L7oP1aAZaAfaiWrRLrQbZdAetBfNRfvQfnQ/egAdQAfRg+hQqPbUitLzG3ZHt+2rotv2T0X72tOCrGlmRNnMUKuZkVozQ7RmhlrNDPuaGUo2M+JqZozVzMCrmYFXM4OrZgZezYyxmhljNTPGamY01sxQq5mhVjNjs2ZGQM2MgJoZeDUzEGpmINTMKKeZoVYzg51mRkfNjHmaGSQ1M/RpZujTzJCpmRFQMyOnZkZOzeUhzHXMuROsqydYV0+wrp5gXT3BunqCdfUE6+oJ1tUTrKsnWFdPsK6eYF09wbp6gnX1BOvqCdbVE6yrJ1hXT7CunmBdPcG6eoJ19QTr6gnW1ROsqydYV0+wrp5gXT3BunqCdfUE6+oJ1tUTrKsnWFdPsK6eYF09wbp6gnX1BOvqCdbVE6yrJ1hXT7CunmBdPcG6eoJ19QTr6gnW1ROsqydYV0+wrp5gXT3BunqCdfUE6+oJ1tUTrKsnWFdPsK6eYF09wbp6gnX1BOvqCdbVE6yrJ1hXT7CunmBdPcG6eoJ19QTr6gnW1ROsqydYV0+wrp5gXT3BunqCdfUE6+oJ1tUTrKsnWFdPsK6eYF09wbp6gnX1BOvqCdbVE6yrJ1hXT7CunmBdPcG6eoJ19QTr6gnW1ROsqyfK6+orP/iU4PIXG7gaNnA1bOBq2MD1r4HrXwPXvwaufw1c/xq4/jVwhW3gatjA1bCBq2EDV8MGroYNXA0buBo2cDVs4GrYwNWwgathA1fDBq6GDVwNG7gaNnA1bOBq2MDVsIGrYUP5ang9zeOs0k+pR5egS9FlqA4l0OXoCnQhuhIl0VK0AF2FrkbXoIvRMnQtWo5WoOvQSnQ9WoXiaDVagxrQTHQDWotmodmoEd2I1qGb0M3oFnQrWo8WodvQBrQRNaHbUTO6A21Cm1ELOh+l0Ba0Fc1B89B8dCe6C21DC9HdaDtKo8XoHnQvug/VoBloB9qJatEutBtl0B60F81F+9B+dD96AB1AB9GD6FCo9tQqbjRsnBrGU1kXoitREi1D16LlaA1ai2ahRnQjWoduQYvQBrQRNaFmdAdqQeejLWgOmofmo7vQdrQY3YtqUC3ahXajfeh+dBA9iJagenQpugzVoQS6HC1FC9DV6Bp0MVqBrkMr0fVoFYqj1agBzUQ3oNnoJnQzOoRuRevRbeh2tBml0FZ0J9qGFqK7URrdg+5DM9AOtBNl0B60F81F+9ED6AC6Cm0K1Z5azb71H5QGbG+goyiLpqNjaBnaGqo9teYnfYTRx3hL66f3nKLK214rD9j49J5T9OH3v0ZPJJk9rSt4eMZP9niiT+phRD9vzyBqKJ2T526nL+Mqt4w0X8ZVbhlXuWVc5ZZRQywj25eRN8tI82VcAZeRysu4Ai4jb5aRysu4Oi6jvlhGRpd1AZqLLkKLQrWnbij91Z1r8g9wY6ysw2hdqPbUWtrQsxT9Z2lKz9IenKUhOEvRf5ai/yzt61la1LOU8meZQpylKT1LU3qWpvQshf1ZSvmzFO9naTXP0mqepdU8S6t5llbzLGX+WRrPs5TyZ2k1z1LYn6XVPEsbepYy/yxl/lkaz7M0l2dpAcqajm5EN6G9aA+6BR1C1ehWtB7tQ1PRAXQQTUIb0FVoE9qIYqHaU42c+qe5fX+a2/enuX1/mtv3p7l9f5rb96e5fX+a2/enuX1/mtv3p7l9f5rb96e5fX+a2/enuX1/mtv3p7l9f5o64TS3709z+/40t+9Pc/v+NLfvT3P7/jS3709z+/40KXWa2/enuX1/mtv3p7l9f5rb96e5fX+a2/enuX1/mtv3p0nF09y+P83t+9Pcvj/NDdHT3Mw/zc3809zML+u/o9vQBrQRNaHbQ6UmTeYHm9EdaDNqQeejFNqCtqI5aB6aj+5Ed6FtaCG6G21HabQY3YPuRfehGjQD7UA7US3ahXajDNqD9qL30Fy0D+1H96MH0AF0ED2INoVqL5aW4b3bR0qFyBdRK3oa/QL6Evoy+gpqQ1vQHHQYfQ3NQw+hpSiJHkbtaBv6OnoEPYqWocfQN9AKtBJ1oMdRA/om+hZ6Au1Cu1EX6kR70BH0bfQkegp9FW1Am1AWrUbr0DPoPLQQTUfVaCo6ivajSSiGnkXH0HPoefQCehG9hHLoOHoZvYLyqBu9il5Dr6M30Am0Hb2JFqCTqAf1orfQVvQ2ege9i2rReyiOatAMNBPNQrNRHZqL5qNFaHGo9tS6ykPJPrHBzc/Qs8ii0cmsaBbzk41g/goPXNqL31V4Gf/1KeFlvKxW9AvoS2gT+jL6CmpDW9AcdBh9FX0NPYSWoodRO9qGvo4eQY+iZegx9A20Aq1EHehx1IC+ib6FnkC70G7UiY6gb6Mn0VPoabQBdaEsWo3WoWfQeWghiqHpaCo6ivajSagaPYuOoefQ8+gF9CJ6CeXQcfQyegXlUTd6Fb2GXkdvoBNoO3oTLUAnUQ/qRW+hreht9A56F9Wi91Ac1aAZaCaahWajOjQXzUeL0OJQ7ambSxG7oBi5z3/wsPPUH527wn4xyvDo49W/Fh38l+JBS3Tw/eLBO1O7fvgR7KlMtFJdG33JT1z/91O6fviJ7alLoy/9UvSlPykeXFuapN9CwveT8P0kfD8J30/C95Pw/SR8PwnfT8L3k/D9JHw/Cd9PwveT8P0kfD8J30/C95Pw/SR8PwnfT8L3k/D9JHw/Cd9PwveT8P0kfD8J30/C95Pw/SR8PwnfT8L3k/D9JHw/Cd9PwveT8P0kfD8J30/C95Pw/SR8PwnfT8L3k/D9JHw/Cd9PwveT8P0kfD8J30/C95Pw/SR8PwnfT8L3k/D9JHw/Cd9PwveT8P0kfD8J30/C95Pw/SR8PwnfT8L3k/D9JHw/Cd9PwveT8P0kfD8J30/C95Pw/SR8PwnfT8L3k/D9JHw/Cd9PwveT8P0kfD8J30/C95Pw/SR8PwnfT8L3k/D9JHw/Cd9PwveT8P3lhL+1FLHR5yD8/rRSSv6Pd9KjWP69KJY//+yLzT/+Hn2seLA2+sqPaBCnRQfRD/0UPg1jUvHgy9FvWOkvpxQPHoq+8tejHyyFS/FvJfrCj+g8pxYPjn10C3pe9E8b/dBn7ZMzqooHuY/ucn+2P0Jjfeklu7/o/xqVV5uiV+h/i47uiI62RC/jhcWDX4wOosfR7io/hLb8sv9TQu5PyyFwG3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWH3VWHxHUR53VR53VR53VR53VR53VR53VR53VR53VR53VR53VR53VR53VR53VR53VR53VR53VV47YDTy0q4YbtDXcoK1hS6CsL6BadD6ahWajOjQHXYDmonloProQLUAXoYVoEboYLUZLUD26BF2KLkMJdDm6Al2Jkmgpugpdja5By9C1aDlaga5DK9H1aBVajdagBnQDWosa0Y1oHboJ3YxuQbei9eg2tAFtRE3odtSM7kCbQuWnTpo8KfpfZYOkhg2SGnZGatgZqWFnpIZNkBo2QWrYBKlh96OG3Y8adj9q2PaoYdujhm2PGjY6atjoqGGHo4Ydjhp2OGrY4ahhh6OGPY0a9jRq2NOoYU+jhj2NGvY0atjTKOtQqPZi9xaWpYcpSw9Tlh6mIDlMkXqYIvUwZelhytLDFKKHKUQPU4geptg8TLF5mGLzMMXmYYrNwxSbhyk2D1NsHqbYPEyxeZhi8zDF5mEKysOUkIcpIQ9TQh6mhDxMCXmYAu8wBeVhSsjDlJCHKSEPU8ofpoQsaxPKotVoHXoGnYcWoumoGk1FR9F+NAnF0BvoBNqOjqE30QJ0EvWgXvQW2opy6G30DnoX1aL3QrWnmoov2NJNgtXFlvOh1O0f51NUL53W9ZcwSfrMDpA+8Q+j/qQ+KvUT/1Tqzz8PNXrJNPO+qT+aHKZGWUdRFh1D09EytDVUe/EUi/7Y6Dx8fvIHf5mPTv7Iv5Zzl9/vcPn9Dpff73DB/Q4X3O8Q5t/h8vsdLr9ltaEtaA46jL6KvoYeQkvRw6gdbUNfR4+gR9Ey9Bj6BlqBVqIO9DhqQN9E30JPoF1oN+pER9C30ZPoKfQ02oC6UBatRuvQM+g8tBDF0HQ0FR1F+9EkVI2eRcfQc+h59AJ6Eb2Ecug4ehm9gvKoG72KXkOvozfQCbQdvYkWoJOoB/Wit9BW9DZ6B72LatF7KI5q0Aw0E81Cs1Edmovmo0Vocaj24jUp7HCyRGyWiM0SsVkiNkvEZonYLBGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJUazxGiWGM0So1mCM0s4ZgnHLJGXJdKzRHqWaM4SxlnCOEvgZgncLIGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJWKzRGyWiM0SsVkiNkvEZonYLBGbJWKzRGy2HLGbGbzXMXivY/Bex+C9jsF7HYP3OgbvdQze6xi81zF4r2PwXsfgvY7Bex2D9zoG73UM3usYvNcxeK9j8F7H4L2OwXsdg/c6Bu91DN7rGLzXMXivY/Bex+C9jsF7HYP3OgbvdQze6xi81zF4r2PwXsfgvY4mqI7Bex2D9zoG73UM3usYvNcxeK9j8F7H4L2OwXsdg/c6Bu91DN7rGLzXMXivY/Bex+C9jsF7HYP3OgbvdQze6xi81zF4r2PwXsfgvY7Bex2D9zoG73UM3svajFpQCm1BW9Gd6C60Dd2NtqM0ugfdi+5DO9BOtAvtRhm0B+1F+9B+dD96AB1AB9GD6FCo9lRLKSrPncJPlH7K4VDtqRRpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRGmsZI0xhpGiNNY6RpjDSNkaYx0jRWjsotpefJ10Y7eR3TSn/dk1K3RQeVEX80y26ODh4uHmSiD41fGv3s3dO6gvlrZSJbuWlQmXxHo/QfRAeF4sErpXHyVgYKowwURhkojDJQGGWgMMpAYZSBwigDhVEGCqMMFEYZKIwyUBhloDDKQGGUgcIoA4VRBgqjDBRGGSiMMlAYZaAwykBhlIHCKAOFUQYKowwURhkojDJQGGWgMMpAYZSBwigDhVEGCqMMFEYZKIwyUBhloDDKQGGUgcIoA4VRBgqjDBRGGSiMMlAYZaAwykBhlIHCKAOFUQYKowwURhkojDJQGGWgMMpAYZSBwigDhVEa/FEa/FGGDaMMG0YZNowybBhlMDDK6GGUMcEoY4JRxhKjjCVGGSGMMkIYZYQwygBjlIHCKAOFUQYKowwURhkojDJQGGWgMMpAYZSBwigDhVEGCqMMFEYZKIwyUBhloDDKQGGUgcIoA4VRBgqjDBRGGSiMMlAYZaAwykBhlIHCKAOF0fJA4U6etHSCcu4E5dwJyrkTlHMnKGVPUNydoLg7QXF3gnL1BKXeCUq9E5R6JyhsT1D4naDwO0Hhd4LC9gRl4AnKwBOUgScoA09QBp6gDDxBGXiCMrCsOFqN1qAGNBPdgNaiWWg2akQ3onXoJnQzugXditajReg2tAFtRE3odtSM7kCb0GbUgs5HKbQFbUVz0Dw0H92J7kLb0EJ0N9qO0mgxugfdi+5DNWgG2oF2olq0C+1GGbQH7UVz0T60H92PHkAH0EH0IDoUqj11FzXmEh6ftITHJy3hgUlLeGDSEh6Hs4THJy3h8UlLeHzSEh6ftITHJy3h8UlLeBjPEh6mtITHJy3h8UlLeGDSEh6YtIQHJi3hgUlLeGDSEh6YtIQHJi3hgUlLeGDSEh6YtIQHJi3hgUlLeGDSEh6YtIQHJi3hgUlLeGDSEh6YtIQHJi3hEUlLeCjSEh6KtISHIi3hoUhlPY02oC6URavROvQMOg8tRDE0HU1FR9F+NAlVo2fRMfQceh69gF5EL6EcOo5eRq+gPOpGr6LX0OvoDXQCbUdvogXoJOpBvegttBW9jd5B76Ja9B6ahRah+WgxqkF1KI5motloBpobqj21rfJQpPnTuv7KPRSpspdYWUf8KTz56CdbGvw4K4J/saca3R3t0Eb/EPOnRDu023kicisVcFmH0bpQ7al06Zefu+pdVzrXrkP16Eq0Gl2K1qIWlEYJdAg1hWpP3fNxNoY/f+/5R7/8oiniWz/mdfhTeMv5uVdv6sJomHkgyq+/0H7xZ+195J+1jePoWQ1/O/pb/Z9dPb639GIrns6bv9wVVcbFf+zoXeR7on+2ldEfcO4i/8eTwwKgrKMoi6ajY2gZ2hqqvfjPHn7i23LmiMuZOC5n4ricGeNyJofLmRwuZ3K4nGnkcuaIy5lGLmequJy55XJmcMuZwS1n4ricidxyJnLLmaUtZ6q4nMnacmZ3y5mzLWeSt5yp23KmbsuZ8i1nBrecmd9yZn7Ly1OwHUzBepiC9TAF62EK1sMUrIcpWA9TsB6mYD1MwXqYgvUwBethCtbDFKyHKVgPU7AepmA9TMF6mIL1cCb3MAXrYQrWwxSshylYD1OwHqZgPUzBepiC9VAD9DAF62EK1sMUrIcpWA9TsB6mYD1MwXqYgvUwBeuh5uhhCtbDFKyHKVgPU7AepmA9TMF6mIL1MAXrYQrWwxSshylYD1OwHqZgPUzBepiC9TAF62EK1sMUrIcpWA/p1sMUrIcpWA9TsB6mYD1MwXqYgvUwBethCtbDFKyHKVgPU7AepmA9TMF6mIL1MAXrYQrWwxSshylYD1OwHqZgPUzBepiC9TAF62EK1sMUrIcpWA9TsB6mYD1MwXqYgvUwBethCtbDFKynfK3aGdXp64qXyvOmRnX6LhZjmvnbauZvq5lXZVlfQLXofDQLzUZ1aA66AM1F89B8dCFagC5CC9EidDFajJagenQJuhRdhhLocnQFuhIl0VJ0FboaXYOWoWvRcrQCXYdWouvRKrQarUEN6Aa0FjWiG9E6dBO6Gd2CbkXr0W1oA9qImtDtqBndgTahzagFpdAWtBXdie5C29DdaDtKo3vQveg+tAPtRLvQbpRBe9BetA/tR/ejB9ABdBA9iA6Fak/tLkXl0WJ0VkWd2xvFkvvfRF/PVL7+/03tKmfrb5VGIntKP3DutdnCqkoLyw0trFa0sEzRwuJDC2ssLSw+tLAQ0sLiSgtrEC20KC20KC20KC20Ey00LC00LC00LC00LC00LC00LC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC20KC3lFmVvaQFrb9TOLvpgeJr6lajD3Rh96Xeio33R0W9FR9Oio9+Ojjac++SZ3y7/NvvodI5zlTrOVeo4V6njXKWOc4U+zjXrONes41yzjnMVPs4V7DhXsONcwY5zvT7O9ew417PjXM+Oc70+ztXtOFe341zdjnN1O87V7ThXt+Nc3Y5zdSsrjlajNagBzUQ3oLVoFpqNGtGNaB26Cd2MbkG3ovVoEboNbUAbURO6HTWjO9AmtBm1oPNRCm1BW9EcNA/NR3eiu9A2tBDdjbajNFqM7kH3ovtQDZqBdqCdqBbtQrtRBu1Be9FctA/tR/ejB9ABdBA9iA6Fak/tLwVgQzEfD5+L0S3n5tb3RokZj7JzNRutlRF0ZWh6bke1ND9/NRyIpmZEv/7NcDSa+kL0pZ7oqLRAOxYdnR8d/eOpXeUJ9T+JvjQz+tKCYhWRmhUd/UH0tdnR0T+Njuqio+9P7SpPu/84+tKc6Et/Eh1dEB39c0bq5/Zp21P3n2vuLi41dw9wE+Z+Yqmsw2hdqPbUAXrDBZxfCzi/FpBjZX0B1aLz0Sw0G9WhOegCNBfNQ/PRhWgBuggtRIvQxWgxWoLq0SXoUnQZSqDL0RXoSpRES9FV6Gp0DVqGrkXL0Qp0HVqJrker0Gq0BjWgG9Ba1IhuROvQTehmdAu6Fa1Ht6ENaCNqQrejZnQH2oQ2oxaUQlvQVnQnugttQ3ej7SiN7kH3ovvQDrQT7UK7UQbtQXvRPrQf3Y8eQAfQQfQgOhSqPXXwXPD+3clR8D74we3rSanGaV3BvdPKHdzolulL4a3cs9H1ZlpX+Zbcumldwe3Vyt2xyl3Myr3CieKvvqgruEtWualaue32wctq8z8ofZ+HPnir3KTU70a3OvdHF5P85HN9xEPR0f3R0YvR0dToaDA6mnKut/iH5d7ir1X2PBZ+vufR9Vdqz+OLlX/6gejMWBydIyfZdfifOAneKB5MCc+GVH30+0+eEp4X0ZrFpCk//gQ5O/njnSCpHdGfcXryjz5Voi2Ficmf5jmTWhJ9H//3p/KB9J+Vs6eVkjJBSZmgpExQUiYoKROUlAlKygQlZYKSMkFJmaCkTFBSJigpE5SUCUrKBCVlgpIyQUmZoKRMUFImKCkTlJQJSsoEJWWCkjJBSZmgpExQUiYoKROUlAlKygQlZYKSMkFJmaCkTFBSJigpE5SUCUrKBCVlgpIyQUmZoKRMUFImKCkTlJQJSsoEJWWCkjJBSZmgpExQUiYoKROUlAlKygQlZYKSMkFJmaCkTFBSJigpE5SUCUrKBCVlgpIyQUmZoKRMUFImKCkTlJQJSsoEJWWCkjJBSZmgpExQUiYoKROUlAlKygQlZYKSMkFJmaCkTFBSJigpE5SUCUrKBCVlgpIyQUmZoKRMUFImKCkTlJSJckn5C8xv/98p4T9xWfWoCTWjzagFXYoSaB46D12Jkmgp2obuRml0LVqOVqDr0Ep0L7oe7UCr0U7UgNagXWg3WosaUQZNRzeim9BetAfdgg6hanQrWo/2oanoADqIJqEN6Cq0CW1EsVDtqS99vk77qTyJN1rB/LfRD/0U12k/X6L96Nr6L+exvV/mojLBRWWCi8oEF5UJLioTXFQmuKhMcFGZ4KIywUVlgovKBBeVCS4qE1xUJrioTHBRmeCiMsFFZYKLygQXlQkuKhNcVCa4qExwUZngojLBRWWCi8oEF5UJLioTXFQmuKhMcFGZ4KIywUVlgovKBBeVCS4qE1xUJrioTHBRmeCiMsFFZYKLygQXlQkuKhNcVCa4qExwUZngojLBRWWCi8oEF5UJLioTXFQmyheVr5RO/XO7BI+USq6jaDs6Fqo91cYr5yRd2Em6sJN0YSfpwk7SgZ6kJztJT3aSnuwkXeZJOrSTdGgn6dBO0o+epF87Sb92kn7tJP3oSbq3k3RvJ+neTtK9naR7O0n3dpLu7STdW1lxtBqtQQ1oJroBrUWz0GzUiG5E69BN6GZ0C7oVrUeL0G1oA9qImtDtqBndgTahzagFnY9SaAvaiuageWg+uhPdhbahhehutB2l0WJ0D7oX3Ydq0Ay0A+1EtWgX2o0yaA/ai+aifWg/uh89gA6gg+hBdChUe+rwJ3s7ParuZ0zr+mTvq18Vfalu2idzX718l37ytK7wDvtXeYjAr5YuNF9EregX0JfQJvRl9BXUhragOegw+ir6GnoILUUPo3a0DX0dPYIeRcvQY+gbaAVaiTrQ46gBfRN9Cz2BdqHdqBMdQd9GT6Kn0NNoA+pCWbQarUPPoPPQQhRD09FUdBTtR5NQNXoWHUPPoefRC+hF9BLKoePoZfQKyqNu9Cp6Db2O3kAn0Hb0JlqATqIe1IveQlvR2+gd9C6qRe+hOKpBM9BMNAvNRnVoLpqPFqHFodpTXytF7Llq+gh18BHq4CPUwUeog49Qsx6hZj1CzXqEivIIdeIR6sQjVIZHqAyPUBkeofo7QoV3hJruCDXdEWq6I1RxR6jiyvoCakHnoy1oDpqH5qO70Ha0GN2LalAt2oV2o33ofnQQPYiWoHp0KboM1aEEuhwtRQvQ1egadDFaga5DK9H1aBWKo9WoAc1EN6DZ6CZ0AboZHUK3ovXoNnQ72oxSaCu6E21DC9HdKI3uQfehGWgH2okyaA/ai+ai/egBdABdhK5Cm0K1px767A7Ko7L+zLSuYGL+4UH53ywe7I9+zmd5Yr65ruvzgflf0YF5pax+kSduvchTtV7k2Vwv8oytF3mK14vlp8U8/MEbxspfPErhcJQLQYGep0CtXaDnKVB5F6i8C/SQBerwAnV4gTq8QNdYoCovUJUXqMoLVOUFqvICVXmBrqpAjV6gRi9Qoxeo0QtUu0e5PB/lcnK0HJvtpX+A/1L8F2wo/dRJqedL20lfD2e8m/9rUEiUcUmIS0NcFqIuRCLE5SGuCHFhiCtDJEMsDbEgxFUhrg5xTYiLQywLcW2I5SFWhLguxMoQ14dYFSIeYnWINSEaQswMcUOItSFmhZgdojHEjSHWhbgpxM0hbglxa4j1IRaFuC3EhhAbQzSFuD1Ec4g7QmwKsTlES4jzQ6RCbAmxNcScEPNCzA9xZ4i7QmwLsTDE3SG2h0iHWBzinhD3hrgvRE2IGSF2hNgZojbErhC7Q2RC7AmxN8TcEPtC7A9xf4gHQhwIcTDEgyEOBWhPPVJKqenF1PqjaaXL0KTUl6NrVTSt/L3o6jWlePCb00rXq0mpY9EPTYvqmeigqniQm1q6QBXLqvIVrljuTS1dpCal1pZmnI8Sg+NhDI6HMTgexuB4GIPjYQyOhzE4HsbgeBiD42EMjocxOB7G4HgYg+NhDI6HMTgexuB4GIPjYQyOhzE4HsbgeBiD42EMjocxOB7G4HgYg+NhDI6HMTgexuB4GIPjYQyOhzE4HsbgeBiD42EMjocxOB7G4HgYg+NhDI6HMTgexuB4GIPjYQyOhzE4HsbgeBiD42EMjocxOB7G4HgYg+NhDI6HMTgexuB4GIPjYQyOhzE4HsbgeBiD42EMjocxOB7G4HgYg+NhDI6HMTgexuB4GIPjYQyOhzE4HsbgeBiD42EMjocxOB7G4HgYg+NhDI6HMTgexuB4GIPjYQyOhzE4HsbgeBiD42EMjocxOB7G4HgYg+NhDI6HMTgexuB4GIPjYQyOhzE4XorBx1glX8HQaQVN/QoGISsYnK1gPLWCwdkKhn8rGJmsYHi0gqHaCgYoKxgGrGDgtoKB2wqGmyuoY1cwGljB6GMF48UVDJ1WMKhbwahsBaOysi5Bl6LLUAJdjq5AV6IkWoquQleja9AydC1ajlag69BKdD1ahVajNagB3YDWokZ0I1qHbkI3o1vQrWg9ug1tQBtRE7odNaM70Ca0GbWgFNqCtqI70V1oG7obbUdpdA+6F92HdqCdaBfajTJoD9qL9qH96H70ADqADqIH0aFQ7alvlKKyMk6qTAcrU5vKOKkyE/vz36M1WPxC9Gt+o/jf67uCIVdlhFSZdlWGeJUxU2UuU5nmVcZeHx7rVSY1H/FGoo4fN/n88waen8ac89PbAy69yfETn2r+iHeu/TRnlx9nZPnLxX+Kx7o+n1h+/BXfx6mL0tRFaeqiNHVRmrooTV2Upi5KUxelqYvS1EVp6qI0dVGauihNXZSmLkpTF6Wpi9LURWnqojR1UZq6KE1dlKYuSlMXpamL0tRFaeqiNHVRmrooTV2Upi5KUxelqYvS1EVp6qI0dVGauihNXZSmLkpTF6Wpi9LURWnqojR1UZq6KE1dlKYuSlMXpamL0tRFaeqiNHVRmrooTV2Upi5KUxelqYvS1EVp6qI0dVGauihNXZSmLkpTF6Wpi9LURWnqojR1UZq6KE1dlKYuSlMXpamL0tRFaeqiNHVRmrooTV2Upi5KUxelqYvS1EVp6qI0dVGauihNXZSmLkpTF6Wpi9LURWnqojR1UZq6KE1dlC7XRd9kme9RPhHoUT4R6FE+C+ZRPh/oUT4f6FE+EehRPhHoUT4R6FE+EehRPhHoUT4R6FE+A6iseeghtBQl0cOoHW1DX0ePoEfRMvQY+gZagVaiDvQ4akDfRN9CT6BdaDfqQp1oDzqCvo2eRE+hr6INaBPKotVoHXoGnYcWoumoGk1FR9F+NAnF0LPoGHoOPY9eQC+il1AOHUcvo1dQHnWjV9Fr6HX0BjqBtqM30QJ0EvWgXvQW2oreRu+gd1Eteg/FUQ2agWaiWWg2qkNz0Xy0CC0O1Z76VmW//O9+UCFvXl7KiEmbbyn+91TxB1onl2JiUupLk7vKn/zw5cmll+ek1HPRQbRP8iuTSxE7KfV+dPC3igenJke//ROl3/6Po4bn3Pr65lIn2Um9HKdejlMvx6mX49TLcerlOPVynHo5Tr0cp16OUy/HqZfj1Mtx6uU49XKcejlOvRynXo5TL8epl+PUy3Hq5Tj1cpx6OU69HKdejlMvx6mX49TLcerlOPVynHo5Tr0cp16OUy/HqZfj1Mtx6uU49XKcejlOvRynXo5TL8epl+PUy3Hq5Tj1cpx6OU69HKdejlMvx6mX49TLcerlOPVynHo5Tr0cp16OUy/HqZfj1Mtx6uU49XKcejlOvRynXo5TL8epl+PUy3Hq5Tj1cpx6OU69HKdejlMvx6mX49TLcerlOPVynHo5Tr0cp16OUy/HqZfj1Mtx6uU49XKcejlOvRynXo5TL8epl+PUy3Hq5Xi5Xj7Cp3KtoYZbQ+WyhrpiDVfFNVxN13A1XUPFs4YqeE35OvHt0jdx7pf/m9L3+QY6irJoOjqGlqGtodpTT/L+z/8+JTy9y6pHTagZbUYt6FKUQPPQeehKlERL0TZ0N0qja9FytAJdh1aie9H1aAdajXaiBrQG7UK70VrUiDJoOroR3YT2oj3oFnQIVaNb0Xq0D01FB9BBNAltQFehTWgjioVqTz1VOvX/NBo+T+kqD6jbp5RePZM2/1r0E57+7K4hf4zndaQemFz8Dc/v+gyvIX9G1o+jbejzuj5fQ/7pD/W7mFT9bulV+kXUin4BfQltQl9GX0FtaAuagw6jr6KvoYfQUvQwakfb0NfRI+hRtAw9hr6BVqCVqAM9jhrQN9G30BNoF9qNOtER9G30JHoKPY02oC6URavROvQMOg8tRDE0HU1FR9F+NAlVo2fRMfQceh69gF5EL6EcOo5eRq+gPOpGr6LX0OvoDXQCbUdvogXoJOpBvegttBW9jd5B76Ja9B6Koxo0A81Es9BsVIfmovloEVocqj2VDedAm78XfH9lzAgxM8QXQtSGOD/ErBCzQ9SFmBPighBzQ8wLMT/EhSEWhLgoxMIQi0JcHGJxiCUh6kNcEuLSEJeFSIS4PMQVIa4MkQyxNMRVIa4OcU2IZSGuDbE8xIoQ14VYGeL6EKtCrA6xJkRDiBtCrA3RGOLGEOtC3BTi5hC3hLg1xPoQt4XYEGJjiKYQt4doDnFHiE0hNodoCZEKsSXE1hB3hrgrxLYQd4fYHiId4p4Q94a4L8SOEDtD7AqxO0QmxJ4Qe0PsC7E/xP0hHghxIMTBEA+GOBSgPfUM9WI39WI3FWI3FWI3NWE315ZuasJuartuartuarturknd1G/d1G/d1G/d1G/d1G/dVGzdVGzdVGzdVDTd1G/d1G/d1G/dXDu7qTC6uZJ2U990UzN1UzN1U791Uwl1U+10c3Xu5urcTY3dTW3XTZXUTaXXTVVWViv6CtqCtqI56DDKobfReehh1I62oYVoO3oHfQO9i76FnkC70G5UizrREfQeOor2oyfRCfQGego9jTahLIqjGjQDzUSz0GxUh+ai+WgRWoyeQ8+jF9CL6BWUR6+jZ9FL6Dh6GXWjV9FrodpTR0sRe65O+JPoZ9SHuDLEpSHWhmgJkQ6RCHEoxJIQt4doCjEvxIUhkiHuDnFtiOUhVoa4N8T1IVaH2BmiIcSaEJkQN4bYE2JviFtCrA+xL8SBEAdDXBViY4D21LPRp7mc+z/y2w9Fn+hy7Gd6xPn5ZPPzyeYnOtksz8ynd32CI87nSq+wc/sU15Ru/Z2P6tAcNA/NRxeiBWghuhgtRnFUg2agmagWzUKz0QVoLroILQrVnnq+stuy7oME+mC35YXSDxwu+opw6aX0UwvRwTPFf8VVxf/+s+J/V3eVPsJq85roV75IA5GngcjTQORpIPI0EHkaiDwNRJ4GIk8DkaeByNNA5Gkg8jQQeRqIPA1EngYiTwORp4HI00DkaSDyNBB5Gog8DUSeBiJPA5GngcjTQORpIPI0EHkaiDwNRJ4GIk8DkaeByNNA5Gkg8jQQeRqIPA1EngYiTwORp4HI00DkaSDyNBB5Gog8DUSeBiJPA5GngcjTQORpIPI0EHkaiDwNRJ4GIk8DkaeByNNA5Gkg8jQQeRqIPA1EngYiTwORp4HI00DkaSDyNBB5Gog8DUSeBiJPA5GngcjTQORpIPI0EHkaiDwNRJ4GIk8DkaeByNNA5Gkg8jQQeRqIPA1EngYiTwORp4HI00DkaSDyNBB5Gog8DUSeBiJPA5GngciXG4iXoioz+sSzL0yJKswcCyb/rfQrbkf1qAk1o82oBV2KEmgeOg9diZJoKdqG7kZpdC1ajlag69BKdC+6Hu1Aq9FO1IDWoF1oN1qLGlEGTUc3opvQXrQH3YIOoWp0K1qP9qGp6AA6iCahDegqtAltRLFQ7anjlU+lfHdKV7kIuaNYY14e1Zjbop/wMq+N99k3fZ990/fZN32ffdP32bV9n+3T99k+fZ/t0/fZp32fXdT32UV9n13U99m8fZ/N1PfZTH2fzdT32bx9n92099lTfZ891ffZU32fPdX32VN9nz3V99lTLSuOVqM1qAHNRDegtWgWmo0a0Y1oHboJ3YxuQbei9WgRug1tQBtRE7odNaM70Ca0GbWg81EKbUFb0Rw0D81Hd6K70Da0EN2NtqM0WozuQfei+1ANmoF2oJ2oFu1Cu1EG7UF70Vy0D+1H96MH0AF0ED2IDoVqT73C0uv3WHr9Hkuv32Pp9XusuX6PFdjvESzf4yT6XvmPzX+a78modJePla4JX0St6Gn0C+hL6MvoK2gLmoMOo4fQUvQwakfb0NfRI+hRtAw9hr6BVqDH0TfRt9ATaBfajbpQJ/o2ehI9hb6KNqBNKItWo3XoGXQeWoimo2o0FR1F+9EkFENvoBNoOzqG3kQL0EnUg3rRW2gryqG30TvoXVSL3gvVnupmHDTEC3aIF+wQL9ghXrBDvGCHeMEO8YItqw1tQXPQYfQ1NA89hJaiJHoYtaNt6OvoEfQoWoYeQ99AK9BK1IEeRw3om+hb6Am0C+1GXagT7UFH0LfRk+gp9FW0AW1CWbQarUPPoPPQQjQdVaOp6CjajyahGHoWHUPPoefRC+hF9BLKoePoZfQKyqNu9Cp6Db2O3kAn0Hb0JlqATqIe1IveQlvR2+gd9C6qRe+hWWgRmo8WoxpUh+JoJpqNZqC5odpTr/64T2IqfQzSv5r62fhMpk/rk5he4327e+kY9tIx7KUzLesLqBadj2ah2agOzUEXoLloHpqPLkQL0EVoIVqELkaL0RJUjy5Bl6LLUAJdjq5AV6IkWoquQleja9AydC1ajlag69BKdD1ahVajNagB3YDWokZ0I1qHbkI3o1vQrWg9ug1tQBtRE7odNaM70Ca0GbWgFNqCtqI70V1oG7obbUdpdA+6F92HdqCdaBfajTJoD9qL9qH96H70ADqADqIH0aFQ7anXozsN66LFkWnRnYY3KOa7KOa7KOa7KN+7KN+7KM66KOa7KOa7KOa7KOa7KOa7KOa7KA27KO27KOa7KOa7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KN+7KNi7KNG7KNG7KNG7KNHLehptQF0oi1ajdegZdB5aiGJoOpqKjqL9aBKqRs+h59EL6EWUQ6+gPHodPYuOoZfQcfQy6kavotfQG+gE2o7eRAvQSdSDetFbaCt6G72D3kW16D0URzVoBpqJZqHZqA7NRfPRIrQ4VHvqBDesTlFonaLQOkWhdYpC6xRF5inKrlOUXacou05RSJ6iCDtFEXaKIuwUJecpSrJTlGSnKMlOUXKeokA7RYF2igLtFAXaKQq0UxRopyjQTlGglRVHq9Ea1IBmohvQWjQLzUaN6Ea0Dt2Ebka3oFvRerQI3YY2oI2oCd2OmtEdaBPajFrQ+SiFtqCtaA6ah+ajO9FdaBtaiO5G21EaLUb3oHvRfagGzUA70E5Ui3ah3SiD9qC9aC7ah/aj+9ED6AA6iB5Eh0K1p97khtXvTw6vQGUdRVk0HR1Dy9DWUO2pk5U17UlTun64gZyqjwYIi6Z0fcSK9cPRqm50Oypacr6BpeIf8djqDz+k+ofPpu6prDP82A/IPjfECYYeH5rPlCYom/9jVzCo+VjzmcpU5oezmMoE5iPmLj9c4P7hjKWXTmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGAyn2Ayn2ALmKALmKALmKALmKAin+AnmKA+n+A+n+AfmOAfmOA3mCA3mCA3mCAzmSATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGATmGg3Cm8FUVs6soohTumlv7pJ6XeCLcjCqRugdQtkLoFUrdA6hZI3QKp+1GfD7kFzUGH0VeRnxb5EFqKHkbtaBv6OnoEPYqWocfQN9AK9KM+b/Nx5OdtfhN9Cz2BdqHdqBP5aZjfRkfRk+gN9BR6Gm1AXSiLFqL9odpTb1McnOE0PcNpeobT9Ayn6RlO0zOcpmc4Tc9wmp7hND3DaXqG0/QMp+kZTtMznKZnOE3PcJqe4TQ9w2l6htP0DKfpGU7TM5ymZzhNz3CanuE0PcNpeobT9Ayn6RlO0zOcpmc4Tc9wmp7hND3DaXqG0/QMp+kZTtMznJhnOBXPcCqe4VQ8w6l4hlOxrNVoHXoGnYcWohiajqaio2g/moSq0bPoGHoOPY9eQC+il1AOHUcvo1dQHnWjV9Fr6HX0BjqBtqM30QJ0EvWgXvQW2oreRu+gd1Eteg/FUQ2agWaiWWg2qkNz0Xy0CC0O1Z56h3vcjzNkeJwhw+MMs8r6AqpF56NZaDaqQ3PQBWgumofmowvRAnQRWogWoYvRYrQE1aNL0KXoMpRAl6Mr0JUoiZaiq9DV6Bq0DF2LlqMV6Dq0El2PVqHVaA1qQDegtagR3YjWoZvQzegWdCtaj25DG9BG1IRuR83oDrQJbUYtKIW2oK3oTnQX2obuRttRGt2D7kX3oR1oJ9qFdqMM2oP2on1oP7ofPYAOoIPoQXQoVHvqXaKymqisJiqricpqorKaqKwmKquJymqispqorCYqq4nKaqKymqisJiqricpqorKaqKwmKquJymqispqorCYqq4nKaqKymqisJiqricpqorKaqKwmKquJymqispqorCYqq4nKaqKymqisJiqricpqorKaqKwmKquJymqispqorCYqq4nKaqKymqisJiqricpqorKaqKwmKquJymqispqorCYqq4nKaqKymqisJiqricpqorKaqKwmKquJymqispqorCYqq4nKaqKymqisJiqricpqorKaqKwmKquJymqispqorCYqq4nKaqKymqisJiqricpqorKaqKwmKquJymqispqorC5H5XtEZRVRWUVUVhGVVURlFVFZRVRWEZVVRGUVUVlFVFYRlVVEZRVRWUVUVhGVVURlFVFZRVRWEZVVRGUVUVlFVFYRlVVEZRVRWUVUVhGVVURlFVFZRVRWEZVVRGUVUVlFVFYRlVVEZRVRWUVUVhGVVURlFVFZRVRWEZVVRGUVUVlFVFYRlVVEZRVRWUVUVhGVVURlFVFZRVRWEZVVRGUVUVlFVFYRlVVEZRVRWUVUVhGVVURlFVFZRVRWEZVVRGVJ+UmTJk+K/lfJzCoys4rMrCIzq8jMKjKzisysIjOryMwqMrOKzKwiM6vIzCoys4rMrCIzq8jMKjKzisysIjOryMwqMrOKzKwiM6vIzKpyZv71yj3dyVO7ym9Rryn+90+K/y3d8/0bpR8/NzR6hvPyGZLyGdLpGS54z5T/sFOl3+wHxd/7C6VfOCm1JbrDfLT4hSuL//1e8b9XlX6PSanXp5V++aTN1xT/+0fF/14b/QZ/84PvZlLqVyeXv9vUBdOiH/hb5U3Q8p82MxoyPJT6xc8fbfbz82iz09Gv+rgfwPz5s826PtVPbfglHin+B0GdVcaMEDNDfCFEbYjzQ8wKMTtEXYg5IS4IMTfEvBDzQ1wYYkGIi0IsDLEoxMUhFodYEqI+xCUhLg1xWYhEiMtDXBHiyhDJEEtDXBXi6hDXhFgW4toQy0OsCHFdiJUhrg+xKsTqEGtCNIS4IcTaEI0hbgyxLsRNIW4OcUuIW0OsD3FbiA0hNoZoCnF7iOYQd4TYFGJziJYQqRBbQmwNcWeIu0JsC3F3iO0h0iHuCXFviPtC7AixM8SuELtDZELsCbE3xL4Q+0PcH+KBEAdCHAzxYIhDAdpThVKYVa6klet5dAF9Kbywf3g17sMLdWeLB9dHpctE8RddFKZn5cp6LoXbU7/8V7FAiZ5I+qWun99C5fP6pOsvvT75lb+KL6yf1xdUFBiXfP7C+ky8sP725y+sn/yFFZ3IT30GX2Cfv7D+8l9Yf6fypOsnJ3eFT7r+u//Tr7jpxZ/wx1M+8qX3z4sHf/YTvwaPRf+fp30aL8Zo2NM17afzqvz81fj5q/F/fDX+KvOtsXC+NRbOt8bC+dZYON8aC+dbY+F8ayycb42F862xcL41Fs63xsL51lg43xoL51tj4XxrLJxvjYXzrbFwvjUWzrfGwvnWWDjfGgvnW2PhfGssnG+NhfOtsXC+NRbOt8bC+dZYON8aC+dbY+F8ayycb42F862xcL41Fs63xsL51lg43xoL51tj4XxrLJxvjYXzrbFwvjUWzrfGwvnWWDjfGgvnW2PhfGssnG+NhfOtsXC+NRbOt8bC+dZYON8aC+dbY+F8ayycb42F862xcL41Fs63xsL51lg43xoL51tj4XxrLJxvjYXzrbFwvjUWzrfGwvnWWDjfGgvnW2PhfGssnG+NhfOtsXC+NRbOt8bC+dZYON8aC+dbY+F8ayycb42F862xcL41Fs63xsL51lg43xoL51tj4XxrLJxvjYXzrbFwvjUWzrfGwvnWWDjfGgvnW2Ol+dbfI8yGwjAbCsNsKAyzoTDMhsIwGwrDbCgMs6EwzIbCMBsKw2woDLOhMMyGwjAbCsNsKAyzoTDMhsIwGwrDbCgMs6EwzIbCMBsKw2woDLOhMMyGwjAbCsNsKAyzoTDMhsIwGwrDbCgMs6EwzIbCMBsKw2woDLOhMMyGwjAbCsNsKAyzoTDMhsIwGwrDbCgMs6EwzIbCMBsKw2woDLOhMMyGwjAbCsNsKAyzoTDMhsIwGwrDbCgMs6EwzIbCMBsKw2woDLOhMMyGwjAbCsNsKAyzoTDMhsIwGwrDbCgMs6EwzIbCMBsKw2woDLOhMMyGwjAbCsNsKAyzoTDMhsIwGwrDbCgMs6EwzIbCMBsKw2woDLOhMMyGwjAbCsNsKAyzoTDMhsIwGwrDbCgMs6EwzIbCMBsqhdmvnXvi0wuTo1v8/0sp26J9gec/aIFSf1Q8SGWid5Ynusr9xxej2vCfRT1KdPBfopI5Ovh+8afUd73yw08ROvfhQamLojct/vsppb/zSalfib50afSlX4q+9CfFg2tLVWIf78lPLY5+ysmpH/yqXw6bjNSS6McazzVNa6d0fZz365ff3D+ZVuInfOd+f+lbjR5v/evB/6vSX8r6qM96pniwYVr4l1H5SKXoL3vjtA/99dxeWrsYKP2+0Tf8Xbq0D/2f+zj3Tn7UrZJfL/1BUUv0u9F3d+7Nea28Oa+VN+e18ua8Vt6c18qb81p5c14rb85r5e14rbwdr5W347XylrtW3nLXylvuWnnLXStvsmvlTXatvMmulTfZtfImu1beZNfKm+xaeSNdK2+da+Wtc628da6Vt8618ma5Vt4e18rb41p5e1wrb1Ns5e1xrbw9rpW3x7Xy9rhW3h7XytvjWnl7XCtvj2vl7XGtvD2ulbfHtfL2uFbeHtfK2+NaeXtcK28fa+XtY628fayVt8618mayVt5M1sqbyVp5M1krbyZr5c1krbyZrJW31bXy1rJW3lrWylvLWnlrWStvLWstv4HrN0qvxygbnio/Hr/8oz/+qXA+pc2nwvEkvfbUYOnP+NPinzGLVPhQuBQzdfOvfRCc/2ryJxCXf//PuSV87g+M/qBrpn0Csfb+ub/GzRd/ZPjyeXa15cTePCv6ld/xyhdd1f516ao0VPqBXyz+vO6uYEz4500HK5O/D/2frEz1KjO8ynzux0zjjjCEq8zeKtO4v9AQrjJ7+/DI7cOTtso4rTJF+/Dw7OOMwT489PoRs66fbLL1ceZYf5HxVXvqN1l/z7D+nmH9PcP6e4b19wxLnRnW3zOsv2dYf8+w/p5h/T3D+nuG9fcM6+8Z1t8zrL9nWDDNsP6eYf09w/p7hvX3DOvvGdbfM6y/Z1h/z7D+nmH9PcP6e4b19wzr7xnW3zOsv2dYf8+w/p5h/T3D+nuG9fcM6+8Z1t8zrL9nWH/PsP6eYf09w/p7hvX3DOvvGdbfM6y/Z1h/z7D+nmH9PcOacYb19wzr7xnW3zOsv2dYf8+w/p5h/T3D+nuG9fcM6+8Z1t8zrL9nWH/PsP6eYf09w/p7hvX3DIvTGbbeM2y9Z9h6z7D1nmHrPcPWe4at9wxb7xm23jNsvWfYes+w9Z5h6z3D1nuGrfcMW+8Ztt4zbL1n2HrPsPWeYes9w9Z7hq33DFvvmfIi+m8VozK1IepjuqdGfeRvlx5WU/xC+Wc9PjU8w0tKbeQHU9Nge+ofhB1WuUX6F+d6wV/54AqeqvnoFqtylY/qqWujnxM1ZolSh/UPS7/vzKL/0ZRSvk7avLKUiZNS700uxVPxAj85+pnDxH8H8d9B/HcQ/x3Efwfx30H8dxD/HcR/B/HfQfx3EP8dxH8H8d9B/HcQ/x3Efwfx30H8dxD/HcR/B/HfQfx3EP8dxH8H8d9B/HcQ/x3Efwfx30H8dxD/HcR/B/HfQfx3EP8dxH8H8d9B/HcQ/x3Efwfx30H8dxD/HcR/B/HfQfx3EP8dxH8H8d9B/HcQ/x3Efwfx30H8dxD/HcR/B/HfQfx3EP8dxH8H8d9B/HcQ/x3Efwfx30H8dxD/HcR/B/HfQfx3EP8dxH8H8d9B/HcQ/x3Efwfx30H8dxD/HcR/B/HfQfx3EP8dxH8H8d9B/HcQ/x3Efwfx30H8dxD/HcR/B/HfUY7/kR/38eFREN96Loj/3dQP4jtVSuTTH/Oz414qHjwcHbwQtTJ8mtyzURXPx8q9WDz49eggmg/+cnTwvxcP/mZ08Hzx4N3o4PXiwS/xGXTdxYPf+OgPo8sXD4aig+PFgywfTxc9ie3vFQ9SV0RXqcPRl14rHjwWHTwXtWbRwctR9xcdvBr1cdHBK8WDv/9Z+3i7zz/Q7qM/0M4PmPvUP96uPTVaelVE6xqvTg7+nlYxIl3F2G4VA75VfN+rGOmtYlC3ikHdKgZ1qxj+rWJst4rh3yqGeKsYE65ipLeKkd4qhnirGPCtYhi3iiHeKkZsqxixrWLAt4rB4CpGeqsY6a1ipLeKQd0qBoqrGBquYvi3qvwv+DvWwB3UwB3WwB3WwB3lGvh3f9yu2icxhKoskn14beyzP5b6C215Ratc/51Vrk98dPWzs53VnvpH5wabxStwcC4tLn7hH0ZfqKw3Vk6iZcWDX4y+ckP0zxcdzCgebI+u65UFxduKB3+neJC6OroY/lr0pbroG50WnkaVvcZ/WTz4o6ldwdLh/cWDnsnh+fRgdD5FX/m3URER3TC7JvqtX4u+FLVt3578keda5RRbWDx4JPo5lfXDaB3y9cnB66ayR3juxZBaFv0RndGXVhUPnogOro7+dqODyk5n1Iu+NTk8DS8uHiyL/q9+L/p3i36ja6Pf6G9EPzarePA4S5iV3cLKSmHlzPxPxYO/PTl8nf6L4sFL0Vf2R/8K0cFlxYMT0cH/WTz469HvHLW1o9H/53uil+fkruA94T9ik7Byit4Z/YZTwlO0cmbOLx48xYZk5RStnJCV8zBVPHiGs66SWHdE/5ejr1TWbM9l1v9R/MKO6AuVbdpoGD8YHVRWZe8rHvxmdFCJsSui0zc6J5ZHf8+/wx2JSjSdW2RNrYh+0u9HP/ZvigfnR1+6LvrSH0ZfqizSfozN09TK6Jf9y+hLNxcP/lM4Ik9dH/3Yf46+9J+j3zv6h/l30d9adFBZ9q1srM4tHvzWtCBoUquiX/9fox+LhhH/z5QwaSq5ck3xYEqYIqnV0S+7cUqQFak10ZemERZbigdVUz8qI1IN0c+eEf26G6KjL0Q/69x14z9Gf1/hFSC1Nvo5s6Kf3Rgd1UVHN0ZHc6OfFhX886ODSuRXkv7y4sGC6CuVgF9UPPjl6K/g30cv/g8eVJC6KfqhSop/OKErq7Uf3p+tLNtWQveB4sFl0cGfFQ+uDu8XpNZF3/Ty6EuVDeoPrbD+8CJcE/0DRgeVa2zlclm5gFaugH/+nnPqpuhPvTP6UuViVrl0fWgvOXVz9LN3REe3REc7o59VWVGuXMX+dfFgX/STbo1+0v3hZSy1PvrSQa5jc4oHQ9HB/1U8uCf6DeLRqzw6mF08eDA6OL948JXooHJpOneRaU+d4bm+bXQvbXQvbXQvbXQvbXQvbXQvbXQvbXQvbXQvbdTFbfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybfQybXQvbXQvbXQvbXQvbXQvbXQvbXQvbfQgbfQgbXQrbXQkbfQZbXQWbXQWbfQubfQubfQubXQrbXQkbXQkbXQkbfQgbfQnbfQSbfQEbfQnbfQgbfQLbfQ1bXQkbXQkbXQkbfQZbXRAbXRAbfQubeWO5H/9mJOWylylMk6pTEg+PBipjEHOTaDXlhqd+SiOatAMNBMtRIvQLDQb1aHFaE6o9tQYH0Dze5PD86KsoyiLpqNjaBnaGqo99V0++Gtq6Tu7HdWjJtSMWtClKIHmoStREi1F29DdKI2uRcvRdWgluhddj1ajnagBrUFr0W6UQTeiPWgvugUdQuvRPnQAHUQb0FVoE9oYqj31jz84dydt7gjO2jOctWc4T89wnp7hPD3DeXqmfJ7+XumPuCuqJ6J2pikqI/ZFRweiowdKd8r+CS+h7/MS+j7fzPd5CX2fb+37fGvf51v7Pt/a98vf2v9WWfZ5sZR1kzZ/pfh9TY9WVZ+Nfvz3Sz8eDYB/9Vz3+mdTox/4g9IPZIs/77og9r/L9/1dvu/v8p1+l+/0u3yn3+U7/W75O/3Dn8m3+UZt8n+IvvIZeb/vz+A7C1N3RmfjL3Z9/hbDT/sthv+UDPpDXst/+P+zd++BTZX348cLFKWQUnohbUpLVQS5NlCw3AmBkELLabm03JoUyiWoWxWFEy9RvMUgpiVNuIMghbgr3ZdsbA0Zu2/syza3oU67abbOuau7b9919/1ycp7G5/1DHTov6Pr94/vJq1bbQc7n+Xw+z5NzcC0/gxz0DK7sZ3BlP4Mr+xlc2c/oV3Zn8scm3uFVTyb+4YuJONaXOkCpKt99oxPcN3SZX3x1v7GPC1/K3PdNv4RfYwD8ui7YNzYbvpSr8o1Niy++9BIXbFX4FS/Bd+WV973ke7znWnsC19oTuLqewNX1BK6uJ3B1PaFfXc9pn07R3nvjk88jfx7X+HO4xp/Dz30O1/hz+C2ew2/xHH6L5/BbPKf/FnH82KfwY5/Cj30KP/Yp/Nin8GOfwo99Cj/2Kf3Hfj9VvqT2r+3JucsP8Ps8id/nSfw+T+L3eRK/z5P4fZ7E7/Mkfp8n9d+nCz/2WfzYZ/Fjn8WPfRY/6Fn8Es/ixz6LH/us/mN/eMm1k3Y/kA++Rk79L75VyruwdOqtmN7ivP1C8sLSPghxwiedotQm95npvlc6xaN9WOKz2r/6o+TWttZpKS2Jb1Wu1F7dr726Qns1R/uLEP1Y6sDfx5MX93WQCRoNjYFKITM0EZoKzYCyoZnQLGg2NBcqhmzQAsgOLYQWQYuhIVA1lAflQwXQUqgWKoFWQoOgLKgeckDroPXQJsgFXQVdDY2AroVyoZHQKGgsVAiNhyZAw6FJUBk0GZoCXQ8NhMqhaVAmNB3KgeZAFmgzZIXmQfOhCqgKUqAaaAm0DCqClkN10ApoFWSAVkNrICfUAK2FjFAjtAHaCI2DKmWpyouifK1aqFWvP8Z22S5sl+3CltgubIntwpbYLmxA6LoFug3aCo2FCiE3dDt0B1QK3QlNgiZDHqgcuhuaBt0DHYH80FGoPzQbehh6AOoHpUGPQcegWyEbdCXkgzKgm6CboWqoBsqDtkBBqA0aAG2DVGgZVATVQsehu6AT0HboXqgeckBZ0H3Q/VAY2gk1Qg9Ch6FDkBd6CKqEdkADoUGQAcqEsqEcKBcyQgVQMVQCNUMt0C4oAO2B9kIHoUegVigE7Yb2QfuhA7JU5SfJunSTVoM6+iX/0tKUcf2Sf+tpygPJ0+Y/TVW9n/e95meHtGL3Cz79CR5fTPyb6mjlZ8l/V7uvhF8+t92Ay7YBqbwBqbwB6awBib0Bl0MDLoAGXBwNSAwNuAAakAoakAoacDE2YHlowPLQgIu/ARdHAxaLBiwBDVgCGrB0NODCaUDCbEDCbMAi04CLqgEXVQMWkgak+Qak+QakugYksAYk4QYsHQ1YEBqQQhqQQhqwWDQg6TcghTQgvTRgGWtAMtX1KFQDBaE2qBA6Dh2BTkBZ0FEoDD0GHZOlKj/HXFDFhEhFS6JiQqTqxdMv3pV7Zr3zHt+bN+/RBnrdvt65z5s793kJn2udh5Z/HhqseWhDdQ2GsqAhUDaUA+VCedBQyAjlQwWQCSqEhkFFUDE0HCqBroKuhq6BRkDXQiOhUdB10GhoDDQWGgeNhyZApZAZmghNgsqgydAU6HqoHJoKTYOmQzOgmdAsaDY0B7JAcyErNA+aD9mgBZAdqoAWQougSqgKWgwpUDVUAy2BlkLLoOVQLVQHrYBWQqug1dAaqB5yQE6oAVoLrYMaofXQBmgjtAlyQZtlqYk6Qx7ZXJM8gnUjdBP0Puj9UCXUBN0M3QJVQ3nQFuhW6DZoKzQW2gap0DLIDd0O3QGVQndCd0GToMmQB7obmgbdA22H7oXqIQd0H3Q/9AD0IOSFHoJskA/aAZVDs6GHoQFQEZQB9Yf6QTuhRigNuhJ6BPJDzVALtAsKQK1QEApBu6E90F5oH7QfOgAdhA5Bh6Fa6FGoEDoCHYUeg45BNVAbdBw6AWVBYSgbKoYKoBJoEJQLDYQyoRzIABllqcqvUkdYd0lvyb+gdviLno1/nXqmQ5q8P6kqv+l5imnVCunf6tb/rd+mHsjaM9+p8mlf/538INaqf0qXXBKq8ntteq8NiIYlD5/84VIfa/aPxBcsaObe4M3s/ph6OGu8b/JSTquKa1//P/4mf0l8/aDvVe6q933tF/lr4sXIvq/4G6W6ikv41VTlT6l74f3B13svvP+me+F1izt86JdWKWZrpZjClWIKV4q5WymmaaWYppVimlaKCV0pZmulmNCVYtJWilleKeZupZi7lWLuVoq5WynmbqWYu5Vi7laKuVsp5m6lmLuVYu5WirlbKeZupZi7lWLuVoq5WynmbqX63O3Pyb8q7VPCf+rn05/5/B2f/jHoj2hHNBZpR5K/q33nX1IH6A/79Bl5YfIv+6+9o7fXPXrTDstf1ecS8867aAbXO3vzvWmzt1TOug319216JfQ3zMu/jXm5rv6QHyqFamSpyt9T6/bT4g3+aLrvEhbw1Gfy3+yV/DUWcO2WDjf09fWu5K9/JdduEXE+/dLelKryD/HJLv2dUonmo1J/S/4T84/nkqvNjdD7oPdDTdCj0C3QbdBWaCxUCLmh26E7oFLoTmgSNBnyQOXQ3dA06B7oCOSHjkL9odnQw9ADUD8oDXoMOgbdCtmgKyEflAHdBN0MVUM1UB60BQpCbdAAaBukQsugIqgWOg7dBZ2AtkP3QvWQA8qC7oPuh8LQTqgRehA6DB2CvNBDUCW0A3oEaoZaoF1QAGqFQtBuaA+0F9oH7YcOQAehgdAgyABlQtlQDpQLGaECqBgqkaUq/0qmWHx49Ue+l7eazmKr6Sy2ms5iq+kstprOYpvtLDaezmLj6Sw2ns5iK+0stqHOYhvqLLahzmLT7Sw2pc5iU+osNqXOYtPtLEqZs9iiOostqrPYojqLLaqz2KI6iy2qs9ii0jUQKoemQtOgTGg6NAPKhnKgmdAsaDY0B7JAcyErNA8qhuZDNmgBZIcqoIXQIqgSqoIWQ0MgBaqGaqA8KB8qgJZAS6FlUBG0HKqF6qASaAW0EloFDYIM0GpoDZQF1UMOyAk1QGshI7QOaoTWQxugjdAmyAVtlqUqaempD5d8M9338gdJelJiDCkxhpQYQ0qMISXGkBJjSIkxpMQYUmIMKTGGlBhDSowhJcaQEmNIiTGkxBhSYgwpMYaUGENKjCElxpASY0iJMaTEGFJiDCkxhpQYQ0qMISXGkBJjSIkxpMQYUmIMKTGGlBhDSowhJcaQEmNIiTGkxBhSYgwpMYaUGENKjCElxpASY0iJMaTEGFJiDCkxhpQYQ0qMISXGkBJjSIkxpMQYUmIMKTGGlBhDSowhJcaQEmNIiTGkxBhSYgwpMYaUGENKjCElxpASY0iJMaTEGFJiDCkxhpQYQ0qMISXGkBJjSIkxpMQYUmIMKTGGlBhDSowhJcaQEmNIiTGkxBhSYgwpMYaUGNNTYh8tJaZ6wxeT37ITOiRLVfqm90x2PyGqSmVKv5dzqar0S35DT3oo7yenVF2joRHQDGgxVAeNhDZDPU9wPJf8ldPTX+nBDKrSP13ep/ua/C9+LfkvXpH8Bm/i+3dL2bcCA4kKNEsVaNEr0MZVoBGuwPCgAm1qBZqlCrToFRgXVKCZr0CjX4GGtgLNfAXavwq0fxVoaCvQ9legfa9Aw16B1rACbWMFxhMVaJIrMMSpQDNfgYa9Ag17BcY2FWi1KzAcqUCrXYGWuQKjkgo0yRUYclRgyFGhN1lXpstHHmuQXmqQXmqwjOkaDGVBQ6BsKAfKhfKgoZARyocKIBNUCA2DiqBiaDhUAl0FXQ1dA42AroVGQqOg66DR0BhoLDQOGg9NgEohMzQRmgSVQZOhKdD1UDk0FZoGTYdmQDOhWdBsaA5kgeZCVmgeNB+yQQsgO1QBLYQWQZVQFbQYUqBqqAZaAi2FlkHLoVqoDloBrYRWQauhNVA95ICcUAO0FloHNULroQ3QRmgT5II2y1KVAenyfQnP47I/j8v+PC7787jszyPlnUcSOI8kcB5J4DzS2nmkhPNICeeREs4jAZ5HgjiPBHEeCeI8EuB5pIvzSBfnkS7OI12cR7o4j3RxHuniPNKFroFQOTQVmgZlQtOhGVA2lAPNhGZBs6E5kAWaC1mheVAxNB+yQQsgO1QBLYQWQZVQFbQYGgIpUDVUA+VB+VABtARaCi2DiqDlUC1UB5VAK6CV0CpoEGSAVkNroCyoHnJATqgBWgsZoXVQI7Qe2gBthDZBLmizLFXJSJdPOpWjrC9HWV+Osr4chXw5CvlyFPLlKOTLUciXo5AvR6tQjrK+HGV9Ocr6cpT15Sjry1HWl6OsL0dZX46yvhxlfTnK+nKU9eUo68tR1pejrC9HWV+Osr4cZX05yvpyvawfmP5vHytc9SHff34Qc1Di5ySb6ce0g6CGdHFXh79qykRrMR5X03hcTeORtXUNhrKgIVA2lAPlQnnQUMgI5UMFkAkqhIZBRVAxNBwqga6CroaugUZA10IjoVHQddBoaAw0FhoHjYcmQKWQGZoITYLKoMnQFOh6qByaCk2DpkMzoJnQLGg2NAeyQHMhKzQPmg/ZoAWQHaqAFkKLoEqoCloMKVA1VAMtgZZCy6DlUC1UB62AVkKroNXQGqgeckBOqAFaC62DGqH10AZoI7QJckGbZanKYLQWHbjsO3DZd+Cy78Bl34GU14Ek0IEk0IEk0IG01oGU0IGU0IGU0IEE2IEE0YEE0YEE0YEE2IF00YF00YF00YF00YF00YF00YF00YF0oWsgVA5NhaZBmdB0aAaUDeVAM6FZ0GxoDmSB5kJWaB5UDM2HbNACyA5VQAuhRVAlVAUthoZAClQN1UB5UD5UAC2BlkLLoCJoOVQL1UEl0ApoJbQKGgQZoNXQGigLqocckBNqgNZCRmgd1AithzZAG6FNkAvaLEtVstKlZ1qnnmStP9z6T9pB6otvR6NVnVGffjeamE+6PY12B5tPa//RIal9k+STv1IP6ko9qEh7oFu6dvDfpR0uuiH5Rkqr2u6Tnr72E+0kqrbXPjjxYka6T3qwW6d2mjfdJz3aLPU4t6HawVrt19aeOzRN++E9T9VKPaoteZp3VLpP//jBrdoL7QFMO/BMrNTjn7QHfh3Ec6C0x059XXuhPQ/tM9qLPyZ+9y0+6Wlqv028uKC9SD1sS3v22i7tReq5aKlnbKUeefSrxH8m5JOej3Ypz0ASdW/VqeTfZna6fDj21mSDciN0E/QQ9D7o/VATdDNUDeVBW6Ct0FhoG6RCyyA3dDt0B1QK3QndBU2C7obugbZD90L1kAPyQfdBD0APQl7oVsgGVUI7oHJoNvQwNAAqgvpDV0L9oJ1QI5QGZUCHoMNQLeSHHoUKoSPQUegx6BhUAwWhNug4dALKgsKyVCUHF6wLl6gLf40uXKIuXKIuvE1deDO4cPm68BZ24U3rwhvahQvdhTetCxe6Cxe6Cxe6Cxe6Cxe6Cxe6C299Fy50Fy5fFy50Fy4SFy4SFy4SF1KCC0nAhSTgwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwiXjwpvdhTe7C292Fy4uF976LlxqLlwILlwILlyGLlwWLlyULlyULv2SyU1P3VDvvnTfy/fR0z6MrHw0eUO9vOS35CcfL9hH/5aqP4rveDh5w6Gh8ois6rPajxkkwyAjU8ZgGVkyhsjIlpEjI1dGnoyhMowy8mUUyDDJKJQxTEaRjGIZw2WUyLhKxtUyrpExQsa1MkbKGCXjOhmjZYyRMVbGOBnjZUyQUSrDLGOijEkyymRMljFFxvUyymVMlTFNxnQZM2TMlDFLxmwZc2RYZMyVYZUxT8Z8GTYZC2TYZVTIWChjkYxKGVUyFstQZFTLqJGxRMZSGctkLJdRK6NOxgoZK2WskrFaxhoZ9TIcMpwyGmSslbFORqOM9TI2yNgoY5MMl4zNElTFmN7zVI5t6dKKsxmf6Nysf3wuH3sDQ9EOD0U7PBRjF12DoSxoCJQN5UC5UB40FDJC+VABZIIKoWFQEVQMDYdKoKugq6FroBHQtdBIaBR0HTQaGgONhcZB46EJUClkhiZCk6AyaDI0BboeKoemQtOg6dAMaCY0C5oNzYEs0FzICs2D5kM2aAFkhyqghdAiqBKqghZDClQN1UBLoKXQMmg5VAvVQSugldAqaDW0BqqHHJATaoDWQuugRmg9tAHaCG2CXNBmWapSkP5WPpq2p+dzY0jjRgfoxpDGjQ7QjQ7QjS7Pjd7NjSGNG72bG72bG72bG72bG72bG72bG0MaN3o3N4Y0bvRubnRkbnR5bvRnbvRnbgxp3Oh+3ehw3ehp3eh33RjSuDGkcaPfdWNI40an6kb/6Ub/6Ub/6UZf7kZ370bH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UbH6UYf6Ubn6EZ36EY/6EY/6Ebf6kbf6kbf6kan6kZv6kZv6kY36tY7TlP6v7n3jHajlQe10qv3JjRV4t4ZWjV6SPsjea/eCLr3JjS+N/8mNBvRsmzUW5ZC/aiT/rUM7ZLcqgxLl+8e887dNOZSbv92mdw9RrsTy3fTL/FdebndRuaS7h5T9LYUbCoKNhUFm4qCTUXBpqJgU1GwqSjYVBRsKgo2FQWbioJNRcGmomBTUbCpKNhUFGwqCjYVBZuKgk1FwaaiYFNRsKko2FQUbCoKNhUFm4qCTUXBpqJgU1GwqSjYVBRsKgo2FQWbioJNRcGmomBTUbCpKNhUFGwqCjYVBZuKgk1FwaaiYFNRsKko2FQUbCoKNhUFm4qCTUXBpqJgU1GwqSjYVBRsKgo2FQWbioJNRcGmomBTUbCpKNhUFGwqCjYVBZuqF2zF/65g663Tqt4Lz+nQ6u6QtqT11mm+t7VOuxF12o16nTY8vefewH/v59Mf2vql5HZcSc9Z9TatdLvq312c79zz599jj51P5JGqI6/3mnpHHj//Hnns/NU4TdyGjYI2bBS0YaOgDRsFbdgkacO2QRu2DdqwbdCGjZA2bCK0YROhDZsIbdgyacOWQhu2FNqwpdCGLZM2bDC0YYOhDRsMbdhgaMMGQxs2GNqwwdCGDQZdA6FyaCo0DcqEpkMzoGwoB5oJzYJmQ3MgCzQXskLzoGJoPmSDFkB2qAJaCC2CKqEqaDE0BFKgaqgGyoPyoQJoCbQUWgYVQcuhWqgOKoFWQCuhVdAgyACthtZAWVA95ICcUAO0FjJC66BGaD20AdoIbYJc0GZZqnJNqgToeTyA8slkCTAi+Q96skMZmtgytEtlaKzK0FiVoZUqQ4NUhgapDA1SGZquMrRLZWjBytCClaGVKkMrVYZWqgzNUxkaqzI0QWVonsrQ2pShtSlDY1WGhqwMrVQZWqkytFJlaJDK0MiVoVkrQ9NVprdS12q1mzbMPZB84sRIHB+YgPf/BLz/JyDP6hoMZUFDoGwoB8qF8qChkBHKhwogE1QIDYOKoGJoOFQCXQVdDV0DjYCuhUZCo6DroNHQGGgsNA4aD02ASiEzNBGaBJVBk6Ep0PVQOTQVmgZNh2ZAM6FZ0GxoDmSB5kJWaB40H7JBCyA7VAEthBZBlVAVtBhSoGqoBloCLYWWQcuhWqgOWgGthFZBq6E1UD3kgJxQA7QWWgc1QuuhDdBGaBPkgjbLUpVRb/oWRSINV532/SdbFdu0r7z6VoVSrX0cp9p32exZvIu2KrTtlQ9oX3mN3vHFxIvvpftecfPiOnF7PP091BfVTF/URH2xhvdFPdEXFURfVAl9Ub/01df30RdXbB9IVmxjemeo7/oZqvaw4g5f71b3ZTUkGovbXNbhNpd1uM1lHW5zWYfbXNbhNpd1uM1lHW5zWYfbXNbps9pxb8HVrU3jj2nZTWsXPpjee71flnsmvdf523Kdv3wKD1slbv3yG5+uPwAy+cWqL0vfoWO2BFWZkPzu/0tcMV/y6Z9IbkmWDKWvcq+hix7/eCk3G/pb4nvH+5KPiqwa5nulmw89mvgna3zyTYjMmAaYMQ0wYxpgxjTAjGmAGdMAM6YBZkwDzJgGmDENMGMaYMY0wIxpgBnTADOmAWZMA8yYBpgxDTBjGmDGNMCMaYAZ0wAzpgFmTAPMmAaYMQ0wYxpgxjTAjGmAGdMAM6YBZkwDzJgGmDENMGMaYMY0wIxpgBnTADOmAWZMA8yYBpgxDTBjGmDGNMCMaYAZ0wAzpgFmTAPMmAaYMQ0wYxpgxjTAjGmAGdMAM6YBZkwDzJgGmDENMGMaYMY0wIxpgBnTADOmAWZMA8yYBpgxDTBjGmDGNMCMaYAZ0wAzpgFmTAPMmAaYMQ0wYxpgxjTAjGmAGdMAM6YBZkwDzJgGmDENMGMaYMY0wIxpgBnTADOmAWZMA8yYBpgxDTBjGmDGNMCMaYAZ0wCzPg2YKG6Xnlb1G9+eVL+lKpOSX+85FVaPRzjX48Ho9Xigcz0eaV6Ph3XX4/Hj9Xj0cz0ekF2PB0HX4/Hc9Xjkdz0e+V2PR3fX4/Hc9XicdD0eJ12PR3fX42Hk9XhUuK6boRpoCxSE2qABUBFUCx2HTkD3QllQGNoJNUIPQoehQ5AX2iFLVcrkJqLq+9IiomO0jBEyZshYLKNOxkgZm2VcJaNChl1GvgyTjDEylsswy5goY7KMlTKmyCiXsUbGNBlTZThlzJLRIGOtjLky5slYJ2OjjE0yxslYIEFVJif/arWjqWt6ZnyfS6aKKfJTBxQzLk+z/ra4HreTOICTqgdwGvUATqMewGnUA9hq0nULdBu0FRoLFUJu6HboDqgUuhOaBE2GPFA5dDc0DboHOgL5oaNQf2g29DD0ANQPSoMeg45Bt0I26ErIB2VAN0E3Q9VQDZQHbYGCUBs0ANoGqdAyqAiqhY5Dd0EnoO3QvVA95ICyoPug+6EwtBNqhB6EDkOHIC/0EFQJ7YAGQoMgA5QJZUM5UC5khAqgYqgEaoZaoF1QANoD7YUOQo9ArVAI2g3tg/ZDB2SpSnny3iKbtY2Scz79fr5f973cJSs3aP/kG4kX12gvvul7hZnXxc13auiQauYvbtlf3iqYermM5nvuq3LRyE6/98opbQbYO7zzvRuGd9rw9lPa39fbOcXTdps+rf3Qy36cpyrTerZzle241l7tEnsnPmnWu1n7qm+GbyHNvr7PlU1/+XZSYXHHqdTtpI4nN0tnJN8c2t9Vi3hP6LfKfD7xnUXaN8wURb2+lExO1u5l0NXQaKgcGgHNgBZDddBIaDNkl6Uqs7RTXz3N1Be2aie/ZuN/wRT8L5iC/wVT8L9gCv4XTMH/Al0z9vZJ65Om/R++vBiqg0ZCmyG7LFWZg5YohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYohJYopLdEllRpdGkf5Hr10kirgQPaEvveqJFeo4B/04ulN2uP/C2rpVVl7uXSt751R0y0Nmrw29Su1mhvjz6v+L797+lbew+d+OQu1YoTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMG05k2HAiw4YTGTacyLDhRIYNJzJsOJFhw4kMm34iYx5SpQWp0oJUaUGqtCBVWpAqLUiVFqRKC1KlBanSglRpQaq0IFVakCotSJUWpEoLUqUFqdKCVGlBqrQgVVqQKi1IlRakSgtSpQWp0oJUaUGqtCBVWpAqLUiVFqRKC1KlBanSglRpQaq0IFVakCotSJUWpEoLUqUFqdKCVGlBqrQgVVqQKi1IlRakSgtSpQWp0oJUaUGqtCBVWpAqLUiVFqRKC1KlBanSglRpQaq0IFVakCotSJUWpEoLUqUFqdKCVGlBqrQgVVqQKi1IlRakSgtSpQWp0oJUaUGqtCBVWpAqLUiVFqRKC1KlBanSglRpQaq0IFVakCotSJUWpEoLUqUFqdKCVGlBqrQgVVqQKi16qpyfTJU9k5kfJb/lELQT2gH1h/xQKVQjS1VsPfeN2a8NoBcgX1uRr63I11bkayvytRX52op8bUW+tiJfW5GvrcjXVuRrK/K1FfnainxtRb62Il9bka+tyNdW5Gsr8rUV+dqKfG1FvrYiX1uRr63I11bkayvytRX52op8bUW+tiJfW5GvrcjXVuRrK94oVuRrK/K1FfnainxtRb62Il9bka+tyNdW5Gsr8rUV+dqKfG1FvrYiX1uRr63I11bkayvytRX52op8bUW+tiJfW5GvrcjXVuRrK/K1FfnainxtRb62Il9bka+tyNdWXOhW5Gsr8rUV+dqKfG1FvrYiX1uRr63I11bkayvytRX52op8bUW+tiJfW5GvrcjXVuRrK/K1FfnainxtRb62Il9bka+tyNdWPXHak6myJ0MPxdHWoTiQOxQHVofqW2YV4nHj4sF/2mP9Puzjrqb+wD/tFl9jtBfaowC/ov2rC5NbpTdqW6WfSE9etmlKRH4oxdPYxHga2wFPY3vlaWwAPK2PmhelbvG5pWejtbpnuLYy8UIZqP3o8p7RzkLtRWpglprxnEy82NMz7dsvz28Ug/bvPypPcpTB2peOaq+ytFff1F4N0V59u59PH6M9qX0pW/vSd7RXOdqrZ7VXudqr72mvMrXTQP/y6RO557Wv5Gn/LK69Gqq9+gHGftpYqys50anEk4rOSqueDoOMTBmDZWTJGCIjW0aOjFwZeTKGyjDKyJdRIMMko1DGMBlFMoplDJdRIkFVqsTnqaQ36Pg+2j9YnPwH2iMW16ZLv+pz8m+XxEAZg2QYZGTKKJJRLCNbRo6MXBklElRF6Sl3ZmjlTrX4wID+9t+Bo+s7cLB8Bw7H78BR8h36FV0jEkKa8ueeZ3pOSx5cWIKiyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyo6iyq4XVUuxEMfkdSImrxMxeZ2ISWlSR5aMITKyZeTIyJWRJ2OoDKOMfBkFMkwyCmUMk1Eko1jGcBklElRl2at8JPnVP4msHaC+4HulQ9EXfwL55U8eL8eprgBOdQVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQXQdgRwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQXQEAVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQVwqiuAU10BnOoK4FRXAKe6AmjjAjjVFcCprgCaugBOdQVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQVwqiuAU10BnOoK4FRXAKe6AjjVFcCprgBOdQVwqiuAU10BnOoK4FRXQG+1a5MptiSRcj/SN/knk6bc3jf5h5lWVap9Q90byvXPvO5cvyJ1i6plfaU3z0/0X3MlVoIwVoIwckAY60IY60IY77YwVokwckcYq0QYmSSM3BFG7ggjq4WxuoSxuoSxuoSRScLIJGFkkjBWnjBWnjBWnjBWnjBWnjCyTBjrUBjrUBjrUBgrTxgrTxgrTxi5KoxcFUauCiNXhZGdwshOYaw8YWSgMLJMGFkmjNUljPUkjJwTxjobxioYxioYxkoQRn4PY40KY2UNY70MI8OGkWHDWEvDWBPDyA+6/FAz1ALtggJQKxSEQtBuaA+0F9oH7YcOQAehQ9BhqBZ6FCqEjkBHocegY1AN1AYdh05AWVAYGggNggxQJpQN5UC5kBEqgIqhElmqsgop1oMU60GK9SDFepBiPUixHqRYD1KsBynWgxTrQYr1IMV6kGI9SLEepFgPUqwHKdaDFOtBivUgxXqQYj1IsR6kWA9SrAcp1oMU60GK9SDFepBiPUixHqRYD1KsBynWgxTrQYr1IMV6kGI9SLEepFgPUqwHKdaDFOtBivUgxXqQYj1IsR6kWA9SrAcp1oMU60GK9SDFepBiPUixHqRYD1KsB2nUgzTqQRr1II16kDg9SI4eJEcPUp4HKd2DlO5BavYgGXuQjD1IuB4kXA8Srgcp1oMU60GK9SDFepBiPUixHqRYD1KsBynWgxTrQYr1IMV6kGI9SLEepFgPUqwHKdaDFOtBivUgxXqQYj1IsR6kWA9SrAcp1oMU69FT7Grs2G3tI78xt2Iup8svS1XWvNFn6rxlB+rfjZ/21j5+cA1Ozb+zh+XfrCfw9B6N166R+kt5iq+5j++98DGU3psl+Ho/dPK2XVmO5KGPm7RTDHu0XXbtg0nbxQfllSPJfWantretvQc3JR8j0oAHZZ3GFuppbKGexhbqaWyhnsb28WlsqJ7GhuppbKiexhbxaWyvnsb26mlsr57GZvJpbLaexmbraWy2nsZm8mlsvZ7G1utpbL2extbraWy9nsbW62lsvZ7G1quugVA5NBWaBmVC06EZUDaUA82EZkGzoTmQBZoLWaF5UDE0H7JBCyA7VAEthBZBlVAVtBgaAilQNVQD5UH5UAG0BFoKLYOKoOVQLVQHlUAroJXQKmgQZIBWQ2ugLKgeckBOqAFaCxmhdVAjtB7aAG2ENkEuaLMsVVmb+sj0E5dUp/feTeayupvMf/KU8nXv/U9B95afvv/K8lProCq0X/6dqUMbk1dWz1SwBfcobsE9iltwp+MW3JW4BfchbtEPUK7HCDyOEXgcI/A4RuBxjMDjGIHHMQKPYwQexwg8jhF4HCPwOEbgcYzA4xiBxzECj2MEHscIPI4ReBwj8DhG4HGMwOMYgccxAo9jBB7HCDyOEXgcI/A4RuBxjMDjGIHHMQKPYwQexwg8jhF4HCPwOEbgcYzA4xiBxzECj2MEHscIPI4ReBwj8DhG4HGMwOMYgccxAo9jBB7HCDyOEXgcI/A4RuBxjMDjGIHHMQKPYwQex0g6jpF0HOPxOMbjcYzH4xiPxzHKjmNYHsdgO47BdhyD9DgG6XEMveMYescx9I5j5B7HCDyOEXgcI/A4RuBxjMDjGIHHMQKPYwQexwg8jhF4HCPwOEbgcYzA4xiBxzECj2MEHscIPI4ReBwj8DhG4HGMwOMYgccxAo9jBB7HCDyOEXhcH4FveN3HSS7lGEmy0JVXGVXZmPxB2pBiVB+fPqS4NvlhgU24wfZP0YX9VK/bXYlvUTYnv29b4t/za/+BnlXBgXXAgXXAgXXAgUzlwDrgQN5yIFM5kMUcWDEcyFsOrBEOrBEO5F4HVgUHVgUH1gEH8p0D64AD2d2BfO7AquBAnnRgvXIgTzqwfjiwdjqQNR3Img5kTQeypgNZ04Gs6UDWdCBrOpA1HciaDmRNB7KmA1nTgaziQFZxIIc6kGMcyDEOZAcH8qQDucKBbORA5nAgNzmQRxzIIw7kLQeyigNZzIEs5tCv6xvwEZNFmAQswiRgESZOugZDWdAQKBvKgXKhPGgoZITyoQLIBBVCw6AiqBgaDpVAV0FXQ9dAI6BroZHQKOg6aDQ0BhoLjYPGQxOgUsgMTYQmQWXQZGgKdD1UDk2FpkHToRnQTGgWNBuaA1mguZAVmgfNh2zQAsgOVUALoUVQJVQFLYYUqBqqgZZAS6Fl0HKoFqqDVkAroVXQamgNVA85ICfUAK2F1kGN0HpoA7QR2gS5oM2yVOVGbItc0U/+K74C99i9Are61bUQWgyNgEZC+dBoaAw0FloGLYfqIDM0ESqDJkMroSlQObQGmgZNhWZADsgJzYIaoLXQXGgzNA9aB22ENkE2aBxUCS2QpSo3YVRxV3JJvhG6CXof9H6oEmqCboZugaqhPGgLdCt0G7QVGgttg1RoGeSGbofugEqhO6G7oEnQZMgD3Q1Ng+6BtkP3QvWQA7oPuh96AHoQ8kIPQTbIB+2AyqHZ0MPQAKgIyoD6Q/2gnVAjlAZdCTVDLdAuKAAFoT3QXugg9Ajkh1qhELQb2gfthw5Ah6DDUC30KFQIHYGOQo9Bx6AaqA06Dp2AsqAwNBAaBBmgTCgbyoFyISNUABVDJbJU5X1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw1Ypw36Ov3+5KmZvn3EV73400pK6Yd/qKSDqtKEt2EG3oYZeBtm4G2YgbdhBt6GGXgbZuBtmIG3YQbehhl4G2bgbZiBt2EG3oYZeBtm4G2YgbdhBt6GGXgbZuBtmIG3YQb+YDPwNszA2zADb8MMvA0z8DbMwNswA2/DDLwNM/A2zMDbMANvwwy8DTPwNszA2zADb8MMvA0z8DbMwNswA2/DDP1NdPMrDzOdqBSdqBSdqBSdqGWcqBSdqGycqGWcqHOcqCmdqGycqCKdqCKdqM6cqBudqBudqBSdqIicqBSdqP+cqPicqBudqKScqGidqKScqDCdqK6dqKucqKucqKucqKucqKucqKucqKucqKucqKucqKucqKucqKucqKucqDucqDucqHqcqEKcqEKcqB+cqLmcqCacqFecqC2cqF6cqDScqDScqGycqDucqHOcqHOc+sp/C4aZJgwzTRhmmjDMNGGYacIw04RhpgnDTBOGmSYMM00YZpowzDRhmGnCMNOEYaYJw0wThpkmDDNNGGaaMMw0YZhpwjDThGGmCcNME4aZJgwzTRhmmjDMNGGYacIw04RhpgnDTBOGmSYMM00YZpowzDRhmGnCMNOEYaYJw0wThpkmDDNNGGaaMMw0YZhpwjDThGGmCcNME4aZJgwzTRhmmjDMNGGYacIw04RhpgnDTBOGmSYMM00YZpowzDRhmGnCMNOEYaYJw0wThpkmDDNNGGaaMMw0YZhpwjDThGGmCcNME4aZJgwzTRhmmjDMNGGYacIw04RhpgnDTBOGmSYMM00YZpowzDRhmGnCMNOEYaYJw0wThpkmDDNNGGaaMMw0YZhpwjDTpA8zt6A6PYfL/hwu+3O47M/hsj+HlHcOSeAcksA5JIFzSGvnkBLOISWcQ0o4hwR4DgniHBLEOSSIc0iA55AuziFdnEO6OId0cQ7p4hzSxTmki3NIF7oGQuXQVGgalAlNh2ZA2VAONBOaBc2G5kAWaC60GbJC86Bi6F/QfMgGLYDsUIUsJa0P/uFCaBFUBS2GhkAKVA3VQHlQPlQALYGWQsugImg5VAvVQSXQCmgltAoaBBmg1dAaKAuqhxyQE2qA1kJhyAitgxqh9dAGaCO0CXJBlbJU5dZkrszUzvVqh1Z+mXiRn578g05T0rUXP0686OyX/ENLU2rTffr9WL6Snnznpynt2ovfJwr148mLNE25W7/bZZryhfRkYkhTvH2TV2ya4tJe/C7xvbdpP/k2FLQN+GtqwF9TA3KFrsFQFjQEyoZyoFwoDxoKGaF8qAAyQYXQMKgIKoaGQyXQVdDV0DXQCOhaaCQ0CroOGg2NgcZC46Dx0ASoFDJDE6FJUBk0GZoCXQ+VQ1OhadB0aAY0E5oFzYbmQBZoLmSF5kHzIRu0ALJDFdBCaBFUCVVBiyEFqoZqoCXQUmgZtByqheqgFdBKaBW0GloD1UMOyAk1QGuhdVAjtB7aAG2ENkEuaLMsVdkqbjKc/GJVl/Ru07FFgqps6/2Yx6V+zOOrid/9d77ej3u82z7u8U58yiM1xHQlh9k7ZamKirMPjyQneDdC74PeDzVBj0K3QLdBW6GxUCHkhm6H7oBKoTuhSdBkyAOVQ3dD06B7oCOQHzoK9YdmQw9DD0D9oDToMegYdCtkg66EfFAGdBN0M1QN1UB50BYoCLVBA6BtkAotg4qgWug4dBd0AtoO3QvVQw4oC7oPuh8KQzuhRuhB6DB0CPJCD0GV0A5oIDQIMkCZUDaUA+VCRqgAKoZKoGaoBdoFBaA90F7oIPQI1AqFoN3QPmg/dECWqri1Ozl4tPSevJPD7cmMm1qwX0y8GKi1nBcVJv5EPO3TK4Ms7Tsu/vRGaolIFRYXf+bj5c/R3nG5FFg7E//kj75XKLSUfO2WGP20/8zrKrm0j1H21/7RxbVX4k9RuVL7R72ftfVdfsVX/8QLg/YffK9XYapyZ/Lq61nz+vSR876uQ5AfqoXKoUIoC5oN1UBHoC2yVOWuyyVZXP7d2OtKBKMSL/b06c0Il1M7pozXlp2SPm9PStAWq9F9kBs8WomgrVSLkiXC3clrTySAqhe3+lJTzyRU5R50bV3o2rpQr3ehh+tCD9eFyrALHV0X6vwudHRdqPq7UOd3oc7vQgfShU6wC51gFzrBLlT9Xaj6u1D1d6FL7EKX2IUusQtdYhe6xC50BF3oGbvQM3ahZ+xCl9iFLrELXWIX+oou9BVd6Cu60Fd0oZPoQifRhS6xC91CFzqCLnQEXegEu9D7daE/6EJP3IWOtQsdaxe6ti70Yl3oJ7vQBXeht+1CN9SFbqgLfW8X+tcu1PK6/FAz1ALtggJQKxSEQtBuaA+0F9oH7YcOQAehQ9BhqBZ6FCqEjkBHocegY1AN1AYdh05AWVAYGggNggxQJpQN5UC5kBEqgIqhElmqsh1P8H0BBdoLKN507YD6Q36oFKqRpSr3Jn9sY2Ip+FO/5CWUpnxEfxpkop5JLBrKIu2xiN/VvvW+1FMeruijf0fVr7Sv35/8es+G2ilsjJ3CVt8pbJOdwjbZKfyup7DddQrbXaewNXUK20+nsJV5CptRp7AZdQrl6ilsOJ3CRuMpbCqdwqbSKWwqncI20ilsI53CVpGuIVA1lAflQwXQUqgWKoFWQoOgLKgeckDroPXQJsgFXQVdDY2AroVyoZHQKGgsVAiNhyZAw6FJUBk0GZoCXQ8NhMqhaVAmNB3KgeZAFmgzZIXmQfOhCqgKUqAaaAm0DCqClkN10ApoFWSAVkNrICfUAK2FjFAjtAHaCI2DKmWpygNv7iNvtR7YkO67xGffjtPy84/fpIfgXtqzb5OPylX6pPvkp+A+KHqIRM8sP024EZtAjfomkDf5vVo3c53WoPT0FU3oK5rQVzShr2hCX9GEvqIJfUUT+oomdBJN6CSa0Ek0oZNoQu/QhN6hCb1DE3qHJnQLTegWmtAtNKFbaEK30IRuoQndQhM6gib0AE3oAZrQAzShB2hCD9CEHqAJVX8Tqv4mVP1NqPqbUPU3oepvQtXfhKq/CVV/E6r+JlT9Taj6m1D1N6Hqb0LV34SqvwlVfxOq/iZU/U2oiptQFTehKm5CR9CEGrkJNXITauQm1MhNqJGbUCM3oUZuQrfQhIq5CRVzEyrmJlTMTaiYm/S69KHktZpIRVVNPq2ZTlNe1FJAg5YCJqdLP7Wgn/zn8TwK2OdRwD6PAvZ5PYn6UvnjXB/pb+5F/F29qP9OO/Cgz09q3zFIhkFGpozBMrJkDJGRLSNHRq6MPBlDZRhl5MsokGGSUShjmIwiGcUyhssokaAqD+N0dxo+e5iGzx6m4bOHafjsoa4qaDE0AhoJ5UMDoNHQGGgstAxaDtVBZmgiNAkqgyZDK6Ep0GqoHFoDTYOmQvWQA5oBzYScUH9oFjQHWgs1QHOhzdCVkBWaB62D+kEboU1QGmSDxkGV0AIoQ5aq7OzpVKt+KSWhD2OB/7CeSh5JNbW5faXv/Si+96P69/rxCJhXyEypf0Hkqebkv5Cagae2MlKj5tQMPDXJf/W7R3868QXt39Ee0TjFJ03mU3Pv1Ig+tfXwGhu3qVl9z07xK+xKpKbLr3CT5BZ0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RF0/RG9YN2FIvTT0rWlwyAjU8ZgGVkyhsjIlpEjI1dGnoyhMowy8mUUyDDJKJQxTEaRjGIZw2WUSFCVQPIWGjcm5wV9kpk+TYnI84En0cM9iV7sSfQ4T6L7elJfYVvx4ZgHkOEewPvpAVx1ugZDWdAQKBvKgXKhPGgoZITyoQLIBBVCw6AiqBgaDpXIUpUg+oN/Ij3rugYaAV0L5UIjoVHQdZAJGg2NgcZChdA4aDw0ARoOlUJmaCI0CSqDJkNToOuhgVA5NBWaBmVC06EZUDaUA82EZkGzoTmQBZoLWaF5UDE0H7JBCyA7VAEthBZBlVAVtBgaAilQNVQD5UH5UAG0BFoKLYOKoOVQLVQHlUAroJXQKmgQZIBWQ2ugLKgeckBOqAFaCxmhdVAjtB7aAG2ENkEuaLMsVQklE2DPQnQDBtU36I3k7p6HAFU95et9BtB/0zOA9vTcgr7qzz79APFPtC/vxUGox7Fh8Tg2LB7HhsXj2LB4HBsWj2PD4nFsWOi6BaqG8qAt0K3QbdBWaCy0DVKhZZAbuh26AyqF7oTugiZBkyEPdDc0DboH2g7dC9VDDug+6H7oAehByAs9BNkgH7QDKodmQw9DA6AiKAPqD/WDdkKNUBp0JfQI5IeaoRZoFxSAWqEgFIJ2Q3ugvdA+aD90ADoIHYIOQ7XQo1AhdAQ6Cj0GHYNqoDboOHQCyoLC0EBoEGSAMqFsKAfKhYxQAVQMlchSlX2v/ZQRxahteP/W90YfN9KzHiiF2n/n9z59oNql/eT9SO5eJHcvkrsXyd2L5O5FcvciuXuR3L1I7l4kdy+SuxfJ3Yvk7kVy9yK5e5HcvUjuXiR3L5K7F8ndi+TuRXL3Irl7kdy9SO5eJHcvkrsXyd2L5O5FcvciuXuR3L1I7l4kdy+SuxfJ3Yvk7kVy9yK5e5HcvUjuXiR3L5K7F8ndi+TuRXL3Irl7kdy9SO5eJHcvkrsXyd2L5O5FcvciuXuR3L1I4F4kcC8SuBcJ3IuU7UVa9iIte5FsvVhMvFhMvFgUvFgGvFgGvEj1XqR6L1K9F8ndi+TuRXL3Irl7kdy9SO5eJHcvkrsXyd2L5O5FcvciuXuR3L1I7l4kdy+SuxfJ3Yvk7kVy9yK5e5HcvUjuXiR3L5K7F8ndi+Tu1ZP7gbfgUz7amYE0bbj4Nn7cR7shwou+y/hjP72f9vFdLp/2eUduvrAF44wt+jjjoPaxn7bEW3eb9qmfQ72fuOu99F7Hpad9jiy9T+81eMnX4AZcgxv0a/Dwv3mI4p8TX/hhX9+ltTda6zJf/h26E194QX6farcN/7Lc96jKo+JEn/5rnUTpfRIl2EmU3idRkJ1EcXgSrcxJlIonUSqeRKl4Es3LSRR5J1FGnkTJdxIl30mUmCdRYp5EcX8SxeFJFIcnURyeRGl6EiX0Dmya7MCAfAc2qHZgG2GHPng+ktwUTZ7S9qQnOtGxWif6NzmppI6Ja399znT5HZ16j6eSU+qi6TmMnTpKripHsT+ajy2AfGwB5GOrKR/7o/n4X5iPTZR8bDzlY+MpH5uD+dhEycf+aD42BPKxwZKPDZZ8bBzm4087H/uj+dhgycemVD62A/OxpaLrKuhq6BpoBHQtNBIaBV0HjYbGQGOhcdB4aAJUCpmhidAkqAyaDE2BrofKoanQNGg6NAOaCc2CZkNzIAs0F7JC86D5kA1aANmhCmghtAiqhKqgxZACVUM10BJoKbQMWg7VQnXQCmgltApaDa2B6iEH5IQaoLXQOqgRWg9tgDZCmyAXtFmWqjzWs9enbEcV/F+22Zeohqp+6Ht3bvq9wb2+Y6mPHvxVLt+2onzbqpdvbb1N03u5adLmOgNe8U3/hponZYNW5HVf6kXT2z1pl9hxbMO0YhumFRsvrdh4acVWSytGtq3oT1rRdbRiy6QVWyatGPW2YlukFdsirdgWacW2SCu2RVqxEdKKjZBWdGOt2ChoxbZIK3qzVmyLtGIk3Yq+rRUD6lZsG7RiK6IVWxGt2BZpxQZDKzYRWjH0bsXQW9etkA26EvJBGdBN0M1QNVQD5UFboCDUBg2AtkEqtAwqgmqh49Bd0AloO3QvVA85oCzoPuh+KAzthBqhB6HD0CHICz0EVUI7oIHQIMgAZULZUA6UCxmhAqgYKoGaoRZoFxSA9kB7oYPQI1ArFIJ2Q/ug/dABWapyoreKeS9XMe/GXRdtujxf+6Hv7uIlnPo8YVz7B9ptdJana//gcUzijJjEGTGJM2ISZ8QkzohJnBGTOCMmcUZM4oyYxBkxiTNiEmfEJM6ISZwRkzgjJnFGTOKMmMQZMYkzYhJnxCTOiEmcEZM4IyZxRkzijJjEGTGJM2ISZ8QkzohJnBGTOCMmcUZM4oyYxBkxiTNiEmfEJM6ISZwRkzgjJnFGTOKMmMQZMYkzYhJnxCTOiEmcEZM4IyZxRkzijJjEGTGJM2ISZ8QkzohJnBGTOCMmcUZM4oyYxBkxiTNiEmfEJM6ISZwRkzgjJnFGTOKMmMQZMYkzYhJnxCTOiEmcEZM4IyZxRkzijJjEGTGJM2ISZ8QkzohJnBGTOCMmcUZM4oyYxBkxiTNiEmfEJM6ISZwRkzgjJnFGTOKMmMQZMYkzYhJnxCTOiEmcUZ/EfQANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYBANYFBvAD/Y2wD2NoBvVQOoDdF/4ftvHF6nFlIVe0eqvnf0IdEb6l8sQWVRglxdglWrBKtyCdb2ElQIJfrV/WE+rLIg8cLbL5lGE1ddP9/LT61UXNrRk5n6271qu096jOVPtD9i7eTJ4MSLGdqL1IMtO7VrTXsxPPGiFI+6HKq9k7V3zk8TL6ZpP/xniRdDtBc/T7ywai9M2t+99s3azWZv1V78IvFih/biJe3NiUdmFiZeHNReaE/cPKq9+HXixde1F79JvPiM9uKPid99i096rOZvEy8uaC9+l3jxjPbiu4kXu8QjOBOtuE969GZe4sXntP/Fv0r8Z0LJv4Q0pVr7Rf+QeLFCe3Hx0zmHaJel9qLnFgmfSP7Bf0Q7YKndTHd38r7qH8U9fb/fR14ede2EdkD9IT9UCtXIUpWTeJ8Nx/tsON5nw/E+G4732XC8z4bjfTZcf5+1477xL2z1vXzf+BeS3/Cxy3eZ0eZNI173g1961xvf5bfe/PetM6ryPz1PcKhPZppTF48dv5McO0b+3RX4tl9478bLLJGmqn7qe80jNW/nxXUp11TvpXSpl9LHk5dIWsJN2n9XO7FxQfuOvokXn++5F/4U7c+0X+KFX/uedO2Nob24IvEiqL24Unt/ai8GaFeJ9iIj8WJG8gd8IvkDtFsfrZFvffQUhgNPoc1+CgvzU2isn9IX39OYknViStaJ+UgnZmadmJl1ohPvxAStE3OVTkzQOjFl6cRcpRNzlU5MfDoxeevE5K0Tk7dOTFk6MWXpxJSlE1O5TkzlOjGV68RUrhNTuU5MYDoxo+vEjK4TM7pOTOU6MZXrxFSuE3OcTsxxOjHH6cQcpxOTm05MbjoxlevEdKYTE5hOTGA6MXnrxKytE/OYTlR+nagRdT0MDYCKoAyoP9QP2gk1QmnQldAjkB9qhlqgXVAAaoWCUAjaDe2B9kL7oP3QAeggdAg6DNVCj0KF0BHoKPQYdAyqgdqg49AJKAsKQwOhQZAByoSyoRwoFzJCBVAxVCJLVT6JFNuCFNuCpNqCpNqCNNqCv44WpNEWpMMWpMMWpMMW/DW2IOW1IOW1IOW1IOW1IOW1IMm1IMm1IMm1IAm0IOW1IOW1IOW14O3WgouyBW++FqSEFqSZFqSZFqS8FiSPFiSIFryhW/CGbsGy1IJ02ILE0oLk2IJEpusm6GaoGqqB8qAtUBBqgwZA2yAVWgYVQbXQcegu6AS0HboXqoccUBZ0H3Q/FIZ2Qo3Qg9Bh6BDkhR6CKqEd0EBoEGSAMqFsKAfKhYxQAVQMlUDNUAu0CwpAe6C90EHoEagVCkG7oX3QfuiALFX5VPKzcMnH8E5M9738qF6t5laTHWyH1un2jNk+tlXrdqPIy+3Iy+24ItuRpduRpdvxd9+OnN2OK7kdObsd13U7ruR2XMntyDHtyPXtyPXtyPXtuK7bcV2347puxzrQjnWgHetAO9aBdqwD7bjm27EqtGNVaMeq0I51oB3rQDvWgXZkjnZkjnZkjnZkjnbkinbkinasA+3IB+245ttxzbcj17cju7cjA7Rj1WvHmtSONakdebkd2bYdK0Y71rl2rF7tyHftyHftWNnasUK142rV5YeaoRZoFxSAWqEgFIJ2Q3ugvdA+aD90ADoIHYIOQ7XQo1AhdAQ6Cj0GHYNqoDboOHQCyoLC0EBoEGSAMqFsKAfKhYxQAVQMlchSlTNv7+Rem8aXal/p3Sl+p4eLrz253/tUbVry/3pH+G/SVvE6bBWv07eKY3wsZ03ixWTtT7fn+ZzSYzk/jWKoGcVQM8qfZpQ/zSh4mpE4m1HwNKNwaUbh0ozCpRkJtxnFSTOKk2YUJ80oTppRnDSjHGlGOdKMcqQZy3UzipNmFCfNKE6asTA0Y/lsxjLRjMW7GQVBMwqCZhQnzVjmm7GUN2PpacbS04wCshmFSzNKgGaUMc0oOXTdBN0MVUM1UB60BQpCbdAAaBukQsugIqgWOg7dBZ2AtkP3QvWQA8qC7oPuh8LQTqgRehA6DB2CvNBDUCW0AxoIDYIMUCaUDeVAuZARKoCKoRKoGWqBdkEBaA+0FzoIPQK1QiFoN7QP2g8dkKUqZ5MptueN+QL+wl/AX/gLuIBe0P/1z+BJIZ+S/op0GGRkyhgsI0vGEBnZMnJk5MrIkzFUhlFGvowCGSYZhTKGySiSUSxjuIwSCary2Z4bbis5etGg/xH68dw6P55b58dz6/x4bp0fz63z47l1fjy3zo/n1vnx3Do/nlTnx5Pq/HhSna5t0DJoOVQHmaGJ0CSoDJoMrYSmQKuhcmgNNA2aCtVDDmgGNBNyQrOgOdBaqAGaC22GrNA8aB20EdoE2aBxUCW0QJaqfO5V2qUfaA1AH987cOJJ61yO9fO9BX2T1qv5tVndpTRQr6tv6k68qO7je6cbqNQ9095jZ6BSt5Z7j3VSPTXUS/py+/nL99ChdsF9I12+BHsnFv/5daYlpPw+l+EFd7ldZx9KvBje5z+/4HpauxAe9hrCA11DeERtCI+TDeGhrSF9Cf0CDhP/WCrKklCVL4rHr6Yp+7XfRtsp+ov29S/hk9VefLLai09We/HJai8+We3FJ6u9+GS1F5+s9uKT1V58stqLT1Z78clqLz5Z7cUnq734ZLUXn6z24pPVXnyy2otPVnvxyWovPlntxServfpJ8S+nHpT792QeTav6h/blryS//GLiT/rbfeXkoN1u9GOvlPv8iXja90p3KL34wbMX39f05TtxncMTdn+HI/K/03/lryY3DPv2EV99CPVsUko//EMlHVSV/8Wp/JdwKv8l/MiXcCr/JZzKfwmn8l/CqfyXcCr/Jf0XP49T+T58iNqHN58Pf+E+/Md8+n/sa9qmaDDx59a3j7Yh+nV0mB1yh9khd5gdcofZIXeYHXKH2SF3mB1yh9khd5gdcofZIXeYHXKH2SF3mB1yh9khd5gdcofZIXeYHXKH2SF3mB1yh9khd5gdcofZkfwz+8blUhe8daX566rItWUzclGB0Jzue7XSXEEyeI1KYVTixR7t17iEkkEZr+39t2pfesuqdaVe+xnf0L70xup27RnZ+7Q/mP+wnri4jHiNGyam6olU3X5xYaGthv/U/tFlUmH8p2exn7hcrtH3xm6jdonb033vhiK+t3Z/a6+sb+Jxv2dwL50zuJfOGdxL5wzupXMG1e4Z3FnnDO6scwZ31jmDivYM7rNzBvfZOYP77JxBKXQGd905g7vunMFdd86g9j2D6uwM7sFzBvfgOYN78JzBPXjO4B48Z3APnjO4B4+ugVA5NBWaBmVC06EZUDaUA82EZkGzoTmQBZoLWaF5UDE0H7JBCyA7VAEthBZBlVAVtBgaAilQNVQD5UH5UAG0BFoKLYOKoOVQLVQHlUAroJXQKmgQZIBWQ2ugLKgeckBOqAFaCxmhdVAjtB7aAG2ENkEuaLMsVflWMgGGEyv+zYmKsL9WEQ5O97280xRFSowiJUaREqNIiVGkxChSYhQpMYqUGEVKjCIlRpESo0iJUaTEKFJiFCkxipQYRUqMIiVGkRKjSIlRpMQoUmIUKTGKlBhFSowiJUaREqNIiVGkxChSYhQpMYqUGEVKjCIlRpESo0iJUaTEKFJiFCkxipQYRUqMIiVGkRKjSIlRpMQoUmIUKTGKlBhFSowiJUaREqNIiVGkxChSYhQpMYqUGEVKjCIlRpESo0iJUaTEKFJiFCkxipQYRUqMIiVGkRKjSIlRpMQoUmIUKTGKlBhFSowiJUaREqNIiVGkxChSYhQpMYqUGEVKjCIlRpESo0iJUaTEKFJiFCkxipQYRUqMIiVG9ZT47eQszdYzH7sXs7SklAX4hy/P0u7VZ2kXMHg6I/356jDIyJQxWEaWjCEysmXkyMiVkSdjqAyjjHwZBTJMMgplDJNRJKNYxnAZJRJU5cnUlPUhKdP8Xf87eIr3aum5M8vLN2JJ3XYldZOV1M1Rfpn4Tx7z6Tc1CfXxSXdA0W588vF+Puk2Jxfdw0RVnn6VDz6nPub8eOIfOn36J6G3al94fZ97/g5OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPg1V+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD8OqvlxUM2Pk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGPk4l+nEz042SiHycT/TiZ6MfJRD9OJvpxMtGvn3V4BuvvBXn9vSCvvxfk9feCvP5ekNffC/L6e0Fefy/I6+8Fef29IK+/F+T194K8/l6Q198L8vp7QV5/L8jr7wV5/b0gr78X5PX3grz+XpDX3ySuknG1jGtkjJBxrYyRMkbJuE7GaBljZIyVMU7GeBkTZJTKMMuYKGOSjDIZk2VMkXG9jHIZU2VMkzFdxgwZM2XMkjFbxhwZFhlzZVhlzJMxX4ZNxgIZdhkVMhbKWCSjUkaVjMUyFBnVMmpkLJGxVMYyGctl1Mqok7FCxkoZq2SslrFGRr0MhwynjAYZa2Wsk9EoY72MDTI2ytgkwyVjswRVeZYfeun5rEtyk6uyDz700onSshulZTeKim4Umt0oNLuxfHWj7OxGMdKNsrMbpUk3ipFuFCPdKJO6Ua52o1ztRrnajdKkG6VJN0qTbpSy3Shlu1HKdqOU7UYp242ypRuFbTcK224Utt0oZbtRynajlO1G8dON4qcbxU83ip9ulDvdKHe6Ucp2o6TpRtnSjbKlG+VqNwrUbhQx3Sjcu1FWd6Os7kZp2Y2CsRtFbzdK9W4U4N0o2bpRsnWjOO9Gkd2NgkOXH2qGWqBdUABqhYJQCNoN7YH2Qvug/dAB6CB0CDoM1UKPQoXQEego9Bh0DKqB2qDj0AkoCwpDA6FBkAHKhLKhHCgXMkIFUDFUIktVvptMsc8ncu/EPslrIE2pSo4NvtfzoMyqp32XcCPBHya+YTX24d/EB2Zu077yGg/M1O41e4P2zf/ZkzOVam048rj253Apz9B8Nz478+Id5xcSLz6gfeX1PU3zOQ4Vt2OouJ1Dxe0cKiapqs2Grdsab9u2NvH/t23auueePTd9uF9aWtUTW5sHbrp54//3ZcWVvlW94bPNWUsab9t6482b7bfdcvO2xLftUW/4onPP6GR58bGtyfA/ejilh4gePq6HT+jhtB4+qYdP6aFDD1E9nNFDTA+f1sNZPXxGD5/Vw+f08Hk9fEEPX9TDl/TwZT18RQ/n9PBVPfyvHs7r4Wt6+LoevqGHJ/TwTT18Sw/f1sMFPTyph6f08LQevqOHZ/TwrB469fBdPXxPD8/p4Xk9xPXwfT38QA9devihHl7Qw4/08KIefqyHn+jhp3r4mR5+rodf6OElPfxSD7/Sw6/18Bs9/FYPv9PD7/XwBz38UQ//p4c/6aFbD3/Ww1/08Fc9/E0Pf9fDP/TwTz38KxmUtD567CNiXxH7iZguYn8RrxDxShEHiJgh4kARB4loEDFTxMEiZok4RMRsEXNEzBUxT8ShIhpFzBexQESTiIUiDhOxSMRiEYeLWCLiVSJeLeI1Io4Q8VoRR4o4SsTrRBwt4hgRx4o4TsTxIk4QsVREs4gTRZwkYpmIk0WcIuL1IpaLOFXEaSJOF3GGiDNFnCXibBHniGgRca6IVhHniThfRJuIC0S0i1gh4kIRF4lYKWKViItFVESsFrFGxCUiLhVxmYjLRawVsU7EFSKuFHGViKtFXCNivYgOEZ0iNoi4VsR1IjaKuF7EDSJuFHGTiC4RN4t4g4g3iniTiO8T8f0iNol4s4i3iLhFxFtFvE3ErSJuE1EV0S3i7SLeIeKdIt4lokfEu0W8R8TtIt4r4n0i3i/iAyI+KKJXxIdE9Im4Q8SHRdwp4iMi+kVsFrFFxF0iBkRsFTEoYkjE3SLuEXGviPtE3C/iAREPinhIxMMiPiriERGPiviYiMdEbBPxuIgnRAyL+LiIHxDxgyJ+SMQPi/gRET8q4kkR20X8mIj/I+IpESMiflzET4h4WsRPivgpETtEjIp4RsSYiJ8W8ayInxHxsyJ+TsTPi/gFEb8o4pdE/LKIXxHxnIhfFfF/RTwv4tdE/LqI3xDxCRG/KeK3RPy2iBdEfFLEp0R8WsTviPiMiM+K2Cnid0X8nojPifi8iHERvy/iD0TsEvGHIr4g4o9EfFHEH4v4ExF/KuLPRPy5iL8Q8SURfynir0T8tYi/EfG3Iv5OxN+L+AcR/yji/4n4JxG7RfyziH8R8a8i/k3Ev4v4DxH/KeK/REzrq8c+IvYVsZ+I6SL2F/EKEa8UcYCIGSIOFHGQiAYRM0UcLGKWiENEzBYxR8RcEfNEHCqiUcR8EQtENIlYKOIwEYtELBZxuIglIl4l4tUiXiPiCBGvFXGkiKNEvE7E0SKOEXGsiONEHC/iBBFLRTSLOFHESSKWiThZxCkiXi9iuYhTRZwm4nQRZ4g4U8RZIs4WcY6IFhHnimgVcZ6I80W0ibhARLuIFSIuFHGRiJUiVom4WERFxGoRa0RcIuJSEZeJuFzEWhHrRFwh4koRV4m4WsQ1ItaL6BDRKWKDiGtFXCdio4jrRdwg4kYRN4noEnGziDeIeKOIN4n4PhHfL2KTiDeLeIuIW0S8VcTbRNwq4jYRVRHdIt4u4h0i3iniXSJ6RLxbxHtE3C7ivSLeJ+L9Ij4g4oMiekV8SESfiDtEfFjEnSI+IqJfxGYRW0TcJWJAxFYRgyKGRNwt4h4R94q4T8T9Ih4Q8aCIh0Q8LOKjIh4R8aiIj4l4TMQ2EY+LeELEsIiPi/gBET8o4odE/LCIHxHxoyKeFLFdxI+J+D8inhIxIuLHRfyEiKdF/KSInxKxQ8SoiGdEjIn4aRHPivgZET8r4udE/LyIXxDxiyJ+ScQvi/gVEc+J+FUR/1fE8yJ+TcSvi/gNEZ8Q8ZsifkvEb4t4QcQnRXxKxKdF/I6Iz4j4rIidIn5XxO+J+JyIz4sYF/H7Iv5AxC4RfyjiCyL+SMQXRfyxiD8R8aci/kzEn4v4CxFfEvGXIv5KxF+L+BsRfyvi70T8vYh/EPGPIv6fiH8SsVvEP4v4FxH/KuLfRPy7iP8Q8Z8i/kvEtH567CNiXxH7iZguYn8RrxDxShEHiJgh4kARB4loEDFTxMEiZok4RMRsEXNEzBUxT8ShIhpFzBexQESTiIUiDhOxSMRiEYeLWCLiVSL+v5bsc7mJGAjguJnESSAZmCFPQA8t9N57STAtdMwhn5W7i++sQ9JBTO/EIOrcY/AEMLwbsvP/9JN2dqRdfVytwtW4BtfiOlyPG3ACN+Im3IxbcCtO4jbcjjtwJ+7C3bgH9+I+3I8H8CAewsN4BI/iMTyOJ/AknsLTeAbP4jk8jxfwIk7hNF7CGl7GK3gVr+F1nMEbeBNv4W28g3fxHt7HOj7AAB+iwAaG2ESJsxhhjAnOYQtTzLCNCnN8hBoNWizwMT7BeezgU3yGz/EFvsRX+Brf4Ft8h+/xA37ET7iAXfyMX9DhV/yG3/EH/sRfA0a6YZXbRLV7Y/AJV23KRhGVXTdkrE5C61crWlLmgUjTwKqW9Hldt8xqKYMwFcaUNVcNRRhLHx7OlbGpnC9r8ZK53wOViqv6ndRl/M+NWi3aZlbpzO9r/Xl7fXHsLtxIrhOlE9sp3VDbZ4i0dEtF1kiioh8cFIVVpatqGfnDu2481yoXkbAy8Dcmi9X7QvuXBaEvtSHCVq8htzITnYZPS0UoY5U2pe5lLpfNxAZW6ixpi9T3EP+ZqsR/u25MaZ8im4GR1pQLbizJcqVtkAsbm7JeulGjCh3KfsC3PuJPLqKk/3i9r4PBaaFbZTH5H+uCucA='
+)
+DATA = pickle.loads(zlib.decompress(base64.b64decode(DATA)))
+MEMO = (
+b'eJzVXXdgG9X9T+K9sndCAYckTkziDMIwGci2nIjTkxzZzmgSDllWYjmyZCQ5ozjsUYpbSjG/0hbonkAp3XtQSqHj1126J6WbH5100PZ3pzvr3r1336fTfe9sN38kudN9732+n+948967ruLuGTNmzlD/nBlvktS/xspT0aH4+FhV18FQMBDyK/8bjuZy8UxqXP214kQ0OaL8vKi1dfh0a2vTxtHa0YZ163dpl+NjFUeT0WPZ8SPjY2WZ6MnxsWUthQcPp0YPZwqPtoyPVconE/25AeXhJqn+ZTUz9D8z42PVspw7PRyX5fGxmi6t9Ih/fGSsejiTSGcSudPj0oyB2WN1PfHMUCIVTXbEj46PSDMVgAOzxmp2B8NtvqAc7hofKFdvVY7Vtx5rHW09lkz3RZOt4wPVR8YHasdmt9B3W8YH6lUgZVJ1fGD2wJyRgblqGQPzRqRZ2nvrQuFQMNxufvOc1lRSeUkqnUqmY9TL57UwP0y8v1yqZd9fpr2/qudgl59+98wrJ95W1nLlhPxMaSYrX67J13Z290Tk7h5fpKfwillHGyfeUdF49HCjcjV7rFantDuXGVdfM1N7TYX2mur8a/yhDgNH4R3ljdorBjZQxVdqcg1a8Xs5BGsN6aNrDWm91Cqd3AlpU8EF0bLGtVy51bTaXQF/u78gWHPoisNXHz7TeKR54gX1Ldqtw8q9ApW0z+mcXv4f5Y/2/hpGL3MRtfr71lqUsdZ2GbW6y+bLaPN3txfeX3H11aNnzky8uqolfznx1lnSrIIT6DzW6TxG/D29kZC8JxCibLBhp2GDDTs5Jut1Bwz1BhXnlgz+dxn87+KkGjSpivZwMBwyZFoNmVZOZrYmU97tJwFD5FJD5FJOZI7ulv5gMNDVHeguiJVt3LjRcG7lghOdq4mWdYQNLmZuNArjJeYVdCLEZ8icb8icz8nM12Qqg20RH+UgM682hK7mhBboQhFG6IwhdIYTWjhRUpcv4qcobzKEmjihRRMlMULrDKF1nNBi3SOC3Xt7FTFD6pAhdYiTWqJLRVipI4bUEU5qqR7HSvpTckckENptmDirpKiCiZULTniZkTtl2uXLEqmcIalccJLL9dBTJTuDYZ8hq9Rh6WhBuqoxf8nJr9D9UpUPBroN8fJkIluQrmxUrzjhlVThPb1dQYOritzIcDJuFJ6/5OTPotTu9lNqZ+OU2soFJ/kiCnZHoJ2C3Z+IUbDVK074bEq4LRwOGsJ96XTSEFavOOFzKJ3bDvb4jUiu6Dudi2cNnfOXnPy5lM6+0EFD52jqtKGzcsFJNlKw1UrWgK22MgzY6hUnvEqPH2m/HKSZTtJMJy2YPk/PyIqgr01xbB9Fdlm0L0th7uO1Xa1jVqTbg75uiqxYMpqlyMpfcuJrdLIV8XDb5X666HTfoFG0csHJrtWJVmT9oV5isBVPjQwZbKlXnGyTIRsKd1BMp9L9FNPqFSe7zsAc2B0KUwmkMnEslc4U5KsbtWvuDesN0vYFugNUSJ9IZBNUSOcvOfFmQ7y7y7ffSJYV2eHoyZQhnr/kxM83dN8f6Nlj6H4yobRyC7qrV5zsBkP3oI+0dRiVT2UyOtTXHzV01665N2w0wPtDPREjPiriqVzmtAE+f8mJt1BGP0AxVx4/laDSgnrFyW6iDEe6wlTrrzIxNJzO5CjD5a+5N2zW6wD1DaH2YC/lOVWJVCw5YjhPTaN+g3vJFkOFzkiY8tujmTTlt+oVJ7tVr/jVYDVibVa0EGjljVE+yi6gSOvYTXl7vP8Y5e3qFSe7zSBtvy8o+SMGaSejyePxjEGads294ULD4r7ugyGq7RjNnk7FDIvnLznxiyjx/T46WKIno3Sw5C858YsptoPh/RTbyfRJim3lipO9hIoUuuRyumAlUqzKbTVklTqEklXqDEpWveJkLzVkFUelqi/FLanqS73iZLcb9lLSsZ92ciUBx2kn1665N+ygUvoef7tEpfSBeOw4ldLVS058p+GigU7DRRNHDRdNHOWkdlEuGqTkyuNJQ1Jx0aSF7GW0bDft3sks7d7KFSfrM6rNzrDh22VH01SLTrngBNsMNXvChpq5tKFmLs1JtRtSbUbqm9V32pDq45Neh2GR/XsCdCvs5ECCboXlLzlxv1HDt4dDPYFQr/GG6lg6lUukRgovqW2cuMO9p9OA0Rbx+yjH6MvEo5Rj5C858d2aeL0i3hHo9od2+6hUVNOfyMZTx6JGPqprLNziXrXHQHIw4A8aXfGK04l4st9Akr/kxAOGw3RLAWMkozx7PDFsOIx6xclebsRXxG+uRDJxcyWiXXNvkOg3qL1g+g25kUyKfoN6zb0haLyhw6+09gway/rjScNvlQtOlhgOT9e+ZVTdW9FoVfOGjEL9B9r9XZTi8VOx+DCluHbNvSFs1J6dgZAvGDSKrzqqjo8lTxu1p36De0mXYfqIL0BFe0UmmshSsZC/5MT3UtkpRGWnFJWdeMIjlBRV7SaoajfBV7vdhpt1RQL7DDcbziROGG6mXnGyPYaZunrbDDMNj/QZZlIuOMFeulBqQKFqOJPOxY2uU02jfoN7wz6j6D1UI6NsIEr1BQYsmhn7DQ/RxjYNjdXRS0Nj9YqTPmAU2+4zTFMWi6aMYpULTvCgIdjh76RD4SgdCny98WIDb3ePrydgtEwqs7loLhEzPFq75t5wyMis4X3+SCRANQir0yfimUyin8qsE3e49xw2nJr4etqNNnnFUDQXGzCcOn/JiR8xbN7uoyvAWJSuANUrTvYKqq0Rots4iRTdxlGvOFnZyOhd4e4e8wuqh9PZHP2S2saJO9yLrjRA7PFTHarygXiGUkC94mSjRlbJd6aoWrwq338yavKaRv0G95I+qkbwB6nmRzaepJof6hUnG6O6Y71dVAO5IjsybLSPle6YesmJ9xtFR8JUwJZn0mnKAOoVJxs3XD9EpbP6w32pdO5wtjmROlwIu9kt9N2JIdpKi4HfibHao8bbA92mtyeyymvUl5nebty18/Zjxtt91GB65Zo1o9FUoQqvbtGujSHlMvZFA0Zypm1/ePTw6Chl+xb9hmBwOqG9qSxEmaEslaYGUFIWRhjUFWEGBfc27Wptyuzq2zXatyuza11TY2Nj08bRhtHadet3Kf8fXbt2beFa+f+6UdPDh65obKg9sl557NAVa9X/rV03MRIa0vFbcatDOq5BKldHyg2HCqVTVDCpV9w0R1IXNI2a1fZkRuKjnVGqNV3fYtwzpowqWEKHdNOYBy63Nh3ub246vPFw//p1o+o/zeuaDsX9Rw41bziyS73aNao+kL+1oVm7NVHwthYHwgWTCyhL6bbf4z9QADp/06FTB44c2rThkuiGo74NnbIxibKwhf+tMDcn8Pq0XkwbFa51mw71tSmv2ky9v6GFumnnxcP6i8PUGFr9pkPpsIrxIurNs1vou3ZefZX+anrgul7VPK++fGS98Wr6rmhuaYL1TCF5+7vb5ZCPGLl/6fadh6IbXuLb8GL5iP4fc2nLW6AnhErpJWcnQoQuc7G4xKUt4vJEmub0WsIXiYSV/pMxrVS+fYMx71XZqF5xKWZEryM0YSMyy5SnjeSkXHCSJ0ySVAeXKrSi0arMk7pp9DLlrs10sa10sfwE2imTcETu2mIIt9Ilt1qUfJotmRbeTimsXHDCL2FLpmBv2EnBVi444av1FmG7hZWam2krKVec9Khu4nbeTM3NFF/NzZzoGbMoZSeq2IpGq1Kv0dug7ZaGaqYN1cxrfK1ZmrEUXXarRdnXcWWbTNVMm4pX+nqubAp5M22rZgtb3aBJz/LvNSbwdhgTeDs4gRt14+73BSO93TIlN6u1IFje2MpL3qTX8L6ODpNYMyXWzIvdPNEw6G0ziW2gxDbwYrfoYqQ3aBJbT4mt58Vu1cU6AvtMYi2UWAsv9tKJ0sJm3VZTYqt5sdt0MpXuCovzMkryMl7yZbrV1fUXSrdhPy1btt5QsqJxvYWWt+tdDqVFEY7IjK5lLS2UeIuFtmM67LZ8o9MEew0Few0v+XI9QtvUVqZJcJQSHOUFX2EUeYCRvIKSvIKXvMOQVFqkJslrKMlreMlX6pLB7j2BTpNk2fbtFEXKBSd7py4b4WV37qRklQtO9lUTMWlUqbN2UFB38CJ36SJBau3DdiOMt3MC47rAbkpgpyHAJ6m79eZLkBonm7WdQmVBwv/oMrtpmZ2UjIXyr9aBhSiRcymRc3mRe/RGSFew1xhomdlsaMMnzdfoTWoSCNEyGwwZvk58re67+ZBTwtUQW2+IrefEXqeT0EGNXc1sMSRaOIl7dQklmRgSqw2J1ZzEfTS0Lmp+Ztb69VS648Hdr7tpIRFQGa+Fyng8yNfrRXb42xVJeiHbZQbSyzixN+iJss3cX525xhBawwm9UbdWm6lvOnPUkBnlZN5kFHSAFrrCELqCE3qzIUT3XmdeYwhdwwm9RRfS0gQVHNup4OAj8K26WIQR20kt39rJx+HbJlpmclegyy937jdInNVKibbyom/X6wxdtE2iZbe3Umj5dsI7dHPzhY5ShY7yhb5T9zCrIkepInkLvktvdHcoWdtU4kaqxI18iQ9MeKYixxS4kSqQXw/2oF6guh7MT/XSFqw6vL6w9vXw+lWjqzYWompJi/bjxHpX/Wc7fZmH9Ey330hA9U27Wg+dU1PfUHtk3UT+CgnWFv67sLbw3coLxirTmcSxRErP7bXJaOb4xmT8VDwzPlbRkz4eT43fpa75jfQG/cqdbC6ayY1Lq6VZ0szcuBIis8fqQunUxDLb8ZGxmvip4Wgqm0inxo/oL60cSvePqJNlswd3ls+YMRIdq0hn+pUSpBljFdFkIpodD41VpYdzilA2v4h4zvF4fFiOJpNyToWQHb9trCr/3v7N47cNzA2NzcnFh4aT0VxczqZHMrG48oIG5U7utJxI9Sdi8ez4OhVaRCk2rL93RLlRrt4YH5EeVgoZ3FaeX9Q8MGvwEuV/TYOtyt8FrKR2plQ7oaMGe3CX8rdCq6ZUQy49nIyfiCflbG4oV3hI+3GOLGvvkVXC5E2Fn+OD7co/0ozBDuWf0KBfgzC4W/n3tsE96t+KdoOB/I+XK38rWgxKqqDyb1D9V3qPGfpe5X8MQO2HHuqHqFbqTOelPlK0VK2IWc6LeG/RIpomWvXacN9Y7dFEMhfPyOmRnOIVs8eqDTfU3rGPeofOfJlzgO+zyXxc+f/g0fwbZw8eo/gvd172+0GHnZvTPFBWVw3J/enYOAnMkuaJXHeCQDNIoVvj/fYDoAZMkWR4ljTfEr5eFWkrhMz4omh8HzTjuwaw7lhNNBMbiGvLAl0Lrw/ZLLxaXXgi56fXzGUj4u7DNsuuivYlkuqXFUzRiIj6iM2ia7VPMOQT0QxbOiKmPmrX4kcz8bgcyy9PNBde4bzwj9ksvGH4dL5ouS+ZVlcAmQFUOgfwcZsA9FVT5nKrnJf7CTAPmAKbXFQmrRQlMWotoVUeK6zxs/qxRl3hJw9H1UWXpnp7Yom+lVC9Di+hND2yrFzESg6fND9pJusR3kj22Jig1kLlhbJM8a61VzYzz2hfY1gqh0h6n7Kp3OBj5WyFqt1/nJLQ7nyBezKOzo+ftmsDem1qiUYQEIxIr58BQ40KAPKzMukcUaDNl+XC05p7bGHQWyqGd/5HzfB/CmSowWfK3WzpftZmqU/zpSKc7LGiWVEz1rpyaZXIWHX96Vwu3i/nP9E0W0lfuWzlmdpUnNvJ63Nmnf4KMfl3V+33OMikOYGTrnLpPBGViwqJMS+guf5WwPXVR1i+tU/E3Gb182b9qiugrFlXwWbHhgquO4Qg+gm7QBo4IHMq3E/TTxaFw6PBt2C/UDRu855BbimXVgtbM2rA9ssZqmU/RVH7RbNGayAe1/E8IpzpSzCPdEYjD5RLaxzxqDRzqBdpwXyBi5XVl80KXAzRdqmrtP0vXMMb3VTybLm0TkRabX88ls5Ec+kM2641vhyxcsDZhTKULmks6SKbXzHrtQfMLRKXW8KuJrmv2gVCuJQGwkEkua8VhcOXik9yX7dX6sTnf6510L8BejfreaSlQjpfmBdUAdk0aqP7fjQWi2ezci56jG2TW6RX7Zc5idRAPJNQk4n6WjZo6ofiQ33xDNNjxwfFN810JEFfTHNBcRV3Jwv46wj7pEedv29NhjInXQ2+b08G5OuhphEifp9yDty2m1hxjQj970wGZJBrxLjed90HbsEsYtzve+4DBHlEDBN+H8z9dGuFXF8hbRDMFSyQZeNpeTg5kpW3uThn8AMYJFWtkLdVSBtFlZO+QQo0jJn/mMjtZv4PzdA/CbrBZ6yNXvg+yu2K4UdYYIWPvtzuYf4YtDbXICBPVUgtwik4fYcWKwWWyjLzPq27ciHbzlC8eigRk2MDUfUjOmZA2ur9eLf5iZmDp0DrfA/IFT/isspPoOyBcKKfivtFWkOQrKiUtgiSB/XhveV0LoLGn5nx/R5qUVO7c1hCQFD0c5sQClsXWAJAhNPTJQDI7xRiCQDRLPqFTQDGDituz+o/A7qpuQ9B3lIpXSJOJ/C81SJZpl+m5ZKLJmkC65dmDWdXQvliXqV1vljE3cdnh1+BtNfpTGlTkF+ulFodr6OwnrfFM/prM/hzQUbPs2aUn8fHE/obLCaLRRX4+vq3WFT8agt8X+x3aFAD0azl2hxEHvo92n78Egl8V+rZoqi0H9ZQP+DXRfyfzVI38KUiujvP2Sz1Ar7Uauel/sFmqZfypdY4L/WPNktt40utdV7qn2yWGuBLrXNe6p/BqsaIY7K+Srq02FIXfZsEqCembjxn9Rs8vDlHLT+azSaOpWRtP0K7o36IyusvZjqGwEQzDDQHMsD9E5Vst+KUBw2HvyLhF3b2sFIhx6lQglKIavJ5rE1uxdsEUaH+zS58yHVQvCMq3b9jgZcAE1EL/8MuTMgNUPwiKvJ/YoGXABNR878A1hBchiaZKmm7qKIoktMtV6RoP81V2979siofS0ZHslw7DpH0/2XW8INQzfsJvuZF5Op/g7zyupKHqqQdjpYVVOfnIPnaVf022rI+jp8azigVsvp5jHsM/8es6xOgq3+Rc+kvs3cmdsizXAJr2m7I5dqVzJjpjhroKpHMnAk6j2Fw8rcqaafDYX1P3IDMgmFrU/NkU7Xkc7YSpEZ9gcvLPEgZA/iPUGp43s3UQMphnig1SbBaahORVdj+uLSGt+N1BbV5bC6PJ5EKhoxZVVDUVVRZ15NVVWw01gBP1rFPerO4gFROok4NVW5mnqpJRL6Eu49ujZNqNH7bvmPFvPPmOKmZROQg887b6aTWM/wWPDtvlpM6z3CCrDpvnZN6uKqg0zG5u1pqdzpBM0drsQ/FU7kSW+0LZNkAoU3sXDw5EzukgSFGAs0YAszVxYVFBHhyH2RYRBUx2wP8PdwdEDmiipjjAXIQJ6IqmAuHTmEKivyrWur0YmlyvV6C2y3WeYxSWZD8ExzJp6zNMdZwdCQVU/cosASL8PH5CLAvcbVZswCB5AYeCcIrF9pGApjLihlEs2MRGo8FP4hmxOLieHga0LNuZIndYm/gi0VU70vhHMVEJdleI+0RfnlH70RtOUdafBZH3US7tM4kODBVo8I3JxT9XVpjIRdNuJkXlzFEvgt044cAN34YuP8IcP99XKL4AHfnQ1x/03TWkuVHVZ50SJf/d9Az+HkP2isrpqXuH3G1Vlk5LXX8HCALWhlRj501LRkANUXUkC+adE3tRK6FPyOq47OnpY4l+zOiZXDOtGQA1NT5IiBy7jTQ1MJ7nS8wIo3TQKOSfdX50iayahroC+rlfPEUOQ+tl7utIwsvrXeu3epppl3JHtvgXPc100x3UMfZznVcO6U6WvjqHOe6NE2pLiV75lznmq6bUk1BjeY512i9Zxo5zJnznevSPKW6lOyHC5xrev6UagpqtNC5RhsmUSMLr1vkHPnGSUReso8tdq5XyyTqBeJf4hz/Jtv4J2f0zMLrljrXbvM0065kz1zmXPct00x3UMflznXcOqU6WvjqCue6XDClupTsmSuda7ptSjUFNTrLuUYXeqaRw5z5Iue6XDSlupTsh2c71/TiKdUU1Ogc5xpdMokaWXjduc6Rt04i8pJ9rNG5XpdOol4g/lXO8W+3jd/zduB5zrXYMUValOxpq53ruHOKdAR1WeNcl12ToouFj611jvmyScFcskc1OdfINykagcjXOUfehkbuMEetd465fVIwl+w/zc416pgUjUDk5ztH7vcAuYW3bHCOsNMDhCX7xkbn+Hd7gB/E2eIc5x54daN5fTR5sEYKeL24sd0HfAtZ+uLG+vgJ9WMJ5ktl/XWerG8MMFSeqIFMfrrG2uRXA/fPAPevrWFd5Hruzo3snala33j5fwc9g3dxb8Ovb5QmXXc7mt5cw2VsxPrG4LTU8U5AFrQyYn0jmZYMgJoi1jeG0Jq6G7MWnoxY2RieZtqV7MOINY1d00x3UEfEasa9nuno0FcR6xgjU6pLyZ6JWMHYPaWaghoh1i722NZoclo+Fp6JWLvYO820K9lXEWsX900z3UEdEWsX93umo0NfRaxdPDClupTsmYi1iwenVFNQI8TaxRfb1sjzbIlYtXhoirQo2fcQ6xUPT5GOoC6IlYpH0Lo49DHEGsUrJgVzyR6FWJ0oT4pGIHLEusQr4XFXenSSnFUrXS44f6IWPvcbMZIZZcClagFaRRsB1k0cPRJNst+XezPA2CcYyjYNBhNSK0nFdm3bH+jZY3tfPkPMf4Db9VCnI+Lv6Y2E5D2BELANsyf7/cUYUq6HTDl4U611hNxSy8bDS7kn8cbrdx9nfvsXf6gnYumfgy8D3jNWy+VcxMhv3AP+Xwfxjxi9PYrGyXtFyTwjxl6PeYAfP046gEbF27pkVhEjoQkP8OPHKAfhRE9taUJeXysRp+drzS28Rx6OZqJD7M5S1mdnTWmmP86w8jhoqycBW32RyzRf9iDTJ9E4eVTa/a8A97/makYf8gA/Pn+n7KJCuSciQafhoOWDjdTVSV2i2F0my6yQtrfhJez6gPyP8oloxs6WifgoHGbU/DPoHc9z0fZ33k8RcXaVbSR/55D8E/JQRNxkiuPh4aBPcCNZQWVh+Abx1Ul7RQ5X3d3ji8hd4f3WS1um9d7vJMdwML8OcoVFddYpa0kd6yLL6tx01hG7CHVDkN6gZaNejFO7swLQ8SxeI4S7n7DN+XoM54jIOGkbocusImqRUy5hxjftT8N5xTgTjry9TupxtnepOpgQIF2Wbj5W15/OqVvAq2mHrfDyhWeH4zHLH1xe8/YShoUAaI8gZ48Q4DFd3JM9ruaaq21jto8wYgczIpuMeoDZAiEim5wR1LOGS5Jn6qRewXgmeLwBflDzGgbgVTyFeqDw22Liz5O41m7p1utW0UfpkuuK2Ucbb15ZL+0TjTdbnC+BN831DLZbIHKsFu7ibXODYCz+WDLdF01qbcQr66WDwgEFZ4fsibd29+SQPXIjo/LdYD65B8gn93L55H7uSXyuvskuzvzq8t3BcJvPumH4Wg5uCQogwu5m20Q/gCcakb5vgWOAc1DypnrpxcIzxhyfVlBrSLrYSrmVUe5joBE+yZH9aWuzWHX58O7+0uJAtR8epX7A1w232S32C3yxCJ97mWgct3BYMPlPvXTE8WydcA5IdPwWfAST1Zwr3kdvZ8j4HuijPwQSxY+B+79wtfU8BhuNOc+cRBqkKwVtiaqug6FgIMSSjG9OvByGWJ6Lqwns2gYpVsylevzdwOcxk+wZr2DU+SfoGf8GPGBWvZsecIeguUSb/4kG6ajT824WypQnaSO7mzdN0rE1r2T0m10P8T2v3prvRdx9POt3CpKlwk8unq8zybMN0oAg5uqUpn46kzMfDo+PuFcx4M7lKdMDa+JUF/da73fZLds4Tdu9mnPcbuE1anc2ro4Gs6UjKtC7bateGJFiCkcMxf2PbZsnjlrSjhh8e7XdsmtPDiSSccviEdPi99jm/Wg6Y1k4Yvb7NbYLz2VOWxaO+HTmtbaJH4rmYgOWxSO+dnmd7XA7mchZl474AuXe4qVPDOvqwwb8hJCgO4/4kuQ+28jqU+mUUqeWig3xHcj9dm02RztzOZY7ZT3AhPge4/W2+anLxHMjmZTZdYrSg/iM4g32nep0Ip7sl9UZQvvIEB9FvNE2MrWTdTDgD3ZYDr3cArWGEJ8xvMk+a5loIhsv0Z6IzxHebN/VotlsnG2LFYWG+MbgLfZJU9oq+XZ3KcgQXwa81T4yiwGiosgQ6/zfZt+c/fFkPFeqpyGW87+9lKTGt/qLQkOsy3+HfXuCq6kFyBDr7t9pG1lNLJdJlkgZYivfd9mtJplRFqaSRGyo+4BdBPXZ4WguEU1atq8Qu90+aBeAlQWi6A1qH4J72IUuDEnNlW4RDWqoH0QEgBP6QFe3GjfSnTCeZHtP+AGOdzOK/gIc4PgVMMDxG0pCu/M79o4Kna138aMgD3sMHT/h8x7BOI1hTPLgXOnWYiOQ/uB096RHGGXLGyBzVDVYm6OmgTVHHXvHG096r8fQ8Z70PqEnTTBCnp0rvbS4J3VP5oj1+wUjxNSADNkwT7pduOhSndnZEwgC2EuKArxWHxCs+CqM85CT86RXFNMJPpNaXULQGY7Ynhs1Kp2ecIkkCT7dg0sS5hcgSBGUf5Ch/FIwSHcCQXoZcL+NC94O4MlO7sk9wJOXc08G+YSASFkfss3G9NFauxNyNTF++L+QB/wKjY/Y1RqRYuonvtkdiCas8kUA2J7RWXsEyBeIOYmP2vaMk4AVTwP3r+asewZ48lruyet5P0DMfXzMto5e66LduZHXDjG18vFpox3+O8VPCBoMhbkZ0jZfelWxVYXQ+hU4vOrip2LxYcvlVxaRp0f/0UQqmkyedrsW/yTDw9tAm74TsNQDnKUe4u487Gpd+6lJwfyIq/Xipz3GjK/DPuMBwoftsIqoUx71GDO+RvisBwgtOERk9cdcRYjPzJ+DM7MpcZKb5kt3CZbTLJJl6nF5ODmSlTdvdnFhzeOCnrRecv47o/vmS+OiSqQmvzVJu7/L/ie/RqvP1z0t1sF9nuHiT6AT/RVwor9xbv5vVyuNJ2BrmetW8tR86W7hd2FqIz0Q8gWD9it+PMNPCryNWs9BVi6Q7ik2xkF8Pe2lbqBTZEWgAUGPtC2TtCLwCzAvczVQsWi2sO7x8ALpNcUG5Np9wIBc3XA0l4urCxDiV1l1wEodEIZXOA8u4Me9ERx9keFo7WwoOtfPto7O82ez0bkFeNICOSJqvySoDGhrkMcXSPeKvo1KZ2T9eRdrgC8z6Hw8r3rx0SxUPIKc/xWkBEpf8vsF0n0ip1fC13hcX9C7lf3klYWP98qvMPC7APYGe6kf8Kx9VcAaZSYyf6F0v7AasHApR/UynsmvCWZHC/psWyi9QfR1ZzKhPBdNehAmX2fgDUFhMi+bSB1LxnPplAfR8g27KObEosO5kUwcwoDoBX7TLoa5SlIbiadiIIjSO3p3V8yYOUP9U0DzLduMDEWHhxXTQGAQPbhv28XQEEtGs2AWRfTQnoKDh4sJ8sxC6Z2CICrj9+3Bh893GIDjEEUVncGwDygfETjftVt+3dBIMqf0tTKKq7gYNN+DDWSRMMj2RdKDAhOVh3qD7GeoeBt9n8H4Toij8rZwGCgeYaIfCHyYzWbkpkXSw0KC+CoKT9APBc10LteRRxdJ7xU204Pde3t9Eetm+vx8fz+RSsWhCnq5LLNl6s2eC9hmT8SyIHyV/SOGj8+ATfLHgIb241yT/Avck/gG+I/t4hRu2VfUJINPsNoA2/jhR2J/Ypv5pwDmv8sx/wOIecR47E8FMc3Wx+S2xdIHnX7PN78/ERPHyzK1f28qUQ+XbZPUyf8Zw8WvQZv9DrDZs5zN/uhBtPwcjRNEhfD4p2FPsgpM8r3F0odE3ylaDYPga4hfMCgr5oBz6KJtxkRdLIRlnxFwaBE/pH6J9GHhNgxQd+tMkaEha/rxIfZLRsHFReiHttvzhv5fwfQzHQNyeon0MRHz8ND4Elk2vUtPchdyI6FwRTfn+MmCtMX0rrBOQxjv1ww9zZDxBjfOsc47m+ZwA3zAkxdy9/Hm/Q0aP4T2Ak4vED8iw/7WM/wgWkTL4nd20cKxwvuLMCzqBTEh2HEGE02IMYnf27Zmt+1o2gc8eYB78grI4ogxjmfRGtnH/2LgycP2NUXMZv/fJGoK4kfMfj8nmKY0hQJpWCp9UlTPOYw5j5oXf2D0upa3i/bDLdQP+IGRPwo6UWxyITuWSp8SttnE6UhAKrgHMbTXsEdW+BNDx51gdNzDeftrgbi4l3oS3xL4M2wwat8A8sal0qPOV/ILd6WqV+dr5WjWysTeTO3/hR08BK3ybsAG7+Gs9V5XrfJXQVYy0UW+vVT6rMgwi2WZFtCb2Bexw276My6S/DyjwqegBPSYqwnob4KpuQklyb+WSo8JpxqdLAHyZrvyvzP6fAWi8euu0vgPwaQttZ8H6VkmfV641krbhlIOd8F52hz4eMr+KQge044fJLdMekKEvi4UDgXD7ZOM/wVBSjbKI/csk54UgV8gy4Wn9bC/mF39DO7biID/Lwb+85DHvuCqx/5b0PJgN1Mhf1wmfUloeCfngnhZZf1HsC6H3qWF7F4ufaXY4kdNuUlMYjNmmdEvnAu4xJK5bH2Ld4yZs0Dq6F1kyO3Lpa8Xa+KAG7vkmzidkTCZRFZnMYqdx7OqN2PWcrTqnbW5bjZaygREUxvPkG8tl75VjOiILwB9pSs8cnCSTVDOqHwRaIJWwATbXTVBRXE8EBz8uoFK2P6m7X3IphXSd4rlKF93tz9S8gJtwWbKnti/ilF5L2j/HsD++1y1f7UgBKltjMitK6TvFwvB9j3+dmkSuawRuA+9nRB5coX0o2Lu0+EP+nvsJxA8+loBenrHIdKwUvpp8Qq6K1yC8+PR18Hoqa1/SGSl9LRoE2MFercUYJvK+KnKegberUBay/ttW8TvY/0W34posAuhTg2dcKgnEOoFVvUgUuxs2E7mjYjIQyulX4rWZ59IZBOub307h4F3L0hS4lgqnbHeixRhpLl2y2/oV5ojqegxawQIA80TJGCKclJxlvSbYgl4X6AbOD9ZMFvt5OsHgZAnO1nMZ0h6BKw13w/Umh8E7n94Ljsu91HgyY+zT3p0EPcCtK4c0sFP8m0GhMsu9ADhk9yT+FnURYIalk4nJHeW9PtiNWxgdygMLGd0tAsfIhoWw3oxaYp8+izpOeEUlNryUTpOod2+3dbKeaPCEkHWo7bPIf86S/qT00ODFsoydZKK9s0be8Cp1a6weO2WMtr9BQyQvwEB8g8u2QiacYhks8w2Ug7R4AuuJpXlCCTl89z8zH6FXSTCDV9KPrsU9kTEQomVtlldPI9ldSl3Z/k869N8BL6JWBJxlkvY8UsWXuSKR1RGR47J6WH7GQixSOFs29xt5rjbyt4R2RexG/45cB0wQRX52Iuk5wWdkppI955AZ4/MxRS+Z3Iug659HtAzqAmKMSCyc6NtDG375VAYxoDIy6tKwXAgHAExIDLyeXYxVCsYBBAQiXR1KTT4Qh0gBkRCXGMXQyUJwwAQeXCtbQAdgX0gAERaa7ILoL4zGFYcQQQDkbnW2TdEbxAEgDjJY71tAN29bSAAxGEezbYB+DpgV6xzDuB82/FIfD0iKyDO5thgF0PdxHp8EAXidI6Ngq4UVW+Tb51NqmYKF8/F0qnYSCaj9pYsjslwtIGGePtcT0amWxg+XgtYZfA+6gd8Xb3JZrFjdcnoUF9/1Ewxvp7eDLsBZ1iy/xxSJ/SF/MxoEPiApOFkNJlRetNa79pF021hdPggzyF9aqXPerBz8GN84x9h2K3FQfHF4u15gWCQx8w/efc5ZLbQmuDi1pr9vmCkt5tPS9rP5cMJ6sQ1vH23MTp9GaLym66G5oWCcUA6GMkL55B5YiLV4SYfaeuwnjKeWzj7XB6OZqJDWYZuxCKhEsfi8ba6iCHtx1AsDv7MelRg8GmuZ/kb4MnfuRqwF6ORPwPc/xVGI0QuuAStUQk4Ef20VjjQtFRCrjqXLBRGmDnl6L26rkCXX+7cb72OqkaVkPuirq6eu5TRpHY+kKnmzXczU20XzKobapIPn0uWiPMUz4n+Q57KNgngsrYvkTuprrtKuzkcvoPRaiVE5ipXydwpaBhTepKaRrJcyKYVK3pWzo83WH8fMiF0ylUudzFKbYS43OYql5cJqlBaUbKtkawQkmnJi95X1EaQxHRGU/0u0ulj9LoMonO3q3S22aBTVZT0N5KV9uikeTHo9IWsA70iO5A46uYMfTujUQQi8qCrRHbAROoqkpc3krOEFDJc6ORpI8vWWTKZPpZQPwlwNbL9jCr9PIN6JX9sPtMMGasMgmgHj893s3HVWRwlXyy+N7RbkMspa5DfNJJzxPEy8TQfLwtl2XiV9v3Dlk0uGngPo8M1EHXXuxoiAVHvhyKDLFlFzrXHXSrNhssigzvlXTp5m10k73JGi1dA5N3pKnmSDfJUNkjnKtIoJK8sFLbOJpas4gkLMsjvBwgbq4qlh5TeKneyOoI1ArNWKI0MrSKrhIzNk2X9Yd2f2A2La6OZRG5gKJ5LxFwkLsSAfxjytPe76mlhwWxobGg4Pxv66lVktTVlejWgDtF2s6ME+LnQLgbbpyBfyo8Rsx874rnZa7d8lYAQd8wOvvqJlEQAUD6iY91tt/xZIWAJMWLqs8du4WW7uQX0+EnPXtulB6HSETOe+2wTvxvY1hMx27nfduFBoHDEHOcB24X7AdoR85sHRcsDjaRPtp9HNou77hZVhB6pJBDqBbaAzsUzQy7WKC9mtPk32LKfuYBbY9wVtEY5WLHAzXb9oeIY+WLxifWwYMQwbwUyeB7ZIh4xNFlLzwUkDPR7h9Mn42722o4wCixdANl2BWfbso7APkvTnu2qaa9AQKwprKOwCxThDDICqHDHQSuciNr4SgzODn+7Qqj17gBWOBEVd7Q4Tr5YfI3dJxiT0cKPPHge2SoekzHHKW1jaFvDyqPRWM7VEZkYo8jlEH97ef4Q8dov6AnoOpIvnUcuEBJYqa0InCSm4gzkw1BECKrdwairWe+obUhwFWuBCJHejhVHdGaiR55KxWPcV2aIlDUg7JFrpZFzV5OLxKtCWGB6I0u/zS9urtOXQ7u8jiDBaHM1mICv4RKw+oUMhHfwBlddcLA4TL5YfJvquOiresoe5PrVpFU84GdlPt3mPlk4KzuXEnV7cjbJKHg3xOu9rublIZhXXlvyzGqyQ0guzJBOvs4wOFlb3Z+Vs8PRk26u+kgxOr4dovbdrlKbhqk1tCRda8hlQkp5RvT76mfmXb791utnKkdSw+466DCjzkcgFj/tKotXCRoOuo7kNWtIu5hD4dbdZe7u/JRhEH8RIuqrrhKVhYnKK0i+sYZ0Fm1eQXOr2uKLWDSZdJGpHAP5+xBTP3GVqZFiC1LyapKGtSQg9iphZWH91RSetBMM+t+CbcAi1dngc642DE7axiXMXFaoEO2GUyWh8oHLby1QIVqup4uj4ovFD3q/RLBvhslbya1rSVDo+6JvAqvUs47ksPWuOfVHE8lcPJOfBXOzt3Y1o9vchVDzecFCpvk8uGih9Seg9dpiZGusiFAZ9QBrXSLVHz8lZ5OJGNcrQcTPGQTUJQvdjJlrEEjO5pEgwuhaBJK1PBLEqNR1dpE4j9fqjnAP3FyHt85EzE9db5vfXRy/PiA8qlQ1oIrQzxsFMcN1gwfwyzqsh72soCPmx25EQG+3hm6FEDGJdhMCIbGPEPEV4c0IhPvsI0R8ZnhLcYRnTEMlpmY//hPDW+2WX66WzxaM+KrwpXYLnh3vPxZXsxqTL3UIs51DuE20fQ9Vg5PeJtIlHrcUHUbo8v5XjoQWyTKlkb7ciTvg2auTDl/GEH0TGIa3AkF3GxeetwNPvpx78g7gyTu5J+/mnsS3L2+flrrfZV93RIN1bFrqDmqKaBC/fEo1LcGaiKb2K6ZUR1AjRJP9jknUyH4WKsGaiIb9K6el7qCmiD7AndNA0xJsiugyvGoaaArqheho3DWJepVgKUTHZHwSNQLxI7otd6Pxe9F+K8F2iC7T/0xL3UFNEX20V08DTUuwKaIreM800BTUa45zvV4ziXqVYKm5zjV67SRqBOKf5xz/6zzD70menO9c03ungaagXguc63XfpOtVgr0WOtfr/knXC9RikXMtXu+ZFiVYYbFz/G/wDD+IdolztG8sjjb/w1h1/sy3E1Fu7Hqp88LfVHwdorZ65DXryH7HM+iiQ61r87swWZ4Eqx77cdD6e1yrkXy9LI8Oh38zw9TpRZBTjS5infyaRdbudB335C3ck/jh07d4gPwG4P5N9jVCDIq+1QONQJyIIc23CT6Ro9ye/HwdOSjeKyh/yGlppyXXHz8plySGj5G3M/q+BbTL2zm7vBOwywPUk/hYeIddhI7pQ7j1O4uD0374KPUD/ruDd9nmpDQ3xA+XP2CXkM/zhCDGtB8UfPCYn8Il8fXkCtFH/hbrSPBf+D/EwPomaCdhfQtOcAprTkTMvdsu7sEfWucAy/33NYmfelC7PFwcrwZrjuoMciydTMZjOZpPfEy+xy6GfLNLCclcPMM3DBGh94hdANoZGhaejgjA9xZZ2FnQl/xgPekXBWJ930gimUukZBWli7H4PgbhzMXQmg91MZrrm22833bxbeEwUDwiQj5gt/i6oRGF/Wwuk0gdczE6Pmi3/Gp/MBjo6oa2O0HEx4fsQqjoDIZ9wNYPiBD5sN3yy8LtQOmImc+P2C69DdppBTEb+VHbpe/xH3B9042P2S6d30EYv+vGxwVfYRUyMXmgmaTFq616Dnb5gS/cvTlA/hPsLo48bXoroH0xsHzdMpfj2yefFIyB0PmLfLeZXCWqbBbJMvW8dprZlgtcrHU+JfhC+OgEyn82k6x4v5XO7p6IrH5CBmydqL5K3Rw7x+6NXZ2X9HPfVOG949OMZocg7xhr0NDvFSjQkFcge5WlDnUT8qAaCFf6jKDDT7FKes8nJ0SetFCWjcf1pYbbXHSkRxmcGZ5uNBefhblgDERefT45KaJjiU7HhITOyIUuMvIYg/ZaDxj5HMwI15UgMzeQl4g4qe1PxHLMpzx4Gh5nII5BlVtNNg6UjiDo87ZLPxZnP2PCt2qfsFt6bX4g3rJ4RKP2SbvFV+ctbzEPgGjOfsFu4VWq3S3KRjRlv2jb6rmR4WTcqnREU/ZLtmmHpl8QLdkvC+oLysnIdzaQG71YPa9up1soRm+wXDRZS9r/V/DdshHfpH4juUn8nbeT0a7Bxyk7n/F05ugrAj2NLEp2bCQ3F9GzLeJrL9HElnpavQev51cFzkxVViS1kdziWNGq4yeUNkCCHQecPC2/JvziJVX4FJjct5HcKv7eXv1Cu/tgqN16xwv1dCdgo33RXKvl7qZ6/uQ3PSh0XCjoeuvqYhc7f19nSPsb2Pn7p3Xnb/BfwP3/sIYfnLnE+smyJW5OJH3DtkbuItfuVPC6IBo+35wiXfATrN8S7Ukz0Uoiz20ktzlOOPNleeJNemCw55NbpyTR1KxXuenbDB2rl0CGbALMs55ztfO5O5s4WXw4PYVGzuPcCDwJ4keE0Hc8wA/iRATMd9E4QVSI3sf3BGFcaHWT5hbyMueNYCdLKDxr+n6fUbgbNMM+wAwHOHc57EFY/gCNE0SFCLYfChrURheRHGwhtzvvOGgvsvAXr7oJP2K0SoNcZwCuT3jgAT8WDDlPDAWQa1rImOMK1klgelWB/oTR9gbQBjcDNriVi8vbPbDKTwVWmWiNkLe3kFeIJwKmz0mWP2MUugcivsgGwwJ0CLp/Lkg4hveSn7WQO1xfxucN308zGj3E86398H7qB/wA7y8EQwRUwiWbN5FXOXddiMr/klWUzzAkfQpMQo9yyeYxIC09zj35BPDkF1ztJv/Sri7OLDoFizR/Zds63+c4/yHA+Y9d7RT/2lvOJ3sR6G9sE/4sR/hzAOF/5AlHTGD81ivC8VsU/M42NKehhJj9+H1xcNoPNUu5SgixgOdZwepCEwlkzmZyj/ijl1JJO6OPGJ00L2bFVxr/xyi1eCnA5Vk8l4j8/pyoIaorSS7dTF4jbhfxC460H2YBh9570yj6A6NME8/hFDZC/whTze7vRV67mdzrfKikSj2hLdxR6mTiUlk249AmFLduYp7zbFTlTwxDOyD7DV621LpeaAPudy5la5Y93JN4C/8Ziz9vOX/HbkvLDXZwSpSgFqLF9Be0WfbjzYJoT/0VjR/FPKLp9DwaeQk4EQ2ovwnmVPMpJT2srWut3ELuEy2Kqs4/HU2ddnFJ1N8ZcCeBmlVpGKuFH83wezwicsI/7JZelS89l3ZxQdQ/BZX7RGlkyxZyv8gkVb5IJLxfZiey8XZ5gV24A9bWtToEuWuzZZW2TF1Q3C9TO3mr59laNOmMF21xfenov0RjTAXHIiNbyOtt0A1884Gg+98MvtcXozvoFt1BL+j+j2DKqZBEyEe3kDcI842GsC3gOt0zysz43jtpdHvi3TPLQLrpk6nIf7aQNwq/55p42CrNIuiexeD7HJRmC2j5TIugp8xu8XUTxVvUcYhMXw6bhzmLi2zdSt4k7swpbdAOf9DPnfSra0BX6O713SpsOJhaXR3YSt4sjOh2r+qrSgbhL8CIrmsvUmE5mrgRjVVQJbof+1V2FR98FmiFPse1Qv/qQT+lGnYhc9oh79hK3mLHidyvhWsYjGXLijkRWC945kSe1Ne1dhUfrF9m7USzl7FOtJB7Eu9EdbATmXI3+cdW8lbhFgLtnrUt6hmM505DJ/IkEzXYVXxwPeBE53NOtMUDJ5otyESm84ZI9gLyDsdrXIQHpSwo3mD0aiXMHEb9XaB/CrUTfeIqVN12i9mrHTPmCuxvOsOJ/OEC8i7H9odG10Xx6ZXN58EqW3oiOWsbeUCouQ0HFkzRsNKJXHzIxebqfEbd47yLaz9klrk5XbMAZlng9CS2jTzo/koioYHwFC9kdD0DUXydqxQvsu/IeZ8ib9tGHnI2O1YZGxrmz3P2Zm5sMawWhY+8sI28R9SqqcsOx2OJaNLlrZGWMOjuBWw9Vivt93e3yyEfYXuneMsvtQuiHC4e0WhYJmh50qyT1gvJ+4VDiPkviLiDI/FWWs4gfAQiqF5B0BXu7hHAQNhphV0YKhGRMHdSGd5UK+0iyB8t2tvlB0YjEJNaZ5VCQrc/2On6DjovKgXBHj83X4z/8PhsuwiUrCHvC3QHerjv8fDfH58jaOuZNjwh/7iQfEI46qA0eGW10et64J7LYPwRaCoVgi/EbtqKj9lGuwjyJHiy6dWqkiB0BKBtlxBBe15Jduj2AwgQQbvaLoKavDP2dgXdD9s1JRkiGOh2f/+rtSXRINgBDLF6rqkkZwD3okIspFtXEgttB3v8wD5siP2w1tvFUJsPiZ5IILTbGgTiKJpmBsS+cgDE3Jz6EelQTj6ZyA3I/emYi23g8+2CaMilh5PxE3ENiouzWBuKI2jif9HurFru5hfNGxFI1vFIECm7hUHyBIRENBhRlxgaTmdy8nA0N+Bin26TXWymX7Q7ly63HiDdwbOH8KjNDMKnIZ+2OFAYH1Fb7JZeZJtJBAFbi0No4n/R7lzOmQgfWBcg8HRBeBDhtY3BU1cBTmXoMWQayBNEHj68LrSLzfSLdqdvOXunH2IP4V0XMQh3gOxBB3Z7s1fkxXZxmX7R7lwFJKasq4npEgbhh0Hmqjv87eEINA9hvZMLnsFWu/hMv2h3rgMYvMFVBi9lEP4AZFC42403obvdLjjTL9qdO7jQvdOD0N3BIFxQCa0YGooP9cUzlm09BEM7i5ffxP+i3bnfVUfaxSDpqYLavcOn5Vi6Py73JdOx4y5ycZldBDVHM/F4HoOLrW5f8dKb+F+0O+9ytdXdhkDyHldb3e0MkudroeRSo53DciJqa/sefGbpsIvM9It251EuszzmQWbxs5FdD3lzNhdVGlPxlJt5pbN46U38L9qdr7maV3YzSH7fAI0sxE/F4sM5ud/VKa09xYtv4n/R7vzQVSICDJKzZ0OjG0PRXGxAjkWz7ufYy4uDaOJ/0e782lU6JAZJN4RkrErpr+fiGa7N0rZf5iYS8JklaBeX6Rftzl+4zPK8B5mFsOMNIHOCsZD5+Q2htO0KWX7xJIbsQjT9ot0pX2Hdbq5c4ab7hRmEzzkiMb+lnVckdtmFaPpFz+oAiYtcJXEvg3DTnJI7vlaT+HjqInaBmX7R7jQC1J3H3ccT2M3gfBQksCq/kizKbsPvUfOqxy4u0y/anc0r2DtbPWCul0H4D5A5cN2PR9zts4vM9It25zKOuzYPuNvPIpzrZMyAX/bomLu7r1w7I/+nAPGAXYimX7Q7YY7EvR6QeJBBeON8sAKRLBoq2k91yfSxRCyalKOpfhdrjhfbxWb6RbtzBZD+rnS15jjEILwLZE/dwNnHnTHC0JdKu7nk8bBdcKZftDtDAH1pV+k7wn7WCNJXG80kcgND8VwiVmTZI563K+yiMv2i3RnlgvYaVxmTWZtCh1mXuolcQaiUnf4cCeENdKVdEgZvB9z45ZyZ7gCevJN78i4PsnB0ijTCj/L1TSJynnnt/t28RojRwtiUaoTf5qN/UvDjt/mIo3FiYhb0HMQ6sKNTqhF+B7Zjk4I/jl5pNuAZzhL8BLFKLTGJ+OPo5WyDHqDVUdU5R3XcNir6l8lsFYCeU+9c6+S011rXscG5jkPTRkddl9nOdUlNqS4l+OQc5zqmp5mOukZznWs0PEUa6cjnOUd+lQfIPcmB853rmJlmOuoaLXCuUXaKNNKRL3SOPDeJyEvwrkXONRqZUo10/Iud4z8xKfh1nEuc4zzJ4OwFjxidOMp64lf86oFTdsuuFH0hghjuOV0cQBP/i3bnyEo3h29egkASW+n+Cu6rGTwj4Km7+YO7uwJ+7twXvH+M2gVRkwfR5u9mD23Eu8iZ4hgwB4GKz8xBONQ1dnGbftHveOBQ1yLwXA3hQYzOXYfAcz2HR7t/40r2yZsh5IjxuusZ5DdAUdGQj4ruvR5F5w12cXgYnTcWxzAto/Mmu7hNv2h3Xu9BdN6MwPNWD6LzFgSeB4DofIiLzoc9iM5bGeSPQ1FhOpbYvTbVS4uX38T/ot15km/SIGLzNgZJBXjISf5wZHYrCz2HnYwmMyNZWdtfy8W5y5fZRWf6RbvzLcDDnnKVv9sZhOtB/ko56hbP3JhdXBbH1j7NxeAzUAwimHs5g7AT3tPVattb7Sfzln7uOd4r7IIb/BNLlkdHmNxRHBEPCL9zxyttE8Efd8BRM/gXPvYQ9eGdrmJ7gceGqBtf5RI2dF03svH/AbALk9k='
+)
+MEMO = pickle.loads(zlib.decompress(base64.b64decode(MEMO)))
+Shift = 0
+Reduce = 1
+def Lark_StandAlone(**kwargs):
+  return Lark._load_from_dict(DATA, MEMO, **kwargs)