From 220e228b89024568a0e35a89dadfb18fd5129e80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Primo=C5=BE=20Godec?= Date: Sun, 1 Mar 2020 12:59:20 +0100 Subject: [PATCH 1/3] Statistics widget --- .../text/widgets/icons/Statistics.svg | 99 +++ orangecontrib/text/widgets/owstatistics.py | 685 ++++++++++++++++++ .../text/widgets/tests/test_owstatistics.py | 439 +++++++++++ orangecontrib/text/widgets/utils/context.py | 28 + orangecontrib/text/widgets/utils/widgets.py | 65 ++ 5 files changed, 1316 insertions(+) create mode 100644 orangecontrib/text/widgets/icons/Statistics.svg create mode 100644 orangecontrib/text/widgets/owstatistics.py create mode 100644 orangecontrib/text/widgets/tests/test_owstatistics.py create mode 100644 orangecontrib/text/widgets/utils/context.py diff --git a/orangecontrib/text/widgets/icons/Statistics.svg b/orangecontrib/text/widgets/icons/Statistics.svg new file mode 100644 index 000000000..f5371108e --- /dev/null +++ b/orangecontrib/text/widgets/icons/Statistics.svg @@ -0,0 +1,99 @@ + + + + + + + + image/svg+xml + + + + + + + + + + + + + diff --git a/orangecontrib/text/widgets/owstatistics.py b/orangecontrib/text/widgets/owstatistics.py new file mode 100644 index 000000000..31626b5cd --- /dev/null +++ b/orangecontrib/text/widgets/owstatistics.py @@ -0,0 +1,685 @@ +import re +from copy import copy +from string import punctuation +from typing import Callable, List, Optional, Tuple + +import numpy as np +from AnyQt.QtCore import QSize +from AnyQt.QtWidgets import QComboBox, QGridLayout, QLabel, QLineEdit + +from Orange.widgets import gui +from Orange.widgets.settings import ContextSetting +from Orange.widgets.utils.concurrent import ConcurrentWidgetMixin, TaskState +from Orange.widgets.utils.widgetpreview import WidgetPreview +from Orange.widgets.widget import Input, Output, OWWidget +from orangewidget.widget import Msg + +from orangecontrib.text import Corpus + +# those functions are implemented here since they are used in more statistics +from orangecontrib.text.preprocess import ( + LowercaseTransformer, + Preprocessor, + RegexpTokenizer, + UrlRemover, +) +from orangecontrib.text.widgets.utils import format_summary_details +from orangecontrib.text.widgets.utils.context import ( + AlmostPerfectContextHandler, +) + + +def num_words(document: str, callback: Callable) -> int: + """ + Return number of words in document-string. Word is every entity divided by + space, tab, newline. + """ + callback() + return len(document.split()) + + +def char_count(document: str, callback: Callable) -> int: + """ + Count number of alpha-numerical in document/string. + """ + callback() + return sum(c.isalnum() for c in document) + + +def digit_count(document: str, callback: Callable) -> int: + """ + Count number of digits in document/string. + """ + callback() + return sum(c.isdigit() for c in document) + + +def count_appearances( + document: str, characters: List[str], callback: Callable +) -> int: + """ + Count number of appearances of chars from `characters` list. + """ + callback() + # I think it supports the majority of main languages + # Y can be vowel too sometimes - it is not possible to distinguish + return sum(document.lower().count(c) for c in characters) + + +def preprocess_only_words(corpus: Corpus) -> Corpus: + """ + Apply the preprocessor that splits words, transforms them to lower case + (and removes punctuations). + + Parameters + ---------- + corpus + Corpus on which the preprocessor will be applied. + + Returns + ------- + Preprocessed corpus. Result of pre-processing is saved in tokens/ngrams. + """ + p = Preprocessor( + transformers=[LowercaseTransformer()], + # by default regexp keeps only words (no punctuations, no spaces) + tokenizer=RegexpTokenizer(), + ) + return p(corpus, inplace=False) + + +# every statistic returns a np.ndarray with statistics +# and list with variables names - it must be implemented here since some +# statistics in the future will have more variables + + +def words_count( + corpus: Corpus, _: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Count number of words in each document. + """ + corpus = preprocess_only_words(corpus) + # np.c_ makes column vector (ndarray) out of the list + # [1, 2, 3] -> [[1], [2], [3]] + return ( + np.c_[[num_words(d, callback) for d in corpus.documents]], + ["Word count"], + ) + + +def characters_count( + corpus: Corpus, _: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Count number of characters without spaces, newlines, tabs, ... + """ + return ( + np.c_[[char_count(d, callback) for d in corpus.documents]], + ["Character count"], + ) + + +def n_gram_count( + corpus: Corpus, _: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Count number of n-grams in every document + """ + + def ng_count(n_gram: List[str]): + callback() + return len(n_gram) + + return np.c_[list(map(ng_count, corpus.ngrams))], ["N-gram count"] + + +def average_word_len( + corpus: Corpus, _: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Computes word density as: word count / character count + 1 + """ + return ( + np.c_[ + [ + char_count(d, lambda: True) / num_words(d, callback) + for d in corpus.documents + ] + ], + ["Average word length"], + ) + + +def punctuation_count( + corpus: Corpus, _: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Count number of punctuation signs + """ + + def num_punctuation(document: str): + callback() + return sum(document.count(c) for c in punctuation) + + return ( + np.c_[list(map(num_punctuation, corpus.documents))], + ["Punctuation count"], + ) + + +def capital_count( + corpus: Corpus, _: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Count number of capital letters in documents + """ + + def num_capitals(document: str): + callback() + return sum(1 for c in document if c.isupper()) + + return ( + np.c_[list(map(num_capitals, corpus.documents))], + ["Capital letter count"], + ) + + +def vowel_count( + corpus: Corpus, vowels: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Count number of vowels in documents + """ + # comma separated string of vowels to list + vowels = [v.strip() for v in vowels.split(",")] + return ( + np.c_[ + [count_appearances(d, vowels, callback) for d in corpus.documents] + ], + ["Vowel count"], + ) + + +def consonant_count( + corpus: Corpus, consonants: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Count number of consonants in documents. Consonants are all alnum + characters except vowels and numbers + """ + # comma separated string of consonants to list + consonants = [v.strip() for v in consonants.split(",")] + return ( + np.c_[ + [ + count_appearances(d, consonants, callback) + for d in corpus.documents + ] + ], + ["Consonant count"], + ) + + +def per_cent_unique_words( + corpus: Corpus, _: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Ratio between unique words count and all words count + """ + corpus = preprocess_only_words(corpus) + + def perc_unique(tokens: str): + callback() + return len(set(tokens)) / len(tokens) + + return np.c_[list(map(perc_unique, corpus.tokens))], ["% unique words"] + + +def starts_with( + corpus: Corpus, prefix: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Number of words that starts with the string in `prefix`. + """ + corpus = preprocess_only_words(corpus) + + def number_starts_with(tokens: List[str]): + callback() + return sum(t.startswith(prefix) for t in tokens) + + return ( + np.c_[list(map(number_starts_with, corpus.tokens))], + [f"Starts with {prefix}"], + ) + + +def ends_with( + corpus: Corpus, postfix: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Number of words that ends with the string in `postfix`. + """ + corpus = preprocess_only_words(corpus) + + def number_ends_with(tokens: List[str]): + callback() + return sum(t.endswith(postfix) for t in tokens) + + return ( + np.c_[list(map(number_ends_with, corpus.tokens))], + [f"Ends with {postfix}"], + ) + + +def contains( + corpus: Corpus, text: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Number of words that contains string in `text`. + """ + return ( + np.c_[ + [count_appearances(d, [text], callback) for d in corpus.documents] + ], + [f"Contains {text}"], + ) + + +def regex( + corpus: Corpus, expression: str, callback: Callable +) -> Tuple[np.ndarray, List[str]]: + """ + Count occurrences of pattern in `expression`. + """ + pattern = re.compile(expression) + + def number_regex(tokens: List[str]): + callback() + return sum(bool(pattern.match(t)) for t in tokens) + + return ( + np.c_[list(map(number_regex, corpus.tokens))], + [f"Regex {expression}"], + ) + + +def pos_tags( + corpus: Corpus, pos_tags: str, callback: Callable +) -> Optional[Tuple[np.ndarray, List[str]]]: + """ + Count number of specified pos tags in corpus + """ + p_tags = [v.strip().lower() for v in pos_tags.split(",")] + + def cust_count(tags): + callback() + tags = [t.lower() for t in tags] + return sum(tags.count(t) for t in p_tags) + + if corpus.pos_tags is None: + return None + return ( + np.c_[[cust_count(p) for p in corpus.pos_tags]], + [f"POS tags {pos_tags}"], + ) + + +class ComputeValue: + """ + Class which provides compute value functionality. It stores the function + that is used to compute values on new data table using this domain. + + Attributes + ---------- + function + Function that computes new values + pattern + Some statistics need additional parameter with the pattern + (e.g. starts with), for others it is set to empty string. + """ + + def __init__(self, function: Callable, pattern: str) -> None: + self.function = function + self.pattern = pattern + + def __call__(self, data: Corpus) -> np.ndarray: + """ + This function compute values on new table. + """ + # lambda is added as a placeholder for a callback. + return self.function(data, self.pattern, lambda: True)[0] + + +# the definition of all statistics used in this widget, if new statistic +# is required ad it to this list + +STATISTICS = [ + # (name of the statistics, function to compute, default value) + # if default value is None - text box is not required + ("Word count", words_count, None), + ("Character count", characters_count, None), + ("N-gram count", n_gram_count, None), + ("Average word length", average_word_len, None), + ("Punctuation count", punctuation_count, None), + ("Capital letter count", capital_count, None), + ("Vowel count", vowel_count, "a,e,i,o,u"), + ( + "Consonant count", + consonant_count, + "b,c,d,f,g,h,j,k,l,m,n,p,q,r,s,t,v,w,x,y,z", + ), + ("Per cent unique words", per_cent_unique_words, None), + ("Starts with", starts_with, ""), + ("Ends with", ends_with, ""), + ("Contains", contains, ""), + ("Regex", regex, ""), + ("POS tag", pos_tags, "NN,VV,JJ"), +] +STATISTICS_NAMES = list(list(zip(*STATISTICS))[0]) +STATISTICS_FUNCTIONS = list(list(zip(*STATISTICS))[1]) +STATISTICS_DEFAULT_VALUE = list(list(zip(*STATISTICS))[2]) + + +def run(corpus: Corpus, statistics: Tuple[int, str], state: TaskState) -> None: + """ + This function runs the computation for new features. + All results will be reported as a partial results. + + Parameters + ---------- + corpus + The corpus on which the computation is held. + statistics + Tuple of statistic pairs to be computed: + (statistics id, string pattern) + state + State used to report progress and partial results. + """ + # callback is called for each corpus element statistics time + tick_values = iter(np.linspace(0, 100, len(corpus) * len(statistics))) + + def advance(): + state.set_progress_value(next(tick_values)) + + for s, patern in statistics: + fun = STATISTICS_FUNCTIONS[s] + result = fun(corpus, patern, advance) + if result is not None: + result = result + (ComputeValue(fun, patern),) + state.set_partial_result((s, patern, result)) + + +class OWStatistics(OWWidget, ConcurrentWidgetMixin): + name = "Statistics" + description = "Create new statistic variables for documents." + keywords = [] + icon = "icons/Statistics.svg" + + class Inputs: + corpus = Input("Corpus", Corpus) + + class Outputs: + corpus = Output("Corpus", Corpus) + + class Warning(OWWidget.Warning): + not_computed = Msg( + "{} statistics cannot be computed and is omitted from results." + ) + + want_main_area = False + settingsHandler = AlmostPerfectContextHandler(0.9) + + # settings + default_rules = [(0, ""), (1, "")] # rules used to reset the active rules + active_rules: List[Tuple[int, str]] = ContextSetting(default_rules[:]) + # rules active at time of apply clicked + applied_rules: Optional[List[Tuple[int, str]]] = None + + result_dict = {} + + def __init__(self) -> None: + OWWidget.__init__(self) + ConcurrentWidgetMixin.__init__(self) + self.corpus = None + + # the list with combos from the widget + self.combos = [] + # the list with line edits from the widget + self.line_edits = [] + # the list of buttons in front of controls that removes them + self.remove_buttons = [] + + self._init_controls() + + def _init_controls(self) -> None: + """ Init all controls of the widget """ + self._init_statistics_box() + box = gui.hBox(self.controlArea) + gui.rubber(box) + gui.button( + box, + self, + "Apply", + autoDefault=False, + width=180, + callback=self.apply, + ) + + def _init_statistics_box(self) -> None: + """ + Init the statistics box in control area - place where used statistics + are listed, remove, and added. + """ + patternbox = gui.vBox(self.controlArea, box=True) + self.rules_box = rules_box = QGridLayout() + patternbox.layout().addLayout(self.rules_box) + box = gui.hBox(patternbox) + gui.button( + box, + self, + "+", + callback=self._add_row, + autoDefault=False, + flat=True, + minimumSize=(QSize(20, 20)), + ) + gui.rubber(box) + self.rules_box.setColumnMinimumWidth(1, 70) + self.rules_box.setColumnMinimumWidth(0, 10) + self.rules_box.setColumnStretch(0, 1) + self.rules_box.setColumnStretch(1, 1) + self.rules_box.setColumnStretch(2, 100) + rules_box.addWidget(QLabel("Feature"), 0, 1) + rules_box.addWidget(QLabel("Pattern"), 0, 2) + self.adjust_n_rule_rows() + + def adjust_n_rule_rows(self) -> None: + """ + Add or remove lines in statistics box if needed and fix the tab order. + """ + + def _add_line(): + n_lines = len(self.combos) + 1 + + # add delete symbol + button = gui.button( + None, + self, + label="×", + flat=True, + height=20, + styleSheet="* {font-size: 16pt; color: silver}" + "*:hover {color: black}", + autoDefault=False, + callback=self._remove_row, + ) + button.setMinimumSize(QSize(12, 20)) + self.rules_box.addWidget(button, n_lines, 0) + self.remove_buttons.append(button) + + # add statistics type dropdown + combo = QComboBox() + combo.addItems(STATISTICS_NAMES) + combo.currentIndexChanged.connect(self._sync_edit_combo) + self.rules_box.addWidget(combo, n_lines, 1) + self.combos.append(combo) + + # add line edit for patern + line_edit = QLineEdit() + self.rules_box.addWidget(line_edit, n_lines, 2) + line_edit.textChanged.connect(self._sync_edit_line) + self.line_edits.append(line_edit) + + def _remove_line(): + self.combos.pop().deleteLater() + self.line_edits.pop().deleteLater() + self.remove_buttons.pop().deleteLater() + + def _fix_tab_order(): + # TODO: write it differently - check create class + for i, (r, c, l) in enumerate( + zip(self.active_rules, self.combos, self.line_edits) + ): + c.setCurrentIndex(r[0]) # update combo + l.setText(r[1]) # update line edit + if STATISTICS_DEFAULT_VALUE[r[0]] is not None: + l.setVisible(True) + else: + l.setVisible(False) + + n = len(self.active_rules) + while n > len(self.combos): + _add_line() + while len(self.combos) > n: + _remove_line() + _fix_tab_order() + + def _add_row(self) -> None: + """ Add a new row to the statistic box """ + self.active_rules.append((0, "")) + self.adjust_n_rule_rows() + + def _remove_row(self) -> None: + """ Removes the clicked row in the statistic box """ + remove_idx = self.remove_buttons.index(self.sender()) + del self.active_rules[remove_idx] + self.adjust_n_rule_rows() + + def _sync_edit_combo(self) -> None: + """ Update rules when combo value changed """ + combo = self.sender() + edit_index = self.combos.index(combo) + selected_i = combo.currentIndex() + default_value = STATISTICS_DEFAULT_VALUE[selected_i] + self.active_rules[edit_index] = ( + selected_i, + default_value or self.active_rules[edit_index][1], + ) + self.adjust_n_rule_rows() + + def _sync_edit_line(self) -> None: + """ Update rules when line edit value changed """ + line_edit = self.sender() + edit_index = self.line_edits.index(line_edit) + self.active_rules[edit_index] = ( + self.active_rules[edit_index][0], + line_edit.text(), + ) + + @Inputs.corpus + def set_data(self, corpus) -> None: + self.closeContext() + self.corpus = corpus + self.active_rules = self.default_rules[:] + self.openContext(corpus) + self.adjust_n_rule_rows() + self.result_dict = {} # empty computational results when new data + # reset old output - it also handle case with corpus == None + self.Outputs.corpus.send(None) + + # summary + if corpus: + self.info.set_input_summary( + len(corpus), format_summary_details(corpus) + ) + self.apply() + else: + self.info.set_input_summary(self.info.NoInput) + self.info.set_output_summary(self.info.NoOutput) + + def apply(self) -> None: + """ + This function is called when user click apply button. It starts + the computation. When computation is finished results are shown + on the output - on_done. + """ + if self.corpus is None: + return + self.applied_rules = copy(self.active_rules) + self.cancel() # cancel task since user clicked apply again + rules_to_compute = [ + r for r in self.active_rules if r not in self.result_dict + ] + self.start(run, self.corpus, rules_to_compute) + + def on_exception(self, exception: Exception) -> None: + raise exception + + def on_partial_result( + self, result: Tuple[int, str, Tuple[np.ndarray, List[str], Callable]] + ) -> None: + statistic, patern, result = result + self.result_dict[(statistic, patern)] = result + + def on_done(self, result: None) -> None: + # join results + if self.corpus: + self.output_results() + + # remove unnecessary results from dict - it can happen that user + # already removes the statistic from gui but it is still computed + for k in list(self.result_dict.keys()): + if k not in self.active_rules: + del self.result_dict[k] + + def output_results(self) -> None: + self.Warning.not_computed.clear() + to_stack = [] + attributes = [] + comput_values = [] + not_computed = [] + for rule in self.applied_rules: + # check for safety reasons - in practice should not happen + if rule in self.result_dict: + res = self.result_dict[rule] + if res is None: + not_computed.append(STATISTICS_NAMES[rule[0]]) + else: + data, variables, comp_value = res + to_stack.append(data) + attributes += variables + comput_values.append(comp_value) + if not_computed: + self.Warning.not_computed(", ".join(not_computed)) + # here we will use extend_attributes function - this function add + # attributes to existing corpus so it must be copied first + # TODO: when change of pre-processing is finished change this function + # to have inplace parameter which is False by default, + # also I would prefer extend_attriubtes where you give variables + # instead of strings on input + new_corpus = self.corpus.copy() + if to_stack: + new_corpus.extend_attributes( + np.hstack(to_stack), attributes, compute_values=comput_values + ) + self.Outputs.corpus.send(new_corpus) + + # summary + self.info.set_output_summary( + len(new_corpus), format_summary_details(new_corpus) + ) + + +if __name__ == "__main__": + WidgetPreview(OWStatistics).run(Corpus.from_file("book-excerpts")) diff --git a/orangecontrib/text/widgets/tests/test_owstatistics.py b/orangecontrib/text/widgets/tests/test_owstatistics.py new file mode 100644 index 000000000..893f43b4b --- /dev/null +++ b/orangecontrib/text/widgets/tests/test_owstatistics.py @@ -0,0 +1,439 @@ +import unittest +from unittest.mock import Mock + +import numpy as np +import pkg_resources +from AnyQt.QtWidgets import QPushButton + +from Orange.data import Domain, StringVariable +from Orange.widgets.tests.base import WidgetTest +from orangecontrib.text import Corpus +from orangecontrib.text.tag import AveragedPerceptronTagger +from orangecontrib.text.widgets.owstatistics import ( + STATISTICS_NAMES, + OWStatistics, +) + + +class TestStatisticsWidget(WidgetTest): + def setUp(self) -> None: + self.widget = self.create_widget(OWStatistics) + self.book_data = Corpus.from_file("book-excerpts") + self._create_simple_data() + + def _create_simple_data(self) -> None: + """ + Creat a simple dataset with 4 documents. Save it to `self.corpus`. + """ + metas = np.array( + [ + "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", + "Duis viverra elit eu mi blandit, {et} sollicitudin nisi ", + " a porta\tleo. Duis vitae ultrices massa. Mauris ut pulvinar a", + "tortor. Class (aptent) taciti\nsociosqu ad lit1ora torquent per", + ] + ).reshape(-1, 1) + text_var = StringVariable("text") + domain = Domain([], metas=[text_var]) + self.corpus = Corpus( + domain, + X=np.empty((len(metas), 0)), + metas=metas, + text_features=[text_var], + ) + + def _set_feature(self, feature_name: str, value: str = ""): + """ + Set statistic which need to be computed by widget. It sets only one + statistics. + + Parameters + ---------- + feature_name + The name of statistic + value + If statistic need a value (e.g. prefix) it is passed here. + """ + feature_index = STATISTICS_NAMES.index(feature_name) + self.widget.active_rules = [(feature_index, value)] + self.widget.adjust_n_rule_rows() + + def _compute_features(self, feature_name: str, value: str = "") -> Corpus: + """ + Send `self.corpus` to widget, set statistic which need bo be computed, + run the computation, and return widget output. + + Parameters + ---------- + feature_name + The name of the statistic, only one statistic is set + value + The value if statistic need it. + + Returns + ------- + Resulting corpus. + """ + self.send_signal(self.widget.Inputs.corpus, self.corpus) + self.wait_until_finished() + self._set_feature(feature_name, value) + self.widget.apply() + self.wait_until_finished() + res = self.get_output(self.widget.Outputs.corpus) + self.assertTupleEqual((len(self.corpus), 1), res.X.shape) + return res + + def test_send_data(self): + """ Test with basic data, and empty data """ + self.send_signal(self.widget.Inputs.corpus, self.book_data) + self.assertEqual(len(self.book_data), len(self.widget.corpus)) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.widget.corpus) + self.widget.apply() + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_words_count(self): + """ Test words count statistic """ + data = self._compute_features("Word count") + np.testing.assert_array_equal(data.X.flatten(), [8, 9, 11, 9]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_characters_count(self): + """ Test characters count statistic """ + data = self._compute_features("Character count") + np.testing.assert_array_equal(data.X.flatten(), [47, 44, 48, 51]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_n_gram_count(self): + """ Test n-grams count statistic """ + data = self._compute_features("N-gram count") + np.testing.assert_array_equal(data.X.flatten(), [10, 12, 13, 12]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_average_word_len(self): + """ Test word density statistic """ + data = self._compute_features("Average word length") + np.testing.assert_array_almost_equal( + data.X.flatten(), [5.875, 4.888889, 4.363636, 5.666667] + ) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_punctuations_cont(self): + """ Test punctuations count statistic """ + data = self._compute_features("Punctuation count") + np.testing.assert_array_equal(data.X.flatten(), [2, 3, 2, 3]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_capitals_count(self): + """ Test capitals count statistic """ + data = self._compute_features("Capital letter count") + np.testing.assert_array_equal(data.X.flatten(), [1, 1, 2, 1]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_vowels_count(self): + """ Test vowels count statistic """ + data = self._compute_features("Vowel count", "a,e,i,o,u") + np.testing.assert_array_equal(data.X.flatten(), [19, 20, 23, 20]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_consonants_count(self): + """ Test consonants count statistic """ + data = self._compute_features( + "Consonant count", "b,c,d,f,g,h,j,k,l,m,n,p,q,r,s,t,v,w,x,y,z" + ) + np.testing.assert_array_equal(data.X.flatten(), [28, 24, 25, 30]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_per_cent_unique_words(self): + """ Test per-cent unique words statistic """ + data = self._compute_features("Per cent unique words") + np.testing.assert_array_almost_equal( + data.X.flatten(), [1, 1, 0.909091, 1] + ) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_starts_with(self): + """ Test starts with count statistic """ + data = self._compute_features("Starts with", "a") + np.testing.assert_array_almost_equal(data.X.flatten(), [2, 0, 2, 2]) + + data = self._compute_features("Starts with", "ap") + np.testing.assert_array_almost_equal(data.X.flatten(), [0, 0, 0, 1]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_ends_with(self): + """ Test ends with count statistic """ + data = self._compute_features("Ends with", "t") + np.testing.assert_array_almost_equal(data.X.flatten(), [3, 3, 1, 2]) + + data = self._compute_features("Ends with", "et") + np.testing.assert_array_almost_equal(data.X.flatten(), [1, 1, 0, 0]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_contains(self): + """ Test contains count statistic """ + data = self._compute_features("Contains", "t") + np.testing.assert_array_almost_equal(data.X.flatten(), [5, 4, 4, 9]) + + data = self._compute_features("Contains", "et") + np.testing.assert_array_almost_equal(data.X.flatten(), [2, 1, 0, 0]) + + data = self._compute_features("Contains", "is") + np.testing.assert_array_almost_equal(data.X.flatten(), [1, 2, 2, 0]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_regex(self): + """ Test regex statistic """ + # words that contains digit + data = self._compute_features("Regex", "\w*\d\w*") + np.testing.assert_array_almost_equal(data.X.flatten(), [0, 0, 0, 1]) + + # words that contains digit + data = self._compute_features("Regex", "\w*is\w*") + np.testing.assert_array_almost_equal(data.X.flatten(), [1, 2, 2, 0]) + + self.send_signal(self.widget.Inputs.corpus, None) + self.assertIsNone(self.get_output(self.widget.Outputs.corpus)) + + def test_pos(self): + """ + Test post tags count + - test with corpus that has no pos tags - warning raised + - test with corpus that has pos tags + """ + self.send_signal(self.widget.Inputs.corpus, self.corpus) + self._set_feature("POS tag", "NN") + self.widget.apply() + self.wait_until_finished() + res = self.get_output(self.widget.Outputs.corpus) + self.assertEqual(0, res.X.shape[1]) + self.assertTrue(self.widget.Warning.not_computed.is_shown()) + + tagger = AveragedPerceptronTagger() + result = tagger.tag_corpus(self.corpus) + + self.send_signal(self.widget.Inputs.corpus, result) + self._set_feature("POS tag", "NN") + self.widget.apply() + self.wait_until_finished() + res = self.get_output(self.widget.Outputs.corpus) + self.assertTupleEqual((len(self.corpus), 1), res.X.shape) + np.testing.assert_array_almost_equal(res.X.flatten(), [7, 6, 4, 6]) + self.assertFalse(self.widget.Warning.not_computed.is_shown()) + + def test_statistics_combination(self): + """ + Testing three statistics at same time and see if column concatenated + correctly. + """ + self.send_signal(self.widget.Inputs.corpus, self.corpus) + + wc_index = STATISTICS_NAMES.index("Word count") + starts_with_index = STATISTICS_NAMES.index("Starts with") + capital_counts_index = STATISTICS_NAMES.index("Capital letter count") + self.widget.active_rules = [ + (wc_index, ""), + (starts_with_index, "a"), + (capital_counts_index, ""), + ] + self.widget.adjust_n_rule_rows() + + self.widget.apply() + self.wait_until_finished() + res = self.get_output(self.widget.Outputs.corpus) + + self.assertTupleEqual((len(self.corpus), 3), res.X.shape) + np.testing.assert_array_almost_equal( + res.X[:, 0].flatten(), [8, 9, 11, 9] + ) + np.testing.assert_array_almost_equal( + res.X[:, 1].flatten(), [2, 0, 2, 2] + ) + np.testing.assert_array_almost_equal( + res.X[:, 2].flatten(), [1, 1, 2, 1] + ) + + def test_dictionary_statistics(self): + """ + Test remove statistic from the dictionary when they are not required + """ + self.send_signal(self.widget.Inputs.corpus, self.corpus) + + self.widget.active_rules = [ + (1, ""), + ] + self.widget.adjust_n_rule_rows() + self.widget.apply() + self.wait_until_finished() + + self.assertListEqual([(1, "")], list(self.widget.result_dict.keys())) + + self.widget.active_rules = [(1, ""), (2, "")] + self.widget.adjust_n_rule_rows() + self.widget.apply() + self.wait_until_finished() + + self.assertListEqual( + [(1, ""), (2, "")], list(self.widget.result_dict.keys()) + ) + + self.widget.active_rules = [(2, "")] + self.widget.adjust_n_rule_rows() + self.widget.apply() + self.wait_until_finished() + + self.assertListEqual([(2, "")], list(self.widget.result_dict.keys())) + + # dict should empty on new data + self.send_signal(self.widget.Inputs.corpus, self.corpus) + self.assertListEqual([], list(self.widget.result_dict.keys())) + + def test_context(self): + """ Test whether context correctly restore rules """ + rules = [(0, ""), (1, ""), (2, "")] + self.send_signal(self.widget.Inputs.corpus, self.corpus) + self.widget.active_rules = rules[:] + + self.send_signal(self.widget.Inputs.corpus, self.book_data) + self.assertListEqual([(0, ""), (1, "")], self.widget.active_rules) + + self.send_signal(self.widget.Inputs.corpus, self.corpus) + self.assertListEqual(rules, self.widget.active_rules) + + def test_compute_values(self): + """ Test compute values on new data """ + data = self._compute_features("Word count") + + computed = Corpus.from_table(data.domain, self.book_data) + self.assertEqual(data.domain, computed.domain) + self.assertTupleEqual((len(self.book_data), 1), computed.X.shape) + + def test_append_to_existing_X(self): + """ Test if new features are correctly attached to X matrix """ + data = Corpus.from_file("election-tweets-2016") + self.send_signal(self.widget.Inputs.corpus, data) + self.wait_until_finished() + statistics = self.get_output(self.widget.Outputs.corpus) + + self.assertTupleEqual( + (data.X.shape[0], data.X.shape[1] + 2), statistics.X.shape + ) + + def test_add_row(self): + self.send_signal(self.widget.Inputs.corpus, self.corpus) + self.wait_until_finished() + self.widget.active_rules = [] + self.widget.adjust_n_rule_rows() + add_button = [ + x + for x in self.widget.controlArea.findChildren(QPushButton) + if x.text() == "+" + ][0] + add_button.click() + self.assertListEqual([(0, "")], self.widget.active_rules) + + def test_remove_row(self): + self.send_signal(self.widget.Inputs.corpus, self.corpus) + self.widget.active_rules = [(0, "")] + self.widget.adjust_n_rule_rows() + self.assertListEqual([(0, "")], self.widget.active_rules) + + remove_button = [ + x + for x in self.widget.controlArea.findChildren(QPushButton) + if x.text() == "×" + ][0] + remove_button.click() + self.assertListEqual([], self.widget.active_rules) + + def test_input_summary(self): + """ Test correctness of the input summary """ + self.widget.info.set_input_summary = in_sum = Mock() + + self.send_signal(self.widget.Inputs.corpus, self.corpus) + in_sum.assert_called_with( + len(self.corpus), + "4 instances, 1 variable\nFeatures: —\nTarget: —\nMetas: string " + "(not shown)", + ) + in_sum.reset_mock() + + self.send_signal(self.widget.Inputs.corpus, self.book_data) + in_sum.assert_called_with( + len(self.book_data), + "140 instances, 2 variables\nFeatures: —\nTarget: categorical\n" + "Metas: string (not shown)", + ) + in_sum.reset_mock() + + self.send_signal(self.widget.Inputs.corpus, None) + in_sum.assert_called_with(self.widget.info.NoInput) + + def test_output_summary(self): + """ Test correctness of the output summary""" + self.widget.info.set_output_summary = out_sum = Mock() + + self.send_signal(self.widget.Inputs.corpus, self.corpus) + self.wait_until_finished() + out_sum.assert_called_with( + len(self.corpus), + "4 instances, 3 variables\nFeatures: 2 numeric\nTarget: —\nMetas: " + "string (not shown)", + ) + out_sum.reset_mock() + + self.send_signal(self.widget.Inputs.corpus, self.book_data) + self.wait_until_finished() + out_sum.assert_called_with( + len(self.book_data), + "140 instances, 4 variables\nFeatures: 2 numeric\nTarget: " + "categorical\nMetas: string (not shown)", + ) + out_sum.reset_mock() + + self.send_signal(self.widget.Inputs.corpus, None) + self.wait_until_finished() + out_sum.assert_called_with(self.widget.info.NoOutput) + + def test_remove_function(self): + """ + This test will start to fail when version of Orange >= 3.27.0 + When this tests fails: + - removes `format_summary_details` and `format_variables_string` from + utils.widget + - replace `format_summary_details` in statistics widget with the same + function from core orange + - set minimum orange version to 3.25 for the text add-on + """ + self.assertLessEqual( + pkg_resources.get_distribution("orange3").version, "3.27.0" + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/orangecontrib/text/widgets/utils/context.py b/orangecontrib/text/widgets/utils/context.py new file mode 100644 index 000000000..fe383c866 --- /dev/null +++ b/orangecontrib/text/widgets/utils/context.py @@ -0,0 +1,28 @@ +from Orange.widgets.settings import PerfectDomainContextHandler + + +class AlmostPerfectContextHandler(PerfectDomainContextHandler): + """ + This context compares both domains and demands that both domain matches + in share_domain_matches (e.g. 0.9) of variables. The position of variables + (attribute, meta, class_var) is not important since widget that use this + handler do not use their values directly. + + Attributes + ---------- + share_domain_matches + The share of domain attributes that need to match. + """ + def __init__(self, share_domain_matches: float) -> None: + super().__init__() + self.share_domain_matches = share_domain_matches + + def match(self, context, domain, attributes, class_vars, metas): + context_vars = context.attributes + context.class_vars + context.metas + domain_vars = attributes + class_vars + metas + matching_vars = [var for var in context_vars if var in domain_vars] + + return (self.PERFECT_MATCH + if (len(matching_vars) / len(domain_vars) + > self.share_domain_matches) + else self.NO_MATCH) diff --git a/orangecontrib/text/widgets/utils/widgets.py b/orangecontrib/text/widgets/utils/widgets.py index b06fcb5e4..effdb5c1f 100644 --- a/orangecontrib/text/widgets/utils/widgets.py +++ b/orangecontrib/text/widgets/utils/widgets.py @@ -7,6 +7,8 @@ QGridLayout, QCheckBox, QStackedLayout) from AnyQt.QtGui import QColor from AnyQt.QtCore import QDate, pyqtSignal, Qt, QSize +from Orange.data import DiscreteVariable, ContinuousVariable, TimeVariable, \ + StringVariable from Orange.widgets.gui import OWComponent, hBox from Orange.widgets import settings @@ -565,3 +567,66 @@ def load_provider(self, path_to_file): self.resource_path = path_to_file self.valueChanged.emit(self.model_path, self.resource_path) + +def format_variables_string(variables): + """ + A function that formats the descriptive part of the input/output summary for + either features, targets or metas of the input dataset. + + :param variables: Features, targets or metas of the input dataset + :return: A formatted string + """ + if not variables: + return '—' + + agg = [] + for var_type_name, var_type in [('categorical', DiscreteVariable), + ('numeric', ContinuousVariable), + ('time', TimeVariable), + ('string', StringVariable)]: + # Disable pylint here because a `TimeVariable` is also a + # `ContinuousVariable`, and should be labelled as such. That is why + # it is necessary to check the type this way instead of using + # `isinstance`, which would fail in the above case + var_type_list = [v for v in variables if type(v) is var_type] # pylint: disable=unidiomatic-typecheck + if var_type_list: + not_shown = ' (not shown)' if issubclass(var_type, StringVariable)\ + else '' + agg.append((f'{var_type_name}{not_shown}', len(var_type_list))) + + attrs, counts = list(zip(*agg)) + if len(attrs) > 1: + var_string = [f'{i} {j}' for i, j in zip(counts, attrs)] + var_string = f'{sum(counts)} ({", ".join(var_string)})' + elif counts[0] == 1: + var_string = attrs[0] + else: + var_string = f'{counts[0]} {attrs[0]}' + return var_string + + +def format_summary_details(data): + """ + A function that forms the entire descriptive part of the input/output + summary. + + :param data: A dataset + :type data: Orange.data.Table + :return: A formatted string + """ + def _plural(number): + return 's' * (number != 1) + + details = '' + if data: + features = format_variables_string(data.domain.attributes) + targets = format_variables_string(data.domain.class_vars) + metas = format_variables_string(data.domain.metas) + + n_features = len(data.domain.variables) + len(data.domain.metas) + details = \ + f'{len(data)} instance{_plural(len(data))}, ' \ + f'{n_features} variable{_plural(n_features)}\n' \ + f'Features: {features}\nTarget: {targets}\nMetas: {metas}' + + return details From faee8b16b379dda73d1d5b272ecba52c6e1a3c86 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Primo=C5=BE=20Godec?= Date: Tue, 17 Mar 2020 13:58:58 +0100 Subject: [PATCH 2/3] Lift minimum required version of Orange --- .travis.yml | 2 +- requirements.txt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 42d238e14..a08698726 100644 --- a/.travis.yml +++ b/.travis.yml @@ -28,7 +28,7 @@ matrix: env: ORANGE="master" - &orange3-21-0 python: '3.7' - env: ORANGE="3.21.0" + env: ORANGE="3.24.0" env: global: diff --git a/requirements.txt b/requirements.txt index a9aa22e95..29ca04a1d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,7 +6,7 @@ docutils<0.16 # denpendency for botocore python-dateutil<2.8.1 # denpendency for botocore gensim>=0.12.3 # LDA's show topics unified in 0.12.3 setuptools-git -Orange3 >=3.21.0 +Orange3 >=3.24.0 tweepy beautifulsoup4 simhash From 964dd6c3b8e1da427db8d650bc60644b4c269e35 Mon Sep 17 00:00:00 2001 From: Ajda Pretnar Date: Fri, 17 Apr 2020 15:22:08 +0200 Subject: [PATCH 3/3] Statistics: documentation --- doc/index.rst | 1 + doc/widgets.json | 7 ++++ doc/widgets/images/statistics-example.png | Bin 0 -> 158014 bytes doc/widgets/images/statistics-stamped.png | Bin 0 -> 7608 bytes doc/widgets/statistics.md | 44 ++++++++++++++++++++++ 5 files changed, 52 insertions(+) create mode 100644 doc/widgets/images/statistics-example.png create mode 100644 doc/widgets/images/statistics-stamped.png create mode 100644 doc/widgets/statistics.md diff --git a/doc/index.rst b/doc/index.rst index 4a4f31b9d..9eaff9fca 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -26,6 +26,7 @@ Widgets widgets/docmap widgets/wordenrichment widgets/duplicatedetection + widgets/statistics Scripting --------- diff --git a/doc/widgets.json b/doc/widgets.json index dd0fa18cf..8a082cf7d 100644 --- a/doc/widgets.json +++ b/doc/widgets.json @@ -146,6 +146,13 @@ "icon": "../orangecontrib/text/widgets/icons/Duplicates.svg", "background": "light-blue", "keywords": [] + }, + { + "text": "Statistics", + "doc": "widgets/statistics.md", + "icon": "../orangecontrib/text/widgets/icons/Statistics.svg", + "background": "light-blue", + "keywords": [] } ] ] diff --git a/doc/widgets/images/statistics-example.png b/doc/widgets/images/statistics-example.png new file mode 100644 index 0000000000000000000000000000000000000000..7afa3a0aeba8f0ce826e320977ff8ee88650f7c4 GIT binary patch literal 158014 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%0D;s~QYEDmp>)$tO zU~1Owjn@X%DF8>jMd+618~9DTi2FC~rX)~mf{;j35ngpkt8G*P!{V2YgpXenUbU*v z;)YmE>}fKmnGqO!~4AgcRsK9QJLDO>1_lDf=hFu zFTq1U?b@4)CCvui@3h|n?ARsac_8qKSsV(+$Qdcdofvl1?s7Sb-oH5wMQI4k?w*e= znyP7S*&6hOd?~N3p@sNC+*X3xe&0F!h$fwg-$p=f9#P3mC(CR&tar@A#*lgmEWwvMGn--lg*5y&rJYk^s{3oh1uzEr_PS+mQFfff;IR52 zwb|Wq6D7=hr@8#}_Fba1N0o>G&Y!&BV31xGEO~)b2^{YB;Kn8KTBFEXdAQs*=<9Bb zzPI5?b5>8g;mQq)YRq?YLd{kXfM>r~ADS)3R5?rRD`MU1l`*57V*(Fi!dT5TG0NB4 z9JoRF^}7)OpIwD`og@J5K;K5w>&tTS)-2zC)SP7hQm)~JC=!aZYu5`_sbQ{26HV0S zh(I&~S@Z7O{ij$Fte|Yly@tMh>k|+8ae-y>MGQ_BQ$HR?>Y=q>31L43010DzPD_Fb zMW$$y89UCfpXL_wy*t-N?gIMenpmrSW0$V3m&ZRKjzO1x|78yZRIgpKss}|cV1Qm$ z+0~yr3;Pbff|9@Rq%?L)@$}3=v9=l~o8Mkt*<~j7mJ=R97TxG}$b-rec7qugsjF;m zu0>f>NXsIREB^UoeT#%aGm?`!8W|IerG>CGt;aOsBr1*auTntxY5OS(C&@#s+q#n^ z;u`a7l_SK1O{$9XuKU)Bo|{;8>kXD>F)x@SG2z03=;cK?(Ik1`Y@X5@VbDP4ubZ^zZGL0iSm>WQJW>v zjKFcNMEwflWnVuHKkr#*B|5B=HfTGDzw_VYAMG{3Zxh5p+1BG7eV&G)Z$5lYV5lg> zZx5gjOwN4h?HXrjjCMt$L-&iV7Iy_~r9B}{?|qT{C?VO858LDJ7koVJBM1zX_J|6; zR6`%_)i4&mKP7}9H^#qgyowyUKRnSpCSZ%e8>LaXQh;Ku1(Z|~ued>(hF@uFu>xNz zcNk_cv0~W0XIm)8^RyrF@3{gOxkn2bu{+G&Q5JXpXe763>>i*be?XJrd>b35)ofVr zVkAi@ttLjB8${e(mJ4P125nuCu>cs_>=7f4lO{0fZf(SC#S@EcKeXMp734LR(0r53 z%Zkw9Pkne#&PWdM7rDmVkm-NeniS;y4T-za9V`x79Vx>A+qZDm32VrqZ@dLr`MFJO zVvvJyylyZv@q7?6g91KjfPL)VRt{wymc%?VjwGKLTGG!|`4QX=k^j5l^wB-&&Qdy$ zFy!=Irt`OPHgQmjaF7{Tdddyk@Vx#kyg?OHZW!p^CV=u_yhk-%Fiz?lQ@`QA+Te8k z{zjTRgt0su9%IYv5Cs$28|)guoPPV)Cq9{X{CarIU4egZg;Yn1+eHYyf+r^a(PT2< z_P+fFE=(lqok$kE1;+Vqg0Wm4oHowW`n;*_)96zt6s4c>t>|rNi7>qnbf_g4g&S(g z;VYRMF)j??WH};RAdiIip2`DO7of?T_l&6754NB-9v*32=at zceIp43?TmAzesfy1-?1KSYcZU+#su6Np@qkk$+Qe5i6UIr(4{C`gapWqBXkrsW-`a z6s|#7p!UX;398{V0^9!pLXFzYYJ{7s!*}Z2qKkx7plQ_3kJQCxx1NFv`=6FTAltkW zqG32bAPvD1_FQ@t!wd zY*Fo$X%Ons)YB8r7@kt7S{|t2i{_2p=Bp_A(tJdTW17Gm!KFeKjw0LgnQEdNPBd?| znVMxAW3YtGk6ME@z!t!KIGNQvL_?ib?k6)zKPJr&hl3jhh@!zX>KmqaqZOBStpzff zGFb%WPQQ6SwfKz1*ol2p|0;R|I79)yJC2`T`pU&SBBB|K7#pvGe5uK@KZ`Ek%QTLM zBhfbhI<0!gRycDtkGMV6UHW8Y<+|l&;pRA)Zx#_7{b`JskJo)ApFm$;yU=n_HnVrI zv}@B?wv(*}wk9KSK_?k-7o5r%@T>q$E)1IYHa$nOp@d?Iqw1DXB)eY@jhro&H$+uK zf;nHqosp7u?q)5S^HO#FaJb;4z3-zoA0qXnx;Bof9yS8U-JvT%Y$|+8DLlsI56rg* zi3x-s(8dQ^q^b}k`4~kN10ENX+0)FWgP;(+&b9>~M!^j>U znhRBYa*T0rVRWfhAXr?{u$KVUF2dIQ1kbdfkjV3eb*e9GUO_(!8oyfC18#1KQ=T~| zA$OK9&Qgg@n+^K9k=Ly6p>ODSC=NWm9n0ucK;Ll<6u*b!i4lOrQ2p<9egP78t1&Ob zG%ySSoR|@VEpkSy*LgN0IwCVY6^G7>c1B8TUq7yKHJzC zIu9D>^F4|HB|k8ROaA6mB^nf2neG7hCl{SkqTl-ekt@%`-NZk-Ie`Zh3!I>aZ!sVpo_ax)F{U%n0@O zgxpA%#S}OxF}hE=)knjjEC8t;Mg_hQDS(}-`Wi54wOKpAP6eudrg5)kRqaV>tc)30 zC?=lVYEdK4t2Qf?kUFY)gY0_zi? zfgJ>$MB=wk0rQ3Sm?S!1;O)FOWNM*NoW=9de?`AbCt4D=3l+-Zos^LNyt+CJW*9B* z|Lq(5-4jP}0P@p4CIzAffQFK=B6*B&^b>b6TSlf>_PO7t>Wso>qz;&(eNP-~$h9tMlITB1Qkf5% zFn}G-@X&)e3lF17gnTOz26dG6C}}&u@=n_~`qyuy!`GjBpw8!?-ky{1O>3VpZ09*M zcNj{;oLJB5wUk%ZaO53r7iT;H86^>%IVZzb5(3mj+w!14%geDWR;3%G+Xdl#3n#WoDYx*w{FIIljR7m`u z>K06K?=LRK1mKJ4*&gJy#H#RBncoP{eo3_C4QMBl+l&?L6cqnio*sD8yY{_n-rrDq zPK|0KMfp5*^5CK=_yqIr9HGO&wm{cHX3bul!@U~rp#TAfDwUMrkb~=2&qJyaTlEwZ z;}l&Jv489))*m&yi~MDg374pAYuUtC^vY$C9ADMkwxb2HNr0T>7MnMYl0CH=+#}&b zI|%TQ=@5}1Uw;2B30a%-5T8~@3r1e`QdQ32`M>ysXOEGQq;S>H5sDm(L0BM~Wa*2TPrl#yIEY)@S;?chgp*<97!T7@gEfZbG6D=8Jy`F#`}{ z53`krU=`gOZ&vM|cKVUr7_TrR-)wdCre8c-$9pc#c1eG@Nssz|0+DN$ecHc0d{iTM zQ9z0Tu!7`}iS!k0g0sIJ^~5%hEE#VGHSG)-E9rF*?SghWISbb_1= zU1`ON{RQM@k9)2{-oP)fH3v%UwC2cD)HfA?7{4iD$5Z#sNPV+cFlBK(I;u$0(b)Sr zU)CLF8PDHYThqN#HvvyS-Ol$S`UCb*-ns{MT5(PH{Pv0`CCtc{4jxIsFy7Ub@3lul z+5CGDn(txkWg77C- zpIf?67S-OK3)g3M0Sf1^;Nj7sQxUfy!#Up-B>x67-O2Aj?P0^FRRf7-Y!-aX?NP$j z@8WGR-v<;lmjt;6a!{Rqj`yg$J3MoEIv~JPR#G%#Jg;~i7(HX=zjEEmRFd29H;VPj z^_1Lx>>b5!6Ag^og9O<*WEU$i<&FeMMdYyA8SCQC89`QcdmsG56|&t%u4Y(s+zu1e zm1wW2lybK+ZHep&f2T~6;>MKLQ3apC>d;2scT&q6AW`{CQ*|28I<^e2W3Nwbelw8V zv4DF!EiMHO#OF;%gVCh#p3}487tlg)w^y(D**xi|OPd%y3Iibd*w}{*unELyCQA zDdr}vcBMF+tczD`zEld0j>H?Xsjz7@>9(h! z46;VQh`Ub}n`#*N@h}koxTd>87wj>~C^oBf8v31>@P7-?CVCsa{P=41L%r|p3&e8H zezi+(7qsNZG^O9xV6@k+Y6FR{Y~627ewkx|6a}WWE}iv1as{yIgcbOQ%Im#U8O~3} zi{t#0u9J3QB4Kn9DNg9MMZuJ@QAlVHNC6Y{i+)P(=W#UP^ZmWNu3VkR4@(C+#y`l4 zHGJH)6PlWu*XXws;{CCbHW`Ism7mYxc)qiWsSF??fMaCqV^=Kk6wA4Nh(75yJYgW9x#@E-X|?k_SZgA0hY-&b03vas-Ef6=V= z0$lw+aS8=!l0;s8a@E(a#Q|`vm`i9>^MI zw=`DSTmgmZ`p5sRK?VwIrB6_d##UjmwZNUw#$dSWUJBg<5p+kzlKmxdb10nHQCKxw z5%UmO&;Cz|ZbWVlufU62f9Uyv8TdYo*w%;LGTUv3Ofib4?3Mk%Y0o&@9rvG$`S}i%U zMp{<3bC_Xm>^n_|648H3j6nrlq1fp2Ip2_*Fu;80&BAr~kn6}@`Lje)W{y87q1$NNK%shppw7kYKbAo$C>msl~ajlEHe* zPuyVzhdp+y5GqpmN+3QX4j*AED`Ue$91CP1fwY%;5gWm><$j)A6nB*~z&g4ZYtM#) z{yTY3_w0&ei=8Bc@=QrYa%}qNWj^cxC7dxXq!KUH1NF7@ZAf{uT7CS~*pzC#kU@nHa!R+mE~Z~caMUav*d7|Nu60{~?7)l38)C!y+@xqs z>#-#R1ykd18z#&rG7bmVPb_YuK4l>E%NvbKCp*3&<=1#Ft+Yfkd^$iCQb%w8bsuC@ z8!GEoGcW2AEpq5~Wd*|WsS9D=$fLVROnz4!qUv)T6FW0?{J6sWh9u+5ye}!db_9DT ze%$cwWQ_JF_*OoYXY+gigHC>KkPC|+BT)HBLASt4a&&U>O0`73MAd&Rv>t@_ksS>b zT;xCbuy?tZhuYoyGz_@lhz6YZw}{v#>4(LOVfOt+R3LniSH{b{HtGo&e8QRTq`H-1 zmUf1<9N%BA3XFc*YrqQJi+P-+hF5+JEyB0FN}w4~I?)py(V3=-=}f-VU6~f>ccl`$ zJ^@`#qLbxmtNVPt32VwxFU0N)H$~qE=RQlV4@(KXshy$A-lYT%W?U?B_$;=~f=Ns^ zS{npAEFcx2Ks`jUGbV}&+C@$WspZGqigJs_8QxmT;jqQFHkvhXt8SVF4D3<=oawrY<=&)v=-0I#DK(4 zx<%vQdc(VB^`<0aGED<+2&4KgO-j69y5FsJOb>_+)1}{xEd*oUfg9PR7M*jHL(Eok zxV%5xm0bP)#K(USzJv6=L0zRKVH=EqZOKhp?jvm4?}kLEk|li|e1gz@K@=OBMu?kqdGVDih7 z2j>Kc`uIF5tS6K)5btrJ#(906!kY#g8WK{QqJ5NIA zRX1WcnZD7zdUvl%#eUg0k6=5>!HsqJu3K+Li^N&_0)1vmzun0#(8HC2Lkrer-emYB zNp0Cc?cU4^gqb9DF8yo z^Qqw{O4p9&cJpV`+hKDvKD@LkirZx0(Icyg?zbOxWS+CT%;d7EzfCZVE;GE>F?!@y z*S$<=!D{PzRuj3rG1gDxfjbK}Ufy$ENZz(2&VJd~u9r|ZEA0{txnZ_`Dv#Gc-cJ#1 zg4lDm)&9P}Jk)Zk^>?R&b|({-Reej)m`eMEIciW`9VKZj%A?+Zij9c1 z;V{v}KyGxS)yAwFT^}7qSx*-%hl0DQ+%47xRE5?OOiCqzXBZQk^%5x*%Xr`ZT znL%<~KmjQUrD259j4~K( zG)Sj~v`9UX&VjU!5hGQaksF;718Es8^?d@qKELJuI+n0YK+Y7b05CIlojqxJcqBYH2V0cLMmGD?R4O>bcq$5#=6hP1^%!YSBv-w0V zs6~pqQ)~$)&@+yd4+V7tlUGr%ynV@xU{sKKroHX_c`te0FSgQZBPx~gK($Ve5CpY5 zEU!HKcNIZT<0DsFh1;!vVYlrf?k*mu@rNGhkS*SUWwVHS*uLVwU_6YBx9y+UR5VsK_EW~umiAO#g>cTl9ip_1RsIbR-s-vog>DiL#Y5eS z<1&fPr3-2}aIc)WY~FF|<|RsL#2d>$rpl+sEM$tcjd#3TdOPp10-ow0FGz zB|3^f;%ivMdU33+Cq8RB+kWSl8ctVys+(Ov`3DaJY(+M8)37eX+P)B+edP^efJ2W} z$6P2)2WPb{mMG;sn@ES)tqiG)5V#em14F;R>Gckck@7ZlT|K951mkT>E_+i)`}d?3 zdIu4(vFR1y<=tK2-7+xHxlhi*A%wWK<`I_^q1bAEMqbY{vg+}l75M_C(=A(Qcu^xJ z=DB7GgcjgpbrMS<+P+9Cbt!Jx_>(GGw)Q3dlU31mn15;I-Q7i(oTi=2W6Nu2a?e8O z_9Mxohc?T#)$!*{8MM9@vf=PiNt+Jyn@1Two+VO{p%+IIDkG5(LC_F%qD1l9%j5&i z-!ozIU00WZ?z@N~iQWCiipBSWs|7a}ht`3Y83J@>vx{>m`5uxZqY-71?i9+KVyCHj z%w_&A$M`531wyBhzdvsF$WN+tz6Pd;AKp*ZY~8Ckmjnpk|F%Z8+OA#Id=zJ(jZN$n@!xkQ_{c$qS=&1yZa&j>Ic+!Xc@ zi`YUu^Hg(^T{UokA579vYV9A2dw<5!#vXn6Qu8S9F*ve}l zte3!PG&`<7?Bi}}%4<|e6q3(%85e&nX>d4c58z7|=r)xH}KB1bLq}9?$<+mpNqi<)IbB1&8Eyh^Z z^VeRp$qH}HPjk;3`#)Pfb=IQxgv=o$B8Cb5nEhT;pps_*Vx&}eUL5jvxMQV^xjYt< zxb7K~iHZpisE<^zmjk$+gH^rBD8$J)I(xfu;ws%!$uCkPZG8*zvfNPO*m(vrVC?N7L3d+r|He`Yiqo( z;(OUr8SGub9iRr_dKm$nIAmbneUK_{xJQlNSQJ^(jK=8tar310UR8BvNwH2Nl9wRl zpGe9FuE(kU6`~4}TX(0J_^r{r8*LN}&(ikpP1o|&7DygU zkuj1)ncP`!&Fb^Ci*7F6+Z~`CDd#4BI8xHK@F1#od=iYE>2kQurbZz_!L zj}~5e&PKlXPk9cZ5}ma?pR%+P`LcEA6{KgU(xvF0Tj*8OZkLD- zppwTavRZyCZQ`3;FGxyi%6C1blARye`6N-dNi)-4_ery}VzD=(MQiX`3S3O8g{;%R zehXQlpV7MI7Ix#l6198Gy)$T6E=rvG}XjENE8qy&{U_C*Y#3$y3r?8~G^ zZ()`e_PI823-J|1@1+MvQ*=@1|8CF-pxy>}N3R^98s}xTGc}1uvO@edT2?nGvlX_t zGdF{f{yF<|+@sG$!T`d%k%`Co{*-0cKKc3tlRhp6r}t`x- z5w}JvvqcV}%aKOHWqA2k!Y|v?U@jUcd+)gXBg(CZM6q~Vk}~yh_I|vkQr4`lf@jsqxO#f?YDxHezWt8LG=Zqkf9=ir}reYCYcN zI)MJgrm+O1F`BTdE%PDui&n&_Yk|v@=fZNAWi%7r(?g_E^EvM}o*BX#=^G~daXJDy zl_@%a9|D&7jo$z{_p(k!O8}bOr0D2btYsjn{akF;Mn%9q*?3j^7@qV_OOq^&1vS6F zOx!4^F#?-J6OrmM8^=;7I(u6tto&(3RtnvN+%EI5FVAdc&KHffA(4_22NYodTbH(M z4O{d}OQ2QCN{ZCP9g`M}H^W}V9cL^j4Ie@-$##=R+U8zVyA1&rnH~A1s zXpKkilG}-X&rMR04atA6g=6b#ebV@;wIZV(5s-&kZ}oGoFsk2>kep3}XJ5`+ZJYAv$q83}~Vz8ta@T@e`|IqE4w z$J?i0Cfgf%DpVWgXTSXqLJGude}{_{nZtxfHDM`se==<^lc*VBhp+cL%=tlDM}z~h ziq5^mPiEB=_s7!(CNKbKechbP%x0gyv+jIT-ERQYqA#&bIa4b_i{WGGA#iBA zTC3Pqt^fEB3bk8p9$RgnRG%?q-I+dW&IIWuXsWH=T?umq~Wkp={{fmK2Re=Ub=$VZn%jK4H{{dTR z@PIp_y-E#QzM&>Aq+XL{$wVC#G z{j?CeM^WVBp=QsZ`iH~6&e!EwWN?~ai4rVYe?R<XDh&cZ7|(HO@C zy;?%Wb4*Dfkv8IYA+lC6y9dR_MhBR$w%>8%D5u7urq&mBw!~WEXs*q})MirNRIi%% zVu3$}F+esbk+v*DY~T^jHU04&H9>_~DzL)^XEAK{|Mmn(6gH#=Tc*XG z;a_3=s_(P&@9&*b#OqMZg&(Fm|}`MynJs2^VRx&du>JUwKwAzTo1VU3JZV zhV+LvVs4AMIU+ydbH&Q#j<43u^>GOAAo8){hGeCN2qR?th5vY_5KO`CrYZS>2Ko1I5ODe%tVk%2j<#4gZg3l1+EC3RLTu~HtR!>EkP%IZT|H|5MBkD6-Rm%42UY0~YIt~zyod>TV04HTe_$H1Rf&?qhtQ>X5vfumfP047$ zl{$zVv&E9i4Km*B)i`c%KfHbAf8Q=$^SJ+ntds-~$HYXpy3n>+f$r2vz#VG8a6{RDKO0Z8!csb_YN_83YG( za{V)v>%JzTnmuJx@DRKG6zIRrx=rhCSt|S@xE#DeagSrGA3kEXn!59^DGxPBA zy7`QF4)N8a>UzCc$hjsD4_)li*W!c~L(H{G53WRzc{_sKy|YU?)BIpd8uPSb9wQa2 zn$rv(gOjH+U&Fl2?c11Lr)Gj8KEynx0x2J#F1~+rrfy>KNlB>^jNYRUeGVz%eAFQW zB(iCinE-oT>=vkLX`5CIwMIG-SlwCS{~cN<5qHP)H^&M5H{=26#jfQu>fPQJp1yG$RqJ~1(TOIgl?dqs4*<{IK;5wZ3sK-{$%(>d?3f5=T zPrO;zgIW!z3du<^&|F7HFOi%#3yP&ghvrZA^O7@6W@XJI^&BJ;;Cv)y=CE#VDP-NP zZTz~$361Il%pO3b^;)!(tc}`qj5OWuK;|yQv_Fp7?A6WxC=5|-37A2zIcp8lf2gd< z_h!B{_ldIj7M@gN{FzgbuNzmVF97K%ssnreQk^U|To}1~1YV1k4_cFVx%F@8X3Vc~RUFrCch3K_fu zO4>-(VNvl4>xd`TVT$^Vn>O*^2lHI_zt2O2Tk-0WITNw*S_10XF;;Z+mU40#gw$%XX_gB_z|3~G>Lg&(&~ z)c1Kqoeno!XBNC#`>?sG6@wafT=(}ks1R6wG0<|q`n5Mzo!c5Ek;Jz!qgaR+cZSsY z^;9^=@R=un7l=qhJ;E{ zb&WojdW6h1G0PH981tB7qI?m`5}9VM-dzEbjzEB&3AtOb#jq~nH!lHZ!Q6yo8qcTP zB5H?xOy^-O_?VB6naxAtf-0Wj;H+`{FQZY@9v))dB)ZNDWe}St-*H@TG-oJwkkG1e z%eH-l?o+)>4ucWgN4i%V5wtwKi%|I+M z@{1Xna@iQ!4^wO}-54j2eQTzHSifZK^(#!Qu|9r+u-In9rwlqYEceCC$d62|x}D|tjmfwhsz9v+^5-Ie0q>N=`lIJ&M|*u;g`jCvDbeBJDDa`U z5_Ko`!&cuwi@YAA>x_j|iuzoZ-1qAMz#`dzi-AO7AyO7*uYMWcSA=?Ej54Rg?WWU9 z>x^5BYz@7ZU7XpiCWv7vI0|fNM#L!3T3h;5cjVqVpUKqSnWS^XVGnxb1x1{&3rr@> z?abPMc4{_DCn=>rud#!{KE?f^?R5O&;M9s5j)@vp+slaIXT4|3D5ZUx?SjFIw%S3; zX})mRvsRa^3lxzz_ZGN)X*Xczh0yhDcsD)XEOkrN8{ru=h{Fw_Im_XrI$Uqz7D!%L zHfXIXB~qWu)3as7U|&eGd5_EL@EwfdZZt6<&yAko*Z@7+Dvtjxm{3x~ z2~UXB3HZNPf^Md*W3R@>c|EihFR$iqd_yz4Tzo6sHVoQ_*Or*k3Sm*kWn6mpM9tf3f z#ATu;RDm0i0EX)t1VzYtG8B5B@Oj!SRntE7i;qU*gao&z}D z@)vbGjfHeb9{$T5Qu3Lcg8J4p2IKW)kpQr*kYi(3eKVmHk1v!T4F=dup({dp0N;ZE zpb^aZ*CN~ES?j@TE2FH;yq}v? ztm!bocq>L1coGZU46V`342mNKg&sE)aT0z zCaOtxU04K`SDY?mD}i-1$wF;POKZL3TK|JktqXI%2?-sE=PzeCiEFETicn^lq-j*< zG^o3(v)-g%JXm0lbYye5%*JdnK%VchWg%&=2iG86*E3OS9Jy3A>}=!-6L=Ym5+`V{ zxWI%4#_~Jeb+2!8mO8sN%d$9T5ScgaC*D@i>~a>%-pz!;U@7T6B%w&4?ZrwIKSrd6 zdpMGH?XF~jHsV@jC+@-Kavx?VB^`344GX+ZXCZ)!nY)TtzqEK zVf;+kGnt)gd{}+Sgb0GC!-`ME+B3i{!T{{HEkPKmpQlwk_Qh~3Ih>1^QswJpcD+GW3Hz{hMe7@G%T-D)sJO*`!$7Y% zMq{(hqw?{b@#kDy#ybxN(0Lg|3t@^x{o(((0HFZ2$$;~f#eZ@ddfQ^KNgSB9eJ6VJ zy(9!KVUBbyL@<{szp96%#sq1!633J13g?s&)Awq)@8foj^DBBXe<-tu0c{4vaH((h zgZ={8uXlTfPJIG780pNKM1*(Iku;cO;R{w!F?K}69Edgg0eOf^Vpt*A^vwzhq~GPQ zFO1zF#;ljH#WsvCu_z>a%C$InkpvrZ8i76XDJ$SKjY#rbd24L=GF%Q<5*WVu_E$nw zf$gr;WPXATd;bkcD!QALRId*U>2k~>)+ErCf@(0@Ih;Y;6-FBPSSG#k`*j{NH)+L) z>6fe55(T()pqZh-Y>+MxKwFMPa~vH0Q`I2mwn2MUo%5{iGaR~=YWe489AD|hK^(9m zKjl>}PQCnZj+1xq-lh6Ujb!9d_m~H;uGdW`73Hr%eX!T(L*g{;+%NEl79TOV<})ik zH#aFs{-BiV`|9jk0Uc6Qqys4to%Hp2GV<9?=aI^aSIRiyB*gA_+m4(+lkKa>Tesqx zO5&|@)^GVN-&YcFG8Gzo4bW;`cAm9S-s<3 z(m8X|S#;dc0ROoJ(wNyw{RNfDUn-Dd>06|eLxdFQ=iUepSE%#iGaptqj&y!k$lx+> zvp~CIRrTuVRd`f{)PrQ{4OiE&Kgq@&m>9Di%5)QxqOL#@*|!t5qlP{z*x#5Q9t-Bq zjg+l}n3{k^GvS)|8+YQ%GHyd6IyntUxv|P@&(PJgg?}GCkDXMVRoRBuYys#PD{((k z`T1Eut-oHUvFSs!(s!W*`%(SiV?Jin$DKW$Sd{Df@3XP+k}c09NeD}{Dq*=cU_N4A z7gphYC$^KKZYwH#E+kykmVIrMbwseuVpnKES~HM#oK{-N>kiU8+_v*;xbl;%m*YnF zuZJ>xaP#BhI<>rL>)pKxa_N*g)?(+!Af+j<<4K+Dw>cfP;UMwC=lWB?HL*W#l+?cR zAkd~h1XAdAgiB_Itn-Oh|#+peT#DS?z}Xv)$!6?=LbpR0XrVaVxwP_9Ns)yGell6w) zlk1grT|ucBr9K~OVFaFsEKpf6y})gc=#|)>f%wz@f!pK*;hG%I8^0n2x_UBC4XP5< ztVlN$2;uKr_Im4g1Ul#1{@RC!hyNVlL{);yEX2+6=p=bp!=}V-9Br z{6Ho0BhPhNM9WTP6VQw2U{efNKxf%5jni(TM=h@He%;4D@TVLKqXdoT(|y*jq&8{D zy>I)Wo%lSSUu3;QF*)0~ACB9`wW5P-CjX0ehrVK}Q$*JaW^G^#_n|2u%9Yi*qw25T z>1h}%WMhk^{q-`{LL$C5$51rh;+P+biVn1CK<)gFrspUDVcZiaa|V-1OjDAk6IM&?pP* zBU~QRGiwid%9uqj(z88($-nClvNR(rul@|ppt<_K?RjcHhZ!S)1aG|&T(N}`(maez z64ZZs9r$QYcDk59@)Q%LfLlkR&}^RMlh zo3qLEpd^Ax_DI@tIsq0>r1!f`4J%_E@R9Rb-i?yPZ>lPiomlcm&>5HT1}axw+hCcg zXkA^ewt~o_;unk>i$`c{zZTaAQsL`79H0ouG*TTf_; zZ-5r$pXkY3?{*?cINKb@_`AAXZ;JGwEWi*@+m}?<7I{##2D6Y@aa79VPc(ad0Tkj6 z{v2b}$teRRz^K2v91-`i_99%1&D=`mtEB{Z;oRe|x@SJ)@kkkq(pX&mhy1L3@ZR3+ z)Uya9#WCl*{bNO8)Rr8_#|nHD5)fK;-w>{dKPvu_n#CJy!|;a_Va+KZ_iN6O^2vat zGyT*16;ey+gG=U~cP93Q|AA;t{1shgwHdb<(>j5*2*yU<@)Tzq1*aw@&or}X%~}~0(V1; zPyEzd(T9e)E-{zQ#h>y6E00GAWiI@fMHcSN9uF+d6B*CJ$hbh7)TN-VA*LoL^$R&4ryzafHUC@5$kH*~?IX%?~= zealBy`TjGxoqw^T%54{K*hKRi*NtC3EkXmKC3u9g+e9U?d$#RMuOoH{B(`c4Qm~2>G?g0%?rh+v&_R$z61wb6UJY8n%3|u^7X% z6));2g;)N=KJ-Y?cn~kKD=$TPeUtE z_Qc6|z9qZHKLWn=U}<}o+>|v`6`T{F4G^hPM$Tp0@;@lxeLVVkt8>l^+ltY}=eX?B zVD2{l5PL{>-iyh_yWl~yeMH7SG`?fisdRc$A4CD+%xPyJO!VVy_Dz5tK6Sv7riET+gpv&s?eQd7boc+I;VWz&`V|KI26IhMavWe$GVq2^C^LM{_q#XKiBV#M?) z0AyIe|3H+Yf)@f&cosM||2gll(D;ldYh25pkmXm$0O>KtnPi69-@1_P!-TPQWA0ar zb03Bym1fMOJ1azNu{ym;qccN*z?WVwqYqQ&$5bEi@IKNMhM7H7$Nqz{b><+4t)SbS z2Q-!SC4Xx#&fT*`4##nKL=OBY^|vU5NF_AOivBl}J*N7Nq4NdAP*etL@V;-0ehL4a zTE2jtD^!P13xh3z*tH_Rv`?j0k|VH0hgST8y{!)`r@2h`Wf;Biyz~orQAwD}g;U@2 z3KHda{nq3%MEZU1KOnS4R4jN_GC z4B-Z@FX~H z**Hcm^Adq**r8XbAMjzoNMN0s6#z`IF(*0@p)_1|)CjnAKjEy#CnW6CEjpJcYB(!*{@ zc?W!?qUojr(Uj&%$?Z9@U+{n!K^}vUm#ssA+z;4K9V0m$pGqJ0EXLNwRuL!Pi5@kE zC)x41ks6He-cIR%7QFesG8%|?F&m~gZp@Dasjiz*F{;E~Z{fF*pLUycVK;{8LmOOK z?3paOrroKC&4YP*O7ZKBDjaR8k*)3A3|udSf)o_V-AaqZ)VTTD{1VO35jN2xrI?W4a_76-{GP*w?P&Cm3o3CU9ql`;{ zh=m5=xmLFj{9^Ay-~)K)ql+Ym_1ywoq*YD{+aVk4&+=l6ql3Q8r6%(AKjC;eXChly zrkGzO&F2WIAFR%EM>1U^p6h-2LmdOuB{qUzjKT?sz}=S8{qnHxt68j51t=ek30B$r zGS(j+*UGTaATVntBkkL3ZJqD5k(<~q8H}f zFs~Z(-H9Rc!8dZ&tdCRfj;KN1f)3~R?PXv^(kiXQY2cg+yVzRsaq|(0#>hvoIhX1p z%UidgN8U2=TUArRi7f%sg(!H70uHoWC#eN>o(K7H#HR4R5$z4djlJg)W}-mCW*c0;4p23 zTTI1MiFFZ>xdSq*+C_#mX%(BfXpB!nl4l_7KBqg~(m?4_mA~ZfLWta&7QtAWxo9Tn z8SZB!Sb73(QJQYN;ft0s-YbZqrC&BM{U;cgEMif3*QooRSdCePGQV-cK$)#(M8&yqkteN9=qBBXvj&c0 z5Hrt84oPGl%0*zytzj}RQ@b*o@h$9O{@jUohtMBIo(5mQd%p(A$aTPSl8r$ZT8IH9 z4FT!7Tk-5$spK8HBZ`+0|AKwi-S2_}#6GoOc2|I6Cjf@XZHYBGK?F%}hw`4=kvq;` z9HXbpEGl58V1h2R%k1aDLOq1eQXd5`1DT$ni|;epi=MfOn}Wdu<tN zjWHHpdwCAy+j(h3xE@Hs>Yq5+E(rHIC%qNd`)8EpXy)!s0oB$0CAM8kCC|xDq8D4m zvBbGjliW=hoS5B!#;ymwYYyonTQ+NYi!J*PX#@k%S+!86+6IC=<&rmE?EDBpmy|vR-$>TXYQJfvhSR*s$91#wLWyo?C92r;X zNQ{RsWZIH{R=^qX$M~R_A*=9m(1u0i^O=?j1wYL=eZEwftWVY7H+jJz;dipfyIW2K z4-Zr${sL^g`Dtzyew1_N?(Ol=!$qiNNEqr$9e0So2!7+?+NmfR`~Ru)dI^T)+9ch)sy|Bmk;sV9P`~_ z&vtT06!Cmlb4g3=^b%gVB({FAC^X&GfQY;8{DBk{Fq0DO2A1rdB#0!EKfL$s(6J?z8@9{7V#@qx!X_t!c?G;3MNUm5`8kP5)2F` zjH|z8jkTirF2GXSvcgpViABcds6Uj6ZAH+;a1-&l(z#iFpJ;P83{^eb zpl5~q7^%sFWXkmG;GN*@Nl)nM#k4fQ%KAp20%g~z(Ac|F*{<>=ONT!V2m5WRqDgis zA9f9DeK%>47eGo9sh4kK7{#>XyW}|#)U-aA!UEDS@BY?Tv^8ILA*r(W%>4-3+keMI>! zw>i~VwG94pIul>HLdWu>li1sl(ogYau~`YOx}A z?@6ht-I-$(IC12~p>G1Kn!cBJ(;2ixvuH|iaHiZiqk4fFfVB^e z8GDI2Cv@+$70MZ>EEBMC*-BwNkpG!~d!_IL;9ZCb)7Pk%6Gc8JJ`@>J^v}Bp^Aimn zZLBqe+DjS1I!C-UrPguLWuhtWx1V@T%uS@}DHCPJ6NKYrrlXBETGjk4ZcpB>t=xX| zZ1euEFB`s?&8ExajrtzTgJJWf)$Er@BXfG>vgme{wf?`>&kHb1{U`7cm^{w?d7lsB z-iL3LN2)&XFtM2LZhm3Qo?;Mxy~DsK8m$p~uE(RYTaOL%2q*i6@k7BK&(0hSqC!`e zcJ7iBu|E}Y1Q)3$aTIEi;9-X%^&2se37zIvx&S{J1Hx3K$sqhm&#Dt0PJ{JDM@y zz%Hmd#^){TJoT~iUyfdfXi1bVD@v|wIZe%p<#s(z&6asP#?P$bBUYn?yJB}c_lx1> z6N#KFd!k0uOzKX|(9f`J4UJ(ibvd`@A=a-6HL`7pw9{+rNs?>x=nZKTDA1S0Yg0k4 z`}y!W9F9HBA#x9oOKM_tZ~Zd-<+BPK?#h&v_f1&4C=6+IC%nMKD5VgqB95LKT8lv< zSf%mjB)qQug*sc85Vjk?Jj4(~1-3XDhz|%cGcmYxO=%tLBAM%fr-;ep zjh4XL$Qncf1W^mmtuKjO{jyuGt}Hi8X#Le&?ABbiGKWfaAx2=BLFz$S?@|jxAgkHs z2-OF+{iy8TGk|K+jZ)o!#fQq|qP+QESZ<1#t@DxY^9WOfxznLq=_ zSO=_4f4-rWO=Sm%Wih>YO*LB;qIf$do=OCw%GGU}&{<8$E;lgfT8SZAW9UwOoEu^NcScg|+Xr8CGHyarOiI~-j~Q)N3IZ?|AWLr4?^ zd#O785u4g(glBXxVC%qAsT%f$iN-n-M}WwH;S>#cz>`vT2dwlQ zN%sj*wlCD@i+8m);khC?U!5Ed5PNgpsIxBx~zOuv6CwZ!Z>M z)T|UyEm3_I!i4Ez2fJuKJVx3N{ts!#t)vm@`UoUS@G)UVjZH(vV~Jwh`dZM!M?S@C zYHI}7<8~-s{3nabqJneKD%J-Gb<{A?yApg58jz~Z3$0vw+<}p@K*5=h$WD7SoP~)d z0b;rm9QFlj=V79^!3LD9#qR-^6wVQeYOsTeFLw_i`@u;^0nn;H#OV{XzZ2>7X2=4$ zK|L5`i$dAvpgI6|Zwv~LBRIz;1L#=5XrBqx;HUh$^RRxFZfD-fXb5*Wlbim+v=LFq z!t((GoDMTOKX}s&FFGUf!T;=k4PYMO%qWUsluSQ$e@zdmK!KD!jEx>1pB|d?t;*xK z;NR|n#~Aku%r*PFn`=wxupo!5#Vl{BuBF2FKvmcor$B)ej$>VU0q#=3XpltMA~1 z6mjAqKpKiu{%sNC+3}McIH=|p5j>sVqw}^n)BAD!)J7q~kRG;6uwfxXu5ZR#-OiU~ zIYIwP^xjd<>obs?PfxsuNEHFV{XtMgf=%9r8-zo^OwF~QP7R!C@M3T)ek`Iu1j{Z` z^B5napm_se0{GehhM)SW6f*`>pZN>47-HaRst6ury#-W;X2c;nKQu^|V#X_ZWPqqq z2-8{&{+wYim{aqs=+(rvcR%*h>L~tw%szE{HX<)JQL8&lDz`w!D<5&~II{YyozBC8 z5)O^@SK^N70IGO@;BP~5j^g^PXCe6+#4LyINTB$TJ$?7k(N6HoF{F#9I(n4q8-WS> z7}_+(23{^ubNqzC-5Xq?j3#J<31XP%d9a3TPL25b7%NT(w{5=~?(!|xRwZ2It^yUG z0aSd$VT&ja(GZXWDlhhNJbODd`5HQGzsjb8nx5= z2#3a8hdY{~h@jfFpAmAP|hM&4;Ls@0=i&gQo`0Wt5;g$H5b=2F3p|OnU9;%a0Bj;1G`A zo%vxA;&zbr3$jnav-K{?tDAv6^7CYi-4(BsWDcQS*WI@@q7zvDqHBS)pM2u& z@uis^Ve}gCI>tTLMPOWZew`S1Z6QiamtV$gW@#Y zdt)@x;KsH**90JaP#jC*7(8ANZq#5!1(WO%THH1c1uS77MioXprvBss-oJL-L=)#Q z)sPf5wPIRQ<9!L_!GNK%hnvL}?48sO>k{rh?impnuekIJ#SgIp=2Lbv0~hC%Sf5-X zJIS)R@IfXvJ*`7lO+m92kGa3jJj_3g4}mt@(!;Ss{J5!qygVM_gfL-uGMLcUAYhba z-1$PU(ch4HK)D5^px!QBxnqa*9VaXO2OBf-eZ-@8D0-N7XCM+}I4Jn%0^~y{()M%PeYE<#ai6uiiWjHogObO1h6J!Z^>Dvj#c592JS(g-PCT~BV4xP*lLdu46<4} zh}VdlZQk!klha7cysv+Rqr@%;>#!B+wR zv3Z#bkQ_Cf$)(hbZ#FcYu>x7}QYiInpaTaIe}>+HXA4q`8QV1;5rN7BPCocF6cdDz zS3WxfT%4gST*#Ng9&41LcW9JrkE&-}Gz6#Mxg#*- ze7RJDnHE&_&X|}zItH@F3^4p0=`SQSlm~?ejUZILTiA4|jrv|yRETxe6kKfs3-C{M zKmMk%CT#UfM@7Lu&_#ae3kFtoaBJgw(ATEl5|n!I>NqwVU(qmtDGBMxUiAfJed73V zWormmHMR5r1?dE5!IKjY`k12_B%umCCbv(TSUu02sw-@Z-TLatnZW;YC+1i*eosb7 z__1WTU`k~qPQCwX(e>Xvd=MkP&K48jhxnrY7l>=UNbL&lXkY#`3tGfb_O&GC1_=Ro{U%P|22FB9fI|;J`ZT4% zJz^sZmCcT65=|?kUK+xqStf+7MvKYac>*!ClTLs_zmQf4+V3QQ zJ8%KP6Cn3&C>Fqrf+t8=-|%xVm%t!lZ6A zg0(-O_l9Yz-FbYQKD2Rt>S;LfOuWmmi;gIG1&xgrJ~wORewNH}_&hRy8zy6!&B?@e zB!L+6td{aatO`^naYD>iMzJ=l>C-|oblqsZzhna34f2M!86rb2IQI##A}K2lInVl& z`qa-*Vd~=Qi(eH2Mfw+Cg<*D%BVPV}+;saatiNifJ3H+bv?Ja{#V6X09W=2uD*yQ> zZBg^9_J4Nsd0G6kdxXBsoBDR1v`qNhtG>UwXPV0tczrYf_=o>?qD+IEVtmA|e*w4B zv9&%9l)zEsajC}eR^`)D_Q(&JD2_=72pBsiOAa^_y8I8e2%~3ZVN4ny&fkGfsoY{&i<2G5aCv1pm0r zGSqbLP9;b1wqg;Xi zd8giJzvuX!MMQAkiTLDrQp;2EF!b?1$&YXvtCg0~*L9DFRFI4Tf*m>D)?q;z%h)X+ z@M1PR^1}l0_zl~?@*(0W1Iwqi1iSK3*s~ND;g%hClLkqt{0OdmZKhdJ@O( z50VZvOMImYkB67OpK+qtdvF@8{foZ=vwT5$hZaj=l+wa^&7ukY+mJ>;<{fy4!U=42 z7HnD%-kY<^Hag=wx7X=@{j7W#b^E)lp=c2#g}hvpy{N|6WV1_@-H@E<$Md2OdtIr& z&yWe-vkmMp6E{SzEG17q?wo!zdQErG`>AwOe`&|0g1@e2fyqE4Az6l;*UE=6sNm)1 zD{jNBhWiSoa^JT17I$-%%f7(bjaLWMr{?y2{H5t{)@s$Z%a8$~!^vfn+ntiIZI&^&|k zY#?4iPr3^2nYeM5OYIh{C18BIe0+=QKG%uU?lPVIr}Q1{L%i|#CjNsZ-0sYH-KbN4 zqwpimJF)A^Z0QDfUHgPGJl=NV9~DnA(?&S#9xhxLv8(({be8M?)VfF&Bu`6dSot!d zVVoSQbvZdN$zOd70v3yWveu7^AIc?e?!K!|=U#wtdFLt|X3+lmZ@~P<84rNVKz-I{ zvcjGHTWk*midObtt;zupv4mXl@m#x@R0LUn|4FjOCh;$HI0OvWSwEN&^ZtLVy?Hp) z?-xI;g;FFcLI{yC_9fX;_OWF*w!&D(7P7CUBKwlDg%D%LfgRlNl6CGDV zc2g-!-A-Ap0D`8QJT?<{8QKrm`1MzWQQytsFbR{=#m}1qN;Ai)^yoW>7rlQnPVAAz zVtImDItN}_qEI3TmvHdxJ^1X3W}5tdY;n z7uQ&Qp#{Bbl8{06BK*!x^>C}Zj{0RZYoVVlj@f5NZsONuN4U6=A_n#wy$>Kt%FY|} z)SLSsm=M3c`*D5q{6!vZQDsq4NtTQAvPTJm;4ccGAAyg7*1%d=DP62F)8vjE`wglJ zb4F$j%94kDg{<@%eGf*Oe|O?qXG$7A*C-AYMtOi8!y#7!RofWR5e!%8p-%1?&)&0- z1DR=mjLq9NBb)3W9>M$cqznbD%wL8&{w@N91!H+dTC#(w50d`$$U!*C0z-N%JW@i&Md!@~FPZ)*q|{y@Kgy|LR_lPz{=4SX!9~1rnb%mE^&Lj;?0c#y3MA%nUd7Tih;PmPszJ}v%FS2 z$}B1Ym&Qa`+73F)BJ1w%*Z2w_JLF|S$i}Q8VZ-p3v3Rs~(OxR6>n`;K1$8+z7u~qSxaSv@!Hn@b^66e z3W}H+=w1z|#y_T=MDNvF>C5d=Y_m^B&#gDS(i=+EbB7jFx#L;e$qI~ApRHvZSyr#> zf-}Sy%~%%=+opBF{X&MY_;eqsmOIYRiVIxV=28Z-0%v+)<+uvlGdkdK+FxV5i}!J^ zg1C(+oa>UDP_|LalJ#$MY*kd6)x-^pce!_)4qSF}O1Sg!-SN~KDd|Q`{f6@!l{%nd zb1Eg49<6W+jwxsAaq2_%fc%6C^;O9q{VEuDqv)8{5Y64s+OMUr`16d=PL*i|OSZRt~~L+D}0Su`(P z1=Rm{Bl_urxx-NnKc9VpA}1#Y?G|T$QSM}R;WjRG&eWT!!JoL)3M95OFS8-Hf#>^v%GMp^@V zdt#`mvv(QqXFbruJ{RK5loX`*_$dued;LnK!OiDtj0Lj;GToUI((eHn&Sm`a#AHavfU9EyZ9 zZcDox*7DVxjKp8f=h2KA?y}Z);-)umUlpR{vCy~G0jC(wUM==vbN2tDkO2Sr>=7in zSUrzn*N|Vlq1A^#vdvIFIs0~{w$GZ`ROCYD8wej=JnNxHLB8us5D!6SRLe7m!Ua8r z(|6C2;!+!Uz)_l@P8p-0QUvE~Ur40 z)+>THGqyP1*BR)hjMQD!cO++7IQBVX1pGv^W@-6uTaI)_cLJ{PrN zSi3Eyq`~r4kIIYu9JhD-8m8k-w?#lDdbv%Itv97?X4F06q#cvf~UwV5?8c;B}@p-vRm!i_Ss{qcJ$wLAo$8-i_ejA!M zcX`(QR@Qv7DU6GQ2iD>dzhZB$(i$nQ7(eNv!H5iDeJhnHbTe-69usz4?cV4r(kWpRcs?1@o7D=nw4UzHzq!W9tS&1Y8?7G zSrZakd%HZy>k;JX{hvA>4LVJf>vudK!ru8-*>oSuQ~<|2l3^F zlop)B+{%NrWUzvLnlF}UVSP|wr?UBk7>v)Ry*tGjd z;Bhvpj)8Xe8R*lv^iAz|GFj<@*OyE)dJbgg?;pE>Sowc9zNJiOqbGMyw%-?-g`5R! zuPY2eDCp@7`k3s~k_B(H;NTnf5jF+c_|Im+qhGuztGK?|o;t=5Iql60+mF=&bv=q= zE|%>no)gL2?uggIeluyYte{Xw`QxfD&Gq@w+K<_&rIzvc#uhFF4?4k;^_UQZ`}nx7 zCsKTOuzH}Se!R9HsVQc$wZ|h5G+hF!WJWYSd~Pu_+xpB&j!C3F!PzIRDEB9l52)(ug zlJ-Baedonv-_(_zO{H%)nG8YOE{M^ok1Z6zvj<;7q6|RAJ$LPgvgVnS>$Mzou%#^@ z6k?xcG|ngaRklxA_}@r}c__(>xmaO7xOHnU-ZAEPO0!?k1&1A=avZ#Y?&y6u*K)zz z-FKbP)a$6`Zgo(*d3b|!vqez)aZ!u+lq*5=;1qi%XSjhBrnpm0_mN4=?TJuheB3%- zwO*~IJYr6#Zif=X12t`7uQuAFTXN9ows+vmF)X&suwQU}9=-fTOEbbdVaMhzM8gGh zYZ|^_6aHyn!P`Ps)xYD;(c#9Vo{?4QQozI1h#I~p*yY8CpjH%Iw|(~an#FoWeS}iW z8LAGbl#mgUf4aBvb;_(RwzSFQjayvt&^Qux6JxL#1T+zcS9gQca6OQ*WFwGWczAo( zxEj+ZWX}7hy?(X;6&~lKFIOS#v)sF?iCFBy8tnIj4eEc+EdW3+QMEVoOM2`6q8D1y z6mju>2>@5$^1x@jwa-`^8*ak(w;uyAGF0mDk_$4=SAoic(2Wcn3W&FxY`LBRv(o|l zvf4*i1gs*bG#z1|rjs+_I>w+@ukY*?6fX3UFrkNbMU;sd<3Gxq#mj6vtM4dzu@0Wi zgIMe3nQ1aNU0N5+Ck(TduvDpSI3=D0wz%By2qkb;sGOZ=!?nOEEK{acvJ0$cElnuZo(7rQlbhT^jRL7A& zDEP0_FI;Z^{efwxrYLGbM`YhgWr1i@u($FFcPT@ztc+lmzGrHFgj+tra*K9eY^fxX z!KYc=9WS7EW46&f-0i`v+V9`5@}6AT1irXo1TgOSYMThFNY-q$nAvdwkU9>fDi^;I?qH@)xKzm%Sbbb-o;u3g2*Ob&~3o zwb8FYsXK?cIS=)@385a0ZN+_V>V&CS|H)WU57gZIBD&)0;eN<6@xr{NF<0K{vVu`O zqp(Lz5q!%LlP0TQ$`=>)n3<>Rg-u<|tpdd#!F-YgIJ zeud@IAMIO4Kp$lTu;pS-T@0r6vKygS(q6l<+iX~v(eWWD4*`M6R1Cw@{o=LA6NU`@IpeT87R5kCAP2s!j^cR=z-YmhlYew-pFN+x&cSNYl>W&vK=J` zWa6a1aV#Y-W5Xdb1uR=_rRMQ^V$V&-><~GXLd-$M2$!`lwJ|@Ww&8^P%Fm*$GTn8s zJOdz6st$hv5D(sJPv}VeJP9oM9On0@&a8wuAp{`}NjN+GL#5!)Y>1C@B4og5z3v7y zkcOwpxsbr&g#XoCQM_@jE=1EmB!jhH|56&Fu8Yn6!uAnIgW0{o(O=u+KFOn^vImo4 zi>WNa)FKd<>*#H-eQ16B6L*-`5b<=M9#nDz)_c-hHF;RFKU&GHbN0pso&LX{H~}_ zorsT>2&msxyZ7v!PUonNfvNdzXd%IS-Q$bN(v;ufK+L;vL1nMlqt&y8g8;xWbH$Dp1=$PR*E+o}~;8o|8aB=!-%lxyNg%bx~0y^%8 zYmIo!o3!vhXr8?}Q@_}GvQO7h(CrFS!wZ;ObQL1%=C9)!R2O2qrU%#pqdbm=Z{^=Y zN1AhHmEaK4@}fxpd&Ax7Wu$+Qf%1$TVv06}tuU>$FoDLX85Z`xF~RRL z)SY{xhS49%%Se|Q0Z;DkN4@q@{7rc#ht`?@{#DEOy+y5(&q%8~BcutyMK%qg zg!l$(iK7Gb`P7Va2XM*%+K{lwL1@*!uS!; zlG~xm=*oSWeJgxO)JxZgiey(vb9`M_%?z9XG+Yl^D3q5*mlfHlwn zBq1KEBok}z6X8Ckg*EBbU*~Q-r23~8piVERSWN9>9rIzx4OuhK`OCF9EpY3+#}}n- z?R8S!%9}XXjr*9x@1K0k{5Au9eqHUPc?jB627w#uR%1B4xl*ZJ5F8{rK+p1%-s~Uz zFj6zm+uXH5o^l{S&;YI?A%RKM2Qx=o2@cc1$bpdDNq=)JuPyK`3Ff>Om;{Ith{N{p z0*?a!!JH>~2+D*5AEz_E2A=u|2LL!pk{E3Gv%Tp;{KWB2JkJ2r!TJB1P7p;Xy5Z>+ zb{`-E!O_N#iI9KwRe)jJFzv}8> zpWlR#f7$8-A2w{=%Z4A6L}>Iol=t)h0zf)cS6;uLktMd*Xk^dJHE=XuF zHihX#5CWuln&QhO{rlzzx;o%Q1mVGd$>+y@6QwE0z;JZ|wy$ChO!<$rIzPcDWUR(U zIM&`j`j7m9co{N;tKsO=DjeEEyGW@f{a*s^)CLXGb5=PSxC18%Jf7L0!1!6D^?!|) z$bvAt0!>L${%6G`F~6_TTr8y21+d&{Or z;~Kbz$l>ea2+52mD)4LK(Aph})KI=h)iJT7lim?^p{6#k(&pa=K+$A@nVKfEJ zRZ0Ii)*H11oNf-{rT~^C=$#$_O;mE|H1CanetbCKIP`fE`pCMEg)u-R?7kT{J(xIt z-SUs~_^`e^O$EU<;NS>nc+UtsA9ZI!fHRX<-sx)(vDxf)n1=na@ zLWjfI^ppK{`lJ*L>2qWEQrM^}a|on-|9!SQt;G8NVr2uS;(ZJ^MjCcmLhN1#we&oq zyj28WyyqaNTncA!8Z6@+HoUeX57%jYqCV4NH|VZm5OHXvBD{k<@K<8=X4U(lM*H@g z=~R7=0+BD`t^wZqa1|%?Q>}X*Cd9m9peZ zXzDVr@9H157)XBaQ7R zk8Pe+*ecp&r$Y1@I4f27cfC4qE*6P!_sH0g8#%$nS*|jfbM=9l2B*T+F=hYG?iy#? z#tJaCVF0?Z7UcWpOhr4K78AjL*UDYlew6pl3hxnhU)czaP@eIU#pBV~P!O9$Hg~?L zv|Jkl626-j)v|j{sK4xSDQ$c!-QqXa0igHu5>o||AU3k8jY@JAE)0{mpHs=p$v^Cm zp_Tn&kf3xDBf66%0U;_^>8EBl+wY>&Ej5Hf?_W1h6^JB;1-7uAJI3>=cAOfIPEX0< z{FWe`Vx;~0s=a=}l7_KrqsaTbVktRm@y%t4xfzXw5L4Qpy6B<1(GkbCOe|Y6#!X^i zal9*v_t?-GLZ@cDpx}okD;fQ6?dn_srH`&tK;-Cw;z?D^n|D@u!;Z#u0>(wB(XBcO zna`s0YJW5J6urGA=SeD%Y-MYwlT!+pJDX{ zb(wH=e1w;FS8drNa+bYIp?L8Xi)7_nWttmf?5YNF3MC~4?jaBj&!WUcn{0TV)Tndy zgL|TFZz(8!?}U)K?UXG z#DVgOX=J^90~5eavJ#gBaN0aP&L@Wr%?(6DxxuzgT&?8`9Yhae&$rsU+7ou8?>Xnvg_`I9xS8;5n!A_KGyACYx z)jdtY_KIt^TF#BGJx33Y1mmT9=Wi307!cx2FeJ)-lQkDEYr?_xqh<9){h_$UZieA1 z4xKK#SJ>yyKZ8v0WkD=t zT#<*rx2eceqL^T5$l}(zGw#_11C%Z&9CG}l;W+xwZqNPQ>tm+3E#73qEysoYg(o^% z<@!^bs^OzI3)4}>$yLG_tAI9}=MQEf)rg!b-np|AM;muosWLPGPu-Rp;Ij-#fG&E~ zjAy2Mq}zW`_EN)GZQlL!W_(133y%)VXR7$dkTSGV66J4<-{8c^>Ay4}yi^MSX-i6> zsp=>P#?KsFUF%)aKg4)Zj9RXK1SOQTbUy|}Uj*Ct{Bt0iDN5o&&Z!A%_4_`p@o0+) zn++!wvY=K!5K8B0VMxuF)CQM`&Gn7-;`){!6+DndI`ft37+^U{woc@j3OOFr>Hb~# zfqX2INs6W|EA}m9z^lBq(oH+EhK*aasecO*mfaFXT2-*f3JnO5k5M%tsczC%h( z0rN7wm3u8HK^PZNECbsUS?X+R^Hiag=h47jkyHy|3U}baOjM@UQTsxpJWXE z6eqN-XL9^mCrn%l4M9ipdJk=o=v3`Ns?uUIfr|{ORD~RDxkEzH#Yf!*aNjgoyTS73 zgKR`jufmauDToSt<~d+!0@BCXaDDmkbEM?L@<%D$=B2-fxsPqetTe<0w5Eq!oRBMm z*%q>T*q6sgQocW1uJi`k4(a51ARKSh9z!+vy*(0vel0m7M=Fd6Yl$tVgn~h-=Q(3; zQD%3)Wu6%o4FqJph}V24#`N&(M>vi*Q{=Yu42_unO&D^2%-Wc2jCOq}Bz6$p)hao3 zb?<`{bCX{sU)Cx=o3ODrg^RU&HhrfQRzttwGP<9+0+x)|E`~B)4J_g_sd*of5BH-X z9JKrl@cu}p-d*H0cWz4?)P6bAy&G5&eateyauVy}po9LM!*+^T4h!DiRvKQ>p$YTp z^;_iILp&P}$Feq!2eXgy!L#U{*n=#^@Fq_$215e6I;l6trHiF; zC&|ZsJxBvMM6rQyjLueaBsu(h*2|mX(M{LU;hNX5FQXD^mym@m2QJ~F%-`J%b|JeL zgv2lP6<|CTyNB2`?fq6IO+ero`Y9(^`&7<{h8w=nj&n>l4p(7D{8T<=6~yBSg5P*w zWYf6{>wKLFe?;dgO7Q>}r@&x}Lp$uQx>7lYi5KdOJHB@+$%kfSW~Fl*)h}zcA$W?s zDMu}d#stWuO&nR&agvYU#=z5@ z6T|BpojBBGRkms1mqxX#y$OK5RV~n;8+_+BF7FvWL*(Rgn>C~1cOS*WJo;!TDvYyI zCwHE@_M~i|~HS9baXuqqYb(0K$uJ*o&PJaw``(gF6H_7&)bKBbi{byU;#l|y#I$I-B zVf4X(h4060G{`|ozQKR;A#!Nfz3WtOKZsGKls^|XxD;+n0y7GQA?;K0Fbz5_jP_Ew z5Hd!~w+v=TE+Ezq>YS9gk!#WM_K;gjPujYF{h=ilPZydG4g@5B5O(MtY6n=THZp%* zW*!OIhUDiE1OWq#rN+}tPXeC9Y8a$%_fE6@$Jfs+Ns;h3`_%p=S+#oM0v7M~0yMqt z*?JWditolgy(?0Va**7Zm4B6N{0esKC@`z=)sIYzp@&Pt7|Y@G$08YyGFEm;<{4Al zcKxGv{b@G}7Br&s3N)aMnc<45-lQXnqUr>n=7_+zgxz*8od)>j_BMuX6G;6~4QHlna^P$&3i^@AJlCsOOaAR$=Nx#6yW$ zr}zr6wXBQbN3hS2p_x7yc0|6JY+b7Amd1gV({2GQkX!B${ANvzKr=y ztEJcL+4Tb@P-4mefbB1l-jYr89+7zklCA24J{`lMzBZ)M@6QTU!RX12)nclj-k)+J zsp3miYD)EsXff2!8TG4w9BkPEc)kb@E(gr=88HoSDQH-9q|aP6RLpn7+;7cWicom% zw>luQ0CCsTP5m z27AI!!8*nYM&5V7|E6t(x-u4a`}@t5J#&&vWSAFOxyiTP<=kz*VF^^?QRLYoY*D(P zAK7sBX7 zMVRkwv1ISGIq$Z0rq5qYek`r1mmIe9kevu!w1!|vwZJUZXD=0Iw6JBO;!M`Iy%hI7 z6Zftpk-%)9NGE>*R2^P<$FRw5K=us-WO@LMudp%60p)m}b9RlZ9iCc(-? zs|my)3g2B%f+!MgyxR0&KFsCo7WFbfT!2C?9`N;lG-_jaNCiUb=sOq*+ol> z6nOj2?YIwgJE~Zr{-%!-L_~JU2*mz$=;G$BO$ZnfIm;F~~{18_f2!J`(|t`Oc*pfZs;6f-*eI2k7-l2rf5 z#HxHj{SLdSpTLnV#U*lJ>x9f^kUdCpTm52g-YaYbX7j#dl19VZ(csnMKHG*`d(Q) zy4%uxq6}>?iIs`(*P$1I1uy}XKo7K{X@!+AIS{jWH$FxS3s4jaB6K*D*_{*)$#oVM z`Jxfm6e~@XYY-rfO!!j<6vq`Gk;Jk4cy04@GPtQ+IP%lyCXJG8tr4O0n2WE;8U^(| zl;6rx$pKIQOQeWC_V{Va<$NbOq8hV2h%~e?QOn0g&-ES&ICWyA7HN{+pM~|*&d1w- z^Jer3Znq3Qc^xrb{2KBK5dP!d&pM=yPbvcW0SjOt%p3jIhsMvL=2>X*kxU2NtyK8M zBWXx#RYa=+T|e*3_H5JOqkMZ#^J~nipIM)$_)c@#hf;-FVu9*{(-46cSfCK^%0*M& zOpky5R#Y6ARXk}T*I?>@QwjQZ%#1?nH;jt>!$+&=$5vKKMH zW+L1vj47=n1Oam}{?S?J&Mr00g41G>3Hg#mnl|}#>kD723&D5s*=)v_@l=+YxNlImd+xMDKNO3HjDIrrDzu>di$cNUiLc*|TJm8xI4fj@f&TmzX^ zA@w3hLEJG!6G044M#zEmip68laCOq!@q6<`$J6qc^6B)aJEal; z6HjX8Y!*HmxJ0}&_bI`BtB9J*l+%kl^qq_)3g++T13wqX_svm$qNDQizk>MyF1W>P zWX)G!nYG`2gR2H|XaK#ap$|B^x1`Dc839DTp7O%zces&TQ}>z~J-9}yDH+9T)!Nh! zEE}U0dof^+?Dn}K`;|N4K0sAP2{6)C1R@neW-5Fz4suQtF{o|q{s{m03rEu^c6%Zy z=0?yzwR0}<4c=Ck`f>N2)qqrVp(=XjN*3JGH}0%HmgmN3P3h;d4Bw8P8f%jsuY40> z4FLNmuI(&8a0Pk7l1qe7n7ViIY>dsrw%i6tzFBkKtEuw1)=apg48b-{LBp^90iWjz zh~ty0V>ATSl6sw>th|Pi&P4_^)1l#?2OlVgxAvv#uS_b=2&H}!pKxL!z(o!I;N4WJ1 zvFiMsCw{2xg}o^ej1sp1MFo5pC8lZV&V%GEI`~JDD3cMqjo!QytL@Dm@D&6+A#d#lOP(iA|RK3TnT|D|el|CA!7I@mqI?zukF z4=F3}dNk18$HJ`i(3Jv{7v+||{8)bbHzyJ%8sYQt#c(s{j=D!3OH5BdOGqOa zTkierWDXlQl>(!ZB1y+}ihiy1`i=9+KRQe2K3wB*E+A|{))Q*4JC=p=hD)S)@J(kj z9C#Hwgy%zv!7TA!VlWH1=E+iM4;Sp_MnKD9Ko{BZBG1=C+Nsycqmgi3F6{Vp>0M11 zjMd{Gl9elh__40@0`ZVV(v&n%zn?c0WU=$URzrHj+}3V~gfDI7SMBsY%gD4-BXUBu zjuOao@k}eqZTR!H%4n?$@bjJAtoHJ=7hW%8MBFml)IoMG!&pvQM49-C$;JBkt0mX^ zSZIfYc0%Xeimvu}L`veci_Yco4Qh9bthQWXCbv5C$P`rkOHV|6$G6-F=MvIpoqFvD zVm&ExVIMR`#jitsOU&7#x`@gXZn6Q#H*hBR;{hW<|x!Fe6q|3?^ZY)rq^ z^&_0BEjRGDLq+z&6I>k6zY#bSg9g3oRVV_gh*`D~z$_;U7);aYjvv@}%DV*yUe;Wv zheJaiEsN=a*;5r54wHdf?JZ+Q3(4lZXN1-Vc z@~MuIehF9FH}c)r0?{g^C@cB;xzM$!Q&2_(bFXSn%FNM`!81 zfUSE3+J~_WhyZ2Em@PlH!15hWxNkn;OL-A|{Wi;`hA-@~VwkZWP;o=UBS;24UaEOy zinMZ{l(AR>BKE!y(lny;S&;JpDJID%!b9{jPa)^48YDcW$FUsx#gRJN|Gqb9^mT1; zq)yMm?AOMSCAP(5HlfmlRwf&L@s@&PrGY`xVdi;bOeYLEXwe+VaOD_wkKf5TWyO5| zk!6}=Pp1+7Yi^DO_C@~tQq<`Fe3cfsmy>7P#I(}m9(+Bb2wv#0ttOH$XvCApJfy!m zJl;r?&c4Du8fAijs=+L3-}-*q3k)=gO7y+bY#6nG)CL`T{Aw9`D_7K7td z??_v+CBJE;l*Ze%Fy9HOQ|JH@Z3Hnp+OCHUouYgIzEG!%(*uFk1Z(z0N^W&|*_Es~ zv=E|#nW^ThP`(PnA=^7wMm_cEFcDK=pEUJwQVFC4$4)u5?LS;v5?8oLq!5jT{a&1toJVl6qjz zmcuDAWwa$bP5N7H+Yh6<^AAsDePYOd{EdSNuK!OQZ0SF7u-9wS&IVwh#G@$CLbRuO zzvu}VTsShVWNOTo$gtzAd!zg$P7Eb7`SuA=Y5y>f9neZo|5l%0}DyNsGdKp0u~r^dgt_Z zG?-QRhI^AVzU4WW7%W^7gpt10fqQXh1nNAZ53m3Fc5FmZ$}=kY5UG+Tt;# z1Yzxc*kTPEBx9A!@&fMwaSm!oIbF%_Cxz-;>irEg?4D#NNp}EgqH)^c5>xjM|EUGo zt2N`e%A}k_mUX6iXr1XK37xj27fOol5&%>?_8%~^f>Kf$c*TBZ*hUL8?;+*0ZJ zCJnv7lOES|zKjDF<)7V<15e2%^V8+OVgB$Ae-FFAeo-&x}THy7Q(#UkU;gXwonrZu5ht$LiMs(D zc|Q!W=?hU=TmOH|WvY+0i_Wrrvwejad;0r^e;jWjcp-B3_X}caKd_yuAc}dCVKi@u z9GuoV#Am@fw(g$&yCMMDAK?<(*oV(vQVAkB%(zcxd0v4N(kA(7%5<_HfuTv)F-?-p z#0mZp!D)btd^HN9n5|X#jg0|#1u*txKB6p6WOniaRAUg`oD)9?pbD5IrVv6FoZk_} z@$&hNFnz^rp!xw|=G4JDU7QnX%@jiv*}gu#dHwp=kE4o{r!PPG2KYE-WnaZ9*(|$*mlAjk@CNy1V-DDUO>OB3A}Ub zHIQHgzCUH)^!tzSoxr{Cssj5yc7IUhtidNTK4tdw{ijO+EYQF7o^m%+3VHP6%gnjI zO7#C_2r$FHF6{r6mw(pgRQ&&8;#36x$l-*xzZ9Kh$^j{zOb@K{3GXM)Fz_#6tpL*g zne>$NQ!N7i_U|n5DEK;vN0nn@f=s33%sNPOBXQH0=ZZT}=z$(dY-Mr-4i+WzurrXG>&Y9}xE||Cogy1)BtoWt`$XokRcNxU@ zDqhAd6eEveXw>~KBw(TB0y;6ZBGC@F=1xdfH|Jur;%VsLIA8bb zT~~vr*N+tZKEV9N>jEGVMn5JP&DB<;+wI;IY-pfAdGKMM>+>68A{Nf5_I;RC_+7US z>vIJPAO3(oa@G?+h8R$(W+sl^Pg1%A#U; zhh}$~ZVbX+`{!uabSjEbXSZK&w$i9j02QwE;{-DrdX+Kz(ahwN*=GTLYYW8q8E0&l zCFF?FyM451*|?q$KZq%=MTmgf&Fa46H_kn}V&g>}*f8YR3z=;{Tbd%egfg;IlS}o# z0$^-)P}iCo@AiWuRo%|xaZVagVDq0o{k3VN{G&gM^4Mf^tw>sMrN$+*Z1WZhOj!j> zAo#ZqVv5ulzJa@3xc8Z;7#mukLg8Z#G_>mpv#(T#DASyflIY z6*B=+pUkMp$WatsEyRhfG*!4Rw1w1sw-mT6(~eA@MYR`|_fj0(s|GT}08yZcWSY(k z?luMdLiN|yGo7&pdGf#M^C0QhgMSJM4EHh%V$aa@!SqGR)b69(Wa5K$s$#`8X-Qt5s?|7)FH*}Td>FEUT z&6uarSm+tE(FCUY=Y(Ys=e_LnV{pLQYcmwGx*048>3v^fg1e!)( zw+1RvcXpNtW{KN8`Y(iy3FTI}{j_%cjl=>rNfGMe|Tx=^X%M&R4A5F=ukl~_<=S@+}&OR8veT&9!Z zAtIf@2$ZvbA4OLUDVnpMKW2lNtH(#`N0(8gJqF1!=jSl|3SU!$KfN>I$HU4Iulnf- zrBe-I;9Sgt!*_;h6{z6&_Qu=hd4KfHq_2nl-40+(8AZ9axZl%+pTK2{%X+`{7pfCW z4Z!x>uk^rzzT3)eTPs_1y+Dn{`(ns~SPg{l735W|9vJJ%87{ctdEJyc88TA;AO{6) zse(uC5MrgN^f!a%RnwE!JG}i2iRK&7FIqX_lZwJ z1>nqqUzBD!L(~Ole4OLr*Xbw&eQn>FO#yOK%-xZgGsH1qSS$SxB_mY#Ed$%3`NMHIarOkDw$Ji{2O%*d;fMp zOh68L#VsIi-ibcYSf14#19Zmy!*7vk0_y3Aj5=VZff7&e7#o;fBtNr2ckk1?S34|4 z(+{IQXZcheK{KQZ9S5+r8yfw74*1Ikpuz^fT)N)c%DuAVe5Qed;#my{ISGzNh?LH$I#>6*v- z^8QNd?`h*HH~|n&VFk-p($A1ZW$Rxw7I)Qr4+rU%pgWuqgsJ=UfVCxQdyIJ@=SUU8 z`_5zZ)d%G=F#q-TtOqxVMiFRd>c7b6_XD@@X_chlrMTaYuTh$;zG%37g z7h9~sX5g2DF85J&5-u})f1iu2VP(bKJ6?Rl`8fbnZOUn+m?>jALT^&lU5hlb*2`}`pPqp;2ud5w#Q4D2Z^2vfvhiZcxXui(P?Y-j)I1La31O&Y@0B5{P zg7Qtl!+^bt`A`Ie?;i79*5qILlMm!R9)e00pJ?B{z;)^0RKy9zr=a+R?|%c|z;poo zBtDn>9`Xot>BwC41ke9F@??!pu-!k>fxV+*{foa(T!nu??Wu!wl6xT%xsVGN=k74h zgzsHF!C5ErfA6B*S(0gi5J_T^gOt{<(%HdIgoxC|O{^{-$_5KvgCo25kZ zrbI(lma@!@K}AOIT4ZP9X4`ru`A2K~&ezO)r#zk3ocHCzA760Kl#;vX{g}&=+(`HZ z9p077=moKe;ly_X@G(6`*V2KY&klDYrPX)Z!$dH)AxRk`a z_w7XVo(1p~!D%#4HpI;QAzU!_5GJUHHOeS4mTX_{k+&XOlVylY$#bW?0$??>>D}o4 zB@5o_d-%BVJi7~JXj!ZKQ;}i~4XY`Y8uB7XY@G2b@UF}D5DudurUjxriTVd4HhoXP%C3)bmKf>SC4h(A06UDg8~ zsaoB1?(dfeg@mw&u>ji~x1o^@{{~7n%2fcV%T+_w;|3 z`U_)~*peNX=N3e3)0i0ZBNUNfneLYQ_zTI;(cE3No!6{(LY!b#dSZKq{8S&qK3dnu z2>j@aKPhr}lMfGjHE690Tr=GvoJ0VCVw@^tF|xicK-t?>fouNXxRIkSR5PkoN)+!m zhog5rN^8ZvHniXAYUI9d^?tD#tDhH{oDj|A2-O>)SnQ}8Q~)8@pS&N#+_?JkHr_*Yg(sq z(HlTn*1`6X9Z}qyZHjc5_iu7^X44>??Ajo9m4EEiUM1Pbr+Dp3s50Xd5R!GZZe7H@ zx-`0Tzt-&htw@ZR18IdG(A!%&)^xjYX35FAw$CvQX2;YoV~2SnjxiBRnt&xQ|Fj;C z{nuDw&VPK47wQg%yO&Vor5Y7uJ-1Y5)p5lz^GJx4V z=*77{sYgMDl)HqI{&$+V;-Al)fZGsg#H3Nli#%t+{Z@4gz3wlZu7Sm=kO0Uh->Eki zN8HH~;vjtDQK(V;m}Y$Ut7-^eG7OeX;dS<3HUVRC$pF+m@=J`a!U`tw^ow||iBKD# z=SCXW{txNbx8~^lFC(n32w-MZU?Ew{4|B|PuN$k;ZZE!*_8CYB+aLqqD1YkrG^ncy zhoV4x&@NDJgsaxQNGHZHP6AORTK8e}iJQEpV|_*NLAt9>e(&S`CR_u&;W0`wHgwL{ zHd=y!R2PNHjYIFuq(k-_{e@%KSmM65?UjXgO7!sUtPA-hU>z>7_d}4j)hI$;2Cx)*IeGt%zCAQbL)Tpl`c@K83_MWX`hWm3#L6@Pad$1tFo zA$8Yp0P9ELAN?4#v@aJ8_-p`7v&R$+n@Z~iHWvq)jep3_ElONFAiBz25ogvl+y*nn zYK$J>Hy)Kt#|61USb)pmznrr=pB~ECsVU{aMlGy@UEBfGwxh8Jvs~@ z{$XIOfF^LjQ;a~(ZkNH*`08jWnKoU$?!vLV{4i#YYDZ%7=(Z+)gZ+`r`$Y5ly`w^% zMT1(^iA`51vL^<54?rRxZ{u9gUw>0=E(TmNZyj6nq=dvlLPlifwGoZlMvexLt?3I* zR~RzQ3-eI2YxFmXktYC*HUy*;^cGXm2+f5fw|D|1GHPQ{Yo+4ut?(w;fpfRV-C8iV@J=J-u;E3{v?7kO= zodm94r2po(6ft4$*$-NSsa%o10jy9`K9Hk|PV}wa+9fI>DGGkKjlz<;=PY^_COC{z z63DSxxyC+gzRuw{b5DlOjmk*dSgq|yJj9tL3A^TeEx==mM6>WXdVgl`b1D3*LF)dG z5LtRmHt{$#nw+-&KV-cHR8(E}KaQXvoq~XLNenGW36ko7gi=E)HMDet2m(si(9O`z z0MbY*Lk-<1-AFh5@A$mW`+L9ZzwTNr=FXiH`|Pvhv-jC|<>Gy{oB@b0RGc_;WicV) zYw*)Sg}0I@sj=~CA^F~Pw@Vyz3{k$(VNcUUi}(kTNoX7NuLuM*@=d`CyWkq%!2yfa zhdSRj?`V&4AycNoZ_TN*U_Rc#2~mzqWgW%^z3tUMuYKeMpGEn4kqa1$K+DYtOcK`3 zP9nxp35WgNVQ|GyJvZ;s^u6dOK6bdaAG+OzyLxUt@!W6IMLWAKNg@Tp^(K>P z>^x-So_)vsBrIk$nVAEd;_%q?BV2eYbGF<~D)HXRL)C@nJ;Ar?9Qq==`S)}!?+Vy7 zJ8dW21Hg8U?@C?)Wl;LUqo4g+y0v!y1`p&GE|n@4a|u<@mv&yotsBs;c~lVulEND2 z0r(od?a;Q_fjp>{M?fT~sh6*OQ?!gSw9;JQ{fz{(-5Yxo@o%bu*U&7xm!(zPZ!zF6pX|7OS4BY?B#!zCB~>@ z_ULeag%Yw)=Fa z^?;Y5|7P<3rTQ22D0q8)`*lFok*ao&3Um0@X0X0Qv}Ny~)irzqs(K6_o)}uJ1=DRb z6qbMFAijB%_E7ECnOApjO|t*h^g)nQQ@r}Xm>_ku74^%%=>F?O$VEKA;m$s}))lZ) zX8uJhm~(jri2gtBk}H0yruu58X}@Y+z3S^Fl?vd`QHk+x1%%-XURpp6P7A>V^7 zbH&Xcg)oN3q7`lX4NVRA1t=6})9Q zkP91!P>(w1Mx+9jH&P&u3_h98@%cK>JoUOn&+}v@9hT-2&h2ZWRmxcXN=0vasZN@% zA|dRt&o6#`XGJ?FD|d_Fly7B-?xPQ`nE4m490&i9qJ1hoe!6&0$HZWm#{JeVb~YBO z!|;>R%EJq!S8l75)WRG*A(gIWt&_3lersf7B_^x%x+YiZ(d#$h&6LQDIz-R9J;aI^ z+&Xs7zL2;+QopgLv*{6s?DA*|3nu?_H|DQXKwbn(-aP$I&=WjpG$a7@{;qgsA{6fD zlZ(%$=LO3CDr~=pTVK$l<0+K-3eICyuOE?)UwGx{&ofYqC7!N@)bDoEpU~ZnW^rDA z3odGR%w8>=o3T%}I?syJLUzX?#uW142QCVTT6+E($w+;tIFV`Ji7`jUf0Tez3EBkx zJ~^hrJ7{igw0qtc!quDh=_I=KCSvyMIwn)(p(97VukL6}%KXkmr|B!MASAR>&py-# zL|4O_L3VJz)k`hIKdGK2A5!&1+{>(Kc+xwhXyqL>7x2=9LZ1C&xuYq&QZ}a+{-bDH zkDp-QW* zgZ=CG$&V$r^0`Dt&&m8)xf&zuh)yQ@R(vW0JZrnMZ7RIWg(9y7$Meww;IBsf4ircT z+fQR$U0mNHe%bY2i1XOzQ;X-c=f@>_pOW)WlJEEHTN8pk_(<^mZ!R$n2MobVyuaB^ z6|429Vk=o%zC?$6ZvBjLELz{Hs&_l;54*da*|QZ23VsE#5{h}wH=e&3M++U6{%@xu^CYZ z!!I`@G5e&Q^?B6sJd28Bm6SON)++TmT}yES%}m1W;0wts9_a+kqV zcPyn~rh-akL(0?4DhzRaRE)M_e&5DT4i^Ph;6M-FT?Z$qq2=YF+NEAz)G zV~H?8u>U7EXQBpnrFS0~SIA&o{yhSz+Sz+)SQ_&4Yufn(#D546AO+cw`FTN6i+A8! z+~{BFtDGlR2I;rPzEVJx7vqE5D4AZ~-z?XM36Rw|y(f#x`?f~Ejv4A8=En{r3&dz; zmjtfqd>;81o;r8|;=DG12!GZ_yM2iS}&tP4s-{| z?J>t6zc5f9O|4a$;s53Wq_DT9Dv1zlrs? zgZ^*|OU+eP;G+zERLT|o|3X&!Xg{1kA*wWBd-H(&h)df_Eb>u0P!;HiJ~#-d`l5-9 zdtyU`fnhAk8jE%P;W0n8)fBxDZ=+!G3j6!S<+1mIYff1((djECIYnxa%o}~_U@}tM z$5X52w9d2nL*h3L4{!D6$24S#tPPmCJ-YdjBQ!_!wih&wdD03F+~zEbo5{-Zrd|i1 zo;)D_c5=U_&%Q<(9&;2j< z=q=wq^T#h*$N?Fd2DT?i855oWhz7@u)sJDBTK2OgjPL^noTE*rl!>dJNl(jYsKhN=6Sw36s#{JiBd{hp}i}^y2 zfq@~$=FhidESUW-WjP*B}p)&eU5{YG^yTL;>NvMu4<*A;v`dhl6|b-8J9 zw#=#`e+5@|{>6#20T)xSm#~AM*0C{hs5AY~w*up8#@)!EgryBgzZ=7tFYQ4T4waEC4Qs z?8ZJ z9Smb;AlC_38@vk(_jj%aq6sCt!Zou$_*x)5e0RORJs3W?&1jZv^(zcaV#!ev6NY}J zZ|0ks>|Avo1`1tY-hy@X;JIkQ%!}i*ANc#h(dwL+*2U! zC7{j^10(UiXNB@3?e^Oj1Cy~x3MY)`x|s)@4z7xi63gh4uQhbHg{`E>PmAQ)WISv(UNKn zR&tdFpq`Ej55b7t1qX% z04W|bY8Ypa{e!K1f*3w#$M*_1U~}6O-vi1zIuh4GfKZwsy9{J^#2h$tNcGj`lBygyD)Q;fS76if9ui3J%WSGC(Gt|;C$u#PZ7ISQe zCu$OtRk<1e;)!-4KETi6^vF7Wn$*Jpbe9XWxY^;rz7_eT@0xzr)e81?$QE*{UwBhG z>T!E|hPd-LmqQTeU-$;_+(`|l3PfVe0(h-{R&TuoPOI;|k(=XE*fRu90((@}ROu|d z$_o!7zIjc#=k=oQWnn!`as1UrbDt~E;$nT6i;v}V_L^DznpD7I+{&0dbIGIMBCK3? z)XgZIwf8k&5jU=f#8U+?QO;7!E+xzBRgmNXVFKyS@DGp#9d&^)mjfS9d~8b2Y6 zPIK4}uPFKt+H?Oy4Atga7yw9kMyes3w2)A7qUu~bYL_lMSRZH(Db^R$U`9c~vwvM~ z_bYA>FFeb$znYe(WUqGBr9}twM1$tzPaNiZK-#NBf6Z^(4IHUtE3u*0DV+`}Iq_s5 zk<=*GgZ7*3E^2JpAwz-ho+RQ2)%k}NiOdC~VdM;qbeQ;P#;E~RYi{4EW7v}C))sT6 zHy?tEYvT6`guDjTC<`G8>~y#I!JDue-6Xczs?4#2QjGxHxw4b>DSD*NwM=2W1rVSB zR4|^0Ow-7$OF_RK%(dpx!>7juA8L=+bT==&1-SZ6!wru1EP_8vPkO`jemytY&Aq;9 zlR+MqgyR&;pLDIcpvX@d%IGO1gFmOx^g|{jlMn@elx;R%Jl9{VJea&^6s*XKUjJ=H}T;pm@eJpmQD2 zL}(~v6SlD93L>Gk)tN12{+nF|;8}oifo#l$l|2V1RKWFyhCw#xGa2;J77JPL2vLtg#&&V;Zy753*c}tves}jgUr{Eq?CoAGT_`Fdp`QaR=>{{~9~sp#A`p z_+19$NL`tC(?*`|N59D|0LpvVa{@U(LApiAj4T*pdFEnguUoJH-W+0>fHE$ETk$-) z=y_=92M`;mf^hw`({~n)S8=Fv@ru!K4Wlrsv5}YCzRyIGj5IQCzbiH;YbNLsR!q3*-lkuJr@# zQWyJA^qV#-OIE9-ox&bhhQ&eL>WdA+#)6 zlUaD0Q9>_#;$Le1JsY_41ZjaIAio>@_l-+-h&~v_Ho0Ja2dK-0z_hDun0U*Zf(UjZPHN z`mG6sp4C2}JrJFaEvaXS3LrQOXkYkd8Ej)OaTiA_FTqKAoiyVqz{eTg9g>v@NH;$m z(lTr(Pp_#h8fUffST=U>YlUez+t;asY}C7NbbQi)DI%*51{HjKL^7HQThc-b>D~j) zb-*^BBMIJt?*cx6)kr9Omc%+2G9I^S_4D3-q)oHvWj&h#=rlAYg4yOU>zJ-;1>5AK zcePEc3Je=9uVjHzYJ#h-y@TBg z=Z)d+jaaXnH`~xwow(2P*4mIly@#Fh2M_47HN!2*nlrf8R^jICy`>BJ!Vjp#;FIy& ziU7vKI{Nmv|H;e+f{4>=dg(u}%BEb~qmV|aP^A8D9jr!j&m^7g1f_(%dG z{d=kZ{fLlff-pm}(ZB!u>;JX@G>5*>zXzH#8**{FyX?A0*J^O1%YttEKP^9(L)NP1 zDd&6cgr~Kh@IdS^A5Kq~y7g^t5~92LPba3(^Tgr}&8V+ZCr^KP{+Yk@pYXsi)?ZrM zeM=O!)BC@V3TLe-e>|n)GrZw_hfFlCHmk-u!AY&(+4E~YefZxIz3t3`cPrfm^$4|i zRuC8~M&$(czpS`)I4cT;o}US1n|&A>MpL3-0Cx&^EDh?Br6^Hy@EK;JXEx!!4RUq1 zTWD!bqnMb}3}3#ox00;K^a<{UL=UKo%d3M*Q1Y^p#EneSikgocO6CJ zVaH|CkoArARkGjsaB8?nL=@MHh9DTLfx~@N)eMS^idF{QBjLG{tE>wPB%S-&H4l#L)+Jgw1kr3PwaMgY=*U3m=D3mSsQIy9q(Z+L@e<8UO8zO{1wKHa8K8K~@*a zuL7x;WQVYlr-F?MxtR0h22~a1Khe)BRvetIRsD1X zb$~CnWuf2Pqi2^LhA}i8m6Bdn3|5$);fV!a&m_9+8Ao7wWFfLM%pvW>ctZJeBdTVN zhOR!njo8G{v@9dPXE645ac?qv1se-uCxehj$O8-`4}QBB263#-HMRT#vGUH%G^6Y^ z$X??=jacgzjIbOF{ITfTz`GE8&dIkbG9IsTS7)UXDRssWUL$e;+~8nTQ&Ym&Ev-?V zv(ZS5e>E@v^1LQ7?Nm~MhzOo1m`95T^3Mu%V#vKOsT{l?PA`7!bMTV5RBAPG^M1d` zxw702#1U)rf^2a}N_9t&^Z-%toKTO~UX70lf=vuMMKg4fi7Z0ii-+oi=H0l*cfaP2Hlg8g*=cjN~w-Y9Ou20huMtwZ1XXjwdW$+lEs+S+0oN`;d@bNIa zFl-}e_{&?*7@`@xjr&8GAr=u8-!r|}SJ=AZoOfg?w@7Y7+*|&XbI|%!z`>btWB^)t z<%m0AUdu=iMM6(IxFMUyQ!;=I+QdaH+jtDqJ%sQUiN@s7K`3d4hOKu8a^SvLBVrQ# z3u;`!zur3uJ}Rew=$2Yxl01!4y|1AFUXdk|L*i7Q<)#zwx?3QTVLW_ZXj!*E@&%ad zI!-oQ(P_3B2p>XUvL6nsm?##!B^REPr1U8Kzh}V zkDiV`GXbU$<`0M?;W+OLW~1;Q5_;*3qLRO#1DxKe%JG+uz)H@C!fddK&AhlUeazd>bKVM@f&$v`Y zgpCfST<2%_^s>9E?N8Q@RHx9d2~_|88L(y0`VItvI3Xe*D!YPdoKaJJR|UJzUgpc^ z>Dv~#wte$-J=!@K+-zQ@#Bnx{(D+8txq|6x+zYyKAsIC*)a8jquT}E!?_}_(PCaYZ5;=o zE+ZtH1k@Y_Z*ldMfu2WIEUo)}8z{{}M$TleXv%trzD}Q8!gv)v?+8XX%e1B`S;w_8 z_C3>iiS$%L$~nuTrpRafEd=8Q=G4dyMq-#A&mk>ZompMiR$|UEu6YY1hW3+>+F5H& z#cN2lGMqD5&IM`yFVom3*?`Ogg7dMXCOvUqc}v*xl}QG+pMhx zHP(~|%YzH^dhw~O{)|xL`XY989pJ&&1yT+tvMka~wY!7i(btl*Wf5Y3OntX2hmtoB zadA!zIaSvk5HiW~9B}W|gvuGrvl!&i3I%~}xG91sr*R1{5rRE~S+FiH0|~huI6Mx- z@+c=zEil1rb_2E%P@-&C^EHPDM|1Is&B|vQh6!%Iw}wyxen1%veDFR0q%oSJ!%ky? z0A45~X`)aoHb=!Z=6t%+i%}w2oOK5!c!4@l$2%vv=8e9JweEP9^v)l{V2IrXDEyn4 zFty|R=;NK%57`t(N0E1}FEApLDx`H3ML2pEHVPP=`%WtsfY-Z@Waq!LFdb67%ZV1wH6w}SMc-0S&CG^76HU#wBm~>>knzIeR1%M=bbnuCe6>F! z5u@>woD^o;AoZV#8k(EePxunMsQpwY^X^@> zYOivbI&n{ZxS+N7w#l<`4SJ|&RBhNC3IC2Mk9<{Y@B(djqN+xqVkBrqmLC8sZ$DGS zO(L*435#Z_IrA1e@t7BidKA8xBVa#VsULe=6X#do0>=tAaXWAaUq#xJYDnE{Vu{&R zrs0JaIxG>25G8e6mSc5%$#Z^T{Z@ZxVBMOCFh!~*`Kc9`&%&F#3X;;4@K8>jeaW=Ig%v?JoWkFSQ!Z9Kn zoQdksz7THZSx$74*so~vv*Psx?Rl5X>-#YRCI4)$>Zjqw@lP%$Qu{KdIWOpA@os9u zS_*sUQ?9EcA?8D*HfGwVGkE`y#_GK)rxm2VQqPHUqjNxP40KG6 ze@w4X!M}T8n3NH9u63}%ed|;l2}-;Do@r4nB=6Jcymh=l8-%^Z2$?tRtIKv`f@HUo zgBYF>T#lcej}Th4PqzgVlY(;SKq+*dr?jC|w#*CB8(+d2)(b%HOzGY}EsS5B&nWvn z!WtHHs#J zKjNH; zD9QqB^I0FM2C?g6#Q!!Gg_c5V_Ku-q)czx&NVy8*6&3QISeO{Q9p z6)+V!W1$5F;E>i;X0=k^k$RUxd4IiGP?~9^6p>%vx}Vo$?)`F`K%mJW`M7tFP%glQ z0JMi+m0CR+4tQFKFbyWi2{t0^$uFZr8JZ847nqBFsLEx@(DvEHdsv&6iLtzD2Rkw+ z_j0%PW4DpZ7F3S3QsK*&-R5wfjlRCbp=|h?iU`>b34XZL%dEhaUyo+V=@y->o<2`@ zo^*9%wA{;!CZHv>_54bdcIXbB88(-W`;pu%_Jw9Hjz|dc`lsmBaTV+EDt&rg-*@-6 zKp6k;fu%f~%*SJ?qbQ<%6?QWCxPix&JC2YQd8g4kN}D%^_nuTz81I%J&1Kg;5EYdq zfm2k*umk0$VNcFD(nu(NY%(R4fU;BV=LQecsfo=eShjU_wSEiK_3uD5^h?!)#o zWkJcTkSSU$NAD1=x> zfZSNn${g($Ugy9$2wc8;7mpq0k#lS)9txAm`9_r!tLV$Rm2-S~S+OA3qS>?llIa|C znA_Xv!ucZBTSKez)qva;U9!}wj#7VC#sG;s=hYwgve-ek>w4U7^2T!ZHi1RG944?D zMF9iYI3-_9?1bz(&uf<`ta(WQ*vI2>h?ka5UXnPIgH|}Ri^O0p`Ley$iJrRNrsXw< zegRh;-MQH4qd-CR;44NK)5LlD`BX6UqMrN|5i|-A&H>ljS@lhkqf-YK>Xq#$>Z2Yv zCEDYlVI<8}>}$1(5w6D{9ZIopo1`M0Ua!4N_EF4Xn(~4-QFpO0`=vx}1@(1PDVJ}n zA5>5+`H^~Hxwns_nXO8asZnn~pU;S3#6+l-l~OLuJ^^8P-TclQZ{F-VvPWE(tkydO z&24~hg$R3rki4taRN&Oui_Hanx%Tv%{X)yN6W5)rkwvfX&m@=euxJjXmKT0qUtx*H zu*V|CKgc29@c$y(&&?wV8m*3G2vId5&N92>e=-s$EAl)qKkD7bN)=UHc`-t{EvZ!V zhY8;c{6-5N{M@>7ePh71oMP%cbLNHU6I$nVN9 z_RXk(-xCjp)z*;_aoRWSS5jB$qIo9YIdI(9{$YkJ&X8lrBTZVs;CvSXJ0%4*Mxg%! zBC43Kvh^XEUCB!ltgD*x!5mW`vllVKwd!&Y9L-vd!?N(G`QN`Mtq10f*&q8&Zx;6p zk5m9m8`pn%=;5HpaEWfo_b^+}SHf=oXUd@><`Oo9dhUwvMk~WFDq(JQ_dq?acR*6Q z%tZw`D>`h;jTS}TFXObItJ=KQ`tW9c_Kyrg!y8=1De)wMz>M%_N`tYETL!_(Q#bq^ zl=0tO0PKpNM%3EgS#aNMsq7I-gmANQyWvG^|IM4_@?e!CQk;W85QyZLmzk$*ZJl5i zeC6Ni|GQ-{Knb)%j$+wtT-!qj-1#YS#d0psbMMRzl#`%oFt#TpmTz*j)^uBs3sM4^ zU-*>et6gJy%7Mk5`7u6hkRrS@8V~LeYKg!DmKV~WBRN=>ZjRY^bi4%xPmIck1KNg$ zop#<}-)-z?xKhi3SFTNdgxN6nq^`WgM!Y3s2uCP^ul*la4%kcQ<_a1r-Vm4tgu$kw z6qWRNixTraCfE>fjrgD8vAk=tFyBsF&8!O0vdUM&d~v zAoV(Sal}Jm`HVMI8u;gHyE0-TLtbzZy2YTrd|Pq38sZ znBL{esy|M&un`Ck8+L>+_4{2C2JRsF^;S`UUDZQj@vql(MQhzAmY;1oYcWFe*sGiHyvqk~YU)1~?* z8wy+NN;sWv3Gk*FWD}5S+uyNgUY$Ukx@S<<>t_gT+l*U>K(C12C zl35^Jso%!?J3?(y0#So!>>vyIs5&`~>EDdDzGGv4!gUXu*!dmzhOoh!cI!LanCzE*4JHKxIUw=v!mOzIx(Y4kGS2Af}Y z0)o#gzGbQ4A7_&rJJl{wU$H4R?{1afB#s z-{Q_7WIpc2Z{SYNy?WZY;GWWxXI?GPIdpMBn|V7AfM^PQkOuBkpU?7Z`-b`WoJ#sPhB@JpN^Lp7w`Q?^D{1M@M--Na$Yhv@t-xs0mm3uh#n1drK zs>;_%;H+4>J|;zEO5iU;-=wlrW!wBCy|zSUr_hN?kVks? zTh;XEcx~W4_QximDU;lZLKA0oYgg~j!Q;l0$n4C52x-m>?aypnt3AZxfxmVpex&K< z6hdDvO*$J~PY{}b#^klmJV^86MYS11w7yD)C5kP_Khn1UR>@=iCo;%uqw%GbkZkyO zX}&?Zf#rcu-@0%;^BX5#b^R3F9mn5(W@R2A-TTpedP?Ocj}Jrj`=DP{^9PZ%$56$P+YE`3ilA`t{Yo!MqGo^2<#0qPP{x>MZFb@dlXkKD)E zKOFp~mHKL#?KSVSbe)zidVZP{vd3aU&y^o`j)#vJy}yaV+}v*G-hT7?=k|AHdgGWf zS3XFLYU_Rb2kS=ma25QTb#3YeBPU#IlbgOgIxPm4nRN#y{N`R2hWZ}o+qUluxlUGz zOczR)AT#^(TdcNiCDg;At!L#C?9iAL26L|RPs!{1-V#B!<3DNLAKd|uRvF|kvmm?97;x7C3IB6QT&oWu7?aqTCb5h>MRP)hb(XTcWPdI5Wvmrm?%$ST@#ww z*tEt?OYIDJ9N;TY2^n8HTo;E>)_Em$AO2xNJB~nng!&pfg@D=5S2mz}sHha_%7 zXU|0*@(s2Xm_?z;de8&|d}lftWYA;O_1;axo^g02feYY)XzlD%P$|igX8~B^#qYh- zklTX4?kLdel*G{g!K>5@=#`MckNvEmk9ifP0ql&W;o2A&vjQVzF=petp`g@Py;0=i zpAgvDhCKRvEcDoZex{Ye_R8rYZ|;605598FMt9_oHvELUc+y^LgC&Z=V7bwS!kgmV21H@hr?h#soSf=<%K|Hc?iE7- z@Sy{EO}jZ);eo2$BOot^+*=-m>#@6g#wHIg@5MBr4#D_$pxZqE#;Qj3gc~>^r^2Hq zpe^s~S_K5bL4NhY_EdGeQJelnH6AGjFwDQCMgtY7AXxHjJk_Q%=3=Ijyl-J` zl>`$f&9k(rC`)J`4R;+*y$Y$>zqA5~vQ3HL3B-MJmwf5=3B$T;2#;-Kz$4;?!Ys4n z%t^51p8KokX0bn3e%_Kn>n$=3Nl=0^h`y-kg|j^lOv|1}L@6~wCJ~==|8JuNPastt zvJdtAG8p^u`E9s1WIb8z@$-JhodR!B~;s#E^mPxncLFq{E(AUPB{zZ?7#h{>QaKY1i?wi%&Z zsy=4;%P7}dU(U8!iBmsA{Of@i2xX0-7}jGJ49~~@St}kN$DW*)_kX%`90E&|MUFk$ z6=#72W&YnmZ)+j?ayjntm$it{bx%Ys;S}C=vKgw1Q{vv+gG;|$753Cf>m(-yNqmJR zS>ajlsv$VD3I4@a0cM~33JZHrL|PQrb9&65dOhgpMh>w} z0NJh0HoHGfp^p9U$~~4x?ka&j4<1j6LMZ=avbV|$S{Dm5L$Gl`a;Urz!GE~|U?oLt zNCZ%Ib@Q}71O|i*Gwc34f^2#agJD@o(FU2>+@m|d*T4fx;AsYHMX*xIDbfBM>WVhI zaY!&U|M8L@>79QWVCoK{srI9b8{xv#z251&{D=ntA|yBo^^i{ERg$l;fCY&~#+-{k z-PjaPmlX)NP^6Q(yj&Pygt*d!@QpDE?`05crZD&Z6Byv4K^;`)(M{_V;kwaZPNa)v zJb}C+2GAex+2TMbwLYRGCtFxoiBw7AT`2L`SlQ=q;6==HwTIRwF}aq@Y2p>-8Pq`xXH2M~A`g zIp>GBrk^DT@%BtyauliX*N!DmpPaVNdxfC`Brb>&(QLChs^u>4^w-R&NeezPucQjr zem!kPqI5rh(6K>}V9yYk8ubD;7X*{e#~|<$bGH2o2*6AR08U+(1Jgy7v16K6xi9s9 zS^godzS4GPNSS`brH3d1&AT0$;!FGLj7|IIoUKcx8``|E=bCq`z(x%R!h(%I(bwdL z5=S$5byxhRv1@;}an(-L8($1&3OA$#G%DEUjVz2BC1{N36V5W53-`!#p>)Ap1bb4T69E7lySNK zG$^rfYFzhkEZTPfnX&6$ckG?)NK8$74ITUx6hRn|N^iV8l$lf*Jguu+NF5xB{BmS6 zwJllw05$v(cGBQ|o*NCkK$dS}-9j^-_d56FV5O+xv8Jf6I5%G^fx-V8GHI|P{%RPkt&x3W}Q-<-WX0HWAdPu4idcR#A(u&Mi?pK6b zie9=U80RS_Pa|MyojXVJWw1f@8vRz|U|2tqn4Jr)6m4hZY2AWK+(u8l^E5IPN{s<1 zl>aa-ifnA;e3`_ax#y&-1 zG%Dmx08K4W6x*;WbH(x_bxG(YMyL{5V3@`FWUbG>1&OVo)!fZ1lVsS2U`9C4Y=6m;EEQ#sp#~LpI;jCxr1~;br7TX+Ia3cyt zSgQg#uFy{2EREY2&GVZ}H)c^A4dlq31xAM@Yf_Nco|+SK2z$noFAIM0*% zN|B=BVwSJ4{}-?eN&PqU3iu$_*)1w$A}Ja`+!PkD&-Cs^cbpi1Eh;g?aAGLNCD5yk zeP~1$!1L2X61*xIkzIC?st6lB%%#qz)JMHQUr!uuip4AUim&QeAqUP+|(C3E(z(y{-N(TE%CU# zxL(6uNP}bx>R?J)Bu)cgb#wX5wDeKHSLg;IC@m`|t|BaMR3jN+Zc{-M*qnp9T2vwWkNC`~8^P70!>X`$;lw~xLLdN!Nh zwjYxA;7?^dA)(mf#~@K$(*ymE$oMM5J*9w$U?RbY8t*piWY=$5b(w5gFWgi#bB?tY zQf3UO>RZ>dDM5#R(mtO(TQGv`2atNA*WsmBoB1OP3pBM*-J6YIzkRUd9kb1*S4wTY z1<%2eNSDSgWKHd>g#Fvyii4c*D@9hg#H`juMTjR|Hj6$9#d%m`kZI{xL&IxcK*|AL zIrXC9igS#c##nth(XIp}hgHAjL)L1RcKue-dSnAKzAX6Wt;cW2{*HpTaseQSA{-b} z9c!ELu`sEznc=)-$W*~(~!vNO z{Brb2!(hJi+-Q#jopok*H^*$gfmnN4;XZ^6a`k2~XGQtpHTiix+igz)AO@DPS{qj1 z{bVJfwcaP}I+3~)r<%a?CWJ7F3MzI#kH_MIKY@SkWJUH+ zHUOsj27^7L5DxX4P56@XCZb6N*x|wh)9IE(-EOZ#QOL`LId*WxZGza>jHZ4SXQ{l6( z!Iv}j5B#AUr_E?zj{x$_JEVV3Qwjj@sqqjz7e=@htm2@?w^146XueXnsklZ$s<_^K#}*Ycy7g|TXk?m9Z!xG z@F6rpsOs{_KT9z&cpe`y7vMH+-;6~ARES7QyIkuE5^lJA(krh*D%sq|$QsEUl-2qz`S92yTg&V;bHz|Va!WOi zMtUBp{hlOk*!xb&Gum*dWeP6k%?~AIqVtzTX}LIX8_#>nzdz_c%ScnXoactzMEzhX zAZ4i0$6JD!t$`Gf{?w(570pt5cjwj_Wg3EXbh7%Y_rBhi-vOCK)=8%TUSSg*q-dE+ zUV4`(kQ!7)TIV4upw#Gd$oLL=SuOfpq4PQ7dGJ$R=W?_<`8QNYJ zDOgKk1$fio>_?ZaQCV;beC2^)b#aLA&7;=gHH8QmGhfOYi*Wd1L9O6+H~n*PA&STO z?6ahSsSKDe3EOWF!=YXE6UD}JrshAAa}r;NO$&Ku_GrtYoZUW(ascK{+LHV9a5+;k z>8OK`ITc zD}bK|4VrV2zu{r0A3B($dz|=H`1YF?Ipmc@>3^390CXM*Ks^{xRa@x4g6mK*$6dO? zzNl=r@9n?!6iOVJy1JfmD;x-uLyE-iLAomoOmA38)AbJ@DVtBds|^Vb@@|OS5l(;B zD9`9b>ffw8l%PO`Pi|cH6&9pi_(=lEF+9tTVAaJxl~>BhU`B`bb@5G$%>WZHnjs!Cu#P6WBeLIOP} zHQ{FY|4o4jdLBQb(mR&bz<6<6amd}QpqHJ*qvxzDH_POUK#fp95UGPK;m*th!CS}F zi{~sn(8873#VDxQjBu&P)0@^`!J(8Xi%?t;Zj;Q_@9`7bLyVx>X>3ry zMi0AfXXXQtCV56otNm(Bs*3XmY&qniq?U~gxF0R+8XkB+H*WvRy8Dn_r}VB&lL?pc zdR2RMZQ&d^vcCM%JR}&<+#J-*p)|a!s=&<{rxtl|M6z{y0B2}Y_kHXK)N5`|qZ-*O zJ!FTJmBuSG=gQ=4qbfPXHd~6FBb#-5H7dM97go^D6b*T8iiXd`xl&RGKpqmo=8jv1?jU}D62UnQ-s(O*gq(=4R;U8(pT2)9C z=_4T?JnH01m^}?;Eh5o9HaNs2;sO5)o*`|I;USH>k?9)|JB1Upk^R;*2Ywky{@`xf z`V)|6JDn#Y4vcz(Ah@_VdA%lQ%iUv~xl*x!+l&w+$cC|7JrYUVniCcO0(SXlX$}x{)5byQGE=13_@;PEi__?!FKD`^R-(_w(*~#ahE!GyCkb z&)(nfr_Q|X(#`s%{Hi`gYL^tKo3%#9j9Yg(nY!O?Rr;j>AfkGXA{a`16}?DJ2wnHy zCcM28(TBAgXb9(7*#<2VC#|bRDk9V-$?3+x)9mN2#F->r55tU(8mWdu*kqB^eo^nb z2xDTH{g_s49Jc@l$g#N+I;hE8EqB%4aH@veI~9jZ1SNhsFhcK^;!M)IBg$q67E3;B z`2d=H>UKHbLYnXkdf|6hA`k_`*|cAp4r0kdL_{_kr*+TdA)t*^;OChz!?r}tLgB0K z^`;1>(ky1q2l`j8aQ*FiafQX^gdF3lzA-Yswi5a^L-8P$Y5n&U62K&ek9U0zf|pt; zC%wa_bsASZ>Y6C+w?=eS)_-$KUnE4}{&W(rkrgL6v!((QJ;{7^*y-hEFF!n0+FVd< z2UIVP3sDn`uYBL@{Q(I9_?CRM9*lsUpSz8`DQr87*FzYg@uuAuJ~Tyn3|-e)j(#yF z>6X(OK5}3|Wmgof#XrEA%k*j#!V(r%jK2x6M`3ZM_Y{z_--S|H#~=00uF~~b9!Rkt z*XgsEB9#lQMoT$iL)+1}vXv&y%U`g56Vjb#W=Zf538KEm|9sVKJEc66H*hSUHo_qS z>ZYLfP3CH<_Ga=b_Xm$ZMBrA?jRhT|63(Ao{iuzN^rHDxRT&whF#q$62QGThyX~)U zQ#ZbFqub0#0=n+{_a(h5w4(j-sSD>xRi>&Q*=Zy^nSMprA&)bkYBX_hCA~h-IDIim z6M2*Qz6+MGDBAD6Ml_XuUDsU3j701yV;k#TTeJrGs1O-nX6G>*oBFLKJn-S*b>Dk) zt6hITxhICh8b$5WS@$OH5m4&Z&cUpf`jYx&kv28NrUcChK}SqKK$C*t0j+xx}cjJXS=kQqj)EtP?ZVhL`ddBheJx$0E+ zekM)%CNFZ)U}F|7?3#XZuVfThSB48wYKWuDyITCN_)K1g#{5eQ0MC|(cq;DRD+(fYKbtodn)w+^Y$r4*j)*N%K=?q<9VSkXeCknCD7Fvsls@# z|CDgUZ`~nIDXl)CG_ivibU0OqJ>mC_y!{v!P2jPTxJ7DpC<0~aXXdnt3@&IcbLoCk zVF9X6H!(w!M5?Vh&>gWa*|=$QnZG?X{wOwqoUXtB`ZnTgSaH?}xyi%H+sNZmzybAD zk+NHOFddOCW`q;F_*pA*pHoL4BfoIR5KJdMk~Q z)aMG>)hO-#6Y{s8U3Sg!P4#g$vR`vY zcFW!S;`?y>VsQ5QTL>k%yp0rWU8Z+k(QWOyP(y=F=vI!yGRH~f>9xQM?Ay+ANcTQm zb||ssg7ibe{-O+CNrg$tdU3WdA$^Sbdy^ zb}?-|%SF=-2A|dV=!Fj+J%4d&qxTzWtR4`WyU1saGw}Isft4cWdq6Z_R;GlE?~8yF zaiKvKYZ)J+$i`X%Sd!U(ck6KYReo_^OkSQJj2Tj>Vsm9zqu=2QQZFXhK$&Gsa;daMI zXL>q1g>M%tJ+Tn(kzXCt`-ETC20vjXN2T=I)WTiSrO=w7Ua#c#_)vz-O}9fsU)4+T z>xMZ|#%ov}+7{TA5mmH;&9E5x=$}M9 z(gQdocAJ}GqP!k+l=p>lneO2(m18m)5TzNLp1{>=jO7|u>yb}3qbTT-56hUT`mSX< z6Y?rp6AiTqGBgEctD7G`8IIQ(W=XfR=}F44Pwg4q+5SyInaKG<$({Pu04A%4bhMQ0 z*Pb<1frXviEiNR1|0BNU-j_O!o%BxAzJzrOJl0OE;VzZ-3xO9s9J!up8Q6PTrV?+< zT6?~Bik~GOh1nch7xa-f|03~mp0bPniFZuo2cezcv%tUwrGzQ`wRrsnfi{(DM-t!J zC(xI;EKuw-=BHC82i*(n#Nqu;-hBB{Eno|MMDQYCAuK7{Sls2BRx;hS2rWYYR0G#8u~59(M3pV5^ETg7>& zf@9|X-pD`H8YO@$W03*KIU)({*Zk1<>wV1wwg7A!Hu&eI(J)O}#n|=%l%$##=Yb$c zColZZx82*^s^4d~`0^>D;`$L8_9R=lmZTtC`J@T{Q+%s>#M^IKvxX8_y3;MrTxeR8 zCeXLZk4!Z_JYC_M+l5rH>Re|%xb#32k-oE%XTK#5jHw(1Q($*z{|2QlgZ|pPkAP%MeBrKR8@Q^S(gm>J| z?)jMu*eX}H>qf&CwHqt|tv?(?msls88Eowgr|=~*Vx*jD87jU8{8(D-k@;&}WQ%V0 z79$lO|2#ciEOf+68v5lf766D39`z1_9{jjZx<8^7giC)hJ&|i%6fT{!V;ODr8|v_|u&lnhVmxKL;c)Io#er5hdFS?8 zSQIQbbf66vOtaogzh-y=)4zkLio@VTBR|1^peo#pQNvMwxqPwKAIX6`=qr0%9rzc| z#Yz%BI~WK8{?(DO-N9qqAyoR))K3*Zix6|^&|#7HTJ3O0D)=uNkbhsK+?Aie}kA%KZ=6;`2DQQ|2spAq40O+fYUMxHFtDCG;X2!KN2kL zRkPh_Qp2#SD#id^8rR1{E1E79kf@ud8-?T?T4)N$+$6J;kA@Ni-OGTvmo!kU&vEA}}%Q8EORL0Fbcdo*>2TLvwi>UXzV%4X6LRWxbj2j`)C zwnD}O#G5S|pWeDhso4g#c|6`dwZh(-qqf6=60ewhPL24x0T4hF)#%vNfZEi#QyhE> zb@J_ufJ6POFfg5JTWO1xEaYvCiQ3V260v};F`v4%$?xU&`Q ziC1*R7cBS!^5vFHMOQ%a2d+<9IMeE=AZ{4Fz>bnAm1_%Mzu=TsBk;U~t;t+1q$?-m zOhZW04Y{naKTtg)s&t}Eh`ZbA$q|ARdeU(;d;Eh%;Qu|!;F#BbyUKYe+>ZPL*B_gv zBhS@>!6xzwkW)O-SY~UX%B?x^ruIR4GS$M%_aBnGW89Z{%1I-rs0vC@mKH#jIadTI zS-7-#(dc#RHZx!uSAj>152o6=D(4R8j-GhdWANQ=5E#A2&5i>LNy;s*(;fb)s7Jqg zeeHCK3@dNu48JDsRTzdJVQ@AAJGQnj+1dnGL3#wuh%@VOk)T8V4@sbEFo}i7$+4Fn z^8NE55^ck5uhktJ_`IqmH9uE!8;yXg-&JUPUcVE6U5}OiZ2%L|T_CfwC>fV=spoB(7a^2m4jRy@za zfLPBnRb89q9#CrBNgpEN=kIg7WF<`RbwAlytIoXX)fGA(-`aJ?dxGG)J?eh%9<%-` za*U{!|2yMrvYJgD*sShWh22s54=L{H&OIf{Xu9P=&u5`wZdRp6}_bpk3BxN`Xk=N?_9(HcI83J~P>R3Rs zJQB)Z`@Sa!Q3@YTOqs#qW%$lG z%X?9}31|t+S2MeE={6#^xq7clEcIoHdk>s%k{-7H=&7icgY>9H(`k$sFSgH~PX;c# zf2fW>H=Bot1SA!+&;QPxaHwnzC|+)&iP|8Ff`fsPL`L}lLLUFrJ()ZoH0XNu7o6{g66pT7GyOtbi#s?%py%yM6O7-bY}z!VKG!70Qo8 zGuh3T1QJB(y+{+$7gp*Wy*S*d}3 zd35Yu-JgZP<|`B&0H-bg+CaYJ9mG{SPC^J(O^z`~{EjG~2IX>NM0hJa8yru#3b;S^ zmQ%Co2hRgn24(Q-laGazKSKE{(#fQrqT!lh8GP6tBEuSoSBIDe{|a|BbbbD+rn9B7 zSY@y&11F7BG8b#lGo-NC(c*8XcxDGUl4mQ7YuoseVXaQ*%WJ=y?O^E|L(|c;`*>8i zz-RjhQVuDwR)&ihWN>Y1X@IM7896Ybf*Nj^X|`)YFsUg%1y2co@VJ>84WvV#5o`kjsQ0Ra6u1D2lD` zQ{(+M=cz%B#!LdNHPp=MUlf5e3RO({m#OVgNgRXF!xs}9k1+fd>0J=lXDS+*^6fY@3SP8&3nABF>EZmk z-f$7VTR?t-dR6}EB_TUZgtxHqI$0X&5b=ZWads!$MNy-Qb$brm#YYv@SNX*s)f(sk ztx5*NClO_|H0n+psTTj4M&`-J<-+Q*2pzDxUDKr22c!LxnU#l-$B#gcRF##mt@_;0 z1@C%aZ95C`uPywz=l`R*U=L0~qKLJxsf~?J2J_vT_|9qG%B-NBx9K5__@-$-ZBYC~xFMb~N5o*0rt%ZbD zo=K-J{>0IPewl+fX~=;w-9ctdbaiIs;U zMiVUc1!ob1EXbT@Y9*cVq?bqy4K`hirIGB0hf}dA?SYvL^2n}C9^KzAyfd6k;2SRm z1)_Z?aFhh>qtoc(rFAfKxX7awA#c&gh5@1@Foc~s~X3&yqG@|M}Lw^bF~{_bid#+#!#LA zkq(0lB(q6-vI$dOucQ3W1~8*by#=$K*Ed##%&QlrIKJO{H*L#UoV=}U3^e1HOGook z?dBZzZU)NQ#Civ8+V&9J~smHiB|=C zGWL*T0@nJNA?bSIAwPmiU)Z-YLWsMlWyYphImcQSB2+4k6edd<$YuJJ1c2}TTw()c z`y=rhr<$YnalhZPeAd6X6j_Q0SfR6pntC=_TwI>ORO0KUI%NsnxXtv{|EX~S$CA=$*Kc$YMFmOC|`cMp@%ho)s^CCGg50|{u`qEcgQ_j|D| zv?ROd%iQPE5SQ6LC`w^*EhF-U*PsdRE;{fR#%V{x8K6TD$GQBWbuvk2fgjsfUQo=>1^~a{PIz@_ zr6o-ib{H{tg8RH9>_8F#n!au|5xz`K>Npx8O!OC7vyM*)H= z`9&@mex8Jzpnyky$eJ;#)h}XNz^pVVH2g8SN6i8~I4b6_{fS-w7ftx^!_RsL$M7qU zT-I6&Yt#?5Yo@oGG$8DUPp#QhM&j>tE)CgaCyqS>t;2$IsD3@bsVHh+1AqkT;qK%CX782V?eQV*A!B{f@IaIWSO<`*}D zNd4L;RZ73qm250_WlEM7|@w1)wxFXU5zn$FWE+BbS zN;AbH(672lAurlyJxA$ztI=0e_`}Xw%=o_LSsiK=d?LyLswB(8d42F55=M;S(!P!s z8(lBv|4d_-AEr2p<=yEiHke^pNZC`bJYH`6M6H=8;xY{X*uedZktIPhhxL1DMU$%y z48boNkJqPaJ^7pRr6Gs0e-dxZg5h{=L#)!)a?jS>!B_}tiwLftnh+r0LSztDj!W_b zCQ_j^;+hZzSFo5!7cR(kIkR?#_2=(}Gr?ciEI+&5#rAl5)^BYLF{qdAk0%v^mEU`y z;hj9N5!l?xP9J`9(-52)eDo16u@gQEY}gocstdzo=eVmjzUTMS_Mf}@*P~pNoFX%&bbFXDXF*RZxm3u5L-k1ERWME zn%2t;Z4dcH{EJd`*@1S!NT}wX7HY?ptMxI3*2VFt7cO)C*1br5@MJ`Cpv&h9J4^;K zS1-}i2ChrDWc<3ozL2_c~jOc`}(5vN^8le;Ji&a zjY)NQB2cK)oi;Y|0TsfxY|ENBrsfTWwn#QXBOr_mgm?S19*wQ%L_;fJ{hNDh(;Hlb zNgYVZ4G7oZNf^A?ov5I*!{#;5^<>}i4pk>9$mY{C$3pqJZnadkst(_CR|S6Dv*}sI zsC%xYeP}*2^cU6Ne8cylH&=r4r`gcUnyB2pv$FhXH%IUVBC`+ zH8oaJCmILGrjC7~iI?rAepdc)c^GJ6BUc5U)|S!zsFUE*XnG4*SrJlmA_#UHz)72^ph#=bvUuxqrpcIY7SL;+-hsh`);(TsFg+a`$AB=fv1UCgkA$izw8D% ztd+sdJU6_ye0ffHhc5%trt?qd#c?%qaQ|HSn>Pg`g6WLBU4$Mna5%?sbM96<;@Oas zBZqW7pmJGL7>A1~2zIm~aiF>bLH(o z@Pgjr)dHv`kJ<}eX3CKRnF^$} zBDJv~-!NP8i@4>Q12ETKAUypbruI?x>Sk6^e(?*jAsG121j#tnC*Axk4s&yxB^dSF z1>0zjBu-2@_n2z@WU&+40YB_tW^t<&L{xe1z4*m|0ZIWsJRi859<>y5JHn!8i-4xo zTIQ-aJYNnuoEv;YHQ5v1QLy$X;G^J&^xFp%qx^4(P0^E1(hqN$i!{ifd zYz*$H3Ip=;)$hiex3Oud-6TlXQ9CS-gR)ieS|v!L*~F>2M}dN9`VDV{-t(ia2TKi)WrLE;TR%pnyE1<3XB~@8SYjYTe4MC^v41L zC`AlEuYZ%E<#+-Yc;V`(Vd+)Pi4&+B^rv0ncu_6b*u1O!IU_Ry<80Inj6T4^vr zl~PyTvu;wS0O^eQ$Uy_@!TUFsSGmrs zD(HF43h&O|Gzo&x{A?U$xL4NJ7iup|AcnK@Sd-u8jWhB1yC$dNtYxpFcf6hA-=mp3 z?SH4>65VPAYj_Cu`KLML;b28dbenmoN0&x)aJWMef4kWkiK4r@jl2d2RxS@R$aO_I zx;z}kAuU&(sGm@pNHoean{nyA4|?-7Y!)*vXMu_kDr){-1mYp%sbceyV@VUz7((C0 z)mPOatuoCz9Xg(_-D95ERw#4QZP{ID`Te!U&&P7CSJv}I z)`o)^4zyZDy9`d3%Rq61bEXe@Y8u?<{2V+wYn)jT(>SotH=Bb8XjWo#lQFa^M+ zZvm1-AE}=UGsxudOqghz2gleUsO-z(g!KB#N&!&}Ne=*|b`QDqPRgOLK$fX}cM^b2 zs$k`0`BWe4V(ufDK)uWFkz5uaw~0D<2^EmG@a#t@{NhGK?w4E$-1{7dB23*tW6LGa zXxcRqOZq_Kvv;n@{0dQt!)iHGjXbi$gNMJ?$MpA9AxLr}7E;36?*X!@3og)`Y1)+9 zZ#WQI`0~CYnxKw&)f6RSjr}V)-oXk?(WPl*K3|}5E~%9HUndb%xrI^rOW9)Ubo#wn?e+=!-F(dgPfI!L?5U21qm>rQOiYUyN zW)1bQtgU-zGrR-lSNZEI|2PXp0UUjA=Ew`Pzrxz3QewwFC9e{D4&4I-Sc+1t-H4=} z0;X|XmxJ}4Du(LPg5qyszF{p|$VLo0BOnee9}xe3nGSgX!sd6Pe-N>Hum%6o1SN-w zhFn+uOAA2CAPcEf-8}ggHcmoH^Q=E1@i7g%&tf@90$6^ zd%npahct`ayJ`RM$>9NXEHGrJ@?N*(ivf5U&qMh}^zX42_Yp<*3f%sBxVfvTq4LZe z(3`AJ0>1)BQ0)@XOn@TE4tut|GZ^k2T5Z)o$Skh}+uhIx5*c5HCv!cJH&G8ULoQ7! z`BVVsh-<`kqxh>pBG6Vvo;(%1PCXUXTs&3Pgcb##m^rZgd`O^Ss)~r17w6K*2(1uC zX+$3G1(A%uJ1(e)o3DM7TPT>)YFmZLsMVfU?$bUg;1O)r$Lln!60F&l+#Gv7GEy=c&Q4@W^>YRZ}&M! zHwLx}k>g-~V7cgyNtfoD=5hE-6LN|ss={vV(a9GruMdSEZye1VSg4VPl#{hKt;cTV zF7_|O(#x$D{-E5tVw)33G5~!Fe(3+RF`2oS_P^L^fTRFK=GRXUO$dl%aT`ukRk{fcVHA8w+=qCrUFp2$!?edxvEIE$G>>LT^Z!l3eRvXlN0WJ1BD%$57T60 z?ZaP|T-uQ=9F=?uE2mUYobsdxQ8Y%yv!^cAMUgKZt&i6Q@t{4w_b z(;h$ok~&{}V_Vd`vc|sTh5p+gFbmL>d@LS0y)08imS_anc~qW!TuM+Tu{KS>4!=Kk zI54#*o6b6)o}M%uacBel9lx=4cbJfxlpWmdJcL5+Vb`_b)OR#B!{;?C-+sToBMX+7 z2b(t=DYo;|vYAD`WlA;+)sK#y{v!znyqLsL|8$r%@`?x-v>|6o0>#G{LvU$e&=54_ zz4%^RM4eyQIE)l!^ zXYhZRb3U+HzzK8y#zE4cTG&bfzT}XMGt#6@2TLZOSwpV8LJQ_&&B_ zRlGq$0$6(gb$!?%TbmiN=P2fH!~gIB_|5-|53s^Twj>s=rDE@av!B-{8W|)>*Blx2 zab#f@N@`40{FX#epFH?LhX*qN=eB}<$wjyylAogb8s%r#2ASKjr`o5UM(< zB$J?!@gtJW1N+Z;Rh58dYDMp&qid5152YHf&PyS+6Pb6c%#I)jI7Rrw)ECObY_ILi2M!EfopfEa43#*$V zg6qtG=1Hn~d680sp9cOIxjvu~HQA zp^}fvW90|TSI(Zw{N@o87Tbt=mdTVhev#KwyI<%?Q0wnIr6PW=2AR(Z%<6q=D^Q26 zcHqq@lDwW13bwOdGU8trey5`VY4G!5?0=LrKjUhVUiaMCt4ZSEpQZj2P)oKx%@U55 z^{9NB^|Dnq06u+iGf8VZVID!2GHnap@LTQwfWy9Vrjhd z#%F2x&1?8sPEK<1O8}f4n}{n*a=*r94Ilh|dmO}LWnO^-h}V{QDX zIgaFyAbv+=*!5d|5xt|5op_fs&MZCoH-OCBaL6T5` zxq>(ro5yr_f?nXfzXIorUSBH$Rws6-DhS6Q{LGiuwur<<(x_&baG1_a22fLzh07yn zOKjH;^KY%KriKlx#5ylW4p^reIw1vCa3+~=h3fbA;~o-}4wmNWmzguNgIASi13UY) z5= zSO;=oh7}J2v3+e%S?AZZ;=jBie2)K}1eaxfFoXiMoe9A`8hEA!I-!h8RzX~yJu&=q zF?WLNGQhL*uwsLBpeNjDV_j~cZbWURKi4vX%dRC&YBUC}I&@A960rmBP6?OwqsJ85 zmRU=Kn#f%Jjs$5&C8T>S`mD&u4uxc5sc(?+_s^81ej4fLsKu!<+g7*h?;TjQ_k^E} z1%Cqe`&`?CHnvf%gUL6qe&z7(W1P^di(s-LgM0DQ|AL0&OueDjf#7%Sf-#)Cpj z$zN^T>VE0Sk++S41y+G!$?!UOn*w8<2<3%9P*HTO^^7o;u?0|b0)-_Y(H}j?e|G$O zycG5Gwm*g1{|)uVLdPP%*K#7sK_{xiQP+CFtXrFC-f%YIS_2bt z5S?y!F7x{i_#euK#pB8(KF`-&UlSmwbBRXWpz~}A!wY_3lCY+)?5jV7<+9?;n2H$F zqr+J>ehJiKM#3Dd*Vd4!oQY;1-VcGpURD*WyYW3nDr$29?6cBjnhc6fnymu{~hRK_j2N(!33hg*U&bfxzp0wBcB7}F5LSvI?xh&!*uPfm1-ni_mpLef zF4-z=XM|Kf=iOM~?ge1`S+6ZG@#_UHL9f4zBrpInWQWd{Hi)h7ybO@nx!=5xj9&b ziu4~>>7VAJJqT{V+Z1-gwA48;lJ{SRimQ|Vr=j9d6Vl|)Tqt?q__MjS2-cOQFUO+> zKWy?!A0aNGVLu;Z;7@}btnqrC%R)rGy#UL_siP6E8{n;gjxu%`U4G%>pWC4FCT@bM zblXNh^?5g#L?WMonGo_ihYG#f!U_8<=GF!>&TrMa!z)dR3W!-sdY;Q?l}xYCh9Qe}QTzS>n%eTe!=A+zyt;xOt4 zm4wsi2)}b+mHEUJtsGKYLjNq3{*&t#G}pM^Fk^hdWV|;zqcib4OA;SEqoqBR@Y9VO3L~}Y^wfQ1})DgGp|Ooz>e;NS>mnv>N|ql zZ*MhZNj_d@XhDiwthc9r1=PFsm|;n>q(R<#ym_V?!(Wb;bK z%jM-vR`M2aTDthxO~?>oLAhb?mz%2O z>vh(D`*6cCtK`li!HP)sJRNov%Idb;>Klx_@K4E@8=GW^&))-X9|ob@0EOe??xf^) zfzhqsgc;8ezf!M~;J*#nz>VY1x7zju54@Qe`kql*z%0{?Cy$a~B)Q1Hp!*B8no%CM z<>Be6(jOW1!Sbt}_@H@vm5?iF*(BucyIs<4Y4*uIL;2|2C*gjNGo zeIxckdlrC{)sE`n0V`?72m~^j{TlA)NU9Var`!0-tBL9gtJU{EuA|hE#1Ctceo7is z7_;J!0h_{AfmQrbu$)Qr+_y}aEV@j5f&yHB~HNo8<$n^><+O3a^zwgD zk3R^(GX@2S7w|>@zac9Xzy3?pi>der<QW53teyBf12D zmOnP(yH~*cC+p(w$O1}OUupn^iu(@)10X;3Nv@=C*5pHt^z;ZOhp~=ebn&&CL{m{vK#ZT|qv`>mgqC#6`fnCbe}8 zCW(Krjo&FMwMll`jf6@LU+14Z9tm@Bql)FDT3UBqbUJpS#ems*oBY`c_M#0$v){oz zwXr5;=K%)C6@sevT!REfcYSRzI4#!h-8nCl@906ey#7PpQBY{t(qkyp{Z99YQ6=by zDqnbG>lIt^S3rp;mCQHe0i*X|d@j&%m#$DHa=cC9Be}hlFV7E=^Wi(`KasayNcVib zl3P_=%6BXEdKZ;y(&O0gJq`&KwP~#mmd7J*N9h0yb1fpmhxx+n8uT;yy+*`1Vkie` zeSJ?lXYSLcB|JNqe_D$6jo#ke1Mgs_|RT%4FCcJj)@F$|IZ(dgSo( z_rC9?&yEGbtG9k{4c?Rw%x?T{7&f_76OgLuoSw6nOF8E0%ZAzdn*M>(Fe|?5h40xk z|Mb=Iy9d(i{WUUn$tZ_Z+jN#jejJiR&Uvvon#0o1&|wC+qsIBg4yUs+$Pf1q+Hd%8 zjh&y~f2XrDF6e?BHW97yL6Mc z$8O21FJZIhrM_M8+7YdSBC!$IY;{=cj)5#vVE>-8s^~1c|F`~)G;p`j4+{w8jx=K8 zr1F|MfX03OmEf1Q`AEWJj7*WIAv3#_**zxYL-ov_vt|^1@!1k8gb6ec4~Hnk-fOl% zompiDJltlFf{Y^Iib?;rJb?4oddqUvZR?3Z(XMW;5DrqrQKD;P8W9g@GT%z`=?-QJ zF$euFIa2#f=M38>{vP>=dsOqT166G-#FBE3&%5vK@`(WS?+awE;tO` zyL!BzQGlP0EFoV7k_IyXZN=Z{wILqr`&@pB?oVNz96StR8Kq}1Zd$AmR-wm#* z=VX7s;UZ?Cf&pD9mO;+helW_$GFjvZ$p++OL$S!Igl+U#gwub1WKVMME3qkq%k*^u4rqY+u9f z28{s!c?Rz=cuEz-0@iR1f&kRHa!*TD{F}%Y~tEwsgU1BygmkzAza9y_b7PNXV`>TK6sQ@p5> zM*c4J&+xN;Cl679BkX1kZud`xnIFv+znY0N`X+auORh5m-Ig&{^N9O7&69#+EEYh| zE0>kdVZkA|TAzXXJp8Z&-sW$6;gtybHeXJmps$6r>G_HwHZmp{|1mz80{4E?z057J zhsnq9^4EA7z)Q5o#w`C}{lE!jg+7{i1^X>*O9v(9QY(Mh)$0%yeSOfg1!&YKrhr_E z0B`2b@=p>5yo6)=9({y2&*r=RxVm3mI1&ph1@3n@H(*@$(7u4RDo+$hsz<>e7)-ql zPyg*UG=IL%OY53)E&&AbtTMGkCEv_hMy2(NIw>KOT%EKIgKKDwBTJK4#Ss&ykZxD% zy{Bvmg1f zg!{__oSKh6ck*P6Xq6izu#NI}6YAz*kFI5uL&>x*6ppGo(v%B>1?*JNL=&kgz&`kF83f7yn$${PH(4umrb_PD@oH&duJB{1ot?ERVzumUYTeQlAKWJ;6?i>k&rTE{Y`U!-7?Wz>q^td~lVKzg z^uZDn7xcp>kC070``X&7Q3$#NujDx1ipBa+QfIhz0SLEGUxTbZM`J(_CIg1#Aad{L zSlL{bP<6O9T{FcauLO*WRWf{xRxo2)rpLtNKRydS+fb#$ODpt$>b8+i7UZvMtmg@+ zzB2!_Gu?xJv$^1=)Lne9F?!(7w05`%WCdw$7-)CGtr6Pxk4A~LT@ch$?JyC&Xm}$X zvdaZgG^7fG21UUe$6uvsc{XA|of;G&x2~d(O)>}8$C{7%05>pE7Pn3GS|esZZyew{^$+^1Nsig`t!S0EngYBsII+_lnG1pf= zo9e%bu%lzT*JqkLT{gHNs`Mzc0fN|AbdWPxQA^Uaus+3tX~cDtQ&x({D_~kH8t#7n zcVQ)~%hjk_q_423i?q!^fq3lD} z?!z}CldBZTd?%F_936QfG}x?GU$zKb4{t^u_9aRyHS0~Rp-26l(fD9C@*vv!-{N>z zl&%_dSVf@rH`T?n|2$|`Epxo*spQ>Nb6NLraug8aSemASS_tZKOM<(c26h4*kOTwk z=Ty892jrknRsbCRr&dLyJt!8|>i;C7g)U*i*NP*e%-OgdmjN^~CKWqjf+hDBIx$+p z;`$hB5}B$}sS!j3(hJrVqYmaT@$ckeEkrX23z29h=@I9T4H~t{jH#v3MYElq4Wsh% zc>6SZXczs}O^!cGz@Me+|F_@)(u6EFB7GjfLkztLxnBLYoDG3LHygOAsJNzj@%i1b z^IQm=UwGqq`cPB>QoR24l>{^q&A8?5_=sx~?pl*9as&VDi5-c-!CI2JOi8{mUuqYT zyP=d*$Yx=`>O$+gxAiBkg<_+LEY<4*)jg`T6tUA|2{7BA(<+g%g3cma=Z#+9zEuS* z;@5Qy$2;&Zx9{uY7U|fCnT%O`)^Cbuvd4A4%N3bUF^+><|Eo4Ii)JbF|A7fKup|Iz~dq%s_Fot2K@9%rF@5DCY)7hE1Ze#x;pI+po0>BX3cn@MLXAQKgW zz9aFMgCL3kcXNycQaZlzStgLcLQ5u3V#$AM#ki)KZRqBjl_vXSf+2NG{sa;Re=Yg7 zaA;6S#N8$@SixI~<}EzgnJi*&iyYUM#PDb9jnJd8t7l6;fyHwieT7YRO+cjB8GOkh z5^Wr{(V@gc;n^42a(8e#oWID`u~|wL*g#BA4`!F*ZCZE7TAdaa_y1Ws#d4!#k-Ss< z+1L5sltvErEeuBvx+&FaWF}&kt^hCL5h3^QTx00bqmj=t+4;=OeJI|=f+TIUAOmU* zANKad(M%KM=0UX$Xr%s)fl%}sHt=4t6@4}W^`;!t?WH8_Ic(=y?)ggA_O`H{)fVLq zm!iNm+YKuYM#t>AQTOS-jFd=UDLUvXd*sD-B8E+&m4MlDk9uGy_E)IPbMs#O@X-CV z%SKfClV4NeyMZ&#?S%B}<6z%^_p$#b9{ATI80yZ934tfS-SKV3gC zTA#mDQf5*^eQbc3$PvM|a8f+u9L;lJ$lXvkLq$t zr3ni(s`iGzYxwySSr^A8T9Ykf`a%=jMF7#mi1Y^Yx->KanHhxulXoVV6MqRCk1Oxug)>sN5)pNyFF*0^5h?-(H}xf9$+#p z$z=_vH%QPjbjIW|doV+NqV!*Q{2$W3I;!ff-Btlnq$DH-q$Ib5bV`eKiEN}nHZ9#< z(nxH&yA?JdY0zxC8$m)^N$I=5_x){7Xerytf3z~3YX3R)QIc^8&qjfC{M+JBRA0CAJ z{H~=wPp(efW@Qi?$7CrVVcydABF{t?Rp*Ma&gMmo=r9nL#|T_y>R^M{?Q)q;Tt#a(N%?oF{eTb+)p!l zj-{je>e~HN;GWSz%`%srW`#L>%5$xpl~dDU-HvNGiUjUFDEQGY!eVMt}gdM z_yrPyco@$kPkj4hTUhOra`H;c@tLlItey3b&NwjCZal~!4&wSQ4}6Eo-J-FKlDVEt zbA^!${vL<9T)3+N_q)WWqD4J9M+S&SBXHLe1f~yo5nXGw$S7FIvmmGIQhj(3cZ~*q z3XxRi)YuYIQbYRjh|r!XxW&_K68G?(jM0R)}}R)_acIGD+|-=iXE!rT12JC;cZ z{HWk-T)wyq*roqs#az7|IE(QQ&f7^M8J;3fBZpdw?wtyY(nZ%Lc@XYJogPuq5xn7w zXM$EPD!Od5v3-d-Ra9FV95Su2zABUl%r+^&9UTZgsl(Q2KLv>*f?*Ju7rPFXtNBF|BmlCya5z+;35qK%+ z9E;(nJX(GEyeajXe+2*Yp{q%%Oc>a`IF}ACA<=D~blIpNz97pk{m~%Cj`ThMNP4wpN%zjjZ0OEfxe+b%*gh^I~s02To03$lmk1?>4vQ9)b4|4Oh+!EkIsu#-4AnQ zcU}k(K`ca*kKAv+UnFp9NxF0Ix3kWy&Q?gUCfh5k(R5fNv_NoyP;h&E?Q~S1y_NC% zLFY8yM`h>gHM4qavOUH1!}|y>Y@(}v4*9|+Cw}aUT-5D5^9r)qZ=H83dGE#3p3YB9 zFbq`E;5;%9`*q`(vfuJ8^YB=A0Ck@flJ*z-_)XYx!0a0u6o*pTOkW3rPcI&>N)Wv) zi1Qzx%VfwNui?isiLCOHIxpB9&yeAixX3E2GT05*qrB@Xyy&!PVpR9BcTsgu(56YG z1R^=!Yjn|wX>tN1L= z?vVNe|F{Ih2~9#L3PDk#K$~YS!hdO(Vlu8^L^+Z9f@h4Id*uZJLGnk^d9`6siODGq zHVQ?_4aB^kaZ4Fg6rNt{v%X~ehS<5*6#%7+>j_YV55E60&Gc|yd z>tJgrg}0_P%nJ`K>|(#Y?C3^zIZ|MY;Hj8g$p&7H5rgZ*R7!!`&3uHGPAnH}v);Cc zN?whHd?T66o&^fMnw)MCGgOy}PnuV#}jC$8j}NUSB|x1E&Fg=fix}_7&3eo}R2@#n=}PAE&jD zIh8xp8o~4EB-=6p4f`C+4-LsWu&SHU+jzrMYFCKL|8nuc{T#F=2WNg{002RMR5 zc_#efri)&EgtZgW2-fc2E=ZC3z>r)wy`gj?LOmER#a~CI{v5#yDckQXo^$2rclG0y z>ry~OGImm5H;8^Z|0tD{Y7i553jDO^g4yg?>fGQ%y;RoCS}c5yXzDvtXnJBtx?U!wQSQ_jSq zJ>fZdS>%r;kSxFKm=+y^-~pfW5#3tT8dydn$3_fU@*N2pmt`j9E6$Q1740hn$|KhT zMilQL5FaVc1VaP;-?_ON?SNvdFP;uv&#)ez{o5Fk63bEx^PV!88UM>GHo%At9;8Jz zeuogpZ&qNrq!JaP`FRCXo_9+e8R{Zi@xKCxzBEQ4O;iNMJe9}Xtch2jn)z%BMT|2A zW!cf5dTh~l4hkHPNSUW}`%6DKNNHH8$M|I|vZFw1e=|6xH&pu##_5807R2Q^s#%oM z9#)xhJ7>YwY6R8LE%prI#Nkh_jrd`$Q z?R`dU0(d6PY56`$4#60h$+3l0V*&8CWP*26a`EU&WJKEK`JP;Z*;ji9b_8iJ0@f4w z*OUS&)BFXSB=U{0IpcKR5thsy2$fs2*YV=MBr4S0;x6LB=f;>h z^@Vg+k~?Ol0>*c|3%3?T;08kHJQyRiZ#4xKdUSUpjXoCY>!S;H`gt`>2y-~RKGT0- z+BRjpV$QmP^X!v1t&9SFxM`LuL_wxRNKzQXFp8{Up}i4Ko_l#hbD5Ta$$T6ox=_U% z+et+{;!NQ=Yrtr~#!!L9;5lu1M`*?RCE2MLBTQWGz^!#qbwT{QL`5s+b4@elX|Phs z2UTtIrHsIJ0{I1?wUg9pH*n97YA=0Zq&4%E>raeD1rM||bo_;3qUdAo-N8As+DMw!RpZoPPry@8-!@Ox70!qQKE-8&03XuH>! zv_!jw6hHV4qfd9yqoPn7#u!Da72ik7cuy5;k1*zI_WPtR%;O>IDQyLRTh`oyhO$#o zV4F8sKd`5TuJ<6!uVzj7Y9XeJ%f+(-q&-qC0Br0@E6=iA=PbqLY>NA;3cqDLr-ERg z`w2bNZUoHK8oxa4E&tHaB;n0!V5ab_9&eS?bU8&g-xi-CsjAYOUr_6zX~lSm_V1=P z6o^q9McbzCEeOWrd{TXl#r%B1DeI5G%)WzQ>}2*L8RcEYY3^bQAuQ<*Yh&>E%mQni z>rXwA`c~8tPqWALor*PK)gf-(Y85hbk%t)1f7D%M2_6ru!~UKg(|ir1$C7dzSJQJ4 zevwZNqDyruN#v>e{GgN%Jr}3@==rnm)dsc!yIjy0Hwe&%jsccM;UbK`)OpaZJZP=P zOaP>Xw_JKB>(-m@qCZDGaG%46oFmu5U92i!hwAKn<#KHCgvk=$WS6Xix89Jc+O`o$ z34Dbuv{%^B9RjDH98jBJ^ZTHu`CYXam z?Hd(&HzC1_i*BcyP=tqEYFg?gAGF-4H(K{Yk;GHRxe>3&((;QMpVlub z1+8A%6?e^m=UzKIuh3#Pk!2hT#TpyVS-up{N`G;Ovrr@yUfVn~FDYun@EJ#YAm*E% zyz5KY8U{agv*kl$ZR@e`Xb2$^)BBlC_kvQZC%y~@!0o;^3;^bfS+q3yU~Z`~V$vBT ziQ(b--(J$%-D6UG?sub468Slz#0vecJ3ExVV?{Ee1F9T;SWn^9$i`5Ess%;7D%-+v z93Z_K!!nij`uz4+q42S*2m#D_7EK^r6}RB)>xKbU^wq`-H{AlT;y}nIBWIV1Ic`e` zEgs~C-e<5HzdV7Hz42>AC4tI9#|zb6a4R{Z-dX*^B3ZCbJFNml}sEX`fkZ)&zGW<8qqi zS|LMljp+<(4h-2{od)1;qMkdjTe<4&{A2Z#^mHH`i7xJt#B;3t48eMXM4lpbPE#xj zpuy>Av3*H<>rDahu+o`8EyL`39*x)r58kI!Dvo4=T+sGS{H_6FGYR{Ng{6-d4g2ZJ zd8i*=BWCtgC_TR=r_QV4nySpHtSY@lMo?Dq6_pa5Zl~crl{SU5bx#`Kw%T{0r);m0 zt@wsw;Ikf!HB)3-FVT#eLcWt&K5cNDH0y^qEQs^{vcKn2PT)~)`q?Mvq1~4DwhJ7EQZ}vU8dfEav3?Ij#%C9 za^wB{an5>=4K0GoUY#?kC0=>%)a6&z;-ZL;nlNXDJuo9~IZEHlgZRkwo>z=> z^)9DN22b@SHN$IuM#})2u4qpMUnCXkbZDiK$g#QiSGxdL@A21%)=*s#ju{skezNxb zP09FWjbna;JzZvwq`{if{ys#(G2-e1@XwA0!Z&|HX?hwb2i^!_w9kYaA9Z?r#Y0-v zmg%4(NIMY~=}2JAw^FsF^35ZsynETv*rF zD*V7uMkvp~{86ngD#=eNe+AguufC9+OA4j`5j_g3>TR39-*CX#73{`tQh(|4NCqj! znYF}a`+gOBsxFR`0y*l{Q|eWl>?(9SX%`x~jJIeREA#Bwe;bdcdfEOq7Um<|%G=lw z0)_SZ52;pt_GeP)ACYZ}!hLfQs~>;o7!^I6rfB4eTz#owzPYSkGiJa@8{1T%LntO4 zYRKLE^$7|DQXw-H`59dy3c;aDqbo&ppi@g`ud3xje?2*b5bS?Eg<)`P?ZguHtrGO< zftZIzOe!zwR`axjw2K*M9$8Ar;l&u`C9eZusET{kR4}4!p&3cG)s(=!w?n!h(z(+Y zLFxZRTW`BUAYV3=fUoJ(y1iA*12=K)FHDRCe6KXBFRgjW-ZoO;uDxV#Ko!Pm*vRMb zrg@?h0&l-MX8?+)j3v!>beHfhokra+(kJUJB+FxuK zfZ|+rwA&2k`ceHWbd5<;F3x>m_e0w5G38%1Rjy#35rUlMv@L%Ay7VoLY0;d3wT59~ z#Af4+Frst^5q>p9f4Vw=0|J1G91{)2K2wyT$1ZoYuccFhVsbkb49jLn`-gcm-w#`LR?-G^pWTq-XP8l9}M~&SYM)$ z7H3u2vY)tJoL9ab)K~82+!)0`35GTw;Gnw&2b zpYvKtAs=V>01shs`}%i+3y#b+!NrZ{9%~TZYW!CopAWM^qqHH`Qvc3z!8dJ>{feW= znbXGoa*;2tj)u9Wgws~s>sH7qu~ z1mM5D1E9dsX_!{Bed2{$y{F)DK~~mdhT4m@!OG@l7I4tTer$VgATiRPe`jJ^{1QEE z@(A#4^lX|~_t&l(?qP@6C+tP;eZ+%cjF)-4A@((0qC^^C$NFT9sly`40$;3E#+J$} zn>Kkfs(Me+%nt#Ck`qW3JTWLDwv|5^gyUz+kuk?7eEZ=E75?DZoKV_b_Pkzc!BWbc zrbmOSf~`|VIXVfQAY~N6o%@Ajzb|sFwa=4R(GvXkBTf+jGkT5~Z=# zl@V?(0Id^28g>omP7=>V4SiX4LTN9He*4ls{OnUJYis`-W>&T>baR;pVfoHn=xn@1 z0rD=se;l6(*r7R4L(4bNq0-`DoUe&BeOJU9XFCrwy*u{~iuF@g=ty>-{p?2x&gzl& z>B9el#e=4Vf>p=BJm^*XsntT2VUzlF^Sy_>@~@J7tW}9}3d7kqDVtD8W9-&2-*fzi z-*Ijq+9NgrSi9>9;AA&a$cCNWb2Aws20#H zXFEA^X_}6JX{kvhK*yq?+@-PyZ{N;&kDbXIO@k4+e%KPL`l8KYLV5!Pn8u*c6L%<70BQLSnj497>_{f~&p%_5i1&%49>xvICIh;V*MgLn3d z00qC<$&eVf>Gai)$E|Z><$0ri`e%pWERzlg@u+c~cM}IjzvipV~i_e$< z`l1!tcKQDTcWQ|tW|r+rObd^P0L!N>9o5VJmwu{Y3=w4Vxxy~nut4uSx64;8PZX>g z?n3|?gVn;f8i2nx)FWgd>Qx?tmDXlL&=bdz#!cNE%bB~GKZyRq>vvxNk!vg($-+5i zdGv(>`R04C@So}U0Wn+^S8IfPE1O_($dlA_*0|XM)H}KE^%gs&$zUEE1K8c05n-+H zh0MI?9zhtt&Yj5!e>TM5Qro`s^Yk&tI;N9qT#K|Efwt2I2BT&+{qeD`l&Cjh#yc6g z9X_8p{3vIf&pw<%VJegHbJ;G^$%gAGIrP}XN=)AsfksPZGB1xl9mVIuHNM9&iEV(h zX-JI=zm&)ti?F|0aAmbj#DZxA1HnlM~v zd+>IKN~do&HU&Hph^@IhwiM92rPNEbM$B=sEHD>&3w=4imaozP&=FPghYOG^KJ7Uo z|DAEeqPk|cXhH%&jmt)KwAN#~;|sYfFKvh+(q&fW=ZC`QXzu!$pZB6(g~N540f9G8 zVjzZ{o?cE#aaBcVAuCVZW95$RturTy9$x(YW^&2MqC@e`Bc%ZN3jZ%_p_`*>S4kv# zLs(r(qpH)Jf~+n|;GUMK%H$C-Nl1LU95zgV4J#^R8nC;u_uNe_(7jUsVeW_ZXzH`9 zn&4ALSRMAsj$!Oj?3{3B(65n5Q>7iqP(jGV`9Tkt z(C~zl-qUN6(W$@e`>nXYxd0WFedud>O+N~ad3T=Byqo2kdQWBuS22B}{c+A5yVofb zbU$D?;S~ldg}xk7uo18uO$;HzLq?DECbekf{ zJiupJ#RuZ8N+5v2X;HSIV%>46~&XD z%!DyCm?3=W6<$rZRyl7+4=>f^GdtBoLfjJes2X%ln-#uVEig@LFu-Fxn}%WQ2%{PNOL7cLM?GF z3IH#sC=eOY!{Td}kOD2#k2wZ)&~a4=d6t;L~Z{EM(w~5p|g;vXEUjM9$S3<@m+rSHpXPBA!3mj$~aQK%}n! z4H4}<-SH9lJO(pEl<<>glZv5-Vo!!USrBR0yIs+oy1QVm!FJP!sWbIKZ!=8_*(qd6v)9`C9(yt4sX>THN$k7qXB$(619zoi_~2?pDy^Aa!%)*G?9a`g2AU3?0%>(6`!1L%(GDROf@ zc=J1N&*-gPnmm4B!9Dp#Re`aOCR#B6E2b4^dVBjFTV%&iu599G-sfFE&-4_z1105R zbr?n>SUM~gokpaRwskBf+pgCO3ScBiWd1CDIqtG(^iH}BI+g_@vh7Vzg#3sLoGF*YiZ2WLb#U2p%^ur$@-2KUO63TN zz6Fnb0Y=}Vx;sipR;eYTLHPY^1Vi@wdKVDYG0J2v^EYE{zL6Z@H12l5{_WXG{Ja@m z<%!o`e^8J(iCC@C*<;xo`iU^JB!)E*jjk8nNPiaiiye(Mh=X_Xi#VWfr2I!{YE23# zn0ft(FuMwV%2^X)Fjq^FwO8p5>GJ{at0C5p(Zbiem|QX<`LrceBO349kch5qoEOs^ zKg?C|i;uoEIb|c=DdYuPdfc{X@~heAksWxHfiCj>z>x8{Vs)R#il?V+(lgyH^S{Ep z2fpxNerS3q8q}$BFo%ab+S=^||8q|Y_GL0U$Gp%@DAe?u$I11kRboKM&@G;52k1qw zc#u*?Z@vox?EGE2M2Egq&7E6_)OI^L^N-f=8kP5qGPc-nSXzxI)@pvEQf%v&Sc4@(d zb)41AO$SZhq*;{_j>-B?2%k^b@fTUEcmFG9v6CiIn($*Np5=x%pP>pqyu3v&U_|Fo zgPB7LA^$3l{P{04));p~@CU>3!Ur?)nSUT#r2iS&f{$0;d$=6C$9>E8UT^Gk>4f35 zW-SscN9tF-26D^2XOn%mE?r{fo2psONB?+WLcc>#y)hKxrZXBTRrnE6u#b(EsdUWBhl z2ZzA9*!9fCQoJTtUJ~!L4hXcNqGeKX zW+!ykEpACdIDvCkPy2K4Z&Y03enQyV{2sG^1}CXQ4%=8IcKyt6aD_zbvw4VfOgapIV`p%Q}qWqyzRfvo*RzN@3oyo6OFrdfK@zp?e6fE~+@B);s_|g?qS$CEOk?}~!i&*`b7$`5 z;E~7|(^~_gE4D{lyE_$A-qoW&MW!BHilo2E1h4|Y?uUYcUIECZAMK|kbGQtXZp|0k zGJuF738}YL>j-bkivtEt!`4;Q)MnxO`;BBH{6Ij81cGgK1@24%>;$|>uen2a%Swb1 zV?%|{vhx6VZjJrT;8J%>1UmOYO=OemviDc>v7)T@$t00pJy%{x&+Hn!sWH36Lp7Q*O%^*?3meJXEY zJ;YD%6MS)6dkMbh>IIrEDL3+Drw05jg$`+Pf;#!ZMcf^)sY@z=9R%Pz@p_1NSh&BP z^q#bl?k3dDTbM~nI~|p2nNn#mS5L#d--~N)w!1kBu5Gs~ zu3K^ro7pn4}d$`uhjsMA=Y(ctbB`BTDbghE`@-mZ7e8jECwl|4~6 z$?5U;WEVG@Ef(Fz{S&P6T5s1V)Y;&DPFAZbj4qecmgbuJnrr$`Wx46PX-6^|)L?Nu zOLrhcrgG!*jUaT}#Obm1mFbi+<5A9Xw+jWhu^YpZFwU`I{1dh?eo8}}XY2k7$@WWn zQfc4Q#M;B09D7Pu(6{_>+veQlWh_PP+I8MtD?VsGRRqc#-feao31yLHb|h6p2gMhegSAX(Oku$8CDm{ zFm)((f3@V>^K_bNG?fK0&em7XSlx*yuK4;y5^;tL+bl0+U#7mkL%{fA#uu;Jr~u|& z@bIa>zhkAOoSLwNC@22jTo*-gLU5V1CrrMi7n5sXu$^;0Q;a(x~jOqb{mB(!v z=c(%jq7hRDv{0hul_j`3Gi;518J~kz7g{WV%ub!bWu}M1;V;~bHFg?PQ-!{yls-^V=n-?xh= zg;>;@E5)XGjAnabADddV?Lf%wF`?)yNQ~v!&4Olryw|^2SomahRZ`;xbFy*x(M{yf zU)}ut<;aOf;;~<=9M^#?$6>kyxyU8sqLYKM?9X(z#{6RIj+R7!6o|qB)_JbtVsB$x z5qoj(nV&Vo+mJT`C}rDH$k<(XNBRKX2Vi#*&#L!@&(kv^%QgW+&0_QBf5n;nq%b6x z?E!=Bw#^W`pNC!E!${q=gkG{#>=t+%i^8FLfD4hHWgWPXMHb9GukVcEqzB%CFKqcP z-Fet+^Fb1b+=oykYg;t&Iq+eF5Fd^1A_;JR4B8Fyyxx-};#5E7V0n6|warH%haOY5 z$;GomQ?V?L&h8PE6fJkn50a=6?`0_gEJWjzyB*nw~7?{oTJ0|5tiB@;QM>!&A*9+XFm?x!%OaTRew(P z(wYrwy%Yw~Y_Y%Gf$?ZV9+j0f!Ix+V#E||Wl?}(?tltS)NU@m{GNu9Z#3!+{LIZr%%i(*>in@Y+3AHwt zjj|`d;S(WnhTJNZQ#yrU5T34+p2#9SvQybt{Q7k7`Kl8uy^Y<8$0E=+Xc__?(LWBTQ?dIO8m=p#wI&Ke}tG?yvA83c}Re#LQaFU7$~<8`3WMW!1+ zGJrQi!Z8YDm_=BM_KW#Kz79;5G4gRuD!LKI4{ZK!IJEpIcpr+-v#F=6W)GK&Rw_Ll z_maQyhB!l+Sjvei0;T)m^5kcRnd;h%gW-E{N6W0$Z%Stu!r%GkR1xwOGLd%qI-|1E!KuAh+2oa(OjAGGL;Mla=6*ex)*Z z{}>etNBhosXAhgkr!GRwkVDAXCx`yb&*JkV2>D$$I_iOt)xc@{M=bei_o-Lo&}I20 zrKgpG;&-q;10C!irRX;0mvd$<2y^+Q#*!$Y5xOFTm{y&u2M7uA=7ZI9 zxkjJt$HM$ml|PcK-?|mCAP&eX_dhGWbbklfHjIQPk zE~G3V_gU9>xBOyP$hcO33$gi-emkW`m`n@_Hc@Ee!^}FNAGYQ#dz0Gsyf1| zMAap(yqBFYcFdCm_oBN`QQuYCP6>!=S5<%2MzAVo()W8AoA+n{Nb&Kf^E38{*_dNW zsG3YF25Tz;kllT6c&UH)jg`iO8KIiCxsL}Y%by`OS0Q@m^}>K!HRD2XGT%u zswWNyFsAQ=8Wnk2pnDF9Mpr1*(-p~D7crsB)5y%Q!Aeg*{Q1c1r*l>YN#5MQP7j^a zluUyk(XwRh0EOo}f&T3EYEXC?I{X%1tgQ@60?$2_3w5vlPC8u{l!!VV&@muTL0{CU zd%}F{Hs|fU{LbB5W=Fe&Im@pg&~4J9GTJBDq~!MZp*#!{Tq#+3$CT9;$CTlwVI*sF z9KmtiwsNV#oY@%yFY?)mVQ~$C{i~5*BcqN>QtU(~0jqGhIt0SY{LBn$(X~N(Dobqn ze!7C5<8HNw*f{=y!H++bBe1q+rIF+!V6jA~CgAJK7zHfvaWiZ4OQS%7n`!piPZk&9<;c~ZmMHLqO78I zc=Qe0&6m=|8=D>8h9Ttux*Nq6dq`J0+oxylSz8oERL`hqz;84XAa%(WkpbTu!MI zUZR0x1S9xpTdlC6Npt7hGX&S+lZiLq%lmwPZxtDp!X(<|OZptvJ0gkFnmU|03k zQW{(U5%-0^;#2xK6O@@7WK{=a9{l*~=!OY#u4;|p^pZy3atMS6K0Ht8B1DU)Df-gl zB1so{X$M0*V54+r*NuW-H&jrAc+TU5prTK)W-o3=@ILRf;(eIgJdTm5pswnpm##FO zM<&J2C>>n>i^-&)R9<NVKZ&r z-2B?mtjmio>g1uT(y>{}N>MjKlM|*ES$`MKPubRJZZu7o1-YkIPrS@pYR}`wb+G3d^4Y<5 z(J{zajt)=FL5sSZ0+ajkr#n;B^$|JMTH%4S{GgD-x5#UHE!2nI~0oQ{lk~DOA<( zLA2)cCt2VFZNG98Dp^RIepK(9`t}IB8sF=@4@bK=3A^(vTZwfbX71pXYj3)I^8sI* z1XMm=tFH z5boqS;m0$MJI-VVm5E9z&_g<(nd)gga$&Ml+0U5pIZLa_*gLF;i7`KC!W3}Le)dr> zh^D%iF7H|nurfttQgF!)FXn%qLwjd_LEmJd@~e_;9mG^IQ?|9-Pt|ZjwxajhU?Rup z-itZA7kzEy!b3Y6o8x7;^Oy%$`AkMaW>&;Vbly`rl|)=48y?A5OQN5;i582xMS}ka z&71_j{EH7Cuu zhoiGNpoA)-DaKzubOo2wGkvegRLG3Hca(lB)Wmg!_O@#mh=a@GIz;dlMY1$F?OrW~ zAsDEZ=85=iAAfRWpQF0+ZXt*`H_b4rdD{??8{R_*45F_WTcAJO zk*sngi{23k147||QH?IWMjuB>V62N&U+`ISf4j$TU(-RGoA9eDw_FlPDc-cd{tMh` zaU+DZsmh2Y`Jol9DvM#7G<|<3mVCBGwRf|Si1)ql0Kj*MMlFt)olC0s*8IUYnr-U$ zmsk=U?lmG_c}8b_SPs{V`gF%As@u_G+(rJgI=@0_wIg@mfjC`Gx0!1aE4BHK}z`_M4RVc#sTTZf@>iiTH_- z^(vj(H$36_vj}qB+j3G z0=6<+_Ukz1%gPo;tJYT&PJZz;Ka2%wt1sUq{6UFCfGZs2!dzRvPtNIwz^Fh#AVQbKlsgk%Tj8jiWv z9f57flMq5)EYvLUA3ozGq5BV&*k4~&Ac=I#z*=7T50bO26ISTZ3|!-H(bF|CDoYvf zsT^6i{c|a~jHdc)rPE(f52HGjv>a*oFfB|=6GYz1+xPwqH#mGPO;dK?{1>E#@a|~A zVC6+szx6W&LPJE4Me*(T0AQc|*RObzLCCE~c>flp{gGUWOQArx@fQDUgT#>?fR*Kb zT~_7q#{5@OR+jSPr~eIADFm34jeBwJ9D(0Ny(}+jC=s;H+BT2HRDPsv^TS2+Ai_y% zEb?(MBmlaxUVfqNz9_;!Sj;5a=q9GgGy6>yvAKVh?gK)&l>a2JdJC77Sv0Vwl14^y zV?5>hWwCtQ`w!blt>`$dRySjGg*EQj7JI{VO0&^r?SS-^&E;;o20zIR5=&?1H9<^L zN-dd)S}mp5GaLWBZqJVS%;mz%I0lzMgYHv~*>5ipn`i&{eLIsz97q!zC!#0d0v++- zOg?8hNOp3S6#6L0A6~s9KLrdp&TP5vKo%ILs+K}}&C8B+e^*uka=O-`{e2djIH|YI z)*3kFL~SZjmLFQOT}u|8IBi^EE&c9AF918nW|i4@pq(6uiF6tPWO@aBaR8C*%ChS{ zNCa~Lo@tAWoT^0=`QWan&xGee?O62uZ;GA}S$4*iVe*32dxyutr3iut!SH{eD5QT- zl$CUiq^b9ZD{JaLOjbM-2BVFmKS}FHQ_KoN?fKvc zhr0zTzb7Ni(O-M8vgC?WaCPX0z#*!{ifQ#z_y)%w5QD5dNm)s`vQUG~V+L`gBe*7r zGtUUtXlC}v`cNMQ99jCVKa?lkW=GJSFRAskeVvDvIwT;Kt-V94o*WEOhBi{bd$qAM zvb5X$N>RRse|C6lc%&x>takW)KiplimrrTK2Hcs)^H-e0>saOZq&P$mTvMg$`0ME7 z??T;V>m+;LCcxJRDj6A${GW%w^YY>;wMGTm7#Ng(zGkWmsd=Y4Sp{=-wFs<*GHv~G z^UPLP`+hWTT{Z!Q^p(V$GdIpL)2@tK9=O#8!{T*CE-A72pHCaZv>G&~1M0q*2f;_n zC6G_-<{AJ?ho%!hk!>}KD*PhJf#E)i$CFtDSRIPb(H?+DN+U6t&2B-u8R(hxRNnFX zIlbhe;=%=e%Oyd2Mr{Fs&ez|)A?$KwBobJgorYAFs%gz6!~fPlOh^~5Q0`^&W1A{$ zNK?g!K!q!81ZT+h)8AZx|AvoK$D8qr>1~eYiAfc@Y0G<)U(aKO1A)24lP4z$zfd;r z8CQjD1hT__Qfw7_qn@U^#LdTaF)IjV1~&RvRK_xW;;rrO4=2W)>r+L%LO{y*&}%~+ zjW$4?8_mUIAwI_h6+~m&!$Ilbj4BjG3FMVyPVT%TM#e)u!$fwyY-e0Mn@sdR8na-N zJ)#!VA4F?sD2{8?t^^c%FV1U;AYG@4U;SH@-j9O16IYM+6&K?QVkLqq22vAiLz^jX zvz_T*6KsC?SO&pWdpMFXTGT-jFIsPnH#H}(5V`0P@W_rbe&{xQIt@^ga7_+lDx=G0Ouo;SI3j05 ztEaEJ?(XSx9dGRormsogYNl zW;Md(Djt%*s8MF~h6?I*{wF>u76bxgn)gLNFQ5TH4ha6mG?@Ls_aTXXz;IY>ETF3 zhHAtOd`jhdCNdsq9$i-5xcQYm{XW<8T<-VuzDfZZK8ZWLZ{&4LXnJ0+TiMe=fxk`$ zv9+RKrTW}XO=ex`+NG?ct=`hWP^D|w!V`y$FLHjHlZd+ZjN>h?zBmR#FFFT-JV-0{ zW8mHQ_maef+-^Jb-mh|v1}M&Z_B_?!WK~R$50S(L3}geU+G?50H&){J^Y0!Re|h@M zXp~yww}ch$k;;G_`Tl$x0cw-`XYZfmPnn&jhQ?ST{NQ zxn(JuAsHpC4;y6;FPML{keo_hELI!z3(fypEOk38(PSi0uAdcle_P&vBw@Yd8$i59yxNi$pet-BsqR-S4VjY_sj5Ot{#K{k?G zMbzf~+CEStb=KbPOGhgItV4yK(Y4m4=idum`RKx~o3=ehM-nP>FI!`1?v7`G%NES- zUba~6BdQbIh=*wtYynZ&`c`V}@5PL1@oniq7a|j0cC6|W`k;hu*Ql~R+NjMcO?p;? z3MoseB@r>=b;b`mi+gzXOOm_l2S)l~Ogc`vG7(Maqf+ZPz?$%%kLF}0@x$+X$^12e zzg*ND)1__^H+>I>6%{2h4aVfW1{2b6K*mI(uHLgLRza^r%g^P!p~BtM@E25Z#A!{i z*xromm2gb6>R(etbDC=FNggrN7p@bZ1WX{OY ztz@;;ftyApS-_P6BEj|J1%ghm5fnb=2@&g&ruTQ0A#zL&eFr@c0~ zuXJ6>p~uRPCvn^`OJu-DlfRm~d2hazX*JgI!*|^FC+*{<)r1N!XTPmi17bUPVD4)n zERAVk1P9yG7&pSmX@UA!WwM(CAI86bKPw~QC}wL0Iy9Nwfdv|)=aTf`-RZbuaXC9tU4x$o0~=66^<`l7UoNZ1 z5~!?rO3Z|FNT$U9VYZaF2LWcwia&Lb(tI!Sa@Bt(rs7AZ#W*ZfDw$#Q&M&&-*FC%+ z?aKbpmj6Jvrk%J0z3uJ6RIyZ;+W$coHCzSjYK$N8uP<^U3qu3lMS$#%c(Q0GBT63A z=sHx+sswlkI{JeXdc~MN*)Io)F+f*KEqYuc#sWAIfRj>R?KYn-Fjj2BV|47vU-h7~ z@+NqMag&4lCm=e7BGgM)5-RAY^iGWXBVwNp(Lo08nhN!&eSz$GArw8qx16%_u=-rj z4;mE*Rg3C40nD)Ul(>924AzzN$)Y1{Q}p(CK{2HGEn>C}VCVDpUX)0tO?7MpC9s9! z0rPE1)z4t*+WHG0jxCe=t)Z#(4I|X4F;~8D_bhTpV#IL`H;0rUVma1hkXA{2j>uM! z^-l}SxB*?}nfL{!)zsv|p)nDj$W24nKtsitKk?b$hZqi&NG|&oHb8p({$EllANa83 ziY$un#vN!S;mU|RDH+79uR8~YVcY_E68_G0tS&PjNR-B^nhqamy@+IdIMy3H< z>^xKxyI(|h4ah`{YG1sy>kyBGYAzaBrqHe2TE9Iz9Q-c#7kX{BNx~He?P}oHs+S~_ zZdGmmg1X%yKJ0%Cal?i!X7&xl;4k?!swQIq4VD4&d-(jvh{Mv5fPp(K0!n1<1*0{5OQN5?XAd;+n%qzVKB#QolTBZPbpAqM{Ci?OC`@g8zQSn%^_v3*}%ll6OrIK?&o2RET2F z#xp2I-_u~qs`e=CnqZP?-9#ZPh}E0%a6WPe64XCYHjR<%aRo!zQqh-DpC+Ruh!TBQ zn(w#eEj-`6DFy${XFBO5CF#SsdjIc@4)Ux$v`%ysg*rLy>Y zuLPM#TMbF1rOU(^8#+$VVJh}n)TtzuN35_MS+kr%%ZGw>_*jpl>%(m~X}glAyvUIh zdr~S@tsH(%B*_d-Va?Xu;N04Rw@qver7%=$Jy!n)oiTU)*Vuek45_Vk1NC*!vl}FP ze*{zp58=AvYaC)L)$;dot{j6it{j8K-AF~{)}I6Q0k)~oVL31imK7PXXBs}QzBLmr z`o3;eb29(OY5@n`tMa9455+L}#Z=TJWaov2rf{Xb1n<^Lx{OXqD9=56j5116x;^Ob z>Py}qz_@21#=(Dk7AUAl+|`L5G?Dk){*vh!a_8K_o~Hn85v#JNa3>6dcz*%PrWgAg zWIIRtlQu^DpVj2^bg-rjgPUCyJmL&~htJ}_?ulz*v!7r&Z{$&|-N|3O+7~qcemp_h zqS~?d=kwVBe0q-w>S@981EuVA>rFo9g?_dA+RmPyoSfW}{JrX;TtiLGb8InHRI)^A zJoB=Wh1U%W-Nv)-(|RHgM_*ZS%ju4jlMHCj+-t_#pvR(IakQ4f&Bq;S&JEoAZ*Jpg zYM3dZDehF9G!7qqe~#E({BsXfue~x1Ug$45lp$h`fUOxO(X{F?C(!t)4dQS8Xt^e4 zFskzo4iQ~zh5qt;xqHBxwM-!h+~`0xuz$##t_mhyz5cK=uJifVz`|dw5Rfp`6+^m# zPmTVIs0f74e>fD^xA8xKVQf}jzwYcc0pu@56ZmRQ&f5?~f;;kHHUXa(z{bcN zzgq0+r2h#WxJCf}>Fp8->MdOx0RQph2^2rL`~S(=Fh%*}$08{g0bO6WMwoZ|VmfN3 zJb24_1TcUa5i$OsJN5MqPSd}BuHTxKuyUdL(q7`$0u;1qURRZZ7zw)-{u4c8HETII zw(9%>`%_}B`L0c$Gr?~lRGKj*g0MA-NUU!m-1mE`d3_ko%~DD$d41Dg&aAM<@%Nn` zXIL4)1;^M0A9-07P~eK@_LCe|k5;cZ&$)TNNNG#FEpismsHjW7uIq04e@J`lxTxB% z-yg-iK|&OyrE@@rZYhbOLtyBJp#-E$rCVxfkQlmQKw704LSX1pkS^(lv%&kmpYL;? z^E&7Edj0;LnLYd3*S_|?)_SkcT5Cvt&|&!O$92t?Ix>*pmHtf_AAl488ywi+t1c$T zrRhH<`tbUfB<~=2hxiqWAUQg`PEm0q4l%yo*a1_aIOtMgtWr62>dG$f5sid1z{f45 zohscrn8U*Mx=#|OSUYsH?Ut)d$qCC24*@?4fBAxx zzDa?L><4I9dhAYf~(H_t`N0p!sIsaE=h7PmIy&!@*t$ z-0j`npK*TM1bkDPzSfWUTUyx!Cm%NFdOL@G_(?S^)e#&{6k#%(dS~^#tr1zhIKZdk()*az-oF7(#c^<6>zSi`}U8*!cGiQD(<%RQu5t)(kqBm zEy1(GVnT}ALn}Om8PiR6hbP&JEfW1=N!PCbOx<+pAZRgkhX9)s{$OL2(P1Pew?K?6uKI%(X{92xO>MQ9+P58>K+fIGPmQ| zzCH<%iA`8;HJ?rLl$wx*SF_B~Ys@|5No*|q;vSNXh976x`cv|WO*<$cTN@!VMHimC3rua+nN&OVp) zyQ;cira1LB2P=;GPGRm*W^-Vgib~LQ7+mk~RbHrLDLWQ`X!+~Kd zwYOM-UWAlY`Vu^t-zKB9GkufpLMaAJ$5eSLs<4b$>t3Q7+_-%#UfELn%7My+ci!d8 z-+LOE>I{PR7#s&YZd7~|$3!?Qy2cjPwEQe?^|*4a1-UY=!S6<=-|KfjcPbEGOJFEh zL?+YZV&UsP-Lt6#5u$A4}Wd3EEH`&M_Dk3JgY z(qGd(eYVR1b4#Xnve={-@=_=>%#(PZR(@z`J!`+TCH1ljleeM!b|#>BNt6|x!<12D zVdN0C+V5a>{H@lL93~G`7f>1PU3P^W7@}f6 z#{pyV;N({2rLREcGL>hGOQsys3eSeww$~r75+f9c={oE>X4TvVUo4Tzj#2p3T|{;A zC8X2mjBx0s;qf*`5lwzbxLP?|;LyxA8@uT<0iX;VXz9D{n;XjSlT@ba5>Cw4~r%OPOgm$%_&#`J*X6i0hRv~%sUcT0+bJAPF0(1-ePa^IV z1*9~AshaTu$>^M4VYYo|88+N-U#llO51DHT!u~?P)Fod;j{vkpKhk_n|D z<3p9JbalfYbCan7MlWJR^3hqD6GnxQS;s(Xnx7&?VM-Sj+{3|g}k zEMN!C=p`&bG;@9`-`Fv-(64L_FHO3`?o6D(nvnY*DA^sMuw814%tm?7bil@LE|)1w6`U(GSPjW zD1t35_#5R`8D>8IJ7#QuR1oQXMsQvk=_Xql7gfbw5~`Sbx$YNh1BE8~`HC21;LL#iJ{vx%=32 z`ju2Ia(`(8{jheK-Iu7L{Kb~eoz!2RepF%qy71VHPXV^Dpf$f((;RlC)mu)<^mnovY+0t zrQJ8Eju0S8K*??=mpq-#GIQ7`Ik3FWj6vT9RmDxOH~uu%X3LG5?$FfQom{utyj;{T zyv<{vFTXR~WJ%nms%zM=D)4RqcUY@*`5^-`R@4(p9ty|3L`iG9eJQSa(eqEn%*&Jk zp?M&SCiGtQbazI9U{Pe<<1XPadI8jrU9o+kybXWrX<0|I!)b>l?96as=NXX^es zqcKrBzY@&QxJNV$|5L}143gx7;y95&RsRz5FvYVGcs%DzBqq;e)?|^h!L0{oGM7^8 z0UEcIs}C7v0&&F}aY+3O0JmZ_X~CtG&t+w;X5$0V01jSKVA%hS35H%ulm)t`VnN_*NQ ziTRqWcZpz3c$No3L)s4`WWm0BPN)@BfFfYnooX^SK&Ma6z=WPix`agnwfd-`*s zPW-q=9l!Q1#j}s{eb#SP8`SD5b$G^b77|^(+}G?FuV?dvsrPMA!{r|v3oyJZD=Kms zYfTLn#LxbZ=_wA>P#|q9WjMdekr!LPV^nT5a+#lviL`&DBL>2d!xJ8qQK(@4u|OJf zyTo{Li3`7jW@5i`eNc7%rF9W zC!?yDPw`@;g%Sc?hj0|Pi#|z1?3tB5$S(J~I|I>;nbF`57=h5Q)pr0Juq0b+GNlqB z!{ZH&@Z_?rBQ<>1P?M^Z288@8O(#`+;D#KFVuRo^D63JvqTW6MU#HTa20;i z0p!;GKPvhDR4=28z))Hs_Vd?qAVHZa5@cYFnf^l!5*&Cbc1e!_p#sJ2xney`=#T>C z*>a<>>Q+arlv+hb-mOlK$qA>>b|3!6zqp8O6v}Jkz_07Cr&-^%RIrEp^ccY8;Y4BQ;g;Xan~+ z#3K5+&{l>}mn&YLPBnoKkccvAIJ;8u8V7$MLO)*`a`jbANMXJQXe~VQZ0BII$LGVt z3*7P|tI8j5s?h@9wJ?zA+ks-&WS~`CBl5S0tSwHSyhK|-7Vd<3CtY2@+WhP8@G)mR z_HS7SCbO9~)B?ZKD+*V=@5GVINDDgxY2pX}^`K*(AcK?lNxlU8P6k{{5jwQ~A5w%@ z`v2saB!az@wFJ7~uyv&7HY(fHO1x2Nd$;W#znSXeLz3~F{YUHX``*8C@ApNWa5w8M zI1+Q{GvdIoX4ChJDzk;k=$LjVw_mR_tKC)*L@o7=G2NBUHZyEajC>kX&>plI`_%1Q zE|)U_sr0Atjl2y_&BY%MJ9(``o;;Hd5e$3=MZe20^xC^7D6Xq%koG6gB8$Mdohoo(WxUuxUQ-PZ-`3B!!@bj z!C-|0A}UJL?=fy&T^3$w>WmQFl;o9Hb9vBn2cQC*Eu=pDZef#yre);shtG;cG&6Si zY;?L3c>_*FRya3mvKi2;|JX)B0ItB}wxT`=jvxItXhCl_Kwp}JZs7#=Rbj%Kpdg=EwU-kYMHyWDQR&I>rKZRsYmf z1w0>sBUB1PTX|^)N)P|zsB7QdMU8uedt?TNam^WS>YY64d0kyxt0rO~oP~(>2SCE# z=@@^Lg+B#*ftWk#_y4_cEdU>giT|rIEf5q2)P({m0s25X4DjdQt*_(61K7|>=8UqZ z3~dhLWPhieDF4Zt`8#jshBf}(Cg@LTVew3lyCBLbKyktG-xL?uGy-U^V~hhFY#g`{d+!9Dns(=Ffcy91U0pEgV3nGuHXX-CD|>A#_5Qw(_H=s z=p{B9yzi|x47&KXnVV~Er=0ZtkxnaRdm2O`;e*4v^os5^!j@qv+Sp43mhUyq|a^3$3-J&98s)dwT?{LI|HKXola zwBB6$r>J~Ho~co0Cmqb4i)N|$Xzw+Ox1fsbvx7ImMdVy-&-#jA)1wU6F?Y$z z^k(AOQjFMZaj5vSCa`#&Vt)hTsKhHpmn{2pwAu)B^% zx)j-dC!?%H2UegyL=LOF3nOkFpTi>tooVIw^0dp5|Sn$M4Qn=&%IjHHz)SvCg8dcm4K$R0IWBnlY3bX7;B3oT;^hzjy!v=$;>VT&`4>oC>0sp-%&jZ|0;SajIS8-82d}pjY;&z1tEKCy6u*=s#4{ZCS=6>Uz%X6e1^&p42<9; zXiagZKwV-A-35)v@?G&ts+6hy`*%3I1b+c-t zlnhzU`Iss&^R(S>r8YPVKIP^r`<3IhmUxF+pP7C2Kp)JVL$BAb>Nl|(3Wfwnw{s%o zRWH0iah5Rm%tONl*s>glSo08%QS;E6tE}dH;;KHgUsUp$)uA1Z!Ezq*s;DTZNqz)8 zGSp9ZZi3Ib?CEAtl(N$+yrlu@yyXYIjq$P=y?aLq@dH-pPwPE2`l`g-#Ac)ttY?P# zeJ3rJl@{w_Q5kz!S)Eq6yp5hwR+1kC2U`kv>PR zib~a76t;b{uLh%qe_~Pk9II3fax}@`U0OZ-9Uyvo=_W)0leK5}3zNftL>8!|PqF_c zvoXzw0+iu%+_@lD^fHjpVb#9xMfk)BY*pyb9gK$7$kQ{O?bbmr7i53Nwf|b(HZFkA zKJ*V~+;dyT2Y>poZmcR6UrU>olAC%;2Jb z0yU6CL$ER!_U$RPIEaU+GF}^RuaYt93XB7@!Wm$iGKK{G%=QwND3L6WFX}!X@!+%) zjp5?A3Ux?f08OE3amBk; z;}&Xn_fQ4UL9#07{_p%8UPvH=<|EpPMu8-{g-i#fqY(Lp%oa0$hgxOf+~|vy_*w(d zgW!kjXo>e7A*MJ6wEWv6)C|bC%>miaA)OsQ%TErsqtxJzI*YEv!#|e1LA3>18wrk+ z8ilA7$^6Ckw{YH=U>Gq};M{%kH@}y_!LA`qc<->MjTy|c3_H`87Lk&I->weIBX#d* z=rc4PcR%hIJvg_Vj7y7LG|rJEpzi=&x{adNVd6Ipejncrg~Q>rcobt>Yk*Ocl3KnV!sxfkTBM? zt_!T!mF|*s`s2Gqbg5;&Swd}jAzg_u>T`2y0m7^AG5E4LQQ={-J{nKoPQh z)wlWC3xjjHm&gsWZc-5gehzIPmaeSCX>}X38Vg+FD{Ve6;}10vs=cR~eQG)*LsrL% zp))*lxB_tnj?rk$&7Wn_MrDmQvtb3=OeIR*Xw|43BW<5{fktNS;v*ZF?8OQX|nwn@2J zW`+w-m3=YN|N0eaGqM}$UqE-E(c`;@OL0GAJJKP}gca?0ycc6otn@A)u^Q0Q|5P6I zIGOMKq@XMp^>AHp?^O}kRw-JwLCST+Q64bfP9K%+#zlCu3M#cAi+^A71nnk0DxooL zuVZgMrv4~$&xEt6JD6dQ#H<R;D`l;=BrUJ;e_RVY5>3(xQyd)`bz_No5+{QVsHX_OJ zUVZ6sL6nfOXOV(^ zq`JA|IP%|>+yo_z9dp|`m8|5fffd9!>3da_Ly%lBJDJ)-I&VYSG1(`;vzs*a{>$B; zeu6n{^eGR8A{NGbWK8OQxuig$_W0Zp(*5u3mupu^VG|rGn_Ye2$bueSpNo;Sz^9w| z(xD7lP?tz9dUYv@Idz>ZwGdN5`bm^$#EHdbVrF7`2aTPFQ#plK_%jiw!&;iygD?8c zNu@QCqV1$McK4p@w>`BP-k1|n_I)Zev!(wZhEEw5a#~Tf#jM>Io8A-HKZ@?h{QAp# zFEbxj7y2=i^~-9SWHD^D?{SJ@CBKtOQv%wtP6Jf%!km&*U0I6Wbq@(YTf`BINCH;8 z^>IzSbkI0@$RmvL3|je!)BPCiC*;7W3gYeaiAp=ystlj89R6^m%Sly=}7CvYWe13?4EOzuL1Vqe@4ZFNPkoEvu<7ebxg_ z_`s>LbjkL$tnv{S>GkdTh5Bj`mp3?A@-Tf%dN=z=!JC0vipNFMTQx;_pTUJr)V^s( zYLIo%?NK$l39XefdNq<`+IlHakvpABhKXC2DL51_+rk8Sp-oQM~W z@Aq)uC2dt){OG{7T(zTI*)O$bkSy?x@g#KkH^*Z9##?62u_xFKESyJA!=}t$HBJZb z%Z>NJtVsV@@et6JSc}!H+k2l2Zz3J!zT5InE7GYaQ5fg-8PvQRBZp5yw>N2zlR{Q8 z;IrI1Gjc!fx9Pf%eb=x@cwdmm8`S=n5TQ)CQeiPk%^cqLB&qS4oc^1F32t^?h+Rw!D26*-x(jx| zWaBGRhd{A=l{Bs7OsiX<`CRy@I%&Y1!PqAvR;5*`bte^j{1QbybV9@7r_MLWr+N3S zqpV36{1qvSFY=p;G|}|Rty8v(hWp_4#M!}TN7?PWF1Xo(BhizSezo?bfT` zyLbm|G+zc}K`kK+B6Ga|@gWBKG3?=g0DzaEOt>;+AM@sjmu2~j5pMH)Gw-0{piJ<} z{p(%!6Y%}t|0xbQ^*=fb5bVvm0srk66`2Ku7#P#Hu76Kq07{w1&H|1;eed)9+Wi(K zMTWD87~m1iC*lR&pa%?$n=`v^A{$N%(C4bMMo$bdAdIb-9qf8B43+NEgrj zsp&e?l3B;qX@p^h8Y=kf2Vm;n=>Sekg#2LGs{a#rAtzbY0DYDyYzP<924MO2i`k9K zPLUx&*14B!c<5b@x^r+QZIj80;&SdZ5pGzJF9j++WmhAsp!eb6(p&-0)a1l256j~b z1VAbJ2<2y<)%th|B{nUF9!gj52XQwxCdCUzxD3K=M@7Pa^=-n_!%u}abZ1In#Qa*< z)A6PV3T$rqh$G@sxO+~E0w{<+6{<+fBu*2hNMv482Uz0Y6?L+ zkrF^awM8zEJb$430XE_AaYfZS*CV|+TvN1gkyPmHQxQB_fm8yO7W=TGX2Zm|DPquZ zw4!SbcrORtOuhFFE>tkJWk&5 zRn}jdz2!Gc9TRC2#vo##Q;SwDFr6=2^r4GmmE^uGj_U;}qdIY(?CYkD22)oB8=p>=ZqfC{bi zSuJeyaDZ!lr{>o14E3Fx>wPZKQqS0YYL5da=q({;?SKOeBbkPxWZ|B6612@89ZDW8== zQyzO6AYUh~)OJZ!1_2biw`u zR`BC}w-C5T9W{d4&Ux_)3mNC^o*rcy`dcM{yF#cLR;R~WQ%tXP-r``|tOeuGU@-`^ z=_5Gf!j)IEou(>utohBI^5G=;c+-ODGU767s>ne?HD`=tt7~}ysZ;MI?iGb?05&-J zNz)1jg;s&_HI^>Ul{9JaA-2$}=;vv+osC=lB{u#nmH}MfMi##)Z=< zV(~5@;Oc}E#wcP_FT;n#F5&FR=^kVF@WUhxBFj`jnN%0*5JT_x=f}5?V+G|qIlMw>e8lk0PABbj=**acKbshilfoh-T z25`UP3Gyio240{c_RAO19pBoFE5<96!wo=}w8vmY82|8t_4G>Cn()z~6k>BSEp6cj zR1ZoUD$zHP=~SPz^SH7%vfWJ^i4=p=azb7(y?oE$2F$4E{c@eXQULk^l&Utf5 zqJ+Sdadg`3doCPK8*^v1^CT~wQsL_N1aYJdg9g#W`QEBHD6Eh1?B{Vl!pg@5RTp`xY!zWZqYK4FdmD2{MWQ`%!JTGDP|$8B=sw4hMJHP^K?~6 zW^&QJnAE$e6+>cX?TzW-(7%dUmz;ib=4&{%{QBB+x!x46F?tY7bWW-M8s1op1~~GI zlfTO3&oXQ#X{Wxg#1{&13yQqzcT7ljCb4*?85R$|)r*pLMY-xS4Qf9e<{obRZmHQW-5ynF)^uJz}re@Ns`7 zMOEO`omvu2$ zwn-_tD+$ts0K<1~f!3JEn2N0S@VwXE_ykYjWbN(-d>zg~-EaA|Rcbzm!~N#F7}`^5 z+YxoYKHG4YCK>ocfwu6C{d_6Xr*@U@mfwv`@aN@FP*f63;e&P)?tk)%hlqH{%+Vo6Cu(jRdI<-VOd-= zjzjyddD$iEtLa?$dql@%FR`}_sHl%j&xzrg8c4f2q@9&uo-4g5Vbba8?fz3JOHd^RMe-sN$p=aOc*(@34Mq=@D3T;+&Bur9DNp8ddgTYn|l91j(@W4g4 zV(#5oHf6urMq-G6z5C`^Ljc?YcM2s%eqZy~?5{vcL_Os1B1L4expOpwnq5a*LM^8r zZkj)ob{0zLEQGV}YO8lHHz%x5cJXMHbrZ13+8?)hh_YBEi3lm5_I%KMSW$#PkF9zU z_0EhE(bYp;6m$Jtufc$%yl^aRqAvJwQJAvz>`YQ%CE7>i4@^)>NDH^LU+(+5Zz447 zV#F3*BwaMIB-)2NkuEYk|CUf-WCA_l2ZDqMAX9U^NGDX6l1*{!3kLSwO`pWf(k)&r z)g*siQcN(Fa#~sV%A87!U;Q>4I{9b8Rj5KVjK!^d_s73qos&ohTM%~=?&|gD<@Y)? zKr1g;r3gRstyBytLk5JL!&Eey3gA;A91>~vub%XgIoJkzga}pbYNP~rZOs6X^Wn*T(rUXtrfazYo9 z2`=oLFbE`{au+|heIXrUYMG*3?K-)TYno{b4NFuF)$kvML(wq`lLpmgW*1tPyXGU` zQN|KyeU3~o+lDkX3lX+|yoVdSun}ck2v;XYG0lMa*#*JV(J@=I)R8b^@|Kp;uRo!2 zJhNwV@4fytd>E=D_E$+ z>+*Sn6n2vRQuKS2+Y#WMV_+zwGW?)C=8sjCiGG*K(TJ}3OXt%8&izXO2Yg~c@1_9A zz#9`84tnJn9Ih`88pOT!>Ve}R`HM=6`CYM;%_0~8r}&P0ZCYOwho~@77z_{n_~PXa zx%gfLbEio^_Tv2n54i)-i$9-Y0Jt2$5T<`H#Plb4^ReU8f8oV7Lg)z0g#zyJ{c9)L z%?oK0${7scg=_F|eWG(4G`RHGOH4l4M4XJ-?`F6d*T+M}&8~;?UvT4}YtcmS8VT*3 zPylEB8%^9?1n|q7!!rRM^y4;i|B}8|nSFqUX4F%Nu8v(}RdcS-JG*eZ$ZVkj>&g(s zK0a1LG%6|)y1!d`H-HWB(T)@pYWJ}~3H^G1)k~U*^V&qT*s`oo*P%^UwHi-%x^BH) zlTjNUIbpD483a8xjbz_;lnFt@` z^hY}t$Tp`gXivsB1&X7<2bcpg9bD&JLDO)ZH>0v3P8(R#paODQq06mFSFR(~ITL#M zB2wnH+(~!bVg$5As`?z&rUuC_sjSGPdvR=>{f`!4)bV&%^3*Mgi}+x=3U_`IxAWFp z5}6W*<@>0yaC}=VTh6tKGgEc)x9u}9ZSoz5o0VAhujGQiiS#xRsAq){A*v0+jGr~} zehHeRr9Jo(v7QpQ_%_@`?8~~mEe>h?VT`{zsz0f^T>$yqG&APam?HH zYFQ(Di%92BoJ~ z5n`@0#c&%&9s|KNsjh05zcmk2)ci+dS9K$V1YXTGKo~`}TciYzF!hqphDRT{W479ARZZA*v@l6L0KFo*b<%jINiVsa>;jTurfS=m4jaH73#7R}G{jdJ#WKE~BH=dGpF^-4st(b~(9%5Flt8>nornhl9jg0jQhm4* zz%%>^aL)T+%~9IS@Hsvk-_}^Ba&QcaOv*_i{x~c@1f?${g$=m8lCC119}8nGfq@mb=c^ z%0qF6MrX+yKc_iMOzI59r+2+|C3)Gm5b?g6%Wi59jLb_m&`NMjED$NPSSQ$AHFheQ zr#LD!V~YM@-*a>A#(8iCH|D!)kkfXqydA!Y=i!b#zb%B^sp5BL zn$c4_0)o<`&cSUTGl7r-uqR-@UD-=cUA9VRNqG8y5t^ZB{w+O68P%x?BEP3>L@d+f zQ2(al)VvXi1Scavr zInDonf(%bd(4G}!?RJE1<_pN<{o}^sfWx=m5$~poy2WEljpj8MRoCdk+p> zE96Qs=2lW%M^MDVWPQ!UU?V(8G7m;M)jDO!f}M2G=eGtZ1yzumD886H^0z{Lggiu6 z{YG~odIedJd1Vr+p#~A}@Fm2_Nc?1*{R9{~_9swF9u_i(yO-(hR8fS8O1r#=sLWZk z*mN;`vQ6ZAh0cG1x{CJ3^iLPi^ z9+_%1T{3?CCXW_CZR4J5c7y7ah&hB;c^rvNz9|M@)%A4l_Q&)J(@vz%du|Y*)y>?J zV^$o<#u#5=f3g*}B!bmR&dm>=!m5<0YF1BwPs{EHrHoXXRE~coxIw&{D9^{a@U@*L zPAk*)re{C)W@2IdqmQ+@fL#h^HCkOn$AJ&yFRUG@bcld`R7aIm_Mfl7Cin)&=PJk5 zQ8Oy&N{7I%L8c!r+MKVOGE^a(c3ab4!6kqFxaZ{lz?Isz;DTanS-*pV6%ablJ%dN=TR@aU16?xZTT08s_igqOD0PAeP3XTfYF0=oqfCAy+bt1bv z?dod$ZosvZuZM#W#((bK%|6N?j*iLm#`X1CD_V6>L%lQ{YaGpt}Z+|h_*k7Y-fjA zk-tIFo5 z4uss7Ov5t}{`iECVszLVCaYmDnPygE#tQ^iB+Wy0(5j|Ozsb_}gNNPDNh=?8FX8uQ z-J60!_Us_j`EYe8nymN*Ro(q){OKZkfrq)^+OpZoperr<-d914)EY_YDv&b_*wQop zkIB%j5nQ|KLNmz>Y;EBUC^E+vyDI=Q)9c0x(FRRyxf;xd)Ike>r4kviZm5DHl1Yb3 zV6v22L(Y%IL9Q}I>u^BbZzc4NoRl+(kR+WkI||YE^HXPsgQ>j4f@IQ~#HO0k!bD+K z8k;&QGQ{yN^#Gqf6HhszQLm~U+xlZIkf1clA>z<&BT?QaMV8rf%36{DsqkXKfh5Wn zgByQC4s=A|o^Fx@g`QPg9okdoxBQiE=UN6$SIxLRWztN3y$mZfQR{M`D{jA>%L_$7 zEBt?F5Df32cF`>j2zWu~FSeCzobJsJOQdJeemv5APFpk}P>PmaP7(*X_uz!-lfY!H zgUc6n>rRyW8Ul(Nt!@cYy%z7nk6l(mdE@U7YCllbFyI5!@jnnEkM#crA#&ja2e#iAzlL4tZ$?75Uf&nyDa>4{l@MHUC}})i=kgZ! zYFGnLh3loQCUSPGLuxV*T`IosTS!?#tDjd&Jbmn80Lc!bJt+~WyabGLum$1OnB&$> z5ZpK$NYK9Le%g>&i0BlI3R6)euIl^>GeEHtzk6a49LDeD(?Qc+fTwAthk&O)PG_Cj ze&h~~syI=`wM!C_u(j>iZaw9?Mi4&I8R6q&j*ZQy4pWxShW#WQPlWCUH_M@CJL2kn zRTl67{z@Y9>;kK9U{roSs5~R>tG>7aqdc5aE8Qs{+BgNZD`rTiT8JtTH_qsA5>Gx9 zgoz*S-qD}6DR|m5rUWWhDDPmfx6`~OA<@{(O`QU3J}@z|N?Dk}UB|G?^JRTS+Qo?j zs~gJi%ub2+j`1GFeeReI4V0KC%imycy>>W*!=OvCPYID;TTq*k7-kcGgbw|(nRK9_ z>d=f%n=FXt_u2Yw(OWHZzBwsJyXy&7nVFuvPJLogKYt%w69@az<~^lru|wUp*g2^7MK1 z$m5HZ>>E|WpUD3|_+Y;j>O%l%1MF{f3D~E%{#6e=j28oF!u19G5f=a);QGsV`YI^W zowntMTmO3ge;@>aC$0~_*5rMOQiB+H)&2F~eqkb^1_Cl9Ft6X9Ld{T~c4A3@8vs&? zm)G094-br3)2sP8eH#ZA&dr%IF#aYMH^Pa(0SLej{(&4Uu#*=6B=cDo#4_CVq$yERCc2X|fmUM$x!d*PsK9JNQe37*LYniz#E=xy7+g%X zyEgb1e6^eh2iX&J2yU)@%jm4!jVn_>S@>Gqm?b=@z7(XeT5L3tQSt4B$O0&B-i#{M z^+^&=F+F5yzQAkcTXV`={u@RJ^0p3P<&mc0T^#FqR+9oGw&7CfI=cUZ{(qnaAwYQ{ z>?*CfTa)(j5(Ou>CX<%YJdo>7tV)jRNl~S`I4M|kzr3qN{8q|82HpjpU}RQD%~#<* zhL}M)4+7I^>6wZdJT;gOLEu+=%JehM_<<5tH+k6-!^HnW}d@(s{ zGJOL%na8f+T+5WQw0>$+s3&!S{Ia}wC9bY;n)DQe)Z>H~1!TlS(=FbQTf3fD&kP_t zTPVpFw0`WI@|@BK(WL)^vnYHY#nxe`wtpLQw6IqCR-909_InBJB!A$BsEMk8{zeJt ze^G+0YyKj9Je+7Xa-@%r0AgwA^zdUAo}dsWLPxR=9M@5gj3 z)C+!=RpcWa)JowI)gC485a{W1W9{6_exH`l>%I-DAVG#$bOZAi&&n-cP7Z>pWHEg# z$0Pi~$}s3SEBoRA3#cu*`twe033Age=Re3PP_W%M)zPa9;eQTb{s8y zU!16BPQSs3EdHfUCMzWl;?0TH)S?i>_cqrc@ys>2)$&sp40En`K&7joW*prKQ<_Dh zJ1HZ_jY331HLMu(oMa1RB8Gg~}uWclA(z+#Y>mwRtr;GUO;xTewK`=M^9n2~B?{ zodca6pmnkv#3D9@I?4ZkPTbJW$eeBNk_EN59jj!=B(9b!ah?)Nfu5SUuCO`-0DpaL$DmS?jL+f!v{18qLGDa z%WsW7^!I)Dz(06(B&9szb3NMZzegMRZ$`!z1Je~{Lv@PKg&yn3kl_1|_+}K_LgM$- z-{{FR=kLOEoQC7n=EOnT^~b?~;r~*HC8;ax>n~|bEf$oA2C;?ZK$q0rTD-#-U>%!}BHdx3~udUfTybsgF~-(!@tS9)sAe)dvn19CT170$}+A8f?v z5UH%n>$8g|2(nI*u5S0DD}QKxq7M`D$TXj4`U0pHCchZ3C%3C^nWve*-H5AWWP5*# zKPeUGq@Am&6ZA2sukUMFLMU+Qow5?Bf;|Q6S~~G@zr#z(44^ zHz`cD0yqWe;X3x*Lt*Wr7quQ}E~;OOqX1nylA%A4^y<7Z3vKDA0Ke)G2bhxb+L(oV zNgKKYTDHy(xmijg0(B3nKmBAn)Q>Edz*g$Qp)PwlVc#(~E10W4r!<~X zNJ=Vmu``INrIg&}{q99XuJ)>#Ml=mZCEj){o?V+Bym0utgzporjbZ}B*>!}5Bka~1 zAim2qF8r3oQW0w+^yQe*5F8-i&$xKn5y{u*N-)T=G4}rA&RGh#T|c<}^Dc4t^Df~+ zh*lBQ!paP|OGQ%da-k72;{p)tPdzHDr+{j{*hVbu9MMed<+Q-(usCY|8?##v2+^j$ z*VA%{61q%4Rdzy2mbJMOi7-Kieu)(InIqBl7x5yueP|A((MKSPq}2My$8}UBaK`IU1sa*R9Jz zhtq{$uyh$f;)uQp+v#c!34(wYt>0=&mScQqP`xh&$+%+1=`FGBkevol5A=~?**5|B zT7!dlA7Z7(jGlPi5g4;PfRk7`>_Ok@B8XSkrt)1RDy`?aiBy;?*XZsZDc2A7`Zvjy z^aBJ{APY3WO9NoU$`NRz$p{pR3=U3{~J^+^lN2rG|LkA8IEKwHH_xcVC13iUEJx z(6?z2;`*o5pIJyA+H1u&I=s~2Z)pUpd2r#V-oaOh+;L7~??YPrtbYX{8>{T&o9XxR z#KD{r4@b!P_4y|6T#NCLmdX;1ahx4{Ey3R>+51Y@z|So83ts}SQ%XV_*=C~v;zd;Y+~Pvy@Cr7&^5S_j|v!%yLot+D1t>3_@DccNkI znn{Px!lbx%XcJlIvthjq6jUk9rF%WD2o|L;1abXc_AIvQMvazl9aW zunYnAUjtsVrj=~Ap_dz?<9E1vhwH_O1Y!Fx^otshBI|BB9o&k8$Nl63UC=~QJu|~* zPf-(Og$4F`}I`0D^ z`e^@^->1>~!!0QI^J*0<^M0zu)Y&zGDR;$s{NANFNhhP@?D`}FxvU`*av>qdNjNWW zfDo<0`eh_lJdb*7gtjCP{uEd9QtMc}FmV8ISMrh)k&?PHgW29P=1Fc(uJFxgR;15~Pc0KL6>u>UJOb&GrnIdBc*mBMlu+{l5Dv@5?! z&*&6&CAnNw0+ChM@*Wt0n!|oIJQgH;|B#BU zjVgONh>+oZ#*Y_qglTbeVq{h>Uwo3{=%o3Yjh~bGb!~#QpDr~%2WlGCKA~?haJC1HGT_lw`HQ8cPWgM1NMk1;AG4lI#NK9OLT~e1{S*5yfWo`r*PnN(Y_#yHf2z~(N@8Zj zfdu^E%s+kj-}wKvv_Ou}3?$0G)C~X1|Nkz5-E5A}|4R$-Em0ys-j_aBKTPGr^^$KN zvk7`=lu1FoZ3fzF-j@hQGGKa57hzS9b`fuJt_qZh+bS`etz#_~&PeI9xzF;Va|)^+|MJKK~Z7o3)z zoxcpjg`>AT$r1APt0?aCDfZQb(Qr#Y>y3Sq8151YXc)~y$04j=m}~N8woWBLqWL#r zDC<|IgmpWqgo!4A2fZmzU?8jmJ_+>2HWP3o?OM(2>J56m{W!$Unwv8lfNqhs|C^_i z;c~6O@L>dhRc&Xxa-5QL1J{A1hn3mEnlNh-{c5G+5km3Y$^#vI7>gd>5qH{l zXcZbg3Xns%gw=71LJme*mNd^A!}S;pd17I&Sp|~BR4d$ykv3oH7dM_NGxBQzO7f^Nj^2- z;)i^(5jl~Y_I#Tu2`<+?;@6U@((0y(gZ(L6s9pPApzbB7cl86es|SsgfC{g#g0XMd z@k}v|z4FGDYcU~`?W}b7bsyi2@~|3wN@X*GjeU2eo^4)+AekN{GgMt{H)+}Ckw}uLgKS;sFestu7o&9 zR@pNRc88bxN#PmsKC}b6bzILvm;r0== zal1Fw-mT$`N5?dPD?YSFkbS}W=W?V3JQ{2BazGiCqEjjIZ0XXCAK5XsBXnx;;~IX7 z=CEQYL34wzNFXIfJumo-XBeH>-4{n6Oh9+}PBi2uJe)33y%pK!EQKmEAD-@{1aIbt zCc-Y$t?wlC@(c(Ub^)vM*EqA$AOTLxQtZ~XN zBo|e(LVB>gzyOeLp>!L*P>Iqqie5WU<&}#89?Fep?S07ybby=Tw8h4DZ99UK`3 zCPiXvnhl>6LGXL8=QtBMeDy801XkIxX6fUy2L);9%?0c1r(2BcINog&*XmBAtJf4~ zOY9+tw&d~3QMam!yGruQNJL4NP;S;)7}A~*E?Ow2S8&fd0w+OhkWF}XVUFoCIKB8r z;Ywx7cE%sd1T}2tYp$m`8lB4!9WX>^yCp0?k4to6bqC%^Jb zJq#Rr8-+@+rDs1ppZ{>a>`oqBJ1)mszyBGE?DxPEMd&51`I}*qv;NqM zu8HSO7Tr2@Ul!-D`(LJ9W-7qhp4^(Ud9G8?&(4K#bNjZKmCm`NrolO@*LDNtRggV34S@rz2?u=nuX?^`(Ex?4TbFA!_Daz z{BNrH9DNVJ28bjbnENr^aKq}`w6Szd#%(ljzJ0gV$(Vj74L)WO zkJ~^xFrCz~OS>mSkx#}hYlk|*%&GM?@OtK9Z0SEoWJDisDzCX{G{AUUJ=eo8Vyasg z9h6ez6u;=l9zOUE(6FOc9io&END~U5WTjRkt>~pnKMg=0bUclvi5KJtJ8T*OuY{O^ z#GMuxXhS(OihEK(Kt$w2UAJ;>mToy%2{R*L3PZ7|n**H4+K!w)AH)VbZE>c2{Hl=+ z<8{L_qf{qN_=v^r)X683+>vqH8xmQd3A3V>QOA@uL2jUI*q-%jW>ojWrjWVNetY!KI(TrMa;}PxvRHi$ku1&=Yy@$)s*V8JuFAwg6wx&96NJw zeY%#0Mq6UVBSG0_S0mEV74b4VIW(B8jb9fP-(}--*ii`dX#BGMe=Fn%WuP?xE|k7E z#4tx4%Y|s)I{DKxfxdJ_J+m&|h2uc-slY_%Hpc8mb~7N~bU@vrG0(p0st-ZL)*L*7 zJzw97Lz5H+hT0ci^Y#fxy^Nh;-RvvnVg|x9^pzTp6+a7VL<16v;|KL04hci60oKvsJ1fH2+MV59 z-P4%)V zJ1MbV#`~@#u&3vE>#VG@@9Zx0AyMs>z0n~(%BB1dq}eAG8u3b+hnlhe1tQc{h)%9H z-`7cwm)Z_`ajL$t{}3OXU2bPFwg!m;HMwIH{zjQB-Ay3>}uyEc|kRR8NW@#TtvSc;%*?@^u+^J!|2Lc}k@n?f@seCG%M-p>>m#kv!EEfJo-Gp>DpHE^2Yz-R5 zQoQO*&moc?u6%6x7-cyzc6OTzTk-QMoyP8HUN&}_XwIz7WJbfMBk z$LK%84)S(qbq)c`8@pO|BHuDNL>R+H%Xz3=XKd*w9J5y)B6D4t&#O zvYF%Y*!4>Mo-2-Zj$SEoMmWW5YA~`(W&Pf>B9XMZNzsDsSr0YPmQ~Z3|MRzgKabu5 zJ9^iD@16s(cPgc&neV?q3;u6+nb#{=tTxhEM!~WVIPT7ycXIi&?GG__&@>~YPWV@H zPDHy>tu8TpR1cV#H_GaFc<2eG%$Pl0n4{Ycj2)S03zM{W3dEV}n?UxL-xT^h50lS6 z2c!`_9Qk9ppx$!g7ir#U3+~lXD&AaJ5n)93>m%%#n|`^{NUw_gFhKtAx#hPTCYo#4 zBsEv$mlzP~_L#T!6_>-omQ8TcDa%bDw_MGc()hLF@8_dk8uQSCAJfsYcZ5q>ZtQL7;N|kc^Fg716!hU1 zdU(1e<9cB#9msXYpC1n7{=yOVVl4S254TSP<$mx#v<6oBGkQM^FPN4;gQWv108;Y& z1}#5{~tsF{>iZYNxZ>dS}-yvA^}IkYsb~WHDVcG z7u)eZ=gHGaq{VW8zA(9QT9`e8!sVD%@b9(#e}<%yA_Gh?rREZ${n+l{HBkB= zOoX?LhkpaS8qw$1=G8tVX{?BuOh~&IEkNCj!b3eX>NC)^N@OJNL=`{_W=cqB=%e6U ze>fYRd9Kcog%NFs9NJwcOth<^y63La(F|xF64TT|EXD(tf{S4+TD%+g^8Vle^qTi7r}i&wRjveG*9OEykOFL-^eQyO`= zXzRyV=&~O!HQ|q_y#Lk44T5gbpCni6lPnT?ws}g zGUzKlzfFi&KHTF&%W>tcJ{|o!IxvvMC>Q>F;l=i`O=$!!x>_=Fvymj&ZF}{+h3c+N zu;~^(*5R6BYfppOR`(kxRJ>`o#N~6fU86H473qJl1bX8>=q3QNgE*4xAfr$uk=RJD znVVI|{6%E*)AuRB`QSpCg!%E2sb8kA_w+ET_Fe5#d6rolu(c^OykDHmWLu|e*9UGh zOGEG2UKq%qF&}=~IiPJz3oaZp0ToN-!|6!Nzgiz(35avB9uQER22VX~#YnMD5i!-R z(Kgz94=WH?jFQ2Q_Qn&+^!>3x8gK=N;#!3Od9{FvZZ3?G^-BaCun6K)G`Ejmw!k!> z$>GOVcsx}*dU!p`^ZJZN^1fw&p4fqG43`VBHu*NRfxeK{)2Q-csoqrj=ykIWm3>MB zf{|Gf`Wk05?^ct9RuhTed*P>F0_TAr&oV=D1-h7xJg!6yN+k~apu?et8Dsj3FEUu%Aj(q8J#VN$vGw8p(c1vqa|ma%3g#4sExS3RXB%UM=p6lcA=MBLlHlSe zoj@$Bc`2&&y1h#n$w8sP5t^ohH_1O!c3(Rop(KM)7H#Xu^-F@lc;;^;2>ePi76JvM zsjB8$b6=W1hPXx_D6_174!-8fHycnmGm~Df0YYe%jutjjKGwK4D#($_fqio6YRspe z!V~!4Bx$-Y+z>}?`O`ZY;``Y@GWdv9f%BsKo**yBYrq#5!9v+$eeMb4t1ToQLf&sT z!X?+IZ}4WphHGdA`)4<%ur{KTT5+!au!DwbSg&`niMbtV$m*ZW;$0<1CC30M4*zes zVOGFy2H=pT0DJ=5)@iA-jjMA2jSTQmkhDKx1UXHkIUA*$4J%@~{(3LLS($UFcuW=5H$%W`|z!cXRPm^an!a%KTDrt|nuQ-sJ=nCdm@WF&=c-x7R!twn^>qZ%LG(A6?kxl`qx{e>jrS=0>!Ae*ZZcSo2~E4^uxS)FM!iK zrc%^eADt@-RX=So9_{Xw==#+(mm9*ss>}W)SpyVvt{sn;$v?YbVce_~uL1?R<;iec zh4j7ee29VjFCF> zcEW3ob9r;p6?KU?ie(P7e&yZuA`z3 z*)Td|Z*}ddvio_C0#MJbAF;SW=xWevQ||F&F6yV?AlnUqm{?f<7aRjtJrHw?@T&Aa z7k$T=83&||4*XGKrhwAE>q~Y#htd77CgPQ%uf1`M+%$n;$(i&aiO0p`O8`)nsaLQz zn#wcLlVT6D&Q>x%iYHbyZfMgk3D!TXi$sx= zFsR65@FE$S3vaK=shjz+V;J`Tr#r~eo-)yZ(g^2|Haa*-nyMs#=v{+u;T>O@`z5Xf zW?6@EEBT&DrOiQ0WIwL6Mhh?2)dF;X)kq;O!Pu<n)f4btcIMFPOn%8L$D5=)+0G3LazZ1t2iE@ z^}BzPZY)B>I%TrZiei9Qr{sAFtE{K(FHo|K*h_{c9lVvcI{DN7ZGAq3h`1~Px6wh4 z)@rJ(dmt}2_QJciJA=+2!~=Qc6hS*VQAV}N6zf!DK(cFmmXT!B_)-@#BUD{m;z!(h z26z!Q1r)89#)`0fj@es=5qgKI^1u%D$;9OO09|8sjxEpTs5CO#ZDYq z0aS)tSAo0YgE^*8AqZO$M_~0a>3xnDDVW1^>Bw(~Hls(Vvcin*+iDuMt0Wx?mQ5LV zuxOFO16}@x=z{?1!kZqRr7iyr@WP>>lPA&)8pN zMOdFc+$zR#ZKZm#F#py3aTS{jpK=ES%&>u)ebKTEV=mMWWh|vYnvipH;~XKN7DnAo zU%MZjL0|CUpQj`QOwT#8Ldc5qm1BDA==T5@bXEiTP;)H)ntu<%`zA2~bZyYld6 zIEvO z`LOox`=;)zM-m4KgLM;;BSy{(Y47_fLBSoF&Evp=STlkImC}V$7nvgm0s(r2r|*3v z!a2Dqe77jYPYtwSajH!E4>5xt2s;S~+OjmdP;1Ta1&O`6ICh{ezxkN^UQQLj`i}{6 zKtw6;S(L6feAMJg&?WYI_HbhRW=2%Nl7)P!mzZ;z?S-n;AX9BC=aIN$DMAldC}-)l zg62S|Bm}QLTN(J-yN)%5ld5!b#HClhxd6%dDZEaVt!I=%WHx6_IV{Dmz3SL+tY3%Z z+;ejHUGOd{lSAU`%h7ySf3|8^HcNTCxiI6=li2sZr6W=!zA2|w;-t%V%JXJi4N@$e zI->Vxz6&PVG^hpi#|l`jmLnQ{D2maGnc|*;Q4?FlUdyfv!tkL4=SUNtC+)Qu>o6vl z^|%Lr;1f>)e8Oe^OcMA9v~#6p;Y~}hIMuTE;-g@j2nq}KUpt@6AZaeT^wH<`XOEt32^YSB#D zXYH6-F?n_KPD*I48)(o_NuFiO&P`UqZt;xQeC$rr2=a`5NPp={(4iK>9$HVoFS?}Q zHvgW9L)+bYYjy&8;9V%7CMuY|wN0AiXb;I_Z%C_dpJR26D##!N@O1T%eAj&m_a8w<>U`izr!2n7E`c{BSFaYAIiI;&=i>X{gRKAA(p}KcA0f$G$b|U81mv1u^ zvy9K~OFMI?PVl^JZ?yrW4pk~5I}#pG*GfyQmrs|j25o6!pf5b0$va%+d{s!DP@Brz zo~mY_yrs&(iLQCRPPgoy$qKPc^0<>sbRBX?fs>Z+d_76?@V!xxrMvZL$usQVbq~6r zjH#W2$W#7Y%}CFCqiJ0hwm8d_CWxSN{z^aP+9FBR(A%*2Q}__dz@;kx6CCkjSh>G? zrshGdWc^`D-Gb88e$+4w&n8V(J^ohB|18B0>bo6mko*dz7Y03Z87n|adljkxnuXLM zwUqzCG0VbT4-|0H#{A*k&(PEJHvr(_Z7wSm#QN0|5BDNrYv1Sy;O7b;*4s1BZ3QHy zjvMG8@Gk&LzcV`UVKlO%bA=65Vw_WUuY!XGfz>2@iX3F-_2U>4Iq4IGX) z`+~$$9>pcj&@R~n&pr}I<5&g(SVOY*3+6YY7s$wZwEmgD@c;*#B=vvi3f3X-G#Qx} z37UA+Vua6@2*6VMk&&J1Q&+yN{}jMh9s@{DFewh`Rs~JH=w|rvOoHdbe=w{3Y4`98 z4DtqOYai)SSJ_D(n1Ezsv=CiwR!OR*{@Jc2QXkJlx}d*b!hSC?`VRn1-YH%DH=ren z-@#5x?B$;Lmgc4vpNMrW!7TLdPz-kYRNQM69KKfliQt|e>Y5w`f{Cz-B}Y2gr2Dg! zGTqeH(~G58lRloio;YAIWV^bgko%o3>0rK#lIHZ6K?RU9^I~g(k3aK%It82+1<S8UymkroBp0cvMQ$*5J6%}%>3rtN z$EM94iHo1`-1p7}l8r#)R_PdD-JUygYdxU=J9!5}hM;&;M=pSXJWc&!rwoxb$La02ciJ;U(Y$mej~rS=uDFJ)uRP% z{P(Ao!0sMZ$QTCc6b{FiyY`_|5R!ujC&xxfJ@l^Mi3!vV3(XT)R0*4^`Q~Z>o5lUH zg?^TGvdzdGZ_cW7u{wS)8??NB+{X&vdx?85s>jXlJG>t&lLiIB%MKN51y(D#fkV%n zc?~~{*W$Cu@5Bpq-0yf_D-Eh@>gTk)XYOO1d)kHH@7qdGXNXZp^wj3=A6LBNx2;4c#D4zI@ z>!1@y@giqlqRG(4;2zs*&-x z&91}z8u@oSSB1W1E-u!IoVi(f>N5`lVMnp)>VN^pIcN8n_Z}-H=!7H1JFQ-*$;m@U zyb<|t??83@kT(M^d*3VFFOiMDUtcyc2Cm2BAK!HbvWsLV+!=4yk>0DTXe$>f{{H0u E0U;EMKmY&$ literal 0 HcmV?d00001 diff --git a/doc/widgets/images/statistics-stamped.png b/doc/widgets/images/statistics-stamped.png new file mode 100644 index 0000000000000000000000000000000000000000..ddb90ee57eaf460d956e8422b8063157efafc02a GIT binary patch literal 7608 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�%85!?SO+(~|33ADjf*#O!?7LcIT!)nl9_Zl%tdixvzq?L z4hYKiBk{{?3~KdP;YY%{57_$5+msdLMly46>RwF8y|He&05)Ch@aC^K^3Hs6vQ|^L zm1_9QYYH81{4ImB0?ua$K=84VLIwI(o#QTMVtgY}t6n-{SkTt(&9L;F!`$lNN#b%b z(&cggzVXJAh#?%k0?a|Mm=io58wY3hft(Ii1)deK*GalQ4s#tTA<-D&zc>H?T=f4H z0DQ#?J+#mZ1%Y2JP56l-CqD&viOR5J4DRAn_lvig%TX52*}(cOiFID`)ki}d1;7Hu z1$odY=H7vNEnVQqo-h%Nc!ZOa16$UuPVQgLfat%)1)@*IIOm(6MEP})xMi%svqa>x zwCG~qQRn|hOt@u5F|jTL;%b6!yx2pm2w609MNj%YPOlWa zyrU_au|(cL@OkXg1#^Mgh!Ivf_VX2;MmY1T3{9#wlA)i?9VS_RTIEJyn~=XAv7eM- ziQ=zdD=UksHMx~D z72l`4$>ZEESp*!#%$(=TH$Ok`+!rv!s!{HFeK+=uOEVaLV7uK$zqlC8A0ZY>{+t1& z-bj;wGFQHsEx~2pQAk2yelv60>@j}t)6gd zvG4DNe%=t)u907j$~SZXb$v&l5o;2kW0ANY_+Y1X^E?BSm~gP1E(;E0&8SV=aP}MX z+u2kt$g6n^b^SPHHMLrHDSzGmoOJ%hwcwW6%PuC?&U8+2xqwMa6jyB&udB_ebz7wT zeQZ~JcLG+~DXj&n<9rcpuFh7%rFMXr{INL_D%ZWICB&MA=@f!KS1ZqcrxHun_h?o(vesmVz_$+Gbg=r|x~|>wn*?1=KW!9W=o*@=!*^l7 z=R*qY^ejK#*vp%Dt@q+7?g23nMBZUQGzS4;FYLn_YlJ|Y{2w3zo9u!7?jo{mWi3KwCknnF~qCeP?G^Y$il_fN`n-G;QZdKcIX z2?3t0>fkC?R%yj<`*N4toeo4-G|YSvjAny!`TEZn-}&b(@ZwTd)`~*5avxXGX&i94 zEeD=l(~EoJ)Em*us4UjKM$tl1+5PrIGi3zezDWvhQ)7?G9$DZp zRE=EI7D}s%oCRg&C4?8fS|+1OBjaSWG+zArJh|!GG^3(&%H(|{f2HOZd@cn+Dw0$} zaGhJIhBC9TpTVc4S94FwUCX*Bdb6Nx7iZ~)`uo`N?E8oUUK%{t*ZW(|^mkUEyiU