diff --git a/bw_timex/timeline_builder.py b/bw_timex/timeline_builder.py index f1b5680..9e42600 100644 --- a/bw_timex/timeline_builder.py +++ b/bw_timex/timeline_builder.py @@ -28,6 +28,7 @@ class TimelineBuilder: def __init__( self, slca: LCA, + starting_datetime: datetime, edge_filter_function: Callable, database_date_dict: dict, database_date_dict_static_only: dict, @@ -45,6 +46,8 @@ def __init__( ---------- slca: LCA A static LCA object. + starting_datetime: datetime | str, optional + Point in time when the demand occurs. edge_filter_function: Callable A callable that filters edges. If not provided, a function that always returns False is used. database_date_dict: dict @@ -65,6 +68,7 @@ def __init__( Keyword arguments passed to the EdgeExtractor which inherits from TemporalisLCA. """ self.slca = slca + self.starting_datetime = starting_datetime self.edge_filter_function = edge_filter_function self.database_date_dict = database_date_dict self.database_date_dict_static_only = database_date_dict_static_only @@ -90,6 +94,7 @@ def __init__( self.edge_extractor = EdgeExtractor( slca, + starting_datetime=self.starting_datetime, *args, edge_filter_function=edge_filter_function, cutoff=self.cutoff, diff --git a/bw_timex/timex_lca.py b/bw_timex/timex_lca.py index 936323e..c799deb 100644 --- a/bw_timex/timex_lca.py +++ b/bw_timex/timex_lca.py @@ -31,7 +31,11 @@ from .helper_classes import SetList, TimeMappingDict from .matrix_modifier import MatrixModifier from .timeline_builder import TimelineBuilder -from .utils import extract_date_as_integer, resolve_temporalized_node_name +from .utils import ( + extract_date_as_integer, + resolve_temporalized_node_name, + round_datetime_to_nearest_year, +) class TimexLCA: @@ -144,21 +148,13 @@ def __init__( self.base_lca.lci() self.base_lca.lcia() - # Create a time mapping dict that maps each activity to a activity_time_mapping_id in the - # format (('database', 'code'), datetime_as_integer): time_mapping_id) - self.activity_time_mapping_dict = TimeMappingDict( - start_id=bd.backends.ActivityDataset.select(fn.MAX(AD.id)).scalar() + 1 - ) # making sure we get unique ids by counting up from the highest current activity id - - # Create a similar dict for the biosphere flows. Populated by the dynamic_biosphere_builder - self.biosphere_time_mapping_dict = TimeMappingDict(start_id=0) - ######################################## # Main functions to be called by users # ######################################## def build_timeline( self, + starting_datetime: datetime | str = "now", temporal_grouping: str = "year", interpolation_type: str = "linear", edge_filter_function: Callable = None, @@ -174,6 +170,9 @@ def build_timeline( Parameters ---------- + starting_datetime: datetime | str, optional + Point in time when the demand occurs. This is the initial starting point of the + timeline. Something like `"now"` or `"2023-01-01"`. Default is `"now"`. temporal_grouping : str, optional Time resolution for grouping exchanges over time in the timeline. Default is 'year', other options are 'month', 'day', 'hour'. @@ -219,11 +218,18 @@ def build_timeline( else: self.edge_filter_function = edge_filter_function + self.starting_datetime = starting_datetime self.temporal_grouping = temporal_grouping self.interpolation_type = interpolation_type self.cutoff = cutoff self.max_calc = max_calc + # Create a time mapping dict that maps each activity to a activity_time_mapping_id in the + # format (('database', 'code'), datetime_as_integer): time_mapping_id) + self.activity_time_mapping_dict = TimeMappingDict( + start_id=bd.backends.ActivityDataset.select(fn.MAX(AD.id)).scalar() + 1 + ) # making sure we get unique ids by counting up from the highest current activity id + # pre-populate the activity time mapping dict with the static activities. # Doing this here because we need the temporal grouping for consistent times resolution. self.add_static_activities_to_time_mapping_dict() @@ -233,6 +239,7 @@ def build_timeline( # with the TimelineBuilder.build_timeline() method. self.timeline_builder = TimelineBuilder( self.base_lca, + self.starting_datetime, self.edge_filter_function, self.database_date_dict, self.database_date_dict_static_only, @@ -385,7 +392,7 @@ def dynamic_lcia( of the chosen static climate change impact category. If there is no characterization function for a biosphere flow, it will be ignored. - Two dynamic climate change metrics are provided: "GWP" and "radiative_forcing". + Two dynamic climate change metrics are supported: "GWP" and "radiative_forcing". The time horizon for the impact assessment can be set with the `time_horizon` parameter, defaulting to 100 years. The `fixed_time_horizon` parameter determines whether the emission time horizon for all emissions is calculated from the functional unit @@ -438,6 +445,18 @@ def dynamic_lcia( # Set a default for inventory_in_time_horizon using the full dynamic_inventory_df inventory_in_time_horizon = self.dynamic_inventory_df + # Round dates to nearest year and sum up emissions for each year + inventory_in_time_horizon.date = inventory_in_time_horizon.date.apply( + round_datetime_to_nearest_year + ) + inventory_in_time_horizon = ( + inventory_in_time_horizon.groupby( + inventory_in_time_horizon.columns.tolist() + ) + .sum() + .reset_index() + ) + # Calculate the latest considered impact date t0_date = pd.Timestamp(self.timeline_builder.edge_extractor.t0.date[0]) latest_considered_impact = t0_date + pd.DateOffset(years=time_horizon) @@ -570,6 +589,8 @@ def calculate_dynamic_inventory( [len(bd.Database(db)) for db in self.database_date_dict.keys()] ) + self.biosphere_time_mapping_dict = TimeMappingDict(start_id=0) + self.dynamic_biosphere_builder = DynamicBiosphereBuilder( self.lca, self.activity_time_mapping_dict, diff --git a/bw_timex/utils.py b/bw_timex/utils.py index bab084d..59c3277 100644 --- a/bw_timex/utils.py +++ b/bw_timex/utils.py @@ -114,6 +114,27 @@ def convert_date_string_to_datetime(temporal_grouping, datestring) -> datetime: return datetime.strptime(datestring, time_res_dict[temporal_grouping]) +def round_datetime_to_nearest_year(date: datetime) -> datetime: + """ + Round a datetime object to the nearest year. + + Returns + ------- + datetime + datetime object rounded to nearest year. + """ + year = date.year + start_of_year = pd.Timestamp(f"{year}-01-01") + start_of_next_year = pd.Timestamp(f"{year+1}-01-01") + + mid_year = start_of_year + (start_of_next_year - start_of_year) / 2 + + if date < mid_year: + return start_of_year + else: + return start_of_next_year + + def add_flows_to_characterization_function_dict( flows: Union[str, List[str]], func: Callable, diff --git a/notebooks/data/method.svg b/notebooks/data/method.svg index 7291b05..ff132c3 100644 --- a/notebooks/data/method.svg +++ b/notebooks/data/method.svg @@ -1 +1 @@ -temporalinformationtemporalized system modelenvironmental impactsprocess timelinetime-explicitinventorystatic system modeltime-explicit databasesbuild_timeline()lci()dynamic_lcia()Step 1Step 2Step 3Step 4 +temporalinformationtemporalized system modelenvironmental impactsprocess timelinetime-explicitinventorystatic system modelprospective databasesbuild_timeline()lci()dynamic_lcia()Step 1Step 2Step 3Step 4 diff --git a/notebooks/getting_started_minimal.ipynb b/notebooks/getting_started_minimal.ipynb index 5ff846e..0895b75 100644 --- a/notebooks/getting_started_minimal.ipynb +++ b/notebooks/getting_started_minimal.ipynb @@ -8,13 +8,14 @@ "\n", "Here's a rundown of the steps involved in a `TimexLCA`:\n", "\n", - "
\n", + "
\n", " \n", "
\n", "\n", - "Let's walk through steps 1-4 considering a very simple dummy system. This is our \"static system model\":\n", + "Let's walk through steps 1-4 considering a very simple dummy system:\n", "\n", "```mermaid\n", + "\n", "flowchart LR\n", "subgraph background[background]\n", " B(Process B):::bg\n", @@ -45,67 +46,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Setting this up in brightway:" + "The production system above is our \"static system model\", which we now set up with brightway:" ] }, { "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1/1 [00:00<00:00, 12985.46it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vacuuming database \n", - "Not able to determine geocollections for all datasets. This database is not ready for regionalization.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1/1 [00:00<00:00, 19972.88it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vacuuming database \n", - "Not able to determine geocollections for all datasets. This database is not ready for regionalization.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1/1 [00:00<00:00, 8004.40it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vacuuming database \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] + "execution_count": 1, + "metadata": { + "jupyter": { + "source_hidden": true } - ], + }, + "outputs": [], "source": [ + "%%capture \n", + "\n", "import bw2data as bd\n", "\n", "bd.projects.set_current(\"getting_started_with_timex\")\n", @@ -179,20 +134,87 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Step 1 - Adding temporal information" + "We also need a prospective database. Let's say our original background system represents the year 2020, where process B emitts 11 kg CO2. By 2030, process B only emitts 7 kg CO2. We write this new process to a separate database:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "%%capture\n", + "\n", + "bd.Database(\"background_2030\").write(\n", + " {\n", + " (\"background_2030\", \"B\"): {\n", + " \"name\": \"B\",\n", + " \"location\": \"somewhere\",\n", + " \"reference product\": \"B\",\n", + " \"exchanges\": [\n", + " {\n", + " \"amount\": 1,\n", + " \"type\": \"production\",\n", + " \"input\": (\"background_2030\", \"B\"),\n", + " },\n", + " {\n", + " \"amount\": 7,\n", + " \"type\": \"biosphere\",\n", + " \"input\": (\"biosphere\", \"CO2\"),\n", + " },\n", + " ],\n", + " },\n", + " }\n", + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Temporal distributions - *\"distributing exchanges over time\"*\n", - "\n", - "Temporal information is carried by [`TemporalDistribution`](https://docs.brightway.dev/projects/bw-temporalis/en/stable/content/api/bw_temporalis/temporal_distribution/index.html#bw_temporalis.temporal_distribution.TemporalDistribution) objects, originally introduced by [`bw_temporalis`](https://github.com/brightway-lca/bw_temporalis). \n", + "> **Note:** It does not matter where your prospective data comes from - you can also use [premise](https://premise.readthedocs.io/en/latest/introduction.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To save the information which background database represents which year, we define a `database_date_dict`:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime\n", "\n", - "> A `TemporalDistribution` tells you what share of an exchange happens at what point in time. \n", + "database_date_dict = {\n", + " \"background_2020\": datetime.strptime(\"2020\", \"%Y\"),\n", + " \"background_2030\": datetime.strptime(\"2030\", \"%Y\"),\n", + " \"foreground\": \"dynamic\", # no specific point in time, but should be \"distributed over time\"\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1 - Adding temporal information" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Temporal information on the exchange level is carried by [`TemporalDistribution`](https://docs.brightway.dev/projects/bw-temporalis/en/stable/content/api/bw_temporalis/temporal_distribution/index.html#bw_temporalis.temporal_distribution.TemporalDistribution) objects, originally introduced by [`bw_temporalis`](https://github.com/brightway-lca/bw_temporalis). \n", "\n", - "\n" + "A `TemporalDistribution` tells you what share of an exchange (*amount array*) happens at what point in time (*dates array*). \n" ] }, { @@ -215,9 +237,9 @@ " CO2(CO2):::b\n", "end\n", "\n", - "B_2020-->|\"amounts: [30%,50%,20%] * 3 kg\\n dates:[-2,0,+4]\" years|A\n", - "A-.->|\"amounts: [60%, 40%] * 5 kg\\n dates: [0,+1]\" years|CO2\n", - "B_2020-.->|\"amounts: [100%] * 11 kg\\n dates:[0]\" years|CO2\n", + "B_2020-->|\"dates:[-2, 0, +4] years\\n amounts: [0.3, 0.5, 0.2] * 3 kg\" |A\n", + "A-.->|\"dates: [0, +1] years \\n amounts: [0.6, 0.4] * 5 kg\"|CO2\n", + "B_2020-.->|11 kg|CO2\n", "\n", "classDef bg color:#222832, fill:#3fb1c5, stroke:none;\n", "classDef fg color:#222832, fill:#3fb1c5, stroke:none;\n", @@ -229,9 +251,16 @@ "```" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pouring this into a `TemporalDistribution`:" + ] + }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -248,17 +277,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Adding a `TemporalDistribution` to an exchange is as easy as:\n", - "```python\n", - "exchange_object[\"temporal_distribution\"] = TemporalDistribution \n", - "```\n", - "\n", - "However, we don't have the `exchange_object` at hand here - but we can use the utility function `add_temporal_distribution_to_exchange()`:" + "Now we add this `TemporalDistribution` to the corresponding exchange:" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -282,8 +306,12 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": {}, + "execution_count": 6, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [], "source": [ "td_a_to_co2 = TemporalDistribution(\n", @@ -299,132 +327,6 @@ ")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Time-specific process data\n", - "\n", - "We need to include the information how our processes change over time. \n", - "\n", - "Let's say process B reduces its emissions from 11kg CO2 in 2020 to 7kg CO2 in 2030:\n", - "\n", - "```mermaid\n", - "flowchart LR\n", - "subgraph background[\" \"]\n", - " B_2020(Process B \\n 2020):::bg\n", - " B_2030(Process B \\n 2030):::bg\n", - "end\n", - "\n", - "subgraph foreground[\" \"]\n", - " A(Process A):::fg\n", - "end\n", - "\n", - "subgraph biosphere[\" \"]\n", - " CO2(CO2):::b\n", - "end\n", - "\n", - "B_2020-->|\"amounts: [30%,50%,20%] * 3 kg\\n dates:[-2,0,+4]\" years|A\n", - "A-.->|\"amounts: [60%, 40%] * 5 kg\\n dates: [0,+1]\" years|CO2\n", - "B_2020-.->|\"amounts: [100%] * 11 kg\\n dates:[0]\" years|CO2\n", - "B_2030-.->|\"amounts: [100%] * 7 kg\\n dates:[0]\" years|CO2\n", - "\n", - "classDef bg color:#222832, fill:#3fb1c5, stroke:none;\n", - "classDef fg color:#222832, fill:#3fb1c5, stroke:none;\n", - "classDef b color:#222832, fill:#9c5ffd, stroke:none;\n", - "style foreground fill:none, stroke:none;\n", - "style background fill:none, stroke:none;\n", - "style biosphere fill:none, stroke:none;\n", - "\n", - "```\n", - "\n", - "> **Note:** It does not matter where your prospective data is coming from - you can also use [premise](https://premise.readthedocs.io/en/latest/introduction.html).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "jupyter": { - "source_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Not able to determine geocollections for all datasets. This database is not ready for regionalization.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1/1 [00:00<00:00, 14665.40it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vacuuming database \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "bd.Database(\"background_2030\").write(\n", - " {\n", - " (\"background_2030\", \"B\"): {\n", - " \"name\": \"B\",\n", - " \"location\": \"somewhere\",\n", - " \"reference product\": \"B\",\n", - " \"exchanges\": [\n", - " {\n", - " \"amount\": 1,\n", - " \"type\": \"production\",\n", - " \"input\": (\"background_2030\", \"B\"),\n", - " },\n", - " {\n", - " \"amount\": 7,\n", - " \"type\": \"biosphere\",\n", - " \"input\": (\"biosphere\", \"CO2\"),\n", - " },\n", - " ],\n", - " },\n", - " }\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To hand this information to `bw_timex`, we define a `database_date_dict`:" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "from datetime import datetime\n", - "\n", - "database_date_dict = {\n", - " \"background_2020\": datetime.strptime(\"2020\", \"%Y\"),\n", - " \"background_2030\": datetime.strptime(\"2030\", \"%Y\"),\n", - " \"foreground\": \"dynamic\", # no specific point in time, but should be \"distributed over time\"\n", - "}" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -433,12 +335,12 @@ "\n", "Now we can instantiate a `TimexLCA` object - similarly to a normal Brightway LCA object, but with the additional argument of our `database_date_dict`.\n", "\n", - "Let's demand process A to run once:" + "Let's demand process A to run once. If not specified otherwise, `bw_timex` assumes the demand occurs at `datetime.datetime.now()`, translating to the year 2024 at the time of writing this." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -451,13 +353,6 @@ ")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If not specified otherwise, `bw_timex` assumes the demand occurs at `datetime.datetime.now()`, translating to the year 2024 at the time of writing this." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -467,7 +362,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -482,7 +377,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timex_lca.py:212: UserWarning: No edge filter function provided. Skipping all edges within background databases.\n", + "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timex_lca.py:216: UserWarning: No edge filter function provided. Skipping all edges within background databases.\n", " warnings.warn(\n" ] }, @@ -570,7 +465,7 @@ "3 {'background_2020': 0.20010949904188335, 'back... " ] }, - "execution_count": 32, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -583,14 +478,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The timeline tells us which exchange happens at what time. Also, we see the \"interpolation_weights\", already giving a hint on how the processes will be re-linked in the next step. \n", + "The timeline tells us which exchange happens at what time. \n", "\n", - "For the first row of the timeline, the interpolation weights are:" + "Also, we see the \"interpolation_weights\", already giving a hint on how the processes will be re-linked in the next step. For the first row of the timeline, the interpolation weights are:" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -599,7 +494,7 @@ "{'background_2020': 0.7998905009581166, 'background_2030': 0.20010949904188338}" ] }, - "execution_count": 33, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -619,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -639,7 +534,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Under the hood, we re-build the technosphere and biosphere matrices, adding new rows and columns to carry the extra temporal information. More on that in the [Theory Section](https://docs.brightway.dev/projects/bw-timex/en/latest/content/theory.html#modifying-the-matrices) of our docs." + "Under the hood, before solving the inventory problem, we're re-build the technosphere and biosphere matrices here. More specifically, we add new rows and columns to carry the extra temporal information. Details are explained in the [Theory Section](https://docs.brightway.dev/projects/bw-timex/en/latest/content/theory.html#modifying-the-matrices) of our docs." ] }, { @@ -648,33 +543,12 @@ "source": [ "## Step 4 - Impact assessment\n", "\n", - "To characterize the calculated inventory, we have two options: Static and dynamic life cycle impact assessment (LCIA).\n", - "\n", - "### Static LCIA\n", - "If we don't care about the timing of the emissions, we can do static LCIA, using static characterization factors. \n", - "\n", - "To characterize the inventory with the impact assessment method that we initially chose when creating our `TimexLCA`, we can simply call:" + "The impact assessment can be very simple now. To characterize the inventory with the impact assessment method that we initially chose when creating our `TimexLCA`, we can simply call:" ] }, { "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "tlca.static_lcia()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "and investigate the resulting score like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 36, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -683,12 +557,13 @@ "32.96019709827539" ] }, - "execution_count": 36, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "tlca.static_lcia()\n", "tlca.static_score" ] }, @@ -696,164 +571,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Dynamic LCIA\n", - "\n", - "The inventory calculated by a `TimexLCA` retains temporal information. We don't only know what substance is emitted by what process, but also at what time. \n", - "\n", - "Therefore, we can apply advanced dynamic characterization functions, rather than just applying characterization factors. You can either:\n", - "- define your own, custom dynamic characterization functions or \n", - "- use existing ones, e.g., from the package [`dynamic_characterization`](https://dynamic-characterization.readthedocs.io/en/latest/). \n", - "\n", - "To keep it simple here, we'll do the latter. \n", - "\n", - "Let's import a dynamic characterization function and define which biosphere flow it applies to:" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [], - "source": [ - "from dynamic_characterization.timex import characterize_co2\n", - "emission_id = bd.get_activity((\"biosphere\", \"CO2\")).id\n", - "\n", - "characterization_function_dict = {\n", - " emission_id: characterize_co2,\n", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> **Note:** If you're working with biosphere3 flows, you don't have to specify this - the `dynamic_characterization` package takes care of the mapping automatically." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For a start, let's use the \"standard\" metric Global Warming Potential over a time horizon of 100 years:" + "But there's more: Because a `TimexLCA` retains temporal information in the inventory, it also allows for dynamic characterization. To help with that, we created another package, simply called [`dynamic_characterization`](https://dynamic-characterization.readthedocs.io/en/latest/). This is not today's topic, but here's a quick demo:" ] }, { "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/dynamic_characterization/dynamic_characterization.py:262: UserWarning: Using bw_timex's default CO2 characterization function for GWP reference.\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dateamountflowactivity
02022-01-01 00:00:009.179606395399
12024-01-01 00:00:0014.100328395400
22024-01-01 00:00:003.000000395401
32024-12-31 05:49:122.000000395401
42028-01-01 00:00:004.680263395402
\n", - "
" - ], - "text/plain": [ - " date amount flow activity\n", - "0 2022-01-01 00:00:00 9.179606 395 399\n", - "1 2024-01-01 00:00:00 14.100328 395 400\n", - "2 2024-01-01 00:00:00 3.000000 395 401\n", - "3 2024-12-31 05:49:12 2.000000 395 401\n", - "4 2028-01-01 00:00:00 4.680263 395 402" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" + "execution_count": 13, + "metadata": { + "jupyter": { + "source_hidden": true } - ], - "source": [ - "tlca.dynamic_lcia(\n", - " metric=\"GWP\",\n", - " time_horizon=100,\n", - " characterization_function_dict=characterization_function_dict,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can plot the characterized inventory with:" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIQAAAIcCAYAAACHN3UiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5iU1fnG8e/0sjOzvTd6772IggXBghqNXbFEExsmliQaozGJMYkajckvMVFssfdeQUFBpCMISO/ssr3PTv/9sTAw7gyCsrS9P9fFlex73pn3WXzZnbnnnOcYIpFIBBERERERERERaTeMh7oAERERERERERE5uBQIiYiIiIiIiIi0MwqERERERERERETaGQVCIiIiIiIiIiLtjAIhEREREREREZF2RoGQiIiIiIiIiEg7o0BIRERERERERKSdUSAkIiIiIiIiItLOKBASEREREREREWlnFAiJiIiIiIiIiLQz7ToQ+uyzzzj99NPJy8vDYDDwxhtvHFbX++lPf4rBYOChhx5q07pEREREREREpH1p14FQY2Mj/fv355///Odhd7033niDuXPnkpeXdxAqExEREREREZH2xHyoCziUJk6cyMSJExOO+/1+7rjjDp599llqamro06cPf/nLXxg7dmybXG+Xbdu2cf311/Phhx9y6qmnfq9riYiIiIiIiIgk0q4Doe9y+eWXs3HjRl544QXy8vJ4/fXXmTBhAsuWLaNr165tcs1wOMwll1zCrbfeSu/evdvkGiIiIiIiIiLSvrXrJWN7s27dOp5//nlefvllxowZQ+fOnbnllls45phjeOKJJ9rsun/5y18wm81MmTKlza4hIiIiIiIiIu2bZgglsGjRIiKRCN26dYs57vP5SE9PB2Djxo107Nhxr89z3XXX7XOPooULF/L3v/+dRYsWYTAYvl/hIiIiIiIiIiLfQYFQAuFwGJPJxMKFCzGZTDFjLpcLgPz8fFauXLnX50lNTd3na37++eeUlZVRVFQUPRYKhbj55pt56KGH2Lhx475/AyIiIiIiIiIiCSgQSmDgwIGEQiHKysoYM2ZM3HMsFgs9evQ4YNe85JJLOPHEE2OOnXzyyVxyySVcfvnlB+w6IiIiIiIiItK+tetAqKGhgbVr10a/3rBhA0uWLCEtLY1u3bpx0UUXcemll/LAAw8wcOBAKioq+OSTT+jbty+nnHLKAb1eUVER6enp0eVou1gsFnJycujevfv3/0ZFRERERERERPbQrgOhBQsWMG7cuOjXN910EwCTJ0/mySef5IknnuCPf/wjN998M9u2bSM9PZ2RI0d+rzBoX64nIiIiIiIiInIwGCKRSORQFyEiIiIiIiIiIgePtp0XEREREREREWlnFAiJiIiIiIiIiLQz7a6HUDgcZvv27bjdbgwGw6EuR0RERERERETkgIhEItTX15OXl4fRuPc5QO0uENq+fTuFhYWHugwRERERERERkTaxZcsWCgoK9npOuwuE3G430PKX4/F4DshzBgIBPvroI8aPH4/FYjkgzylyuNN9L+2R7ntpb3TPS3uk+17aI933R4+6ujoKCwuj2cfetLtAaNcyMY/Hc0ADIafTicfj0T8eaTd030t7pPte2hvd89Ie6b6X9kj3/dFnX1rkqKm0iIiIiIiIiEg7o0BIRERERERERKSdUSAkIiIiIiIiItLOtLseQiIiIiIiIiJydIpEIgSDQUKh0KEupc1YLBZMJtMPfh4FQiIiIiIiIiJyxPP7/ZSUlNDU1HSoS2lTBoOBgoICXC7XD3oeBUIiIiIiIiIickQLh8Ns2LABk8lEXl4eVqt1n3baOtJEIhHKy8vZunUrXbt2/UEzhRQIiYiIiIiIiMgRze/3Ew6HKSwsxOl0Hupy2lRmZiYbN24kEAj8oEBITaVFRERERERE5KhgNB79MceBmvl09P9NiYiIiIiIiIhIDAVCIiIiIiIiIiLtjAIhEREREREREZF2RoGQiIiIiIiIiMgh9MUXX2AymZgwYcJBu6YCIRERERERERERgHAINnwOy15p+d9w6KBc9vHHH+eGG25g1qxZbN68+aBcU9vOt2N13gCVjX521DbjdpjJcNnI9tgPdVkiIiIiIiIiB9+Kt+CDX0Hd9t3HPHkw4S/Qa1KbXbaxsZGXXnqJ+fPnU1paypNPPsmdd97ZZtfbRTOE2qmy+mbufPNrjn9gBuc/+iWnPjyLHz8yhzU76g91aSIiIiIiIiIH14q34KVLY8MggLqSluMr3mqzS7/44ot0796d7t27c/HFF/PEE08QiUTa7Hq7KBBqh/zBEFM/38AbS7az5z22uaqJCx+by/Ya76ErTkRERERERORgCodaZgYRL4TZeeyDX7fZ8rGpU6dy8cUXAzBhwgQaGhqYPn16m1xrTwqE2qGyeh9Pz9kUd6y83seGisaDXJGIiIiIiIjIIbLpi9Yzg2JEoG5by3kH2KpVq5g3bx7nn38+AGazmfPOO4/HH3/8gF/r29RDqB1qDoTxBhInmxsrGhndJeMgViQiIiIiIiJyiDTsOLDn7YepU6cSDAbJz8+PHotEIlgsFqqrq0lNTT3g19xFM4TaIafVhMeeOAvsmu06iNWIiIiIiIiIHEKu7AN73j4KBoM8/fTTPPDAAyxZsiT656uvvqK4uJhnn332gF7v2xQItUNZbhs/Pa5T3LGiNCdF6UkHuSIRERERERGRQ6R4VMtuYhgSnGAAT37LeQfQO++8Q3V1NVdeeSV9+vSJ+XPOOecwderUA3q9b1Mg1A6ZTUbOG1rEz47rhNW0+xYYWJjC/64cRo62nhcREREREZH2wmhq2VoeaB0K7fx6wp9bzjuApk6dyoknnkhycnKrsbPPPpslS5awaNGiA3rNPamHUDuV4bJx4wlduWh4MTVNARxWI2lJNtKSrIe6NBEREREREZGDq9ckOPfplt3G9mww7clrCYN6TTrgl3z77bcTjg0aNKjNt55XINSOOaxmCtPMFKYd6kpEREREREREDrFek6DHqS27iTXsaOkZVDzqgM8MOlwoEBIRERERERERgZbwp+OYQ13FQaEeQiIiIiIiIiIi7YwCIRERERERERGRdkaBkIiIiIiIiIhIO6NASERERERERESknVEgJCIiIiIiIiLSzigQEhERERERERFpZxQIiYiIiIiIiIi0MwqERERERERERETaGQVCIiIiIiIiIiKHyGWXXYbBYIj+SU9PZ8KECSxdurRNr6tASEREREREREQECIUjzFlXyZtLtjFnXSWhcOSgXHfChAmUlJRQUlLC9OnTMZvNnHbaaW16TXObPruIiIiIiIiIyBHgg69LuPvtFZTUNkeP5Sbbuev0Xkzok9um17bZbOTk5ACQk5PDr371K4499ljKy8vJzMxsk2tqhpCIiIiIiIiItGsffF3CNc8sigmDAEprm7nmmUV88HXJQauloaGBZ599li5dupCent5m19EMIRERERERERFpt0LhCHe/vYJ4i8MigAG4++0VnNQrB5PR0CY1vPPOO7hcLgAaGxvJzc3lnXfewWhsu3k8miEkIiIiIiIiIu3WvA1VrWYG7SkClNQ2M29DVZvVMG7cOJYsWcKSJUuYO3cu48ePZ+LEiWzatKnNrqkZQiIiIiIiIiLSbpXVJw6Dvs9530dSUhJdunSJfj148GCSk5N59NFH+eMf/9gm19QMIRERERERERFpt7Lc9gN63oFgMBgwGo14vd42u4ZmCMleRSIRdtQ1U9ngJxAOk55kI9Ntw24xHerSRERERERERH6wYR3TyE22U1rbHLePkAHISbYzrGNam9Xg8/koLS0FoLq6mn/+8580NDRw+umnt9k1FQhJQsFQmGXbarnmmUWU1rVMjbOZjdx8Ujd+PKSQ1CTrIa5QRERERERE5IcxGQ3cdXovrnlmEQaICYV2tZC+6/RebdZQGuCDDz4gN7dla3u3202PHj14+eWXGTt2bJtdU0vGJKHtNV4uePTLaBgE4AuG+dP73zBvY9s10xIRERERERE5mCb0yeXfFw8iJzl2WVhOsp1/XzyICX1y2+zaTz75JJFIJPqnrq6OefPmcfbZZ7fZNUEzhGQvpq0sozkQjjv2wEerGFycSobLdpCrEhERERERETnwJvTJ5aReOczbUEVZfTNZ7pZlYm05M+hQUiAkCX21tSbh2MaKJgLB+GGRiIiIiIiIyJHIZDQwsnP6oS7joNCSMUloQGFKwrGOGUlYzbp9RERERERERI5EekcvCZ3QMwtHgt3Ebjm5G+laLiYiIiIiIiJyRFIgJAnlJTt4/uoR5O3RVMtuMfLb03oxtEPbbbcnIiIiIiIi8n1EIvE2jj+6HKjvUT2EJCGzyciAwhRev3Y0lY0+/KEIGS4rmS4btgQzh0REREREREQONovFAkBTUxMOh+MQV9O2/H4/ACbTD3tfrkBIvlN2sp3sb229JyIiIiIiInK4MJlMpKSkUFZWBoDT6cRgOPp2BwuHw5SXl+N0OjGbf1iko0BIRERERERERI54OTk5ANFQ6GhlNBopKir6wYGXAiEREREREREROeIZDAZyc3PJysoiEAgc6nLajNVqxWj84S2hFQiJiIiIiIiIyFHDZDL94P467YF2GRMRERERERERaWcUCImIiIiIiIiItDMKhERERERERERE2hkFQiIiIiIiIiIi7YwCIRERERERERGRdkaBkIiIiIiIiIhIO6NASERERERERESknVEgJCIiIiIiIiLSzigQEhERERERERFpZ8yHugA5OviDIcrqfdQ3B7FbTGS4rLjtlkNdloiIiIiIiIjEoUBIfrDKBh/PzN3MIzPW4Q2EMBjg+O5Z/P7MPuSnOA51eSIiIiIiIiLyLVoyJj9IIBTmxflbePDj1XgDIQAiEZj+TRlXPb2A8vrmQ1yhiIiIiIiIiHybAiH5QcrqfPx7xrq4Yyu217G9RoGQiIiIiIiIyOFGgZD8II3+IPW+YMLxdeUNB7EaEREREREREdkXCoTkB7FbTFhMhoTjecnqISQiIiIiIiJyuFEgJD9IhsvKmQPy445lumwUpTsPckUiIiIiIiIi8l0UCMkP4rSauXl8d47pkh5zPMdj55mfDCNPu4yJiIiIiIiIHHa07bz8YDnJdh6+YBDl9T42VzWSnmQjL8VOjpaLiYiIiIiIiByWFAjJAZGWZCUtyUr3HPehLkVEREREREREvoOWjImIiIiIiIiItDMKhERERERERERE2hkFQiIiIiIiIiIi7cwhDYTuvfdehg4ditvtJisrizPPPJNVq1Z95+NmzpzJ4MGDsdvtdOrUiUceeeQgVCsiIiIiIiIicnQ4pIHQzJkzue666/jyyy/5+OOPCQaDjB8/nsbGxoSP2bBhA6eccgpjxoxh8eLF3H777UyZMoVXX331IFYuIiIiIiIiInLkOqS7jH3wwQcxXz/xxBNkZWWxcOFCjj322LiPeeSRRygqKuKhhx4CoGfPnixYsID777+fs88+u61LFhERERERERE54h1W287X1tYCkJaWlvCcOXPmMH78+JhjJ598MlOnTiUQCGCxWGLGfD4fPp8v+nVdXR0AgUCAQCBwQOre9TwH6vlEjgS676U90n0v7Y3ueWmPdN9Le6T7/uixP/8NDZFIJNKGteyzSCTCGWecQXV1NZ9//nnC87p168Zll13G7bffHj32xRdfMHr0aLZv305ubm7M+b/73e+4++67Wz3Pc889h9PpPHDfgIiIiIiIiIjIIdTU1MSFF15IbW0tHo9nr+ceNjOErr/+epYuXcqsWbO+81yDwRDz9a5M69vHAW677TZuuumm6Nd1dXUUFhYyfvz47/zL2VeBQICPP/6Yk046qdUMJYnlD0Wo8QaJRCIkWU24bKZDXZJ8T7rvpT3SfS/tje55aY9030t7pPv+6LFrVdS+OCwCoRtuuIG33nqLzz77jIKCgr2em5OTQ2lpacyxsrIyzGYz6enprc632WzYbLZWxy0WywG/0dviOY8mW6ub+L9P1vLa4m34gmFGd0nnN6f0oktWElazgqEjle57aY9030t7o3te2iPd99Ie6b4/8u3Pf79DustYJBLh+uuv57XXXuOTTz6hY8eO3/mYkSNH8vHHH8cc++ijjxgyZIhu3MPY9hovFz46l+fnb8EXDAMwe20lZ/1rNhsrmw5xdSIiIiIiIiLtyyENhK677jqeeeYZnnvuOdxuN6WlpZSWluL1eqPn3HbbbVx66aXRr3/2s5+xadMmbrrpJlauXMnjjz/O1KlTueWWWw7FtyD7aOGmajZXtQ5+fMEwD368mkZf8BBUJSIiIiIiItI+HdJA6N///je1tbWMHTuW3Nzc6J8XX3wxek5JSQmbN2+Oft2xY0fee+89ZsyYwYABA/jDH/7Aww8/rC3nD2OhcJh3lpYkHJ+9toK6ZnWzFxERERERETlYDmkPoX3Z4OzJJ59sdey4445j0aJFbVCRtAWT0Uim25pw3OOwYDK2bgguIiIiIiIiIm3jkM4QkvbjgqFFCceuOKYjma7Wjb9FREREREREpG0oEJKDoiDNwS9P7t7q+DFdMji1by4Gg2YIiYiIiIiIiBwsh8W283L0S3ZYuXhEMSf1yubD5aU0+IKc1CuHojQnmW7NDhIRERERERE5mBQIyUHjcVjwOCx0zXYf6lJERERERERE2jUtGRMRERERERERaWcUCImIiIiIiIiItDMKhERERERERERE2hkFQiIiIiIiIiIi7YwCIRERERERERGRdka7jMlhqarRjy8QwmQ0kOWxH+pyRERERERERI4qCoTksFLfHGDZtlrufe8bVpTUkZts5/pxXTixVzYZLtuhLk9ERERERETkqKAlY3LYCIcjfLa6nAsfncuybbWEwhG2Vnv59WvLePDj1dR5A4e6RBEREREREZGjggIhOWzsqG/md2+tiDv27NzNVDT4DnJFIiIiIiIiIkcnBUJy2KjzBijfS+izpqzhIFYjIiIiIiIicvRSICSHDYtp77djklUtr0REREREREQOBAVCcthIdVoZWJQSd8xpNdEhw3lwCxIRERERERE5SikQksNGapKV+87pT1qSNea42Wjg3xcNJtut7edFREREREREDgStwZHDSpcsF29fP5ov11fxxboKuma5mdAnh9xkOxaz8ksRERERERGRA0GBkBx28lOdnD3YydmDCw51KSIiIiIiIiJHJU25EBERERERERFpZxQIiYiIiIiIiIi0MwqERERERERERETaGfUQkiOSLxCirN7HuvIGfMEw3bPdpLusuO2WQ12aiIiIiIiIyGFPgZAccZp8QT5ZVcbNL32FLxgGwGCAa47rzE/GdCQtyXaIKxQRERERERE5vGnJmBxxttZ4ueH5xdEwCCASgX/NWMeCjdWHsDIRERERERGRI4MCITmihMIRnpu7mUgk/vjDn6yhutF/cIsSEREREREROcIoEJIjSjAUZmNFY8Lx0trmmJlDIiIiIiIiItKaAiE5oljNRkZ2Tk843jc/mSSb6SBWJCIiIiIiInLkUSAkRxSDwcDEvrm4ba37oRsMcNNJ3bXTmIiIiIiIiMh3UCAkR5yCFAcv/WwkvfM80WP5KQ6evGwYnbOSDmFlIiIiIiIiIkcGbTsvRxyj0UDPXA9PXzGM6qYA4XCEZKeFbI/9UJcmIiIiIiIickRQICRHrHSXjXSX7VCXISIiIiIiInLEUSAkR71GX5BGfxCb2USyQ/2FRERERERERBQIyVGryR9kQ3kjD3+yhuXb6yhIdXDD8V3pnechxWk91OWJiIiIiIiIHDIKhOSoFIlEmLu+iiuemk8k0nJsa7WXL9fP5Ten9OSiEUU4rbr9RUREREREpH3SLmNyVNpR5+PXry2NhkF7+uuH31DR4D/4RYmIiIiIiIgcJhQIyVGpusnPjjpf3LFAKMKmisaDXJGIiIiIiIjI4UOBkByVjAbDXsfNJt36IiIiIiIi0n7pXbEclVKTLHRId8Ydc1hMFKY5DnJFIiIiIiIiIocPBUJyVMpy23nwvAHYzLG3uMEA953Tjyy37RBVJiIiIiIiInLoaZslOWr1zU/mw58fy8sLtrBwczWdM1xcMqqYolQnVrPpUJcnIiIiIiIicsgoEJKjltlkpENGEjed1A1vMITNbMRiih8EhcIRKht8RCIty80UGImIiIiIiMjRTIGQHPVMJiOuvTSRLqnx8vLCrby0YAuBUJjT+uVy2aiOFKbF70EkIiIiIiIicqRTICTtWkmtl0sen8fasobosamzNvLWkhJeu3aUQiERERERERE5KqmptLRrX66vjAmDdilv8PHc3M0EQuFDUJWIiIiIiIhI21IgJO2W1x/i1YXbEo6/s2w7NU3+g1iRiIiIiIiIyMGhQEjaLYMBbJbE/wRsZhMGg+EgViQiIiIiIiJycCgQknbLbjExeWSHhOOXjiwmPcl68AoSEREREREROUgUCEm71ivPwyl9c1odH1CYwvheOZohJCIiIiIiIkcl7TIm7VqGy8bvJ/XhkhHFPPPlJvyhCOcOKaRfQTLZHnvMuU3+IBX1fup9AVw2M+lJNlx2/RMSERERERGRI4/ezUq7l+G2keG2MbRDGuEIWM2tJ86V1Tfz8LQ1vLhgC4FQBKMBJvbJ5Y7TepKb7DgEVYuIiIiIiIh8fwqERHYym+KvoGzyB3nwo9U8P39L9Fg4Au8uK6G+OcDfLxhIqlO9hkREREREROTIoR5CIt+hvN7HSwu3xh37bE0FlQ3aml5ERERERESOLAqERL5DXXOQUDiScLy8vvkgViMiIiIiIiLywykQEvkOLqtpr+MpWi4mIiIiIiIiRxgFQiLfIc1lY2z3zLhj3bPdZLhsB7kiERERERERkR9GgZDId0h2WPjTWX0ZVJQSc7xLlov/XjqYTPfuQKimyc/KkjoenraGBz9ezbKtNVQ1qseQiIiIiIiIHF60y5jIPshLcfDo5CGU1/soqW0m02Uj22Mj022PnlPV6OOfn6zl8dkbo8f+Pn0NZw3M5zen9CTDrZlEIiIiIiIicnhQICSyj9KTbKQn2eiR44k7vqq0ISYM2uX1xds4uXcOE/rktHGFIiIiIiIiIvtGS8ZEDoAmf5Cps9YnHP/vZ+uoadLSMRERERERETk8KBASOQCCoQhVjYGE47XeAMFQ4q3rRURERERERA6mfVoylpaWtl9PajAYWLRoEcXFxd+rKJEjjctm5qRe2SzaXB13fGz3TDyO2H9ugVCY5kAIu8WIxbT3re1FREREREREDqR9CoRqamp46KGHSE5O/s5zI5EI1157LaFQ6AcXJ3KkMBoNnN4vl8c+X0/lt3YVc9nMXDKyA1ZzS+jjC4TYUu3l2S838fX2Wrpnu5k8qgMFaU4cFgVDIiIiIiIi0vb2uan0+eefT1ZW1j6de8MNN3zvgkSOVAVpTl65ZhT3f7iKD5aXEo5EOL5HFrdN7EFRqhOAcDjCgk3VTH58HsFwyxKy+RureW7eZh67dAjHdsvEbNJKThEREREREWlb+xQIhcPh/XrS+vr671WMyJGuY0YSfz2nH7ef2hMiETwOC267JTpeVt/Mz19cEg2DdglH4BcvfcX7N44hL8VxsMsWERERERGRdkbbzoscYEk2M0m2+P+0Khr8lNf74o7VegOU1/sUCImIiIiIiEib2+e1KR9++CEXXHAB69e3bK195ZVXtllRIkeryHdsNBb+rhNEREREREREDoB9DoRuueUWTjvtNC6//HK2bt3KihUr2rIukaNSmsvaarexXZxWE5luW/TrqkY/S7fW8Of3V3LveytZurWGqob4s4tERERERERE9sc+LxlLTk7moosuYsSIEVx11VUEg8G2rEvkqJTttvGns/py/XOLW43dPak3WTsDoYoGH39+7xteWbQ1Ov6fz9bzo4H53H5qTzJctlaPFxEREREREdlX+zxDyOVyAdC5c2euu+46Fi1a1GZFiRytzCYjY7tn8eZ1ozmhRxaFaQ7Gds/k1WtGcnKfnOjW9Eu31saEQbu8tngbS7bUHOSqRURERERE5GizzzOEHnnkEUKhECaTidNOO40FCxa0ZV0iRy2XzUz/whQevmAATf4wDosJl333P8WG5iCPfr4+4eMf+3w9wzumxexeJiIiIiIiIrI/9jkQ6tChQ8zXAwcOPNC1iLQrSTYLSXFWfgVCYeq8gYSPq/MGCYTCMcfK630EQmEsJgOZbvuBLlVERERERESOMvu97XxlZSV33nknn376KWVlZYTDsW9Mq6qqDlhxIu2Rx25mfK9slm+vizt+Uq9sPDtnB1U1+vh8TQV/+3g1myqb6JiRxM3juzG6cwapSdaDWbaIiIiIiIgcQfY7ELr44otZt24dV155JdnZ2RgMhraoS6TdMpmM/GhQAU/N2URVoz9mLNVp4ZzBBZhNRrz+IM/O3cwDH62Ojm+oaOT65xbz64k9uHxUB2wW08EuX0RERERERI4A+x0IzZo1i1mzZtG/f/+2qEdEgMI0J69dM4oHp63m3aUlAEzsk8PN47tTkOoAoKLBzz+mr437+IemrebUvrkUpjkPWs0iIiIiIiJy5NjvQKhHjx54vd62qEVE9tAhI4l7z+rLryb0ACDFYcFp2/1PtqLBh/9bvYR2aQ6EqWz0xwRCkUiEqkY/BgOkxWteJCIiIiIiIu3GfgdC//rXv/j1r3/NnXfeSZ8+fbBYYnc68ng8B6w4kfbOaTPHhEB7spqNe32s1bx7OWdJjZd3l5XwysKtGA0GLhhWyEm9sslJdhzQekVEREREROTIsN+BUEpKCrW1tRx//PExxyORCAaDgVAodMCKE5HE0pNs5CXb2V7b3GqsMM1B+s5ZQCU1Xi58bC4bKhqj4799cznPzdvM45cNJVehkIiIiIiISLuz34HQRRddhNVq5bnnnlNTaZFDKNtj45GLB3P+o1/S5N8dxLpsZv590WCyPXYikQjvfV0aEwbtsrKkni/WVnL24IKDWbaIiIiIiIgcBvY7EPr6669ZvHgx3bt3b4t6RGQfGQwGeucn8+HPj+XzNeUs21ZH/4JkRnfJID+lZdZPVaOfVxZuSfgcz8/bzPje2bh3bmMfDkcor2/pTWQ1G8n22A/K9yIiIiIiIiIH134HQkOGDGHLli0KhEQOAyajgcI0JxcOL447bjCAcS+z+IzG3WMVDT7eXVrCPz9ZS3mDj/wUBzeP78bY7lmkJVkPeO0iIiIiIiJy6Ox3IHTDDTdw4403cuutt9K3b99WTaX79et3wIqT1uqaA1Q2+Cmt9eKymcl029QYWBJKS7JxwbAi7njj67jjF48oxm230NAc4N8z1jJ11sbo2LYaLze99BW/ntiDy0d1wGYxHaSqRUREREREpK3tdyB03nnnAXDFFVdEjxkMBjWVPgjK65u5/8PVvLRwC5FIy7HcZDtTJw+lZ65b/ZwkrhN7ZvHcXDcrSupjjg8uTmV4xzQAKhv9PDF7Y9zH/33aGk7rl0tBqjPmuMFgIDk5uU1qFhERERERkba134HQhg0b2qIO+Q7BUJjn523hxQWx/WBKapu58LEveXfKMeSnOBM8WtqznGQHUy8byhdrK3lh/maMBgOXjChmSMe0aI+g0rpmwpH4j/cGQlQ3+qOBUHWjn5K6Zj5bVUYknEt+VTPZHvA4LPGfQERERERERA47+xwI3X777Zx55pkMGzbsgF38s88+47777mPhwoWUlJTw+uuvc+aZZyY8f8aMGYwbN67V8ZUrV9KjR48DVtfhqKzex2Ofr487VtMUYMX2OgVCklBusoOzBxcwvnc2QLSJ9C7O71gOtmu5WEWDjz+/t5JXFm2Ljv3lo7VMOb4LVxzTkRSneg2JiIiIiIgcCYz7emJJSQmnnXYaubm5XH311bz77rv4fL4fdPHGxkb69+/PP//5z/163KpVqygpKYn+6dq16w+q40jgD4apaw4mHF9b1nAQq5EjldtuaRUGAWS67WR7bHEf0z3bHW0qPW9DVUwYtMvDn6xlXXnrre1FRERERETk8LTPM4SeeOIJIpEIs2bN4u233+bmm29m27ZtnHTSSUyaNInTTjuNjIyM/br4xIkTmThx4n4XnZWVRUpKyn4/7khmsxjJcFmpaPDHHe+V5znIFcnRJNtj47FLh3DBo3Np8O0OHtOTrPzzwoFkuGzUNPl5ZOa6hM/xxOwN9Mn3YDO3zCaqavRT1eijwRck2WElPcmqZWUiIiIiIiKHif3qIWQwGBgzZgxjxozhr3/9KytXruTtt9/m0Ucf5ac//SnDhw9n0qRJXHDBBeTn57dVzQwcOJDm5mZ69erFHXfcEXcZ2S4+ny9mJlNdXR0AgUCAQCBwQOrZ9TwH6vniSXeYmXJCV+58c3mrsdxkO12zXG16fTn6dc9K4v0bj2Hhpmq+Ka2nX34y/QpTyHZZCAQC+AJBqhrjB5IA5fU+fP4gxkiY0no/v3jpKxZsrAbAYICJfXK487RepDv3u3WZyGHjYPy8Fzmc6J6X9kj3vbRHuu+PHvvz39AQiUQStJLdP+Xl5bz11lu89dZbjBkzhltuuWW/Hm8wGL6zh9CqVav47LPPGDx4MD6fj//973888sgjzJgxg2OPPTbuY373u99x9913tzr+3HPP4XQeWT13irv15pNNfv47exPNgTAAffOTuXdSN7avWoLX6z3EFcrRwOVyYbPZ8Hq9NDU1RY9n5xXw2kYjLy3cHvdxt57Umb7WcjyZefz24+0s21bX6pwzB+RyYTcTJVs2tlX5IiIiIiIi7VZTUxMXXnghtbW1eDx7X0m0z4HQY489xvHHH0+nTp0OSJGtCtmHQCie008/HYPBwFtvvRV3PN4MocLCQioqKr7zL2dfBQIBPv74Y0466SQslrZdEhMIRahoDFDrDWC3mEh1mkm2a8aFHByba3yc+vDn0UByl7QkK29eN4oct5U15U2c8vCsuI83GQ1Mv+lY8pNb+hWFIxEqGltmHpmMBlKdFjKStKxMDl8H8+e9yOFA97y0R7rvpT3SfX/0qKurIyMjY58CoX1OEm688Uaam5vJz89n3LhxjBs3juOPP56ioqIfXPAPMWLECJ555pmE4zabDZutdbNci8VywG/0tnjO1teAIrt2cpJDozjNxOvXjubut5fz5foqjAY4sWc2t53Sg8K0JKBlR7xEQuEIjb4QFouF+uYAn35Tzm/fXE6tt2VaY16ynYcvGEj/whQspn3ueS9y0B2Mn/cihxPd89Ie6b6X9kj3/ZFvf/777XMgVFNTw5dffsnMmTP59NNPue6662hubqa4uJjjjz8+GhLl5eV9r6K/r8WLF5Obm3tQrynSXplNRnrmenjk4sHUeQPU1dVSmJ1OsnN36JrtsSd8vMlowLVzRtvqHfVMeWFJzPj22mYuemwuH/78WDpkJLXJ9yAiIiIiIiL7EQhZLJZoQ+k77riDQCDAl19+yaeffsqMGTN4/vnn8fl8BIOJt0b/toaGBtauXRv9esOGDSxZsoS0tDSKioq47bbb2LZtG08//TQADz30EB06dKB37974/X6eeeYZXn31VV599dX9+JZF5IdKcVpJshhYPGs+3U85JWYs022jT76Hr+P0EDq9Xy4ZLht13gB/+2h13Of2BcO8umgrvzixG0ajAYDS2ma213gpq/dRlO4k220j3dV65p+IiIiIiIjsm+/dfCYUCuH3+6M9eoLBIB07dtyv51iwYEHMDmE33XQTAJMnT+bJJ5+kpKSEzZs3R8f9fj+33HIL27Ztw+Fw0Lt3b959911O+dYbUhE5dDJcNv590WBufHExizbVRI9P7JPDryf2JMlmZkddM6vLGhI+x5ItNfhCIRxGM2vL6rl06jy21zZHx4cUp/KPCwaSm+Joy29FRERERETkqLXPgVBzczNffPEFM2bM4JNPPmHBggV06tSJY489luuvv57jjjtuv5eLjR07lr31tH7yySdjvv7lL3/JL3/5y/26hogcfIVpTh67dAiVjX4amoMkOyxkuGx4HC3rWe0WIx3SnZQn6DfUI8eN1WSitK6ZyY/PjwmDABZsquYP76zgrz/uh8sWu0bWFwhhNBrUg0hERERERGQv9jkQSklJITs7m0mTJnHjjTdy3HHHkZWV1Za1icgRLC3JRlpS/GVdyQ4rPz+xGxc9NrfVmMlo4PyhRZiMBkpqvGyr8cZ9jg+Wl/LLCT2igVBpbTMLNlbx6qJtOG0mLhlRTNcsl5aWiYiIiIiIxLHPgVD//v1ZsmQJM2fOxGAwYDQaGTt2LOnp6W1Zn4gcpfrkJ3P3pN786b2V+IIt29gnOyw8fP4AClJbloLtbceycAS8gRAAJTVeJj8xj9U7di9De3dpCecMKuC2U3ooFBIREREREfmWfQ6E5s6dS2NjI59//jmffvopf/3rX7ngggvo1q0bY8eO5bjjjtOsIRHZZ8kOC+cPLeT4nlnsqG3GbDKS5baR5bZh3rncqyjNmfDxdosRl81MKBTmpQVbYsKgXV5ZtJXzhxXGBELeQJCKej++YAin1Uy2x45pZ/NqERERERGR9mK/mkonJSUxYcIEJkyYAEB9fT2ff/45H3/8MVdddRUNDQ37tcuYtK3mQIhgKEKSzYTBoDe8cvixWUwUpjopTI0f/GR5bAzrkMa8jVWtxn5yTCeyPXYqGv08P29Lwms88+UmBhWlYjQaKKn18uDHq3l98TYCoQipTgu/OLEbp/XPTbi8TURERERE5Gj0vXYZC4fDzJ8/nxkzZvDpp58ye/ZsGhsbKS4uPtD1yfdQ1ehjdWkDU2evp9YbZELvHE7unUN+qnZkkiNLepKNv58/gD++u5L3vy4hHAGHxcRPxnRk8sgOWM1GIpEI/lA44XN4A2HCRKhu8POLF5fw5frd4VJ1U4A731pOKBLh0hHFmL7ViDoYDmPEgFEziERERERE5Cizz4HQ/Pnz+fTTT5kxYwazZs2ioaGBgoICxo4dy8MPP8y4cePo0KFDG5Yq+6Kmyc/fp63hqTmbosfmbajikZnreOWaUXtdgiNyOMpNcfCXc/ryywnd8fpDuGxmMt02bBYTAClOKxN75/DsvM1xH3/ukALMRiOldc0xYdCeHpy2mpN755C3cxv70lovizfX8MaSbXjsFi4cXkSH9CRSk6xt802KiIiIiIgcZPscCA0fPpzc3FzGjh3L3/72N8aOHUuXLl3asjb5HrbVeGPCoF3K6n38Y/oafn9mbxyW7zUxTOSQcdksrbaX38VuMXH1cZ149+sSapoCMWP98j30yU8GYG1Z6x5Du9R5g9Q3tyx3jdeg+uWFW7lidAduOL6rQiERERERETkq7HMysHLlSrp3796WtcgB8O7SkoRjby7Zzi9O6oYjRYGQHF2K0py8dd1ops7awAfLS7FbWradP61fLtkeOwBZ7sQ9goyGlibVgVCYZ+Zujtug+vHZGzlzYH5MIFRe30xFg58mf5D0JBvpLitue/zgSkRERERE5HCyz8mAwqAjQ2AvvVRCkchBrETk4DEYDBSlJ/GbU3tx7bguGA0t/Yf27P1TnJ5EWpKVqkZ/q8dP6J1DustKZYOf5xMsPQN4af4W+hWkALCuvIGrn17IuvKGnTXA2YMK+NWE7mS67Qf2GxQRERERETnAjN99CqSlpVFRUbHPT1pUVMSmTa2XLUnbO6VvbsKxk3pmk+zQ7CA5elnNRrI9djLd9laNoHM8dp66YhgpztgZPL3zPNxxWi9cNgsRIjQHQgmfv8HXsqystNbLxY/NjYZBAJEIvLJwK1NnbcAfjH2OqkYfm6ua2FbdhDegnRhFREREROTQ26d0oKamhvfff5/k5OR9etLKykpCocRvqqTtFKY5mdA7hw+Wl8Ycd9vM3Hpyd5IS9GEROdoZjQZ653p4d8oY1pU1sL3WS49sN/mpjuiMnmS7hZN6ZfPmku1xn+OsgfkAbKxooqS2Oe45T32xiUtGFJOf6sQbCLFiex13vfU1X2+rw2oycsaAPH5+Yjft+iciIiIiIofUPk8XmTx5clvWIQdIhsvGH87szcS+OTz2+QbqmgMc3yOLy0Z1oDBVO4xJ+2Y0GshPcZCfEj+McdrM3HhCV6avLIvOBtplQGEKPXI9AGyobEx4DW8ghHfnLKM1pfX8+JEvCO9crekPhXl54VYWbKrm+auGk5McW0d1o59AKIzbYVbzdxERERERaVP79I4jHE7cl0YOP5luO2cMyOfYrpkEw2GSHRasZtOhLkvkiFCcnsTb14/m/2asY9rKHSRZzVwyopgzB+ZHG1R3zkxK+HiXrSXMqWnyc897K6Nh0J42VDTy9ba6aCBU0eBj/sYq/j1jHRX1PoZ3SufasZ0pTnfq366IiIiIiLQJfQR9FNP22CL7z2Q00DHTxR/O7M0t47thNBjIcMU2qC5KS6IwzcGWKm+rx195TEeyPFbK6/3M31iV8DrTVu7gxF7Z1DT5eejj1Twzd3cz69cXb+PdpSW8cs3IaBPrXcLhCI3+IGaTQbOIRERERETke9unptIiIu2Nw2ImJ9lBlidOg+pkO/+7cjh98j3RY2ajgctHdeDiEcVYTCaMBgMpzsShbM7O2Ubl9b6YMGgXfyjMb17/mupGX/TY1uomps7ewOVPzOeG5xYzZ10FVXuMi4iIiIiI7Ct9vCwi8j10SE/iqcuHUdXop8kfItVpIcNlw2lr+bGa6bJyxegO3P/R6riPP61/HgBzNySeRbRsWy013iCpSTY2VTZyzr/nUN6wOwCatrKMySOL+flJ3Uj9VvgUDIUJhMOaRSQiIiIiInHpnYKIyPeU7rKR7rLFHTOZjPx4SCGz11YwZ/3u0MdggL+c3Y/c5JYZQhbT3idqGg3Q5A/y4LTVMWHQLk/N2cR5Q4uigVCt18+myib+N2cTO+qaObFXNsf3yKJATeVFRERERGQPCoRERNpItsfOPy4YxJbqJmatqSDZaWFM10yy3btnEg3rmIbBAJE4zaeP6ZJBqtNKTVOAd74qSXid95aV0CvPQ31zgBfmbeHe97+Jjn22poKHp6/hlZ+NokNGbDPsSCSCNxDCbDRiNWsFsYiIiIhIe7LfgVBdXV3c4waDAZvNhtWqRsZHilpvgMoGHyW1zXjsFrI8tuguSiJyYGS4bWS4bQwsSo07numy8ptTevLHd1fGHE9xWrhrUi88Dgv1viDheInRTqGdW5mV1ftiwqBdKhr8/Om9lfztvP64bBagpR/RtBU7+GjFDtJdVi4f1ZFOmUl77XskIiIiIiJHj/0OhFJSUjAYDAnHCwoKuOyyy7jrrrswGvWJ8+GqrL6Ze95dyZtLtkePFaQ6mDp5CN1zPHt5pIgcSC67hR8PKWBYxzSe+GIjpbXNjO2WySl9cylIbdmWPtlh5sSe2Xy0Ykfc55jYJweAWWsqEl5n2sodVDcGcNksbKxo5MePxPYjevurEqYc34Urx3Qk2REbCjU0BwmEwrjtZszfscRNRERERESODPsdCD355JP85je/4bLLLmPYsGFEIhHmz5/PU089xR133EF5eTn3338/NpuN22+/vS1qlh/IHwzxxKwNMWEQwNZqLxc+Ope3bziGvBTHIapOpP1JdljpV2DlLz/qRzAUxm4xxexs5rJZ+NWEHsxZV0m9Lxjz2FP75pC/MzhqDoQSXiMcgXAkQqMvyH0frorbj+jhT9Zyev+8aCBU2eBj2bZa/vvZemq9AcZ2y+K8YYUUpjr2+sGAiIiIiIgc/vY7EHrqqad44IEHOPfcc6PHJk2aRN++ffnPf/7D9OnTKSoq4p577lEgdJgqq/fx1JxNcccqG/2sKatXICRyCFjNiXv5dMxI4p0px/D0nI188k05HruZq47txPCO6dHG1mO6ZsZdMgYwqDiFZIeFmiY/HywvTVjD9G/K6JrtpqbJzwMfreK5eVuiY8u31/G/uRt5/ZrRdM5yxTyuoTlIgy+AyWgg062lpyIiIiIih7v9nvs/Z84cBg4c2Or4wIEDmTNnDgDHHHMMmzdv/uHVSZvwBcM0+RPPJNhY0XQQqxGRfWE0GihOT+JXE3rw0k9H8NQVwzitXx6Z7t27nOUk2zlj53b2e7KajNw9qQ8pTivhyO6eQ/H4A2EAttc2x4RBu9R5g/z5g5U0NLfMVPIFQqwsqePnLy7mpL99xjmPzOHZLzdRXt/8Q79lERERERFpQ/sdCBUUFDB16tRWx6dOnUphYSEAlZWVpKbGb6Aqh57DYiLFaUk43j3HfRCrEZH9YTWbyHTb4zZ/TkuycsdpvXjovAH0yHGT5bZxxoA83p1yDN2zW2b0eBwWRnVOT/j8x/fMAmB6gn5FANNXllHj9QOwoqSO0/8xi2kry6j3BdlU2cRv3via376xnKrG2GVpDb4Am6uaWF/eQFmdAiMRERERkUNpv5eM3X///fz4xz/m/fffZ+jQoRgMBubPn88333zDK6+8AsD8+fM577zzDnixcmBku21cN7YL97y3stVYUZqTDulJcR4lIkeCTLeNMwfmM6ZrBsFwBLfNHN3iHiDZYeHO03px5r9m07xzNtAup/XLJS9535d7VTX6+O2bXxOMM+Pog+Wl3HB8F9KSWmYwba1q4k/vr+TD5TsIhSN0SHdy96Q+DO6Qisu237+KRERERETkB9rvV+GTJk1i1apVPPLII6xevZpIJMLEiRN544036NChAwDXXHPNga5TDiCTyciPBuXT4AvwyMz1+IItbwoHF6fyt3P7k7MfbwhF5PC0q69QPF2yXLw7ZQz/mbmOWWsqSE2yctWYTozukk7azsed0CubBz5eHffxJ/TMIsVhpbLRx9fb6hJeZ9baCnrnJ1Na28yFj81lc9Xu5agbK5uY/MQ8Xrx6BMM77Z6xVN8coLLBT1l9My67hYwkK1ke/UwSERERETnQvtfHsh06dODPf/7zga5FDqJ0l41rx3XhnMGF1HoDOCwm0pKspCa1XoYiIkcXs8lI50wXvz+jD3XeAGaTkbRv/dvPTbZz0fAinp0b2w/O4zDz6wk9cdnN1DT5MRkNCXsS7Zr5s3x7bUwYtKffv7OC/105jLQkG+X1Pu774BteXrSVyM6nLEpzMnXyELpmaymriIiIiMiB9L0CoZqaGubNm0dZWRnhcOySg0svvfSAFCZtz2Y2UZjmpPBQFyIih4TdYsJuMcUdS3Vauemkbozvlc2jn6+nuinAuO5ZnDu0Zdt5gJQkCyf1yuaDr1vvWmYwwKguGQB8vqYiYQ3Lt9fhDYQJhEL8b85GXlq4NWZ8c1UTFz46lzevHx3d/bDeG6Cktpl3lm6nxhtgfO8cumW5NJNIRERERGQ/7Hcg9Pbbb3PRRRfR2NiI2+3GYDBExwwGgwIhEZGjRLrLxnHdsxhcnIY/FMZjN2M27d6LwGWzcNvEHizZXEPpt5pE/35Sb7J27oBWsDNAiifFacFkMFBW7+Px2RvjnlPe4GNtWQN5KQ7qvQFemL8lpgfa03M20S/fw38vHdpqyWt9c4BGXxCz0UiGO/EyOhERERGR9ma/A6Gbb76ZK664gj/96U84nc62qElERA4jLnviXxXF6Um8du0o5qyr5KMVO8hNtnPe0EIKUh0k7VwydmLPbO59/5u4S8uuHN2RTJeVTVVNNPiCCa+zvryBY7tlsr3WG7ch/tJtdTw7dxM3ntAVs8mI1x9kTVkD9324iq+21JDptnPduM4c2y2TjL30VxIRERERaS/2OxDatm0bU6ZMURjUTjT6gpTX+/hyfSW13gAjO6eTn+LYa8NaEWlf8lIcnD24gDMG5mE2GluN5yTb+fdFg7juuUUEQrtDobHdMzlvaCEmkxG7xUSyw0KtNxD3Gt129hB6Y8n2hHX878tNXDS8iJxkB4s313Dx1LnsyqDqmhu46aWvuGBYIb+a0IMU5+6eSTvqmqls8BEMR0hLspLltmE1x19KJyIiIiJytNjvQOjkk09mwYIFdOrUqS3qkcNIoy/IB1+XcusrX7HnB/vHdcvkvnP6qV+HiMSIFwZBS6+iY7tlMv3msSzZXEN1k58hxankJNuj4XK228Y1Yzvz5/e/afX4/BQHnTKTAKhq9Ce8fn1zkEgEyuqauf31ZcTrdf38vC1ceUwnUpxWgqEwX2+v47pnF7GtxguA02ritok9OL1/XkxotEsoHCErK+s7/y5ERERERA53+x0InXrqqdx6662sWLGCvn37YrFYYsYnTZp0wIqTQ6uktpmbX/6q1fGZq8t5ffE2rhrTCaPREOeRIiKx7BYTRWlOitLizy41mYycM7iAmiY/j8/aiD/UsmFBn3wP/7hgEDnJLX2IJvbJ4cX5W+I+x5guGbjsZnbU+dhYGX9XM4AlW6rpkuVie20zF/z3S7yBUHSsyR/it28upzDNydjuLcFPJBJha7WXaSt3MHttBYUpLtIrvRSkGXBav9feDCIiIiIih9x+v5K96qqrAPj973/fasxgMBAKhVodlyPTW18lXprx2KwNnDkgn+xkzRISkQMjw2XjxhO6cuHwYmqb/NgtJtJdVtKSdi9R7ZnjoWeum5Ul9TGPtZqM/GpiD9x2C5UNiWcRAdEQ58PlpTFh0J7u+3AV/QqSSUuysXpHAz/+zxfUeXf3OHryy83844KBnNQzG9seO7XVegPUNPkJhSN47BY1shYRERGRw9Z+B0Lf3mZejl7bq70Jx6oa/YQjcdZjiIj8AA6rmaI0MySYSZSdbOfxyUN58ouNPDt3M43+IMd0yeC2iT3pvHNZWYrTwvCOaczdUNXq8RaTgT55HiKRCIs2VSesY115A75gmKpGP7e+8lVMGAQQicDNL33FtJuOo3BnrevLG/jtm18ze20lAF2zXNxzVh/6FaRgt6gnkYiIiIgcXjTXXRI6oVcWryzaGndsSHEqDqve4IjIwZeb4uCWk7tx+egOhCPgspnxOHYvX05xWrnnrL6c+585MT2HDAa475z+ZHrsGAwGBhSm8P7XpXGv0TEjCavZSHWTn6Vba+Oe4wuGWVNWT2Gak63VTZzzSOz11pQ1cMGjc3nr+tH0zkuOHt9W42Xx5mrmb6iic5aL47plkptix2rSz1QREREROXj2KRB6+OGHufrqq7Hb7Tz88MN7PXfKlCkHpDA59AYUplCY5mBLVexMIaMBbj+lZ9yGqyIiB4PFZIr2FYqnS5aLt64fzYxV5Xy2upzCNCfnDS0kP8WBY+dsnQl9cvjbx6vxBVvPfL15fHfSk2zfufzM629ZcjZjVXnchtehcIS/fbyah84bgNtuYV1ZA+f9dw4VezyvzWzkqSuGMaQ4FbNpd2PuXcvPwhFItltIc+lnroiIiIgcOPsUCD344INcdNFF2O12HnzwwYTnGQwGBUJHkdxkB8//ZAT3fbSKd5eWEAxH6Jnr5u5JvemW4z7U5YmI7FVBqpOLRxRz/tDCmKBll7xkB8/8ZDjXPruI8nof0BLO3DK+O4OLUgFIdlgoSHWwNc4SWoMBeuV58AfDfLqqLGEdCzdV0+gLEghFuOWVr2LCIGiZaXT10wt4/+fHkp/iIBKJsK68kbve2r38rFeuh3vO6kPvPA9Wc+uZROFwRE3+RURERGS/7FMgtGHDhrj/X45+BWlO7j2rL7eO704oEsFlM0e3iRYRORLEC4MALGYjQ4pTeev60VQ2+PGHwmS6bGS6bdGeP9keO/ec2ZfLnpzHt9umXTG6IxlJNiwmAwWp8XseAWS6bJhNRqob/SzeXBP3nLrmIFuqmshPcbCt2ss5j3xBTVMgOr6ipI5z/zOHd6eMoVt2SyAfDkfYWuPlk5U7mLuhil65Hk7rn0t+iiNuaCQiIiIisif1EJLv5LSZcdq++1YJhyM0B0NYTcaEb8BERA4nBoOB3GQHuXtZfja0YypvXDua+z9axdKtteR47Fx/fBdGdU7HvbN30QXDCnnqi41xH3/tuC5kuGzRWUiJNDQHiUQifLC8NCYM2iUQivDw9DX89ex+OG1mVpbWcd5/vqTB19Lw+v2vS3n4kzU8cdlQRnRKj/k5vKOumapGP5EIpCZZyHbbNaNIREREpJ3b70DonHPOYciQIfz617+OOX7fffcxb948Xn755QNWnBwZdn1K/c5X25m1toKCVAeXjuxAcboTt93y3U8gInIYc1rN9C9M4f8uHESDL0Dptq307ZaJxbL751tBqpO/ntOP215bRii8eyrRuUMKGNM1A2hZfpbqtFAdJ+wB6JyVhDcQYsaq8oS1zN9YRb0vSKM/xJTnl0TDoF0CoQjXPreI929sWX7mD4X4anMtv3hpSXTZW6bLxp/P7svIzuk4rbEvAxp8Abz+MHaLUT+/RURERI5y+x0IzZw5k7vuuqvV8QkTJnD//fcfkKLkyLKmrIFz/v0F9Xu8MXlpwVbuPasvZwzMa/WGQ0TkSORxWHCYYf7alfTt1jFmzGUzc1q/XIZ3TGPJlhqa/CEGF6eS5bZFG/Bne+z85tRe3PLyV62e+4JhhaQn2bCajOSm2BPWkOGyYTEZKa/3sa68Ie45dd4gJTVe8lMcbK3yctFjc/GHdjfOLm/w8ZOnF/DO9cfQO79l97NGX5B15Q3845M1fFNaT8cMF1OO70K3bHfMDm4iIiIicvTY73fqDQ0NWK2tdzqxWCzU1dUdkKLkyFHd6OfXry2NCYN2uePNrxnVJZ3idAVCInL0c1rNFKebKU5PijtuMho4qVcWj08ewr3vf8OasgayPTauHduFU/vlRoOXySM78PKCrXGf49qxXUhLslJS27rJ9Z58wTDBUJjn5m2OCYN2iUTgH5+s5YFz+2O3mPh8TQXXPLsw2idpS5WXz1aX8+cf9eWsgfnYdvZUqm8OUFbvY976KsKRCMM7pZPptpLs0A5oIiIiIkea/X6n3qdPH1588UXuvPPOmOMvvPACvXr1OmCFyZGhpilxk9RQOMLX22oTvjkSEWlvkh1Wju+ZTb+CFPyhMCajgSy3DYNhdz+f4jQnv5vUm9+/vZw9Vp9x4bBCRnRKAyDVaSXFaYnba8hkNFCY6sAbCPHVlpqEtSwvqaXJH6LWG+C215a2apoN8Lu3l3NM1wwKUp3UNPl58ouNPDRtTcw5V4/pxM/GdiItafeGA82BEOX1Phr9QZKs5phG3SIiIiJyeNjvQOi3v/0tZ599NuvWreP4448HYPr06Tz//PPqH9QOheK8gdhTvE+mRUTauwx34t0a3Q4LPx5cwNhumSzYVIUvEGZYxzQy91x+5rbxu9N78fMXWy8/u25sZ9J3Li3rnOli/sbquNcpTnNitxjZUdecsK9RcyDMjrpmClKdrN5R3yoMAvjv5+sZ0zWDMd0yASira+ZfM9bx/LzN+IJhrCYj5w8r5PpxXcjyxC6HC4bCVDX5AUh3WjFpQwIRERGRg2a/A6FJkybxxhtv8Kc//YlXXnkFh8NBv379mDZtGscdd1xb1CiHsWSHhc6ZroS9LPoXpBzcgkREjgJJNjNJNjMdMhIsPzMZOaFHNs9dNZy/frCKVaX1FKY5+PkJXRnROZ2knTtDXja6Ay8u2BJ39s+UE7ritlv4rs3GjAYDTf4g//1sQ8Jz/jVzHQOKUjBg4K8fruKVhbuXvPlDYZ6es4mG5iB3n9E72qx6W42XF+dt5rXF2wD48eACzhlSSH5K4h3fREREROTA2a9AKBgMcs8993DFFVcwe/bstqpJjiCZbht//lFfLnj0S4Lh2HccV43puNdPwUVE5PtzOyyM6pzBE5d5aA6GsJiMZLhif+YWpTn5vwsHcevLX9HoDwFgMxv5zak96ZHjBiAtyUaOx05pXXOra3jsZrI8dvzBMGX1rcd3qaj34Q+GqW8O8tqi+P2PXl+yjRt2hlDba7yc95850Z3PAB6ctoZXF23jhatHkLczFAqGwmyv9fLpN+V8va2WgUUpjOmaSX6KA+N3JVkiIiIislf7FQiZzWbuu+8+Jk+e3Fb1yBGoX0Ey70w5hn9MX8uizdVkuW1cf3wXBhen4dG2xSIibSo1KXFDZ6fVzIm9svjoF8eyvbaZUDhCfoojpqdPtsfGg+cN4NLH5xLYYx2w0QAPnDuA7J3B/piuGSzdWhv3OqM6p+O2m9lS1UQ4wVLiSKSl71w47OTdZSUxYdAum6uamLZyB5eMKAZg2bZaLnx0Lt5AS5j18sKtuG1mnr96BH127pAG0OQPUtHgZ2NFIyajgaJ0J1kuW7QZtoiIiIi0tt9Lxk488URmzJjBZZdd1gblyJHIZjHRI8fDfef0o94XxGY2Rvtc7KmhOcCOOh+friqjwRfkuG6ZFKY5W32iLSIiB47VZCI/1Ul+qjPuuMFgYHBxCh/+/FienbuZpVtr6J7t5tKRHShMc2De2dfn3CGFPPXFJhq+taukw2ListEdsZpN0aVqiSRZzdR6A7yxc5lYPK8u3Mqk/nl4AyGu/t/CaBi0S70vyLXPLuKVn40ky2On1hvg1UVbufe9ldFAy2Y28uez+3FSr2xce9TU5AtS0eCjKRAiyWomy2PDZlZoJCIiIu3TfgdCEydO5LbbbuPrr79m8ODBJCXF9jeYNGnSAStOjixOmxlngjcDdTtfsN/99orosYemreHYbhncf07/Vo1GRUTk4LGaTXTKdHHbxB54AyHsFiMWU2xQUpjq5NVrRnHnm8uYu6GlUfXg4lR+f0ZvClNblnilJVnpV5AcdyZRn3wP6S4rBgNY99I82mo2YjIaqGzwU17vi3vO5qomqhr9ZHnsfFNSx+/3+N0C4AuG+cWLS3h3yjH0zmuZSVRa28z9H63ijcXbCIYj2MxGLhvVgZ+M6UTmt5Y3N/iC1HkDGGiZgaUd0kRERORotN+B0DXXXAPA3/72t1ZjBoOBUCjU6rjI9hpvTBi0y2erK3hnaQmXj+4Qs+2yiIgcfGaTEXeCsMZoNNA9x81/LhlCrbdlVzKPw0LqHjNC0102/nnhIC5/Yn7MZgOdMpL414WDSN85I/TSUcUsfrEm7nUmj+qA227BF9z7LpX+UJj65gD//KT1zme7PD5rA/f+qB9N/iC/eX0Z078pi475gmH+89l6/MEwv5zYHYfFTCgcYUNFI3/94BumrdyBxWTkjAF53HB8VwrTWs+wqvMG8AXDJFlNCT8QERERETlc7ferl3BY24jL/ntpwZaEY1NnbeC0frmaJSQicgRIcVrjLgvepSjNyfNXD6ekppkt1U0UpDrIS3bE/Iwf1TmD4R3TmLuhKuaxozunM6xDGtCyaYHFZIjpa7SL02oiLclKcyDElji9iHbZUNFEcyBEZYM/Jgza0zNzN3H56I4Upbf0QDrjn7OiDbh9wTAvLdjK52sqeOVno8jfOROqpsnPypI6/vHJWrZWe+mbn8x147rQMcOJw9r6pZU3EMRoMGh5moiIiBxW9HGWtLlwOMKOOLvX7FLd5CcUb09kERE5ImW57WS57fQvTIk7nu2x848LBrJ0Wy3Pzd2MwQAXDy+md54nGhxluKxcP64LD05rPQPolpO7k+W2EQxH6JufzMbKprjXGVScgsNqiruD2i6BUITa5gC+YIhHP1sfDYP2VFLbzIzVZVw0vJgmf5BXFm7lj++ujI5vrmri/a9LePLyYRzbLXOPx3mZt76KVxZtxW4xMnlUR3pku7UDp4iIiBwWvlcgNHPmTO6//35WrlyJwWCgZ8+e3HrrrYwZM+ZA1ydHAaPRwIQ+uby7rDTu+KjO6TFNP0VE5OiX5bFzosfOmK4ZAK1mzzitZi4dWUynTBd/+3g1myob6Zzp4taTuzOsYxpWswkrcO24Lry7rKTV7mY2s5ELhxVhMRlJce59x8skq4napgCfroo/iwjgvWUlnDUwn4p6H39+/5tW4+EI/OrVpbxx3WiyPXZKar1cOnUea8p2L537eEUZp/fL5a5JvaMbKvgCIUpqm/lweSlryxsYtXOWVKIm4CIiIiIHyn6/C3/mmWe4/PLL+dGPfsSUKVOIRCJ88cUXnHDCCTz55JNceOGFbVGnHOGGFKdSkOpotc2wxWTg5vHdccfZnj4QCmPZS+NRERE58u1tGVVqko3T++cxolMawVAEi9nYamfKDhlJPHXFMH71ylK217bMBOqQ7uSBcwdQkNayxCvLbaNTRhLrKxpbXeOYLumku6wEQxE8Dkv0Ob4txWHFbDSysbKJ4LfTp51KapupbvKTkWTllQVbY8KgXd5eWsJFw4vJcNnwB0PM3VDFFU/Ojz7nywu2kuGy8uJPR9I50xV9XGWDj63VXj5bXY7Lbua4bplkuW244vz+FBEREdkX+x0I3XPPPfz1r3/lF7/4RfTYjTfeyN/+9jf+8Ic/KBCSuHJTHLxw9Qge/Hg1b321nUAowuDiVH53em86Z+7eqS4SibC12svHK3fwxdoKOma4OHdoAfkpDpxx+jKIiMjRL9OduMecw2JiTNdMXr92NNVePwYMpDotMT2LMt12Hps8hMlPzGNL1e4PJnrlefjL2f1JdrT0RPrJMR255ZWlca9z2egO0R3Q9saAgcpGPy/MT9w7739fbmRIx1TK6n387JmFrQKmigY/v3xlKY9dOoTUJCvl9c386tVlfPKtPki/m9SbHw3Kx7MzFAqFI5TWNrOipJaS2mZ65yVTlObY69+fiIiItF/7/Q57/fr1nH766a2OT5o0idtvv/2AFCVHp4JUJ388qw83ndSNcATcdnOrxqRrdjRwzn++oM4b3HmkjMdmreefFwzixJ5Z2LT1r4iIxJGdbCc7OXHw0SnTxSs/G8X2Gi8lNc0UpTvJ8dhj+vkc2y2T43tktQperjymY3S2TnG6E5vZGHcXtI4ZSaQmWYiEW3ZBS8QXDBMOw4aKRpri9CwCWLipmuomPylOC+8tK21VE8Dv3lrO8I5peHIthMIRlm6t4ZKp82jwBaPn9Mp189jkoeSlOKLHapr8lNf7WLq1FrfdTM9cD1luW8LfsU6nlq+JiIgcjfY7ECosLGT69Ol06dIl5vj06dMpLCw8YIXJ0clhMZOfGv+2q2r0c8srX+0RBrWIROCml5Yw/abjKIiz7a+IiMi+yPbYyfbYGVgUfzzLY+ev5/Rjc2UT7y0rwW4xckrfPPJS7NEPMDJdNv56dj9ufHFJzGNtZiMP/Lg/WW47/mCI0/rl8sTsjXGvc97QIqxmIw3NwbjjuwRCYcobfDz6+fqE57y0YAt3nd6b0tpmJj8eGwYBrCip50/vreQvZ/cjyWamot7HPe+t4PXF26PnWE1G/nHhQI7tloljZygUCkcorWtmfVkD5UmdWFXWRG6ynXSXGmKLiIgcLfY7ELr55puZMmUKS5YsYdSoURgMBmbNmsWTTz7J3//+97aoUdqJ6iY/S7fWxh3zBcOsKW9QICQiIm0qw2Ujw2VjUHFq3HGbxcSJvbJ5/8YxPDF7AxsqGhlcnMp5QwspSGn5HWU1m7hidEfe/mo7FQ3+mMf3L0imX34yAN1y3AnryHTb8DhaZv5UN/oTnldS20w4HGFdeQN1CQKm978u5ZcTuuO0mvjg69KYMAhaZjNd88xCpt10HJ0yXYTCEb7eVsslj8+N+ZBmeMc0/n7+QHL2mIlV3eSnrM7H0q01JDss9Mz1kO2xYd1LbygRERE5POx3IHTNNdeQk5PDAw88wEsvvQRAz549efHFFznjjDMOeIHSfoQSNOncxeuLP61eRETkYEqytSyz+uOZffEFQzgsJszf2gShMM3J69eO5pkvN/HushJsZiOXjChmQp/c6NK2DJeNC4YV8vy81v2Gfnd6L3I8dhp9IUZ2Tmfayvg7oE3onYPRaKCs3pew3lA4gi8Qprzex79nrot7TjgC7yzdzpQTulFa6+WSqXNbBUxzN1Tx8PTV3Hl6b+wWE2X1zfzureW8t8cuojazkX9fNIhRXTKw75xtFAiG2VHXzLJtteyoa2ZAUQoFKc6Y5XoiIiJy8O1TIPTwww9z9dVXY7fb2bx5M2eeeSZnnXVWW9cm7Uyyw0J+ioNtNd5WYwYD9MzztDpe1egjFI6Q6rS2ejEuIiLSlqxmI1Zz4t89hWlObjm5G1eO6YiBlgDIYNjdlDrZYeHmk7rTJz+Zf326jpJaL73yPNw2sSd9C5IxGAy47GZuHt+dGavKWzWfzk9xMKxjGgA99zLbKC3JSpLNTCgSYUdd/F3UADZUNAHwTWl9wtlGry7axjVju5Cf4uCNxdtjwiBomdF71f8WMv2m4+iQkYQ/GGLhpmouf3I+zYHdfZUGFaXwr4sGkZO8u7dReX0zGyub+GJtBekuG8d0ySDbY8OhTSVERETaxD79hr3ppps4//zzsdvtdOzYkZKSErKystq6Nmlnsj127jmrD5c/OZ/ItyYLXTm6IxlJuxtQ76hr5tNvynh6ziaaAyFO7ZfLeUMKtaRMREQOKxaTiSx34uVTGW4bFw4r4qSe2YTCEWwWI2lJsTNnOmcm8eo1o/jd28tZvLkGs9HAqf1yuXl892iz6JxkO8M7pjF3Q1Wra9x6cneyPXbqmwP0K0xm0aaauLUc1y0DgO21rT+Y2cUXDOMPtsw2+u9n8WcbhcIRpq3cwU/GdGJHnY/Lnpjfqgn3os01/N8na7nj9F7YzCZKa5v52TMLWbJld21GA/z9/IGc0DMrutNogy9Iaa2Xt5aUUFrn5aSe2fQtSIlZxranJn8Qq8moD41ERETi2KdAKC8vj1dffZVTTjmlZVvwrVtpbo7/CVNRUYJOjSL7YFiHNN64djT3f7SKr7bWkOtxMOWELozolI7b0bKtblldM9c/u4j5m6qjj/vHJ2t5Yf4WXrtmFIUKhURE5AhiMBjI8iTeIc1qNtG/MIXHLxtKQ3MQowFSnVactt0v49JdNv5+/gD+8claXlm4FV8wTKbbxq0nd+ekntmYjAZSnFZun9iTcx6Z0+oamW4bwzqmA9A7LzlhLZkuG06biVAk0qo/0p42VjQCsGRLTdwd2QBeWriVn43tTKbbxuOz1seEQdCyjO3GFxbzyc1j6ZBhptEX5N2l2/nVq8t2P8eCrXRId/LsT4aTn7r79/+26iamf1PGR8t3kOmxcdnIDhSnO1vtbgpQ6w0QCIVJdpixmNT7SERE2o99CoTuuOMObrjhBq6//noMBgNDhw5tdU4kEsFgMBAKqc+LfH9Om5n+hSn834WDaPKHsJgMrXY0+Xp7XUwYtEt5vY8nv9jIryZ0VzNLERE56qQ6raTGCTR2yUl28NvTenHN2M74g2EcVhM5HnvMMrWeOR6euGwov33za7ZWt8wEOqZLBn84s3d0tlFhqoNeeR5WbK9rdY2bx3cj222nxuund56H5XHOATimayYAJd812yjUEiw9M3dz3HPCEfh0VRmXZ3SkrN7Hr19b1uqcjZVNPDRtDb8/ozcOq5mNFY38+JE5lDfs7qv0+qJt3Dq+O5eMLMaz8wOminofCzdX85+Z66lrDjCueyYXjyimMNWJ0WiIuUZtk58mfwij0UCWO3bpn4iIyJFqnwKhq6++mgsuuIBNmzbRr18/pk2bRnp6elvXJu2Yx2GJvmDbUzAU5sX58V80Ary1ZDtXj+lEdrICIRERaX/sFhMFqYlnyibZzYzrkcWreaOobw5gNhpJTbKSvMfv3Ey3nccuHcI9767kg+WlO3v1WbhlfHdO3tnEOi3Jxh2n9uSCR+e2ukZusp3+BS2zjAYWxd+tDaAg1YHTasIfDNPkT/yB4q6+R5+vKW+1pHyXN5ds5+cndiU5EuHP738TEwbtct9Hq5jQJwePw0JVo4973l3B60t277i2tqyBF+dv4fVrR9M5ywWA1x9kzY4G7n1/JQs31ZDusnLVmE6c1j+XLHfsrK4GX4CqxgDBUBiX3dxqXERE5HCzz1363G43ffr04YknnmD06NHYbNoZQg4BA5iNiT+VMxkN8K3hJl+QRn8Iu8WI2946ZBIREWlvsj12sveyTC0vxcFfz+nHLyd0o6K6jpz0FHKSHS2/Z3fqm5/MY5cO4a63lrOtxovBAMd1zeTuM3qTu3O2UXG6M+FMojtO7Um2x05Vo48++R6+3hZ/ttGxO2cb1TYFEtbrD4UJRaCmMcBHK0oTnjdzdTmds1xsq2mOCYN2qWsO8pcPvuGBc/vjtltYtq2W8//7Jbv6eZfUNvP7d1YwZ30Ffzm7X7Tf05aqJv747ko+XlFKOAId0p38/ow+DC5OJWmPpX1N/iAV9T6qmwI4rSbSkqytZkKLiIgcLPu9bcPkyZPbog6RfWI2GrloeDHvLov/Yu+8oYWk72w+7Q2E2FjRyP99upZl22opSHFw/fFd6JXrIXkvU+5FREQEkmxmrEYbS2bNp98pp8SEQQAuu4UTe2XTpyCZhuYAFpORVKc1ZoZv1s7ZRg98vJo3l2wjEIqQn+Lg9lN6MrJzy2zztCQbd53Wm3P/O6fVDKCeue7obJ1jumbwwMer49baNz8Zl81Egy9EOMEsImh5bQDw4deJQ6NpK3dQ1xzEFwhzxxtfx32+j1eU8fMTm0lLslFS6+WCR7+MLsGDlmVslz4+j5d/NpKhHVp2giuv9/HvGWt5es6m6I5xvfM8/N+Fg+iQkRR9rC8Qoqzex/LttTT4gvQrSCHLbYvb/wggHI60WuImIiKyL7SPpxxxumW7Obl3Nh8u3xFzvEO6k/OGFkZ3ElmwsYrJj8+LvpDbVNnE7HWV/OaUnlw0oii6Y4mIiIh8fzkeO+xltlFuioM/nNmbG0/oSiAUJslmbjU7qXe+hxeuGsHv3l7OypJ6bGYj5w4u4NpxXaLnFqY6GdU5jS/Wxe6kZjIauHtSb9KSbBgNfoZ2SGX+xta9BgHGds+MPiaRXf2BGnxBVu9oSHje3PVV9M5LZtnW2pgwaE9/fGcFT1w+DLfdzHPzNvP47I0x48u313Hx1Lm88rOR5CQ78PqDzFhVzo0vLMEf2t2M+6yB+dx+Sk8y3btnE22tbuLz1RV8tqacjhlJ/GhQPnkpjlavbyKRCJUNfsKRCClOi/osiohIlN4RyxEnw23jj2f24YJhRTwxeyPNgRA/GpTPsV0zo1PUd9Q286tXlsb9VO8vH3zDyb2zKUrX7S8iInIwOCxmCtMS/951Ws0M75TOM1cOp9EfwmQwkOG2YtsjvMhw23jwvIG8snArj8/aQHWTn+Ed07jtlJ50y3YDkOK08rtJvfnRv75otbvZpP655Ca3vE44uXcOf5++Jm4tE/vkkOKwUNXox2gg4Ywjt73l+5m5ujzh9/XV1lqaAyG8gSCPfbY+7jlbq71srGwiJ9lBSW0z1z23qNU1X1+8jcHFqVw0vAiDwcDasgbO/c8cqhp37/T2yMx1/OOCQZzQMwu7peXvrbS2mQ+Xl/L0nE00B0JM6JPN5JEdKExzxjTGDocj7KhvpskfwmY2kum2xfzdi4jI0UnviOWIlOm2M7a7neEd0wmFI7jssbdytdfP9trmuI8NhiOsr2ikKD0p7riIiIgcGukuG3vbtiTbY+dnx3XmnEEFhCMRnDYTyY7YpVTdsty8O2UM//p0LbPXVZCWZOWnx3ZmdJd00nYuK89NsXPpyGKenrMp5rFpSVZuHt+dJJuZCBHG98rhg+Wtl5cZDTC0Y8tSsL018U5PsmIyGqhvDlHvCyY8b11ZAyM6pfPWV9sTBlCPzFzH+F7ZWM1GbnttaUwYBC3B1U0vLWHaTcdRmOakrK4lXFq4x86sU2dt5NVF23jzutEU73wdVNXo4/1lpfzt49VUNvqxW4ycP7SIa8Z2jpnJFQyF2VHvo7TWSyAUIS/FQYbLqhnXIiJHsO/9E9zv97NhwwY6d+6M2axfBHJoOKzxP70yfruz9LfsOVW8vjlAeb2PL9ZV4g+GGdU5nWyPndQk9RkSERE53JiMBrKTEy9Rs5iNdMly8cez+lDfHMRsNLRq3JzqtPLzE7tycu8cHvt8PTVNAcb3zuG0frkUprUEPC6bhdtP7cnSrTUxHzIZDHD/j/uTtXP51oQ+2dz34Tdxg5yrxnQiw2UjGArjtJoS7qbWcWcPoY0VjQm/rx11zYTCEaqb/AmXxPmCYb4praMwzcmKkrqYMGiXmqYA/5m5njtP74XJaOD1xdv5wzsrouPNgTBPfrGRTZVNPHBuf9KSrDQHQsxZV8mU5xdHgy2LycAt47tz3tDCaH+jSCTCthovc9ZVMm9jFd2y3ZzUM5u8VDtWU+xrtlA4QmWDjwiQqqVsIiKHxH4nOU1NTdxwww089dRTAKxevZpOnToxZcoU8vLy+PWvf33AixTZXylJFjpmJLEhzgsrm9lIx52fitV6/bwwbwv3vv9NzDnnDCrg16f0IEM7f4iIiByRnFbzXmevpCXZGN3FxqCiVPyhMC6buVVvoaI0J69cM4qFm6qZvnIHBakOzhyYT27y7l49OckO/nXRIK5/bnG0WTTACT2y+NGgfExGA5luG5eN6sC/ZqxrVUe2x0bHzJbXJcd2y+SNOLufAfQvTMFhNdGwl5lGAI3+EOFwhJcXbEl4zrvLSphyQldC4Qh/nxa/Ufenq8oor/eRlmRlW7WXnzy9gNAe318gFOHe97+hR46H43b2ZlqzcylbzR47wt33wSqeumIoQzukRfs8ltR4eXXRVl6Yv4VAKMxp/fK4bFSHaBi3S3MgRHm9j0ZfEKfVRIbLhtOmD6JFRA6U/f6Jetttt/HVV18xY8YMJkyYED1+4oknctdddykQksNCltvO387tz/n//bJVD4E//6gvGTs/1dtU2dQqDAJ4ZdFWjuueyen98w5KvSIiInJoOKwmHCSenZKX4iAvxZHwNYHDYmJs9yw+uWUsS7bUUNvkZ3BxGjnJtui29FazictGd6Ci3sfLi7ZGd1PrlJHEo5cOifY2Gt4xnUy3jfJ6X8w1DAa4bWJPUpxWfMEwBamOhI2s++YlYzAQ7SMUj9VsxGBomSVd15w4YFpf3kDXLBcvLtgSEwbt6cFpq+lfmEwoHOEXLy6JCYMA/KEwP31mIe/feCz5KQ5Kar1c8vg81pbtbtg9ddYG3lqyndevHUXBzlCorL6Z/85cz/++3IQvGMZsNHDGgDxuPbkHOXvMENs103vehipC4QjDO6WR6ba1WkoI4A0EafKFcFhMCpZERPgegdAbb7zBiy++yIgRI2Ka0fXq1Yt161p/6iFyqPTJS+aDn4/hhXlbWLipmg4ZTq4Y3ZGi9CTsFhOBUMuU6EQembmO0V0yov0GoGV6sy8Qwmo2Rj/lEhERkfbNbjFRlOakKC1xP6Est53fnt6La8d1obLRh9NqJt1lJcu9O9zIT3Xw0k9H8Ns3ljNrbQXQMkvpD2f0pkdOS+PsbI+de87sw2VPzo8GS7tcOKyQDLcNg8HABcOKeHXRtri1nDekkPQkK15/CIOBVs+zS5rLSiAUZnVpfcLva0tVE82BMA2+AMu318U9p84bZHuNl/wUB1+ur4wJg3Ypb/Dx7NzN3DS+G4FQmH9+sjamx1MwHOHVRduoaQrwwLn9SXFaqWny88yXm7j/o9hZTlce05Frx3aOLhVs8gfZWNHIv2asY/WOerpkurhmbGc6ZrpwfSsYqmzwUdPkp7jPMGq8QTItloTfu4jIkW6/A6Hy8nKysrJaHW9sbIwJiEQONYvZSMcMF7ee3B1vIITNbMJq3h3iBEMRdtTFbzwNUNngJ7Bzy9dAMMy2Gi8vL9zC4s01dMlycfGIYgpTHTjUTFFERET2gdtuwW230CEj8cYWHTNc/OuiQVQ1+gmGw3jsFrI8sT2ThnZI4/VrRvGXD75h6dZasj12rh3XmbHds0h2WHY+TxJnD8pvFQp1ykjiwuFFmE1G0pKsjOuWySerWu+Ulp5kpTDVidVsZFBxCjMS7KbWI8eN02pq1eT62xp9Qbz+EK8ujB9SAbyzbDtXHNMBrz/Ec3M3xz1n+jdlVDb4SXFaWVfe0CoMgpYZR8d0yWBcjyxC4Qiz11Zy9f8WRIOv1TsaeO/rUh4+fwAT+uZgNZkIhsKsKKnj168uY0VJXfR7+8vZ/eiV68Gyx2vI7TVe1pU1sLa8ga7ZbjpnJkVnee1pV88nAy0Ny/VeSUQON/v9Tnbo0KG8++673HDDDQDRH2yPPvooI0eOPLDViRwAZpMRd5zZPHaLkRN6ZDN7bWXcx43onBbdUnbptloufHT38rMv1lXyzJebeOTiwYztkdmqUaKIiIjI9+VxWPA4Es9McdrMDChK5ZFLhtDkD2IxGqPL4XdJd9m4/ZSenDO4gKe+2EiTP8RZg/IZ0TGd3BRH9Dq/P7MPm5+YHzNrx+Mw8+QVw8jx2DEYDJwxIJ9/zVhHcyB2GT7AzeO743FYSPEFSXFaWi0Zg5Zd2TqkJ2EwgM2SeIa1zWzCYDBQ2xyM6cf0bTvqmslPdfDoZxsSnvPvmesYXJxKgy/IL1/5Ku4sqNtf/5rBxankpzrZUu3lx4/MiWk18E1pPef+Zw4f3DiGjpkuANaWNXDho19StseyvtxkO8/+ZDiddp4DLaHRG4u38eqibRgNcP6wQk7pm9sqOGrwBaio99PoD+K2mclw27Rzm4gcNPv90+bee+9lwoQJrFixgmAwyN///neWL1/OnDlzmDlzZlvUKNImDAYD43tn889P17b6VMtqMnL9uC44rWbK6pr5+YuLW/Uiatne9Ss+/PkY8vey5ayIiIhIW0h2WKIzguJJd9kY6bIxuDiNYDgcN2goSHXy7E+Gs7mqiRXb6yhMc9A9201usgPjzibb+SkOXrhqBDe+uIRNlU1Ay4yX35/Rm27ZLSFIttvGb0/txc0vf9XqGpeN6kC6y4rdYmLyyA5MX1kWt95LRxaTnmSl1ts6VNpTSpIVfzBMWX3imd4V9T78oTBVjX6q44RUAA2+IOX1PjLdNp6es7HVaz1o2bnt8S828ttTe1LrDfDT/y2MCYMASmqbueaZRTx71XAyXDa213g5/79fsrmqKXrOH95ZyQvztvD0lcOioVBprZc/vruS95aVEI6A2Wjg3CEF/PzEbjGzwioafGyubOLdZduxmIyc1i+PglRHdHe3PZXVNRMMR7CajdocRUS+034HQqNGjWL27Nncf//9dO7cmY8++ohBgwYxZ84c+vbt2xY1irSZglQnr/xsJH98ZwWfri4nEoGBRSncPak3RektIU9Vk58tVfEbNzb4gmyvbY4GQv5giLJ6H1urvYQjEQpTnWS4rFpWJiIiIoeM1WzESuKZOdkeO9keO0M7pMUdN5uMDChK5eWfjqS6yU8wHCHVaSXbY4/uzGYyGTmxVxZPXT6Uv3ywim9K68hPdXDD8V05oUcWbntLcNUr18MpfXN4b1lpzDX6FyQzvlcOBoOB9CQrozunM3td61ncnTNdZLisJFlNjOmayaLNNXFrHtkpHbfdTGnt3v9uDAYDjb4Q8zZUJTxnwcYqGnxBKhv8rCtv3f8IYNWOeiob/KQ5rbyzdHtMGLTLmrIGPl9TwblDCqlp8nPba8v4dI/lesFwhOfmtTTwvvP03iTZzJTVN3P7a8uYtkeI9sjM9UweWcyNJ3aNNi6vbPDx0Yod/GP6GrbXNtMly8WvJ/RgSIfUmOCo0RekosHHuvIGrCYTHTKcZLltWM2tZ7s3+oL4giGcVvNem5SLyJHre71L7du3b3TbeZEjXadMF3+/YCA1TQHCkQgeu4XUPRpJh/cyZRkguLPPUKMvyKeryrj15aV4AyGgZabRb07tyZkD8/f6CZ6IiIjI4S7LY2/Vz2hPyQ4rx3XPok9+Mv5gGJPJENM0GyDDbeP3k/pw8fBinvlyE/5QmPOGFNKvMIXsnc+d4rTyl3P68dP/LYxpVF2c7uSxyYOjz3n24AIen7WBel/sTmk2s5Erx3TEZjaRnmQlPclKZZweRx57yxItm8VITrI9YVPs3GQHNrOJpp2v7xLxBkJUN/l5LUEzb4AX529hQu8cKhv8MWHQnl5ZtI1rx3UhyWZm9tqKmDBol6fmbGJi31xGdLJR3xzg/z5dy+OzN0bH15Y18JOnF/DnH/XlnMEFmE1Gqhv9PD1nIw9/sja6a5zdYuSBHw9gXI/M6AyyOq+f1Tsa+PeMdWypbmJAYQpXjelEcbozJjgKhsKU1fuobvJjNhpITbK2+u+9p2AorE1ZRA4z+x0IjRs3josvvphzzjmH5OTktqhJ5KDb1eQxnlSnlQyXlYqG1i8krCYjBTtnB22pauKG5xfHrFH3h8Lc9dZyeua6GdYxvU1qFxERETmcpH/HUqUMt40Mt41hHdMIR4jZ9GOXglQnT10+jNK6ZrZWe8lJtpGb7IiGRgAFKQ5euWYUd775NXN3zvAZWJTCH87oE93xLdtj54Fz+3PFk/PZ8zM+gwH+ek4/st02zCYjPzuuc8KlbD89rhNJNjNpSVaMBoj3WaHZaCDNacFoMERnTcVjNhowGFqWgSUSCkeo9QaoavTx2OeJ+yQ9MXsDAwtTqGzwJ9w590/vr+TYbpnkpThYvKWGB6etiRlvDoS5/vlFfHjjsXTLcdPkD/La4u387q3l0XNW72jg9cXbePYnw6OvZ+ubA3z6TRl3vrU82jeqY0YSfz9/AL1yPdHgp8kfbNmYZcFWNlY0ckzXDI7vkUV+iqNVk+2y+mbqm4Mt4ZLTutc+WiJyYOx3RNu3b1/uuOMOcnJyOPvss3njjTfw+/e+q4DIkSzbY+dPZ/Ul3sYQv5rYnQxXyzr2x2dvSLht6z+mr6G+eff69coGH9+U1jFzdTkrttdSXp/4RYGIiIjI0chsMsYNg3bJcNvok5/MhD45DChMjQmDAIxGA91z3PznksHMvHUsM24Zy9TJQ+mTnxwNJIxGA8M7pfP+jcdy3pAC+uYnc/agfN6bMoZju2VGz+ua5eK2iT3YM8sxGuCXJ3ene7a7pZ4kKxcNL4pb66Uji8lw2UhNsnLx8OKE39OlI4tx2y0kO/cedrhsZkJhqGtO3E+p1hsgGA6zpaopbkgFUOcNUt3kp6bJz8PT18Q9JxKB5+ZtJhQKU9Hg54/vrGh1TiAU4ZaXl1K2c4felSX1THlhSUwT8Q0VjZz/3y/ZXtNyji8Q4tNvyhn/4Gf897P1fLRiB3e+uZxTH57Fmj2amDf5g3yxtoLz//MlJzwwk7H3z2DK84vZWNEYU4M/GGJTZSNPz9nIPe+u4JOVOyipjd/WoarRz5aqJrbXeGn+jpldIu3Zfs8Qevjhh3nooYeYNm0azz33HJMnT8ZkMnHOOedw0UUXcdxxx7VFnSKHjNFoYHSXDN64djR/n7aalaX1FKY5uPGEbvTJ8+CwmqlvDrC+vDHhc2yqavll5LZb2Fbj5frnFrF4jzXvPXLc/PfSIdFPs0RERERk36Q4rXEbLO/isJjonuPm92f2wesL4bCasH2rJ06K08rFI4o5uXcOy7bV0tzczJDOWWS67bhsLW+ZXHYLU07oRobLxmOftyxV89jNXH1sJ84fVoRz53njemTRL9/D0m2xS9CGd0yL9mnKcNnometmZUl9q3rHdM0gLcmK02rihB7ZCWf/nNI3F6fVjNO29/4+VpMRXzDMtpr44QnAuvIG/OEw68sbEu7wtrmqieqmAFazkfs+/CbuOU3+EO9/XcJPj+tMWb2Pm15a0uoD01pvgF+9upTHJw8lNcnK6h0NXDR1bvS8SARmrC7n3P/M4fVrR5Of6sAfDDFnXSVXPrUgWt+jn2+gINXB81eNoHDna+jmQIhvSuq4663lfLW1FpvZyI8G5nP9CV3JT9m9w5s/FGJHrY/Fm6spqW1mUHEqxenOuEveapr8NPpDmAyQ7rJi0e7CchT5Xj2EjEYj48ePZ/z48TzyyCO8/fbb3HPPPUydOpVQSAmsHH2SbGb6F6bw8AWDaPQHsVtMMT2BHBYTA4pSWLCpOu7j++R7SLKZqW3y86tXvooJg6BlW9NrnlnI01cMazXNOhKJEIkQ3elDRERERPafzWzCFqd58i5JNjNJNjP5yVY+/fRTCpILsVhi3y5lum1cO64LPx5SSHMghN1iImvnsrNdcpLt/PfSoSzYWMVz8zZjNBi4eEQxg4pSoj2YMlw2/nPxYH7y9AJW79g9W2ZgUQp/PrtfNOC6bHQHXl24tVWfpGyPjRN6ZGEwGMhNdpDitMTM1tmlV66HtCQrVrORvnkePknQt2hYhzTse/m72cVgaFlmtmpH6yBrl/kbq7jimI6s3lEfd+c2gMWba6hu8mM0wF/eXxl3ln1ZvY+5Gyr5UWoBZXU+rv7fwlZh1dZqL79/ZzkPnjsQl93Mmh31nP3InGiPJF8wzPPztzB3QxXPXTWcnOSWcGnBxmouf3J+TH298zw8dukQcncGR82BEGt21PPHd1cwd0M1LpuZi0cUMXlUh+hOcbA7XFq2tYayeh8Di1LJT3GQ4W69dLKmyU+TP4TR0HIPqKeSHGo/aOuj0tJSXnjhBZ555hmWLl3K0KFDD1RdIocll92My976n43ZZOTCYUX8b86mVr/4jAa4flxXnFYz62obmLW29Y4ZAMu311HZ4I8GQhX1PtaWN/Di/C1EIhF+PKSQbtkuMvfSrE9EREREfjivN/FsGovJSN4es03iyUm2c1r/PMb1yMIA0dlDeypKT+LZnwynrM5HWYOPHI+dLLct5sPBolQnb1w/mvs/XMVHK3ZgNho4Y0Ae1x/fNbrLbbbHzqOXDOHiqXNjXoemOi08dP6A6PP9/KRu0V119+S0mpg0IA+DwUDnTBcWk4FAqHVC0zEjiRSnBbPRSGGqk+Xe+E24e+S4sZiMeP17nygQDEdo8ocS7hQH8Mk3ZfxoUAErSuoShkvTV5ZR2egjFAlzz3sro2HQntZXNLJ8ex05yQ7K6nytwiBoeS3+t49X8/sze+OwmFm9o56z/vVF9PkafEEembme2WsrmDp5KFkeO/5gyw51Vz61IOb5hhan8o8LB5KzMzjyBkKsLq3nD++uYMHGajwOM5eN7MBFI4pjlkL6AiF21LfMXKps8DO4OJX8VAcZcfpyVTX6aPKHMBkMZLg1c0m+n/0OhOrq6nj11Vd57rnnmDFjBp06deLCCy/khRdeoEuXLvv1XJ999hn33XcfCxcupKSkhNdff50zzzxzr4+ZOXMmN910E8uXLycvL49f/vKX/OxnP9vfb0PkgCtIc/DsT4bzi5eWRLepz3Lb+MvZ/eiQ0fILu/Fbn+58W423pR9Xeb2P37y+jI9W7IiOvbFkO2O7Z/LXs/vtdYcPERERETk8JMUJgvaU6baT6bbTO8G40dgS0tx3Tj9+2xzEAKQ4LTisu5/XZDQwoDCFj35xLDNXl7O6tJ7BHVIZ1iEtGhoBdMlyMXXyUG5/bRmlO3sBdc1y8bfzBkQ3SclwWbl7Uh9uf31ZTB1Wk5H7zukXXVL1ixO78ZOnF7Sq12w08KNBBQD0yvMk/L4LUh0kOywYDC2zrrZWxw/gOqS31FXdlLhnbTjS0uOoydcSziTy8YodnNAzm6VbaxKGS28s2caUE7ritof5/Tsr4oZLy7bVsa68gSyPndI6X6swCGD+pmr+M3M9t53SE6vZyIrtdfz4kS+ivZ7qvEEe/mQtc9ZV8q+LB5HpttMcCDF7bQU/e2ZhTCA3vGMaD18wMBocNfqCfL2tlt+/s4Ll2+tw2cxcOrKYS0d2ICd593uERl+Q8nofM9eUU9Xg55iuGXRId8b9cHlHXTONviCd+w4hEIpgUT/vdmO/A6Hs7GxSU1M599xz+dOf/vSDZgU1NjbSv39/Lr/8cs4+++zvPH/Dhg2ccsopXHXVVTzzzDPMnj2ba6+9lszMzH16vEhbsppMDOmQxis/G0V1k59IpGWHsmyPLbqLgsduSbg7BezelWPJ5uqYMGiXGavKmbehitP650WPeQNByuv9NPqCJNnMZLqtOCw/aPKfiIiIiBxGXHYLrgQ74gJYzEaK05O4dGRSwnOcVjPjumfyxnWjqfH6MRlatorfc/aJw2rm9H659M7z8N/P1rOpqpFBRalMHtWBwrTds6IGF6dy6/juPDhtdXQZl8du5p8XDor26slw2Zg8qpinvtgUU4fBAPec2Ydsj51IJMLPjuvMHW983apegwHOHJgPQL+ClITfV36KA7fdTCQCyQ4L1XGWzgHRQKV0L5u5BEIRAqEwjb6WZWWJTF9ZxsjOGSzcWJUwXHp+/mZ+MqYTDquR3721PO7r//mbqtlc1USm286OumZ+GmdZ3NwNVTw5eyM3je+KxWRiyZYaLnpsbnS8wRfkXzPWsWBjNf930SAy3TaafEE+XF7KzS9/FZ0R9vfpaxhSnMo/LxwUDY5qvX7mrKvkj++uZGu1F5vZyLlDCrl2XOeYZXF13gDbary8sXgb1U1+TumbS89cT6tG74FQmLI6Hw2+AHaLiXSXLdqD69t8gRChSASnVe9bDqX9/tt/8803OfHEEzEaf/h6x4kTJzJx4sR9Pv+RRx6hqKiIhx56CICePXuyYMEC7r//fgVCctjI9thb/XDcJcNt5ayB+by6aFursXHdM0lPstLQHOTx2RsTPv/jszcwpmsGyU4rO+qaeXjaGl5auKUlzTcZOHdwIVNO7JqwBhERERFpnwwGAznJ9piZJN/mdljoX5jC/ef2w+cP47SZsH6rv1BqkpXLj+nA6QPy2FbdhNVsJDfZEdNPyeOwMOX4rgwuSuWfn66ltK6Zfvkp3Hpyd7pmu6L1nNw7h/kbqnjzq+3R5zcbDTxwbn/ydoYS2R4bJ/bMYtrKslb13nl6L7I9dkKhMJeP7sDfPo6/m9rp/XMBGFiYkvB7L0h1kGQzE45EcFpNNCVY9paW1NLjadeOavE0B8IEw2EafRGWbatNeN5nq8sZXJzGrDUVCRt6Pz1nI5eMLMZqMnLXW8vjnjNvYxVbq5vIdNsorWuOCYN2WbCpmv99uYmfn9gVi8nI7LWVXPvsoui4Lxjmf19uYkVJHf+5eDAZbht13gDPfLmJv364KnreSwu20ivXzdTLhkaDo6oGP68t3srfp62h3hfEaIDxvXL47em9Yhp6Vzb4WLWjnidnb6TRH+SMAfkc0yXjO5dhStvY70Bo/PjxbVHHPpkzZ06r65988slMnTqVQCCAJc7cNp/Ph8+3OwWuq2tZ6xoIBAgEEm/juD92Pc+Bej45etmMcOvJ3TEbDby6aBvBcASjoWWXiN+c0pMki4F6XxDvXrbHbPKH8AdD1DT6uPf9lbyxePcvz0AowrPzNtPgD3L36b1Isu4OboPhCDXeliVrKQ4Le9nldZ/ovpf2SPe9tDe656U90n3fwgyYrQaIhAkEWs+CsRgg120h150cPRYJhwiEd7+O9diMTOydxYhOaQTDERwWIy6rCYhE/35T7EbuPK0n14zrzOJN1bjsZvoVpJDuNGMxtpznthq558w+9MvfwtTZG6n1BuiW7eKOU3vSL98Tfa5zBxcya00l8zbGLh2796w+ZCZZCQQC5KfYGVSUErd30W9O6Umaw0QwHOGCYUVMnbUh7t/N+N7ZBAIBhnRITfj3V5zuxG42EghHsJmNCWcSpTitBINBtu9lF7hGf4hgKIwvGGJtWUPC875cX0nfPDcfLS+N26gb4OkvNnLR8EIMwB/fWRH3nIWbqtla3USy3cj2Gm9MGLTLipJ6npmziRvGdcZgiPDGkq388d2V0fFwBD5YXsqW6iYenzyENKeZWm+Qv3y4mpcXbo2eN3ttJcXpTp79yXCyXVqrdiDsz8+ufQqEBg0axPTp00lNTWXgwIHR5S/xLFq0KOHYD1VaWkp2dnbMsezsbILBIBUVFeTm5rZ6zL333svdd9/d6vhHH32E03lgt/j++OOPD+jzydHJYDDwo45FXDx4IN5gyy/G5uoyFnw+jXA4TGpqGhN6ZrFkS03cx0/olcmqZYtJzu/Em0u2xz3nra+285MRuaz/ai4Oh4PCHgN4cXEp7y4rAwNM6pvNjwdks2nlYpqbE3+ysS9030t7pPte2hvd89Ie6b4/uAwGA1lJSYRqQyzZGD8cGZSZybiLemIwmQh4G6ncvJSZKxuj4yaTid+M60V9pIgv1tfgcZgZ3TGF+h1bmTFtCQBms5k/nTqYpxfu4NVF2/EFwxSmObj1xM6kBcp57715GAwGfjxgGHPWlbOiJDaA+d2p3SnbtIblc7bQqdcAemS7+GZH65Dm1hM7s3zhHJzuZM7on8NLC1u/bjcYYEi+k2nTpjEwP1EnKeiW7aKyrASLzZmw6TeAywLLli1je03iBtP1viBVVTUEIrC9NvH7gHnry4hUbuS9rYlDmmfmbmZCFycRjDz8ydq45yzfXsf6HdUsXr8Ud4d+MWHQLpsqm3ji83WckNVE+Y7ShNeTfdPU1LTP5+5TIHTGGWdgs9mi/39vgVBb+/a1Izujz0Q13Xbbbdx0003Rr+vq6igsLGT8+PF4PIkbne2PQCDAxx9/zEknnRR3lpLId8pPhz49o192bgjw9NytrX5IZ7ltnDOkmGx3F74uaUiY/EciEDDYOOWUU9hRH+CcR+ZEmwcCTP1iMx+uLOeFq8e0SuL9oTBefxiH1YTVlPjfuu57aY9030t7o3te2iPd90eKTOjaIeHoiC7Z0feK5KcB/WLG78hO45qxXaIzl9KdFiAP+u5+Tf745KGsKWtk2sodZLhsTOybQ6bLitNihAF9AZh6WSZ/+3g1b321nUAoQkGqgztO7cnwDqm4bC0TFgq7BFi0pa7V7J6/nt2P4qwUeuSfQEVjkM6ZLtaVtw6XfntaL/p0SMEXDHPmgPy4oYrJaODY7rnkJRdT56zm6S+3xP17GViUQm5WGo2+0F7DpYJ0D317duaF9fFnEUFL4+q09Awa/SFqEvRuAthUE+ScE0/kN28mfq7XlpTwkynHMHTwoITnyL7ZtSpqX+xTIHTXXXdF///vfve7/S7oQMnJyaG0NDYxLCsrw2w2k56eHvcxNpstGmbtyWKxHPAf8G3xnNI+5ada+H/27ju87fL6+/hbew9Ltrxn4tjZe282AQqUPcNeBcooLZTuQaHtj7aUvcuGsncIYYfsRfZOHO89tOfzh2zFiiQDT5nhvK6rV8HfW/ItRTjWR+c+57nLpvLo4j28uKaOaCzG8aMLuGhmBUWOeGVbpgZtfcx6NUqVmlfX7U0Kg/rUdvhYuKmJ86aVoVAocAfC7G7xcO+HO9nZ4qY638KlswZR5jQmTbI4kLzuxQ+RvO7FD4285sUPkbzuD24aDRj12gHX5Nk15NmNzBySk3FNYZaGP54wgmsOG0IoEsWkU6f08izM0vDEhZPZ0tjNos1N5Fr1HDUin3ybPjGJLt+u4bELJ/H3BVt4bV0D4WiMMqeR3x43nDHF9t7XI1xz+BDW7OtMCpeUCrjzjLHk2vRoNCqq861U5prZfkDlklIBvz5mGE6zHoM2zI9GF/LC6tRwSa9RMrLQhlqtZt7IPJ5dkT5cmjUkG6tBQzTGgOFSYZYBlUqV8dgcQDgSA4VC/pv7CnyZ5/BL9xCqqKhgxYoVKQFMZ2cn48aNY9euXV/2Lr+wqVOn8tprryV97Z133mHChAnywhEHnaIsIz8/qoqLZlYA4DBpkhr6Oc1aRhfZWFeb2qRuVJGNbLOWLl+Q1z5Lf6wM4OU1dZw4thCjTsV7m5u4+pm1iWtbGnt4dW09D547gTlVLpTK/dVC0d5+RIUVVd9qxaAQQgghhBDfNqNWjdEx8Fvrvmbec6pcGdcU2g38+cSRXHd4FeFoDJNWhevAcMlu4MkLJ7OtuYdPtreSZ9Mzt8pFrk2PXhN/r5Br1fOf8ydx13s7eH51LYFwlBGFVn533HCG5lsSe77+iCFsbuxmU/3+ihKdWsnD8yeS1/t9q/OsjCiwsqE+uepEp1byi6Oqseg1qFUKfjy2kGdXpoZLWUYNg3LMKBQKThpXyMtrUofrABw9Mo8s48ABnfjqfelAaM+ePUQiqQ1vA4EAtbWpL4CBuN1uduzYf9Zw9+7drF27FofDQUlJCTfddBN1dXU89thjAFx22WXceeedXHfddVx88cUsWbKEhx56iKeffvrLPgwhvhe0ahV5tvRngB0mHf8+cxwXPrqC7f0+Iah0mbnzzHE4TDq6vEH06sxniA1aFSqlgpbuADe9uD7lejQGNzz/Ga9fNYP83s7/9Z0+XltXzwura1ErlZzpNnDYsNwBp1UIIYQQQgghPt8XCZdybXpybXpmVmauXCqwG/j1ccO44pDBRKIxzDoVDpMuZc2j509kb5uX1Xs7cOgVTK7MJc+qR9M7gSbXqueB+RN4YmkNTy7bi9sfZnZVDjccWUV5tgkAg0bNtYcPoabdy5Jd+xt6O01aHrtwEvm97xOq8ixMLnewbHdy02+7UcMVcwcnAi3xzfnCgdCrr76a+OcFCxZgs+3vJh+JRFi0aBHl5eVf6puvXLmSuXPnJv69r9fP/PnzefTRR2loaKCmpiZxvby8nDfffJNrr72Wu+66i4KCAu644w4ZOS9+sEocRp68eDKNXX7qO/0U2OOfPLgs8R+6NqOW86eXsaZf5U9/508vx6LXsKPZjSfDWM02T5A2T5B8u4H6Th+n37+Umvb9jcp+9coGnl5Rw0PzJ5BnSx4X2dITIByNolUpcZpTj24KIYQQQgghvh56jSpp5Hs6Lkv8vcOYQgsffPAB+ZZiNAd8oJxvM3DtYZWcM6WEGPHWFRZ98gmdPJuBO88cR3NPgJ3NbnIsOoodRvJt+sSJApdFzx1njGXR5mYe/XQ33mCEo4bnce7UUoodX+3AJ/HFfOFA6IQTTgDizZvnz5+fdE2j0VBWVsb//d//falvPmfOnP2NvtJ49NFHU742e/bsr3WSmRDfN30/xEcVpb8+pcLJzMHZfLyjNenrh1S7GFdi/0LfQ6GIHxN7ZW19UhjUZ2N9N8t2t3P8mEIA2twBPtzWwr8WbWdfu5chuRZ+cVQ140qzsBnkeKcQQgghhBDfNQNNp1KrlCkf/h7IadbhNOsYmp95eFOuVc+Zk0s4cngukWgMuzG5LYb4Zn3hQCgajTeAKi8vZ8WKFWRnZ39tmxJCfHVcVj23nzaaLY09PLO8BoVCwZmTSqjMtZBjiVftuCw6zDo17kA45fbZZi0Ok5Z2bzBt07k+zyzfx6FDXShQ8ODHu7nnw52Ja1saezj/0RXcdtJIThpXhFoVL0GNxWI0dfvp8IZQKRTYTZpEdZMQQgghhBDi4CSnB74bvnQPod27d38d+xBCfI1yLHpyLHqmDXKiQJHUIBogx6rjtpNGcuXTa5JG2SsV8PdTRpNr0dPhDaIcoH+0UglKFLS4A9z/cfrm8n9+YzMzKnMotBvwBsIs2dXGTS+up7knAEBFtol/nDaG4QXWRGgkhBBCCCGEEOKr96UDIQCPx8OHH35ITU0NwWAw6drVV1/9lWxMCPHVUynThyxalYo5VS5ev2oG93+4ix0tboblW7loZgUlTiNKpQKHScsZk0r4/Wub0t7HOVPKMOrU1O3rJBJNfxS02x+mwxOk0G5gZ4uHix5bmRRA7Wr1cNr9S1hwzSxKnfEmdZFojPouH2tqOtnd4mZ0sZ2qPAv5n1OyKoQQQgghhBAisy8dCK1Zs4Z58+bh9XrxeDw4HA5aW1sxGo24XC4JhIT4njLp1AwvsHHbyaPwBSMYtKqkTv8KhYKjR+Tx7Ip9bGnsSbrt5HJHoh+RXjvwGWCtWkmPP8Q/391GuhZi/lCUF1bX8dNDK1EA6+s6OeuBZUlNrwtsep66eAplvZMN+vhCYTq9IRRAtlknVUZCCCGEEEIIkcGXDoSuvfZajjvuOO655x7sdjtLly5Fo9Fw9tln89Of/vTr2KMQ4huk16gyjnzMsxl45PyJfLqjjWdX7kOlUHDO1BLGlzpwWeO9f/KterKMGjq8oZTbV7rMOExavMEIG+u7M+5h5Z52AuEInd4QFzy6MmUCWn2XnxueX8cD507AbtQSjcbY2+7lzve2887GJnQaJadNLOGsySUUfM5kBSGEEEIIIYT4IfrSH5+vXbuW66+/HpVKhUqlIhAIUFxczF//+ld++ctffh17FEJ8h+TbDJw0voj7zx7HdRONHF6dQ651fyNol1XPveeMR6dO/vFiNaj59xljyTbr0GuUFGZlDmoGu8xoVUrqOn20e4Jp16zY05G4VtPu5fg7P+GF1XX0BMK0uoPc9f4Ozn14OY1d/qTbNXb5WLW3g7c3NLK5oZs2d+D/96kQQgghhBBCiO+tL10hpNFoUCjinWVzc3Opqalh6NCh2Gw2ampqvvINCiG+m0xaJfU1uxkzYmjS11VKBeNKsnjn2lks2tzM5oZuJpRlMW1QNkW9IZDNoOWawyo556HlKferUMDZk0tRq5R0+VKrjPrzh6L4QxHu+3An3f7UCWk7mt2s2tvBMaPyAdjW1MO5Dy2nsXt/SDSp3MG/Th+T0pPIGwzT5QuhVCjINmlRyfEzIYQQQgghxEHkSwdCY8eOZeXKlQwZMoS5c+fym9/8htbWVh5//HFGjhz5dexRCPE9o1EpKXWauGBGecY1Iwtt3HhUFX9/Zxvh3ibUBo2K208dTZEjHs6UH9AjqD+rXo3NqKHTG2Lh5qaM615aU8vhw3Jp9wRSwiCA5bvbufXNLdzy45GYdGoi0Rg1bR7+/d4O3t3ShEGj4qzJpZw6oYg8aWQthBBCCCGEOEh86UDolltuoacn3lD2j3/8I/Pnz+fyyy9n8ODBPPLII1/5BoUQBye7Ucu508qYNzKfPW1eNColxQ4DLosOrTrewyjbpOWEMQW8vLY+5fbXHTGEXIuOdm8wY88jAItejUoJ+zp8KWFQn9fXN3DdEUMw6dTsbfNw3L8/SfQt6vaFuX3hNhZsbOTh+RPJtcWPx4UjURq7/ayv7aK2w8foYhtlTlOil5IQQgghhBBCfJd96UBowoQJiX/OycnhzTff/Eo3JIT44TBq1ZQ41ZQ401cC2YxafnnMUCpyzDz4yS66fWEKbHpuOLKKOdUu1Col2SYd504t5ZY3t6S9j7OnlKFSKmnKEAZBfLS9LxTBGwxzx3vbU5pYA2ys72ZDfRe5Nj3hSJS1+zo59+HlePutHZJr5pHzJ1F4QCPrpm4/Pf4wGpWCLKMWq0HzRZ4eIYQQQgghhPjafOlASAghvkkui54r5gzi5PFFhCJR9BpVUhNrpVLBj0YX8ub6Rtbu60y67dlTSinPNgJQniF0AjBpVZh1arp8IRZtas647qU1dcytctHU7ef8R1YkhUEA25rc/PmNTfz15FGYdRo8gTAr97Tz61c2UtPuBWBmZTZ/PH4EZWmOw3kCIQLhKGadOlElJYQQQgghhBBfhy8UCI0bN45FixaRlZXF2LFjE02l01m9evVXtjkhhABQq5QDjo/Ps+m575zxbGno5oXVtRi1ak6fWEyJ04TDpAUg16ZnTLGNtfu6Um5/yaxBuCw6Orwh9FoVPYHUBtUQP36mVCrY3uzOuObtDY3ceHQ1Zp2GzQ3dzH9kRdL1j7e3ctr9S3jpiumJx9ThCbKlsZt7P9xJc0+AaYOcnDOljKIsA2ppZi2EEEIIIYT4GnyhQOj4449Hp9MBcMIJJ3yd+xFCiP8vuVY9uVY9s4bkpA2ts8067j5rPH98fRMLNjYSjYFRq+KSWRWcNaUErVpFtknBWZNK+Oei7Wm/x+kTSwBoGWBUfTQGgVCUDk+QW97anHZNU3eAlXva+dGYQnp8IR5ZvJs73tuRuL65oYenlu3jhcunMazAmvh6mztAfaePZbvbyTJqmVCWhcuqxzBADyUhhBBCCCGESOcLBUK//e1v0/6zEEJ81wxUwVhgN/DXk0fxi6Oq8YUiWPTqpCbWKpWS0yYVs2BTI5sbepJue8H0Mkoc8eNnw/KtKffdJ9usxaxX4w9FWJemGqnPR9ta+dGYQlrcgaQwqI8vFOHml9fz8PyJZJm0NHX7+dlz6/h4R2tijUqp4I7Tx3JIdQ4G7f4f523uAO2eIP5wBLtBS45FN2DjbSGEEEIIIcQPj/QQEkL8oFj0Giz6zE2d820GHjlvEhvqu3hpdS1mvYYzJ5VQ4jCS1Xv8LM+qZ/ogJ4t3tqXc/hdHVZNr0dPqDuCy6GjoSt/MutQZD5dW7OnIuJc1NZ10+kJY9WqeXVGTFAZBvBn2VU+vZtH1synPNgOwu9XNlU+tYWN9NwA6tZLLZg/i3KmlOM26pNu3ewJ4AhFUSgXZZh1atRxPE0IIIYQQ4ofiCwVCWVlZA37q3l97e/v/tCEhhPi25dn05Nn0HFLlQqFIrTpymnXcfuoY7vlwJ8+sqMEfipJv03PjUdXMrspBqVSQY9Fx2exB/PbVjSn3r1TAMaPyv9BeFECLO8jDi/ekvR6NwTsbm7h0tpmGLh9n3L+Mxn4T1QLhKP9atB2HScs5U0pRKhV4g2E21HXx+9c2sbG+G4NGxWkTi7l0VgX5aXo1dXqDhCIxrAY1Oml2LYQQQgghxEHhCwVC//znPxP/3NbWxp/+9CeOPPJIpk6dCsCSJUtYsGABv/71r7+WTQohxLdBqcwchOfa9Pxy3lAunllOMBLDoFGRZ9s//UyhUDBvZB6r9nbw6rr6xNe1KiV3nDGW/N61E8uyMn6PsSV2bAYN3lCETm8o47r6Th8A25p6ksKg/u5YtJ0jhueSbzOwsb6b0+5fSiwWv+YLRXj00z2s2NPOI+dNxNU7xa21J8Cy3e3c/9FOOrwhZg7O5qJZFRRnaHYdCEdQK5WoBnjehBBCCCGEEN8NXygQmj9/fuKfTzrpJP7whz9w5ZVXJr529dVXc+edd/Luu+9y7bXXfvW7FEKI7yCtWklhljHj9RyLnt//aDhXzh3M2tpOLDo1IwptST19si06fnpoJf86oJG1QaPizyeMJMukJeYJMrrIxrra9D2JZg3JAWDLAX2P+mvzBPGHorR7Avzu1Y2JMKi/jfXd7Grx4LLqafcEueXNzby4pi5x/cnlNby4po6XfzKNqrz9fZTqOnx8tK2FBZsaybXqOHtKGSUOAzaDNuN+hBBCCCGEEN+uL91DaMGCBdx2220pXz/yyCO58cYbv5JNCSHEwSLLpCXLpGVIniXtdatew3nTypha4eTej3bS0hNgaoWTs6eUUpQVP77lMGn59bHDOOW+JSlBTqnTyPDeSWSDcswZ9xE/7qXEE4gk+gul89H2FqYMctLQ5UsKg/r4QhH++Ppm7j5rHFaDhr1tHk65dwnNPfsnrz27opZfzhvKGZOKE/2avIEwjd1+3tvSTKs7wJwhLipyTIlqJCGEEEIIIcQ360sHQk6nk5deeokbbrgh6esvv/wyTqfzK9uYEEL8UGSZtEwZ5GRUkY1AOIpZr0KjSu7VMyzfypMXTuY3r25kR7MbtVLBMaPyueHIKvJs8eBoWIGVLKOGjjTHyy6eUYHLoqO5J4BBo8IXiqTdS44l3nj6gy0tGff7yY5WunwhlEq49a0tSWFQn1ve3MyhQ11Y9Bq8gTBvbmjkhufXJQKtez/cxYgCKw/On5DYP8SPqdV3+Vhf24XLqmNovpU8qz7tETUhhBBCCCHE/78vHQj9/ve/58ILL+SDDz5I9BBaunQpb7/9Ng8++OBXvkEhhPihMOrUGHWZr00bnM3TF0/BHQijVipwmrQYdft/jOfb9Dx98RQu/M9K6nr7CikUcPqEYk6fVIJapSTbrOWMScVpm1QrFDCnygWAWpW5D5BSEV/b6QmxYGNjxnUfb2thUI6Zxm5/UhjUZ0N9Nw99spsbjqxCq1bR0OXjqqfWsHLv/slrRq2KR8+fxLgSeyIUCkeiNHX72dPmxR0IU+kyk23WYTVknh4nhBBCCCGESPalA6HzzjuPoUOHcscdd/Diiy8Si8UYNmwYixcvZvLkyV/HHoUQQvTKsegSVTwHUigUVOdbefGKabT2BHAHwuRa9TjN2sTRLa1axSWzBrFiTzvr6/YfHVMq4B+njSHXGr/vQ6pd/OWtLWm/zxHD8sgyamjzhIim6UXUp68K6d3NTWl7FgE8uayGC6aXk2XSctd7O5LCIABvMML8h5fzznWzKM4yEgxHWL67g8ueWIU7EE6sO2NSMdcfUUW2ef9z0+kN0uYJUt/hw2bU4LLokxp/CyGEEEII8UP2pQMhgMmTJ/Pkk09+1XsRQgjxFci16skdoDdPnk3PQ/MnsrvVw0fbW8kxa5lT5cJl1WHUxv9acFl1/GTOYO76YEfSbR0mLb84ugqTTkMwEmNcqZ3VezvTfp9ZlfFm161pjpT18QYjRGIxWt0B/ruqNu0aXyjChtouirOMNHT5Of/R5YQiyQnT08v3MbzAxlmTS1AoFDR3+/ndqxt5c8P+CqZCu4GHz5tIVb9+TpFojKZuP83dfvzhKAU2PdlmXVLllRBCCCGEEAej/+k3Xp/PRyiU3KvCarVmWC2EEOK7wmXV47LqmVyRvvebzaDlopnlzK3O4aFPdtPmCXJotYtjRuZT5IhPVssyavn9cSM46Z5PCUaiSbc/ZmQe+fZ4KDWnysX9H+9O+33GltgxadV0eIMEwtG0awAauvxAvNrowDCoz13v7+DwYblkGbXc++HOpDAIoK7Tx9kPLuPVK6eTbzcQjERYvbeTy59Ylei7pFYquGLuYM6bVorDdEC1kTtIQ5ePguGTafOGyLPJETUhhBBCCPH99aUDIa/Xy89//nOee+452traUq5HIukblQohhPh+yTJpmWByMLLQRigSw6hVoVQm9xaqyjfz+tUzuGPRdpbuasNu1HLprArmVLkSgcpgl5nhBdaU6WZKBfz6mGFkmbQEIvHqnPre4OdAo4psAOxo9mTcb0OXn0g0RnOPn6eW16Rd0+IOsLPVQ77dQEOHn3MfWp4UZoWjMe5YtJ0huWaOHVUAQFO3n1+/vIF3NjUl1pU6jTw0fyKDXfsnuwXDEZp7AtS2+/CHI5Rnm3CatJj1EhwJIYQQQojvni8dCN1www28//773H333Zx77rncdddd1NXVcd9993Hrrbd+HXsUQgjxLdJpVOgyZBpalYohuRZuO2kUPf54s+vsA3ocuax6Hpw/gQc+2sUzK/bhDUYYW2Ln18cMY2hBvKo0z6rnxnlDufrpNSnfY1iBlVJnvCppSoWDpzOEPUPzLejUSjq8IfyhzNVGNW0eGJzN2xsbUyqb+vxj4XYmlzsx61TcsWh7UhgEsLfNyzkPLePFK6aRbzPgD0X4dEcrVz29Bk8w/sGIUgGXzxnMhTPKkqqNWnoCNHT52NHsJt+mp8xpIt9uQAghhBBCiG/Slw6EXnvtNR577DHmzJnDBRdcwMyZMxk8eDClpaU8+eSTnHXWWV/HPoUQQnyHmXRqTAP03cm3Gbjx6GoumllBNBbDqFXjMGmT1syqzOZfp43hlrc209QdQK1UcNzofG44spocS/z42YRSB9lmLa3uYMr3+OW8oTjNOgLhKFaDmm5fOGUNQGVuvIfQxvqujPvd1+4lHInS6o7w35Xpexs1dPnZ1+4j32agrtPHxY+vItKvy3Y0Fj/GNrzAyryR+QDUd/q45PGVbOjX0DvHrOPxCydRnb//yLXbH6KlJ8DinW34QxGmDc4m36on64DnTAghhBBCiP9fXzoQam9vp7y8HIj3C2pvbwdgxowZXH755V/t7oQQQhw0tGoVBQNUwtiNWn40poDJFQ48gQhatRKnSZvU4Lkwy8Czl0zlZ8+vY01NJwDZZi2/PnYYo4vsALgsOq6YM5hb00xJq8g2UdLbA2lCmYNX1zWk3UtlrhmdRkmPO5ixigigrsML5Q5eXF2bFAb1d8ei7Uwud6BVK/n9axuTwiCIH2M79+HlvHLldPJtBrp9IZ5buY8/vbE5ad0JYwq4+ZhhiSlzsViMuk4fS3e1s3x3G1V5Fg4bmku+XY9WpUrZhy8UJhYj0ThcCCGEEEL8sH3p3worKirYs2cPpaWlDBs2jOeee45Jkybx2muvYbfbv4YtCiGE+KFQKBTk2QY+PjXIZebh+RPp8MbDGptBQ65Fn+hvpFYpOWV8Ed5AmPs+2pVoVj253MHfThmdmMA2t8qFRbeVnkBqJdEvjqrGYdLhDUYwalV4g+n745VnmwhHo2xvcmfcb12Hj2AkSo8/nHL0rE9zT4C6jni1UU27NyUMAnh5bT2zq3I4cWwRANub3Zx63xI6vfuHO9z21lYeu3ASE0qzUKuUALT0+Flf28VjS/YSikY5dUIxk8ud5NlSJ9H1+EN4gxEMGhVWg/Q+EkIIIYQ4mH3pQOj8889n3bp1zJ49m5tuuoljjjmGf//734TDYW6//favY49CCCFEkiyTdsDjU06zjp8cMphTJhTT7Q+h16hwmrTYjftvU2g38MylU7jqqTXsao03q7bq1dx8zFBGF8ebWLssOi6eWc6/Fu1I+R6VLjMFWQbUSiWTK5wZw55hBRaMWhWd3hCx9EVEALS6g0QiUR5bsifjmns/2MWsyhwArnlmbVIYBBCMRLnk8ZW89dNZFNoNtPT4ueH5z/hga0tizeIdbQzNt/DIeZMSoZA7EGZHUw//eHc7Wxt7KHUaufrQSkYU2rAdEAy5AyG6vCFigM2gwSJNs4UQQgghvpe+dCB07bXXJv557ty5bNmyhZUrVzJo0CBGjx79lW5OCCGE+P+lU6so7j0elo5SqWB4gY1nLp1ChydEKBIly6Ql16JLVNdo1SrOnlKGLxTl0cV7EsfHplY4+OvJo3H19jY6Ylgu/1y4LW210Q1HVmMzaOnxhzFpVYmm0wcqcxoJRWM0dQcy7rndEyQcjdHtC7GpoTvtmm5fmPpOH4V2A+tru5LCoD6bG3p4c30D508vIxqDj7a1cMWTqxPXG7v9nPXgMn73o+GcPrEYvSZ+BG13q5vb3trKO5saiQFzhuRw8zFDqcg2J02g8wbCtLgDeAJhTDo12WbdgD2mhBBCCCHEN+9L/XYWCoU44ogjuO+++xgyZAgAJSUllJSUfC2bE0IIIb5uLos+Eeykk2PRcd3hQzhnSimd3iCxkJ+iHDsO8/7bFNoNPHvpVK59di1bm3ritzPr+MPxw6nOs/R+Hx2XzxnE39/ZlvI9pg1y4rLq0GtUHDbUxYfbUkMcgMkVDiw6NW3uzKERgDcYwR8K89jSvRnXPLmshh+NKSAYjnLzS+vTrvnLm5s5tNpFscPIvnYvJ92zhHbP/obe729tYcWeDl6/egZlThMAzd1+/m/hNl5YVUs4GkOlVHD8mAJ+fmR10jE1bzBMqzvIjt7na3CuhWyzVnocCSGEEEJ8Q77Ub10ajYYNGzagUCg+f7EQ/58aunxsbexhTU0nZdlGJpQ6yLfpE5/YCyHEN02viVcb5Vk0vPnmhwydNy/pulKpYFiBlScvnkxHbxWP3Zjc20irVnHGpBLUKiV3v7+Dbn8YjUrB8WMKuf6IIYnR9HOrXeQs2kHLAaGPVqXk6kMrMerU2I1a7EZNypExiI+7L3MYicUUhCOZz6iFo1FisXjVUUea+wEIhKM0dPkosBt4bV19UhjUxx0I8/iSvfziqCoC4Si3vLWZl9fUJ65HojFeXF2HJxDhryePwmbQ0OUL8sraev7w2ibCvc241UoFvz52GCeMLcBmiB/tC0ei1Hf5eX9LM5/VdjKm2M6cKhcFdgMqZfLvIpFojHZPAIVCgcOoTapYEkIIIYQQqb70x3DnnnsuDz30ELfeeuvXsR/xA7e3zcNZDy6jtsOX+JpBo+KJCycxpiQr5Q2AEEJ8l2SbdWSbdRmvO806LpxRznGjCvAEw+g1qpSqmKIsI89dNpVb3tzEos3NRGMwtsTO7380nDJn/AhcrkXHr+YN5WfPf5byPc6fXobDrMWgVXHqxGI+2dGadi8njCnEYdTQ+jnVRmqlEk8gzLub0/dIAvhgazOXzxmE2x/m1bX1adcs2NjIL46qwmbQsLPFw29e2Zh0PRyN8dtXNzKy0Ma4Ui2xWIwN9V2ccf8yfKH4MbsXVtdh0m7hmUumMLJ3qhxAXaePl1bX8uLqOhQKBadNLOK40QXkH9CgPBSJ0NwdIBCOoteoyLXoUMmHDUIIIYT4gfrSgVAwGOTBBx9k4cKFTJgwAZPJlHRdGkuL/19dviA3vbg+KQwC8IUinP+fFYkmqUII8X2mUSkpzBr4Z1l5tol/nDqWDm+QaCyGRa/B0a+Jtkql5PDhufzHMpFb397ClsYeCu0Grj60kkOrXYlGz5PKshiWb2FTQ0/S/efb9Jw6oQiVSonDpKUoy5DysxfiTbZzrTo0KiVZxsxNvG0GLRqlgk5fiOgAjbM7vSG8gTD3frAz45p7P9zJP08fQ7cvzKWPr0qEQX08wQiXP7maFy6fRq5VT32nj9PvX8K+9v37v+XNLTy3spbHL5yUCIVaevz859M9PLJ4D55gBJtBw0/mDOKk8UU4+4V4vmCYFneQfe1e1EoFhVkGXBYdWrUq7X6j0ZhUIwkhhBDie+lLB0IbNmxg3LhxAGzbltwHQY6Sif9FmyfIpzvb0l7r9oXZ1+aVQEgI8YNh1qsx6zP/NW0zaJld5WJEoY1gOIpKqcBlTe6FlGcz8PB5E3lrQyNPLqshHIly/JhCTplQRGFWb7WRVc8/TxvDWQ8uIxCOJm6rUir4x2ljyLXGj+xeNLOCRVua0+7lstkV2IxazO7UI2VJj0mnxh+Opg2f+uzr8OIPRWh1BzI22K7t8NHuCZJj1vHauvqkMKjPjmY3n2xvjU+a84W49a0tvLC6LnG9yxfilre20O0PceUhleg1Kjq9QV5YXcutb20h1HvczqBR8fdTRjO3OidRyRUMR6jr9PHq2nq2NPYwpcLJIdUuCu2GlHDIGwzT5QuhQIHTrEGjSh8sCSGEEEJ80750IPT+++9/HfsQgmAoOuD1Du/AbzSEEOKHyDnAETWIh0LnTSvjuNEFxGLgMGpSjkmNKrbx9jWzeH7lPtbWdlLpsnDW5BKKHMZE/7aqPDMXTC/j4cV7km570rhCxpVm9e5Fy8SyLFbs6UjZx8hCG06zFrNOzbgSe8YpaeOKszDrNAQj3gEfVzAcpdMX5MV+Ic+Bnl2xj6NG5NHmCfLimvTrHvh4N6dNLKHYYWRTQzd/fH1z0nVfKMKVT6/mrZ/OpDrPSjgSZdnuds5/ZEWi/9FbGxr5+4KtPHvpVIYVWIF45dDedi93LNrOgo2NaNVKTptQzPxpZRQc8OFGpzdImzuIJxjGZtDIVDYhhBBCfCPktw3xnWE1aDI2SQWozDV/wzsSQoiDg0KhGLC3kValojzbxHVHVBEIR9CplCmhkcOk4+pDKzltYjELNzURjsY4fFgu+TZD4jhbllHLP04bw2VPrGJD3f7ApyrXwt1njUuEV+dPL+e5lbUEI8kfBGhVSi6YUY5WrSTHrEOrUqasgXjVjtMc/55qVebqZI1KiQIFTV1+YhmOsgXCUTq9IWyGEHcs2p52TSwGj3+6l98dP4zmniBXPLE6EQb16QmEuebZNTx18RSyzTr2dXg5/s5P6PaHgfjkt/s+2sU7m5p46uLJiaNstR1erntuLct3x0M0lVLBKeOLuO7wIUkVXy09fna3enh7QyNmnZp5I/PJt+sTDbj7a+0JEIpGMWpVaa8LIYQQQoAEQuI7JNei48ajqrnxxdTxx8eMzB/wzYwQQoj/nUqpGHDse3y6mZaqPGvGNUVZRh49fxLNPQEau3zkWvS4rHpyLPt/hhc7DDx18WRueP4zdrd6gHjfpL+dPIpiRzwoybHo+OlhlfxtwdaU73H9EUPIMevQaVScNbmUX76U+vcGwLlTSzHr1VgMA/+6Y9Aq8YciAx5l29HiJhCOUtfhpScQTrtmW5Obdk8Qi17NAx/tSoRB/e1u9bBsVzsnjC2kpSfAxY+tZHO/Hk+RaIxnVuxDr1Fx49HV6DUqmrr9XPPMGpbsak+su+O9HVxzaCXnTS/D3tvfqdUd4MOtLdz1/g4au/2MLLTxi6OqqcqzJFUcBUIRmnsCtHuCqFUKnCYdebbk44Z9FAoF+YWFAz5/QgghhPh+kkBIfGeoVEqOGpGHWafm1re3UNvhw2pQc8H0cs6cXJL4hVcIIcR3W9+0tWH56YMjrVrFhDIHz146hS5viBhgN2pwWfaHEnqNijMnlVDuNPF/C7eyu9VDRY6Znx9ZxcQyBzpNvBfPIdUuRhVa+awu+QjatEEOxvceZcs26yh2GNL2GhpdZMNh0qJTqxiWb80YCo0rycKgVhH4nOPN4Ui84uidTZmnsr28po6jR+TR1O1PCoP6e3p5DRfOKKcoy8DrnzUkhUF9/rloO4cOy8Vu1NLlC/HPhdt4YllN4vqy3e2cdO+nPHLeROZUuYD48bQXV9fx1wVb8Pc+lnybnrvPGsfIQlviiKAnEKau08fzq/axt03BnGg9MytzKOrtPdVfuyeAOxBBpQCHSYthgFBRCCGEEN8d8je2+E6xG7UcO7qASeUO/OEIaqUSl0WX+AVVCCHEwcNl0SeFQAfKMmmZNyqfSeUOQpEoGrUypVo0z6bngfkTWbmnnaeX70OpgHOmlDK62J44cpVr1fPguRM568GltPZrfF2UZeBfp4/FYYrf59WHVrJwc1PK8TKdWsmpE4tRqZSUOI0oFaSdppZl1GA3alEqFPGKnJ70TbEtejVKpWLAiqRAOIo7EKalJ8Aji3dnXPfUsr3ccuJIWt2BpDCoTywGv3p5Q2Iq28q9Hfzh9U1Jaxq6/Jz5wDIWXDOTEqcJXyjCO5uauO65tYnnYsHGRrLNWp67dCoVOfEj3P5QhI313fzu1Y2sr+tCq1JywtgCfnrYkKQhEJFojMYuPztb3LT0BKjOt5Bn1aftfxUMR+nyBVEpFYk/FyGEEEJ8PSQQEt9JB07KOVC3L0Rjt5+FGxvxhqIcNtRFscMox8qEEOIglG0Z+Gd7rlXPMaMKmFvtQoECgzZ1kldVnoVXr5zB9uYedrd6GJJroSLbRJ5tf3BRkWPiofkT+cULn9HSG+aUOIz847QxFPUGHE6zjstnD+auD3akfI/f/Wg4uVY9SgXMn1bK717dlLIG4NxpZWhUSvIzHNMCUCvjoVI0Bt3+9L31ANo9QSKxGBvr0zfphvhUtm5fCLVSwd/THMGDePPsdzc3c8GMclq6A9zw33UpwVirO8hvXtnIXWeNw2bQsK2xh1Pu/TQRjgUjUZ5bWcvKPR08dfFk8mwGwpEon9V2cd4jy5OO0E0f5OT/Th2TOKoWicbY1+7locW7+WBrM1a9hktmVjBtsJOcA0LD1p4AbZ4A/lAUh0lLtjlzVZIvFEatVKKRD5aEEEKIFBIIie+dTm+QRxfv4Z/9mn/e9f4ODq128Zcfj/zcMEkIIcTBaaD+RwAFdgMFdgOzh2S+/dyqHF67cjod3hBKhYIsoybp7xWzTs2FM8sZWmDhX+9up7bDR3W+hZ8fVc3wAiuq3rHzR4/I543PGlImrp09pZRB2SYgXt1UkW1iV28fpf5+PK6QbJMWFDCrMofXP2tIu+fjRhWgVioxpgnB+lMpFQTDUXa1pH6vPmtqOoByPqvrTGma3eeTHa10eoPEYjH+/OamtJVSu1o9bKzvJs9moLHbzzkPLcMTjCStWbyzjXs+3MEv5w1Fp1axu9XN8Xcu7rfOx0+fXcvRw/P404kjEtVEO5p7uPyJ1WxvdgPxRuSXzCrn/OnlSRVHtR1e3t/SzDubmsg26Zg/vZQypynl+Hm3L0S7J0gwEsWiV5Nr0aNUZm5ULoQQQhxMJBAS3zt727xJYVCfRVuaeW9LM6dPKvkWdiWEEOJgoFAoyLMZkiqHDuQwaTl2VAFTyp2EolH0ahVZpuSgIdeq564zx7Gt2c2Lq2oxaFWcOqGYYocxMZUt16rnkfMncunjq9jSuL+X0JHD87j+iCqMvY2grzmskoWbmgiEk/sXlTqNiT5J1bkWdGplyhqACWVZOExaItEY5dkmtjal71s0utgOgDcQSXu9TzgawxuMsPyAsKu/dzc3c+jQXDbWd6eEQX2eWb6Pi2dWYDNouPWtLWnXvbWxkcvmDMJp1lHf6eOM+5fR4t5/FC8YiXLn+zvJseg5Z0opSqWCvW0eTr53SaLKC+CltXVcd3gl500rx2rQAFDT5uFXr2zko20tAOSYddx8zFDmVuckTWdr6PSxvq6Ldzc3UWg3cOyoAvJt+sSfTx9vIEybJ0gkGsOsU39uZZsQQgjxbZNASHyvhKNRHl+6N+P1Bz7ezaFDXSnl5UIIIcRX7fPe8Lus8QlrMwZnZ1xT6jTxxIWTafUE6PGHcZq0OM3apECizGni1Sunc+tbW/hgWwtalZJTJxRx2ezB5Nv3T2X75+lj+MmTq5OqdhwmLbf+eGSiMuZnRw7h4sdWpexDr1FyxPA8AMaW2DPutyLbhFWvJhKNYTdo6PCmP86WZ40/N3Wf0ycpGI7S7Q+zaEtzxnVvb2hkdLGdzQ3dSWFQf/9+bztHDM/Fqtfw17e3JoVBfW5fuJ15I/OxGjQ0dPk488FlSX2cWtwBrnl2LQ+cO4HDh+UCsK/dy5kPLk1qSP7PRdu5/dQxHDk8N1GVVtvh5W8LtvLGZw2EozEG5Zj5w/HDGVtsTwqOGrv8bG3qZsnONoqyjMyszCbPqk80Se/jC4Vpd8ePA5p1aumnJIQQ4mshgZD4XolEY7Rm+GUQoMsXJDLwABghhBDiOyXbohswXFKrlFTlWbnjjLH0+MMoAIc5Phmtj06jYvaQHN65djYvrallV4uHWZU5zBySnTQZbGKZg18dM5S/LdiaqCbKs8anjBX09vPJseg4ZXwR/11Vm7QPpQL+dMIIcix6IpEo508v4/aFqRW7AMeOKgBgZJEt4+PKteowatVEYzHUSgWhSPpjahp1vP/PpgH6JLW6gwTDUTq8Qd7e2Jhx3XtbWhjssrC5oTtjU+9b3tzMmGI7Jq2Kvy3YmjKdLhaD659by7ifzaHUqaaxy8fZDy5jT5s3sWZni5uzH1rGc5dOZWKZA4iHRuc8tJzd/Y4IqpUK7j93PDMGZ6Pt/fOs7fDyj4XbeHVdPaFIjJGFNn7/o+EMK7Ci7xccNXb52NrUw/LdHZQ4DEwdlE2eTYdWlRwueQJhOrzxyiWLXsIlIYQQ+0kgJL5XdGoV80bk88HWlrTXZ1XmYDXIy1oIIcTBx6LXYNFrMl43atUMdpm54chqotFY2l44dqOWc6aUcuTwPNo8AbQqJQ6TllyrHoVCkVjzi6OqmVTu4J4PdtLcE2BsiZ2fH1nFYFd8wphKpeS0iSV8urONpbvaE/evUMBtJ41KNIsudRipyjOztdGdspdfHFVNrlWHLxTh2FEFvLSmLu3jOnpEvHKpKs+S8bE7TFq0aiXhSIxIhv5HEJ+MBrBygONuu1s9+EMRAqEIb65P37spGoOlu9oodZrYVN+dFAb1icXgj69v4tHzJ6FTK7n1rS1JYRDEj99d9vhqFl0/m2KHkYYuH2c9uIy9/e5vfV0Xp9y3hJevmMbIIjsQr1w668Fl1LTvX6dVKXnk/IlMKnMkQrSadi+3vbWFtzc2EonGw6U/HD+cofnJ4VJ9p491tZ0s391OebaJ2UNyyLfpEyFVny5fiM7ecMlq0Aw4zCPTa1AIIcR3h7xzFt87MyqzKbDpqe/yJ31dp1byk0MGf25TUSGEEOJgN9AbcZ1GRbHDSLHDmHFNtkXHKROKmVWZTVNzC8UFLrJMycexc616/n3GOPZ1ePl4Wwt2o5ZZQ3LItegSx6RcVj0PnzeJP72+iQUbG4nGwGnScsNRVRxS7UKhUGDUqrn2sEo+2dGactTrwhnliWlswwutZBnTH1O7Ys4gXBY9Pf4QUyocSSFVf4dUu4B4/6VMbAYNapWCQDiasbk2xMMRgA+3pf+QCuCz2i58oQjuQJi3NqSvXApGonxW20mxw8j62q6kMKhPJBrjljc3c+/Z41EqFfzh9Y1JYVDf/Vz0n5UsvG4WRVlG6jt9nH7fkqTfl9bXdXHyvUt47crpDCuIV2/tafVw2v1LaOre/9ynC5d2tbj5zSsb+WRHKwCVLjO3nDiSkUW2RLgUi8Wo7fDxwdZmPt3ZxpBcC8ePKaDAbkgKoCA+La7DGz8WZzdokkLJ/kKRCL5gFL1GhVYt0+KEEOKrJO+cxfdOgd3AM5dO5V/v7i+nnlmZzS/nDaX0gF9uvcEwrT0BegJhjFo1TpM20UxSCCGEEANzGNUs3bSGoWXz0l7PsejIsegYV5KV8T4K7Qb+dsoobjp6KIFwBLNOTa41eZpXidPEy1dMZ+HmRt7e0EiWUcv508sY7LIk+h8V2Aw8fckULnlsVSIMUSkVnDu1lBPGFqJSKrAbtfz2uOGccNfilAbbx4zMo8AeD5emDsrO2IT7whnluMw6On0hqnItGZtwT6lwxvdlz9yA3GbQoFIoCEQiA1YutXmCALyzsSnjmuV7OvAGIwQjUd7dnL7nki8UYWtjD0VZRlbsbk/58Azi4dLfFmzljjPGEonGuPHFz5LCIIiHS5c8tpIF18bDpdoOLyffu4T23n0CbG92c/oDS5PCpW1NPZxy3xK6fWEA3trQyF3v7+CB+ROYMSgbjVpJOBJlU0M31z67jp0t8cqxPKuev/x4JJMrHIkP9oLhCPvafTyxdC/rajupyDFxwfQKSp1GTP36MoUjUZp6ArT0BIjFYuRYdLgsupTqJoiHeL5gBL1GmTJx7kBms3nA60IIcTCQQEh8L5U4jPzpxBFcd0QVxGJY9JqUoKe528+/39vBMytqCEViKBQwt8rFn04YMeAvb0IIIYT4apl1Gsy6gT+QKcwyMH9qGSePL0KjVKY0WlYoFFTnWfnvZVNp8wTxByM4zVqyzbqkgKDSZebNq2dy9wc7+GRHK1lGLZfMqmBmZXaif06eTcej50/kov+sTJpudvSIPE6fVIxKpcRp1vHHE4Zz+v1LOTDLmT0kh8Le3yWOGJ7LbW9vSVkDcOGMMnLMWlo9UOwwpPQj6tMXqOXbMw/FcBi1KJQKgoEosczZEu3eINFojAWbMvdSWra7HXcgjD8UzVhN5QlG2N3qoSjLyPtbmpPCoD6RaIzbF27jH6eNIRiOcu2z6xJhUJ9wNMaVT67mnWtnUZhlpK7Tx2n3LcUX2v+8N3b7ueA/K3jtyhmMKIyHS2v2dXL2g8sSvaVW13Tywuo67jh9LEcOz0WrVuELhlm8o43r/rs28X0NGhV/OH44R43ISxyx7PaH2NLQw+0Lt7K9yU2p08i1hw9hZKEtKRjq8Ydo7Qmwcm8Hfl0pNR1+XBawHPA7ZiQao7nHTyAcRadW4rLoUWWoyov2vjDk+JwQ4rtIAiHxvWXQqCm0p38J+0Jh7vpgR9JEslgM3tvSzNVPr+G+c8bjHODcuxBCCCG+eQqF4nODo1yrnlxr5uBErVIyyGXmTyeOoNsXRqNU4Djg73ytSsXEMgcLrp3FzhY3nd4QQ/Ot5Fh0ZPULCEYU2njx8mn8+c3NrNrbgcOk5cIZ5fx4XFHi94g8q547zxzHVU+vSaoCmjE4m9MnlqBSKcm16vndccO58D8rU/Y7c3B24ljcj0YX8O/3dqR9XBdMLyPHrINYjFyrLqWqJ7HnAhtKpYJ8W+YPvxwmLSqlgmCaCqn+unwhguEoHwxwLG7V3g48gTDuQJhNDekbf3uCEWrafeTbDLy0ui4pDOoTi8E/393GP08fgycQ4bpn16U0Go/F4BcvfMbYknjl0r52H5c8vjIpjPOFItzw/GcMyjEzrjSLcCTKos1NXPvsusSaNk+Qcx5azm+PG8YZk0rQa1R0eoM8vmQvt7+7rV/gtpWfzBnMRTPLyTLFXxet7gAvr6nj7g920u4J4jBpuWLOIE4YW5jUU6mlx8+2JjfPrqhBoVBwxsQSBrvMKQ3ku3xB2txBevxhrAZNxmr2UCRKuyeIQgFOky5jACWEEF+GBELioNTSE+DpZfvSXlu5t4MWd0ACISGEEOIgZtCoMWgy/6qrVikpyjImTWE7kFGrZkxJFg+cOwFfMIJSoSDbkvxm3KBVM7faxXvXz2blng46vEEmlTsosBuSAoJJ5Q4ev3ASf3x9E9ua3Fj1auZPK+PsKaWJ30ny7QZuO2kkN764PqkKaPqgbE4aX4RKqSDXqufXxwzjyqfXpOx3brWLXGv8vk6dUMRDn+xO+7gumllOjllHJBojx6yjJcME1+o8K2qlgqIBKqtzLDo0qnhD74H4QmEC4Sgr9qavSIJ4jyNPIEK7J0hdZ/pqKm8wQn2nj1yrjv98uidtZRbAHe9t599njKXbH+a3r2xMu+bWt7Zw2NBcih1Gtje5+b+F21LW3PXBDqYNdjJ9cDbeQJj7P9rF/R/tSlxv9wT50xubae72c81hQzDq1DR3+/n5858lBWmvrK3n8KEubvnxSHIs8QCwvtPHL19anxiWolDAUcPz+O1xwxON2SE+ee6pZTW8srYepRJOn1DMj8cXJYV+sViMhi4/mxu62d3qYWi+lUE55qT76dPqDtDlC6FSKLAbNRmPzwXCEfyhKEatCo1K+jcJcTCSQEgclHr8YYIDzJ+v7/RTnWf9BnckhBBCiO8ru1GLPXNuhEGjotRpotRpyrjGotcwszKHpy6egi8YQa2Mh0v932ibdWqOHVXApHInn2xvodMbYuaQbIqyjIlwSaFQMGtIDg/On8Atb2xmV6sHq17NedPKOXtKSeJYXIHdwJ9PGMGvXtmQFC4dWu3imJH5KBQKci16fnXsUH76zNqU/Z44poBssxalUsEZk0v4z5K9KWsArpgzGKdZRzAcJduspdWderRMqYCKbDMalYJBOWYW72hLe1+FdiM6tXLAI3EA0Sj4Q9GM/Z0AdrXEp8W1ewJ0+8Np1wTCUZp7/DhNWu7rF/Ic6O4PdjC6yE67J8DDGUK2hxfv4ewppZTo1Czd3Z62qmrh5mZOqenkiOF5dHiC3PD8uqTnIhaL911SALedPAqLXhPv33TPEhq79/eD+ts723hxTR1PXDQ5EQptaezhzAeWJjVdL8oy8MSFkynLjr8uA6EI6+u6uOnF9WxvjvdvGl+axV9OHEllrjnR1NvtD7GnzctDn+xmb5uHsSVZnDW5hCKHAa1q/1FOtz9EqzvIjhY3OrWS8mxT2v5N4UiU5p4A4WgMvVqJa4AKv0A4gkqhQC0BlBDfCAmExEHJrFOjVJDxU6Mci1QHCSGEEOKbN9CodgCTTk25Tk15duZwyWrQcNjQXEYX2fGHIqiUClwWXdKbaItewwljCpk2OJtPdrTi9oeYMTibArshUZGkVCqYW+Xi0fMncsubm9nW5CbbrOXSWYM4YWxBonKkqLdy6ZcvbUg6FnfaxGJmVGYD8aN8fzh+BFc8uTplv5fMrCDbrEWtUnLW5FIeX7o3bejz00MrsRu1+EIRciy6lKlzEJ8qW5gVn1o2otDKyr0daZ+j6jwLRq0alXLgYEGtVBKMxIOhTFp6AgQjEdo8wYyT58LRGG2eIDaDhkcXpw+NAB5evJupg5y0eYIZg7G3Njby86OqMWpUvLCqNikM6rOzxcMn21s5ZUIxjV0+Lnh0RcoEvtoOH9c+t5aH5k/EYdKyp83D6fcvTXoMq/Z2cPK9n/LG1TMpdhjxhyK8vbGJn/13/xG71TWdPLF0L09eNJkJZQ4A2j0BHvpkD/d8sCPx+7Zeo+Sfp41l1pDsRHPw5h4/Ty2r4eHFu+n2hSl2GLjxqGqmD85Oqkxq6PKxYk8HL6+pw6xTcc6UMga5TImAs09Tt5+WnniFU55Vj9OsTVvh1OkN4gmEUSgUOM1adGmajEO8x1M4GpMJduIHSwIhcVBymnQcNTyPN9OMeB2UY0qUU/fpP/o0y6AlN015rRBCCCHEd8nnfcBl0qsp139+uDSnysWIQhuBUAS1UkmORZfUBNms13DsqAKmVDhZU9OJLxhhQlkWORZd4s24UqlgZmU2z106hdve3sqm+m4Kswxcfchgpg/Oxtzb4Lk4y8CdZ4zl+v+uwx+KV3OrlAquPaySUUXxhtJ5Vj1/O3kUFzy6IuXDvd8cOyxxTO3sKWU8sbQmbUhz1SGDMenUOI1aCmz6tBPXsowaXJZ4U/Jpg5x8VtuV9jmaXOHErFNj0KQPFfroNSoisVjaHkl9fMH4xLkOb2olVZ9YLN6/yaxX8+q6+ozrnl9Vy9Ej8mnuCdCQ5vEBrKnppN0TQK9WcseiHWmfq25/mDc+a+DS2RW09AS4+aX1KWsC4Sg/++86nrt0Ki6rnpV7Orjr/eR+V/5QlCueXMWCa2ZRmWuhwxPkt69u5K31+38f39fu4ydPreG2k0Zy8vhiVEoF9Z0+znloeWLqHMCr6xo4Y1IxNxxZlQiFtjf1cMF/ViQ1Zz9qeB6/P354oq9YIBRhW5ObP7y+kRV7OtCplZw6vojL5w5OGirT4w+xr8PH08v2UtvhZ251DodUu1KOkPb4Q7S5g+zr8GLSqcnr7WF2YA+nYDhCqzseGBq1qozBbywWwxuMoFYpMoZUQnyTJBASByWzXs1vjhtGly/E4p37P30ZlGPmofkTcPWe3U43+rTApufWk0YxsSwLg1b+ExFCCCHEwe+LVC6ZdOrPPRY3qdzJQ/Mn4AtF0KiUKfdr1Kk5fFgu7147m73tXkKRKOXZpqRpcQqFgsnlDl6/Kj4tbmN9N6VOI1fOHcyQXAv63mCmOMvAfy6YxLXPrqW5t5rIbtTwlxNHUpETHxufa9Pz7zPHcuYDywj0a6KtViq444yxuHrf3J8+qYTHluzFG0wOc/QaJedPK0OrVuEwaxmUY2JniyflsZdnm3CatdgMWo4Zmc/mhvTH2X40phCbQYMtTePo5OcyXu0+UOWKVq1EqYy3ShiIPxSlJxBmdU36aiqAj3e0MH9aGXvaPEnPU3972rx0eEOoVUr+tWh72jXRGDy7Yh83HzOUFncgKQzq77a3tzKzMocci44nl9UkhUF9nl6+j1MmFOMw6Wjo9HH2Q8tSmqm/vbERl1XHL+cNRa9RsbPFzYl3L04EX4FwlMeX1fDprjaevGgyeTYD3kCY19c1cFO/4Ov9rc38893t/PeyqQzqfe20ugPc9f6OpF5VWUYND5w7gTHF9kRFXmOXjwc+3s3Ty2vwBiNUusz85rhhjC22J4JQiPeCWripiXc2NuEwaTl/ehmDcsyJhuUQf2/S1B1gd5uHTk+QIXmWlGb3EA+WmrsD9ATCaNVKnCZt0rTF/rp8IcKRKFaDGo0qcwilUCgwm80Zr4uDk7zbFQetPJuBO88cR6s7QGOXH4dZi8uiSzTyA6jr9HHqfUsSn1AB1Hf5Oe+R5bx21QyGF9i+ja0LIYQQQnxv2Y1a7ANc16pVFDmMFDkyN2YyaNUMK7Dy15NG4QlGMGiVKRPodBoV0wY5eeXK6bR7gsRi4DRpyTng+NyoQjsLrpnFS2vqWFfbydB8K6eML6LQbkhUehRnGXnh8mnc/PJ6Vu/tjN+uyMYtJ46kpHefLouee88ezxkPLE3qleQ0abnvnPGJDxxPGFvI40v3poQXBTY9R43IQ6FQkG3WMq7Unvhe/R1SlYPTrMNm0HD25FJufnlD2udo/rQyjFp1YkpdOnqNErtRg1YVr/zKVElUYDegUSmIfk4DpxgxguF4Y+9MdrZ4CEVibG9KDXn6tHuC9PhDKBUKnl1Rk3Hdsyv2Ma4ki71t3oyT9Z5dsY+LZ1ZgM2j4y1tb0lZB7WzxsKGumzybgRZ3gJtfTq2CavcE+e0rG7n7rHFY9Gre2djII4v3JK3p8IY468FlLLxuNiUOIy09AX7y1BpW9Tu6uL3ZzTkPLefR8ycyp8oFwN42DyffsySpgfsb6xu4bHYFl88ZjM2gIRyJsqamkwseXUFPYH/Id9TwXP5w/IhE76VuX4iPt7fwpzc209DlR6VUcPSIPG6aN5TCflVQrT0BVtV0cP9Hu+jyhTik2sXZk0sodhgT/aIAmrv97G71sHx3O05DGfXdQfJtypReUK3uAO3uIMFIlCxT/H2VNBv//pNASBzUskxaskxaKnMtKdci0RjPr6pNCoP6RGNwx6Id3H7q6IxpuxBCCCGE+HoZdWqMA/wuplAoyLcZkiZuHUijVlKWbeKawyoJhqNoVMqkI3EQP7Y2NN/KQ/Mn0ukJ0t3TQ2FOFtmW5LClMtfCK1fOYEtDN1sae6jKszAs35p0HKkoy8jzl03j4cW7eWVtPQrgx+MKmT+tLPGG3WHS8e/Tx3L1M2uTwoSZldn8+cSRiQqiQ4fm8t9Vtazd15m0j7nVrsQRu2yzjh+PLeTFNXUpj/3yOYPJMevQaVT8ZO5gLn18VdrnaP7UMtQqJeVOExqVglCaqXGFdgNZRi0GjYoRhTY+3t6a9r6mVDjQquNB1EDigUOMYIaKJABvIEw0GmNfpzfjmkA4ij8UP4a1dFf6vkwAb29o5LBhuaze25Gxz+gnO1rp8AbxhyLcsWhH2jWBcJSPt7Vw1pRSaju8SX9+/f3+tU0MK7Bi1qr5+4Ktaaf53fvhLk4cW4TNoKGhy885Dy9LeW/y9sYmqvKsXHXIYNQqJUt3tfGTp/ZPGYxEY7z+WQObG3p46uLJ5Fr1tHsC/PmNTby0dv+Rwx3Nbp5ZXsNLV0xnkCteCVTf6ePC/6xIqmjTqrbx4PwJvX+OKmKxGNuaerjq6TVs6w35LDo1vzi6mmNH5WecUie+H+SdrvjB8ocirNyTuXR2fW0nnkBYAiEhhBBCiIOAQqFA9zl9gLKMWswaBW9+uohh8+alXVNoN1BoN3Do0NyM91PsMHLT0dVcOqsCAIdJm1JxUZhl5IFzx9PmDtLlC2E3ask+oElynk3PfeeMZ92+Tp5ZsQ+1UsHZU0oZmm9JVL1bDRpumldNYZaBRxbvwR0I4zBpufrQwRw3qiDxmCeUZnHB9DIe7lf1olIq+MOPhlPijFdBZVt03DRvKH94bVPSXlVKBbedNCrRq+f6w4fwyY7WlObgZp2ao0fmAVDmNGLVq9NOeZsxOBunSYtGreCI4Xk8v6o27fN48vgilEoFg7IzH2Uy69QYtWqUKLDqNbR50vdnyuntIZruw+D+Ir2NptM18+7TN+FuxQDvJXa3evAGIoQiMd5K09e0z8JNjVTlWVixpz3j3h5ZvJvTJhajVir40xub067Z2eJmV4ubXKueug5fUhjUp9sf5ra3t3D7aaNRKRXcvnBbyvHGYCTKRf9ZyaLrZ1PsMPaeqFhKl29/0/KeQJhfvbyBXKuOw4flZXxs4rtP3umKHyytWklZtpElGT5JKMwyJP3S4AuGaXEHcfvDmHSqpLPuQgghhBBC9KdVq8gboHIJ4pVCB07SOlCuVc8Rw/OYPSQHhUKRtq9QjkXP1YdWcsakEvyhCAatCpclufmx06zjp4dVctaUUtbs7UCrVjG62EaORZeYCmbUqjlpXBEjCmzc+f52att9jCyyccWcQUn9oypzLTx47gRufmlDIjgZmm/h/04ZQ5HdmNj3Q+dN5JyHkqteirIM3PLjkVh7q6CunDuYdzY10u1LDo7GltipzrcmbjMox5y219DFsypwWXUogfOmlfF/C7elfR5PGFMIwPiyrIzPdVWuBZtBQyxGxn5RAONL4veRbc5cHaNVKVGrFBCLERngKF5fhdTetsxVUN3+MOFIjFAkSk175nWr9nYwdVA2b29syrjm3c1NdHlDxGLwytrUqjKIh0Jr93VS7DCydFd7UhjU321vb2VsSdbn9iAT313yblb8YGlUSuZPLeOZFfvSjj69+pDKRLluS4+fu97fyVPLaghGoqiUCo4dmc9N86o/9y96IYQQQggh/lefV92kUSmTjq6lYzPEG1/3NU5Ov0bDpHIHd+WPwx+KYtarMGiS3zaadGoOqXbx8k+m0ekLoVYqyTJqcPYLBtQqJWOL7Sy8djYr97azu8XD+NIsqvIsSb8/lzqNvHrlDB78eBcLNjZh1KqYP7WMeSPzExVJLqueR8+fyM/+u45lu9vjz4dayfnTyzhrUkmil80pE4r5aFsLKw44xvW7Hw2nwN57XxYdp00s5tkV+5LWqJQK/nziiMRj+PlR1WmP2GUZNYlQaUJpVsYjdieMKcBp0hKKxJhVmcOH21rSPt+HDYtXmo0rsae9DlDiMKLXKglF4lPMDmx+3qfvz1+lSHsZiFfKKRQKAuFI2n33aelt1J7pSBzEj6ENdORPfPdJICR+0IodRv552hh+/vxniYkKKqWC6w4fwsjec9neQJh/vbudJ5btb3gXicZ4ZV093f4Qt586Jmk6gBBCCCGEEN93Fr0GS+Z+1SgUCvJshgE/HFWrlBQ7jBQP0EBcoVBQ5jTx62OHcdXcSpTKeF+k/o2PIf57+33njKfNE8QXjGA1aHBZdImpcxA/Ynf32ePY0+pl0ZYmbAYtRwzLxWXVYemd+GU3arnhyCqmVji554OdtLgDTCjN4trDh1Cevb8KanK5g1tOHMGtb21JHHsbmm/hjtPHJsbT51rjjcYvfXxVUjPrqjwz1xw+BINWjQG4ed5QVuxpTwlyjhmZR1GWofc2FoqyDNR2pDbsvvHoalwWPcFwhLMml/DAx7tT1ujUSiaUOQA4ckQed7yXvgfS0SPysBs1uP0Kih0G9rWnbxDeF1BV56X2Yu1TlGVArRwgfRLfeRIIiR80k07NUcPzGFeSxZ42D+FIlIocc9JxsBZ3gGcO+AShz/tbW2j3BCUQEkIIIYQQ4n+gU6vItQ1cBWU3aj+3iXGORU+ORc/EckfGNdlmHSeMLWRmZTahSAyzXpUyxc5u1HLqhGJmV7no9AbRqpQ4TNqkKiidRsX0wdksun42S3a20dDlZ2qFk4ocU2IqGEBFjok3rp7Jgx/t4sPtLdgMGi6ZVcG0Qc7EkcE8m4GnLp7CzS+tTzTsdpi03HR0NdMGOYH4McQLZ1Swsb6LT3e2J+5fr1Hy8PyJ5Nni91VgM3D2lFKeWLo36TE5TVp+dkQVRm2879Jvjh3OxY+tTHl+xpXYE6HX3KocblErEx+e9/fTQyuTHqf4/pFASPzg6TSqAT+56PaH046v7NPU7U906gdw+0N0+ULEiJfc9n0aIYQQQgghhPjucH5O7xu1SploIp6JXqOi1GlK6rGU7n7Ks038+rhh/NQXQq1SpO0dVeIwcueZ4+jwBAmEo1j0anKtyb2g8mx6/n3GOBq6/Kyv7cJp1jKswEquRZ84Opdl0nLtYZUcNTyPBz/ZRZc3xOHDcvnR6AKK+r3nmVzu4OH5E/jjG5vZ3epBr1FyxsQSLp09iGxLb7hkN/DkRZO55PFVtPc27FYpFVw8o5xDql0DPn/iu08CISE+h0n7OZ9U9KsO2t3q5ra3t7JwUxPRWIzZlTncfMxQKnLMST/IhRBCCCGEED8seo0q6YhbOjaDJtHHNBOnWYfTrGNEoW3ANTMqdYwrtceroHTqlPcjVoOGQ4bmMqLIhjcQpqe7i0EFORj1+9/fqFVKxpVk8fpVM2juCeALhimwG2TAzkFC/gSF+BxOs5aZldmJ0s3+Kl1mcnqnC9S2eznpniWJ5Bzgg20trNzbwetXzaAsO/OnBkIIIYQQQgjxVeubIDcQl0VPSB/izcUrqS6el3JdqVRQYDd8btNy8f2TOrNQCJHEZtBy60mjGF2cnMBXZJt44NwJ5Fj0RKMxXl1XnxQG9XEHwvxnyR6C4fTTAIQQQgghhBBCiG+aVAgJ8QUU2g08NH8izd0B6jp95Fp15Nn0uHpHL7gDYd7d3Jzx9h9ubeEncwaTbYmXiNZ3+tjU0M3m+m6q8iwML7RSYDOkTFMQQgghhBBCCCG+DhIICfEFZZt1ZJt1DCuwplzTqBU4TJnP+tqNWjSqeNizo7mH0+9fSqs72O+6hmcunkJ1fup9CyGEEEIIIYQQXzU5MibEV8CgUXPhjIqM1y+dXYHNqKW1J8DlT6xOCoMAOr0hLn58Jc3d/q97q0IIIYQQQgghhARCQnxVqvIsXDijPOXrPx5byPjSLADaPEG2N7vT3n5fuy8pKOrwBtnc0M2d723n34u2s6mhm440PYqEEEIIIYQQQogvS46MCfEVcZi0XHXIYE6dUMTCTU2EozEOH5ZLvs2Ao3c0vT80cGNpX+/1Nk+AfyzczhNL9yau/d/CbZw5qZjrj6jCadZ9fQ9ECCGEEEIIIcRBTwIhIb5CdqMWu1FLVV76XkAOkxatSkkwEk25plIqyO4dYb+xrjspDOrz1PJ9HDE8jzlVrqSvN3f7CUWiaFRKXFb9V/BIhBBCCCGEEEIczOTImBDfoGyzlktmpe81dO7UUrLNOtyBEPd/tDPjfdz/0S56/CEA2j1BXlhVy4/v+ZTpt73Pj+/5lJfW1NLuCXwt+xdCCCGEEEIIcXCQQEiIb5BBq+b86WX84UfDE9VAWUYNN88byk/mDMakUxOKxOjwhjLeR4c3SCgSxRcM89iSPVz/33XUdvgAqO3wce2z63h6eU3a42md3iCdXulDJIQQQgghhBA/dHJkTIhvmNOs4+wppRw+PJdgOIpWrcRl0aNSxsfSW3RqDql2sbG+O+3tD6lyYdFraOzyc/f76SuJ7li0gx+NLqTYYQSgocvHos3NPLdyH0qFgrMmlzCzMoc8mxwvE0IIIYQQQogfIgmEhPgWKJUK8m2GtNfUKiWnTCjmsSV76fIlVwpZDWpOm1SCRqWk1R1I24sIIBCO0uYJUuww0tDl49yHlidNN1u7r5NRhVbuP3cCeQfso9sXwh+KYNSqMevlR4QQQgghhBBCHIzkyJgQ30HFWQZevHwahw9zoVSAUgGHDXXx4uXTKc6KBzha9cD/+erUSmKxGO9sbEo76v6zum6W7mpP/Hu3L8iyXW1c9sQqTrhrMVc9vZq1+zpxB8Jf7YMTQgghhBBCCPGtk4//hfgOUigUDHKZ+cepY+nyBYkBdoM2qWIn26Sj0G6grtOXcvsShxGnSUuHN8izK/Zl/D5PLtvLoUNdaFVKXl3XwK9e3pC4Vt/l5/2tLdx91jiOHJ6XONIG0Nzjp8sbonTkJLp8EbI1mq/mgQshhBBCCCGE+EZIICTEd5hZn/nYVq5Nz33njOf0+5cmVfFY9WruPXscLqv+C08ba3YH+OPrm9Jeu/ml9YwptlNgNxAIRVhX28mNL6xnV6sHgOEFVv568iiq86xJoZEQQgghhBBCiO8uCYSE+B4blm/l7WtmsnRXOxvquhhVZGNSuYOC3r5AWUYtp00s5revbkx7+7Mml2LRa9ja2EMgnL4fUYc3RLsnSIHdwJ42L2c+sIxwNJa4vrG+m1PvXcKbP51JqdMEQDASoaHTz4KNjWxt7GFimYMZldkU2g0oFBIaCSGEEEIIIcS3TQIhIb7HlEoFRVlGTh5v5OTxRSnXFQoFRwzL5Ymle1P6CI0usjGlwgHwuZU9KqUCbyDMXe/vSAqD+niCEV5YXcdPD60kFouxak8n8x9enmh6/cLqOqwGNf+9dCpVedbE7SLRGE3dfjq8QZQKBQ6TllyrTD4TQgghhBBCiK+bBEJCHOTy7QYeu2AS729t4dkVNSgVCs6eUsqMwdnk9o6dd1n1WPVquv2pDaQLbHocRi2eYJjVNR0Zv8+yXW14Z5bT4w9z2ROrUiagdfvCXP30Wp68eDLZZh1uf4gPtrXw65c30OGNT1MryjLwr9PHMqrQhqZf0+xYLEZzT4BINIZOrcRp1n0VT40QQgghhBBC/GBJICTED0C+3cCZk0uYNzIPhUKBzZDcBDrXouMfp43h4sdW0r8ASKtS8s/Tx5Br09PlC5Fn1VPbkdrEGuJhjk6tYmtnD12+UNo1W5t6aPcEyTbr2Nbk5sqn1iRdr+3wceYDS1lwzSzKsuPHz1p7Ary9sZG73t9BQ5ef6jwLN80bythiO9YDHkckEqXTF0KpVJBl1H7Zp0kIIYQQQgghfjC+9bHzd999N+Xl5ej1esaPH8/HH3+cce0HH3yAQqFI+d+WLVu+wR0fZHwd0FUHPY0QSz0KJA4udqM2JQwCUKuUTBuczYJrZjF/WilTK5xcNruCBdfOZEyJHQCbQcNVhwzOeN/nTy9Hq1biC0UG3EMoEqXHH+If725Lez0QjvLimjqi0RjdvhC3v7uNX728gYYuPwBbGnuY//By3tvSTKRfelXb4eXO93dw+v1LOfeh5by4upambn/a7xEMx/cQiaTvmySEEEIIIYQQB7tvtULo2Wef5ZprruHuu+9m+vTp3HfffRx99NFs2rSJkpKSjLfbunUrVuv+PiQ5OTnfxHYPLkE3NG2Ghb+GupVgzoXp18CwH8X/WfzgGDQqKnMt/PqYYQTCUfRqJSpVcmY8ssjOVYcM5s73dyTyQ7VSwR+PH0Gp0wjER94rFZCm1RB2o4YsoxZvMMKWxp6Me1lT00EgEqHVHeCpZTVp1/zx9U1MLneQbzewr93LSfd8SnPP/qlq1z23jumDnPzj9DG4LPGjcd3+EHtbPTz0yW5qO3xMrnBw6oRiCu0G1KrUfNwdCKFSKjBopJhSCCGEEEIIcXD5Vt/l3H777Vx44YVcdNFFAPzzn/9kwYIF3HPPPfzlL3/JeDuXy4Xdbv+GdnmQ2rcCnjhxf1VQVy28+TOoWQLz/g5Gx7e7P/GtUauUacMRAIdJyyWzKjhpXBEb6roIh4KMLc8hx6LDqI3/OHGatFw8s4L7PtqVcvtfHTOMXIuOnkCYUqeRln4BTn9VuRa0KhU7W9xprwO0eYJ0+kI4zVoe/XR3UhjUZ/HONrY09OCy6PEGw7y2rp6bX9qQuL5ybwcPf7KH/142lRGFtsTX6zt9vL+1mdfW1WPUqjl/ehlD861kp+ld5A2ECYSjmHQqtGpVxv0KIYQQQgghxHfJtxYIBYNBVq1axY033pj09SOOOIJPP/10wNuOHTsWv9/PsGHD+NWvfsXcuXMzrg0EAgQC+98odnd3AxAKhQiF0vc5+bL67uerur+vm8rXivKN69IfEdvwArGZ1xPWWL75jYnvBb0KCm1ack1ZfPTRR+QMc6FRxBKvf50KLppRTlWehTsWbWdfh4/qPAu/OKqKkQVWotEIJo2Cnx5ayTkPLU+5f5VSwekTi4lGwpi0A/+I0qgUtLkDvLK2PuOaZ1bUMKXMTktPkN++sjHlui8U4efPf8Z/zp+A3aCmqSfE6Q8sTeqV9N6WZk4cW8Avj67GbojvqdsfYXuLh/s/2kVjl5/JFQ7OmVJKgVWbMrUtEI7RHQijUihwGKXa6Pvs+/bzXoj/lbzmxQ+RvO7FD5G87g8eX+bP8Ft7Z9La2kokEiE3N/l4Um5uLo2NjWlvk5+fz/3338/48eMJBAI8/vjjHHrooXzwwQfMmjUr7W3+8pe/8Pvf/z7l6++88w5Go/F/fyD9LFy48Cu9v6/LnJFF2NpTqzf6BHYuZvGGRtzuzNUZQvTJ9LrPslr5x3ElaLQ6Qj4vrXvX8dFmb+J6QdlgbjqyktsX7SQQjvfyserV3HbiMBp3bWLj0kYGjZqIRaemJ5A6/WxssY3ulnrcai0KhSLleh+lAjZu2kRNxEY43Tk2YFNDN3Utnexo3ceCxvSNs19aU8/Jo3Pp3LkGZ24BS9r1/Ou9XUn38fTyGh6fP5aOXZ/h8/mwWm24Bg3noSX7+Gh7G2admrMmFjK91MSujWuIROL9lhQKBdmuPCw5BcQUSqIBH231e+S/we+w78vPeyG+KvKaFz9E8roXP0Tyuv/+83q9n7+o17f+UfWBb+RisVjGN3dVVVVUVVUl/n3q1Kns27ePv//97xkDoZtuuonrrrsu8e/d3d0UFxdzxBFHJPUh+l+EQiEWLlzI4YcfjkaT2rD3u0bdvQ8UioxNpHXWbGZNTP98CtHnS7/uh5SnfGloOMrRowpp6PKjUSlwWXRkmzSolHkARKIx7j17HOc/ujJpjH22WcvfThlNaZaeSBROHufnng/Th5xnTS5lRImN+s0tA27PZDbjco7gpbc/ybjm1Y2t/Pn4I9nX4eeOFz5Mue4PRfn9W9t59LyZ2PRq9rb7Of6uxXiC8eCn1R3kz29vZ2qFg3+edmiiWqjNE+bhT/fw5Jsb8AQjDMox85tjRzK7yIpJu/8YWiQao9UTotMXQqdWYTeoExVL4pvxfft5L8T/Sl7z4odIXvfih0he9wePvlNRX8S39k4iOzsblUqVUg3U3NycUjU0kClTpvDEE09kvK7T6dDpUvt+aDSar/yF/nXc59fC5IRBh8KOd1OvqTQoCsclPw5PK3jbIBoCfRZY8kApvVJE3P/yutdowGzQUeI0pb8OTCx3sPC6WSza3Mz2ZjdTKhxMKHVQmGVIrDl7ahmvr29gX3tyZc8Rw3KpdFnQaDQML7BlbHZdkW3CZtQQicaSJpcdKByJolarWVvbmXEo34a6brr9EfRaNX9/Z1siDOpvya52drd5ybU5aXUH+Omza1m2uz1xfWeLm/mPrODB+RM4bGj852GnN8ira+v524KtiYqpYflW/nX6GCpz9x/xDEeiNHUH2N7cQ6s7yLB8C3k2PQ5T6s9BgEA4glqhSGkgLgb2vfl5L8RXRF7z4odIXvfih0he999/X+bP71sLhLRaLePHj2fhwoWceOKJia8vXLiQ448//gvfz5o1a8jPz/86tnjw0ttg3t/gkXnQ07D/6woF/PiB/VPGYjFo2QwvXgKN6+NfMzrhqNtgyBHx+xHia6ZVqyh1mrhgRmqFUZ9Cu4FnL5nKos1NvLSmHoNWyfnTyxldZCfbEg9Css1afnpoJf94d3vSbdVKBbeeNBKXRY8/FGHeyDyeW1mb9vucPL7oC++7xxfm3c1NGa+/vq6eKRVO6jt9SWFQf394bROjCm24rHo+3dnGb15N7oG0qaGb0+5fymtXzqAwy0A4EmV1TSfnP7I8KYiaXZnDX08ZRa5Vn/haXaePj7e3sGBDEzkWLWdPKaXUacJmSP4LJBKN0doTIBqLYdKpsRrkFwQhhBBCCCEOBt/qWYPrrruOc845hwkTJjB16lTuv/9+ampquOyyy4D4ca+6ujoee+wxID6FrKysjOHDhxMMBnniiSd44YUXeOGFF77Nh/H95KiAC9+Fmk/jlUJZ5TDyJLAWgiZeeUHXvnho5OvYfztvG7x4Ecx/Fcpnfzt7FyKNAruBc6aWcfyYQlRKMOmSgwuzXsO5U8sYV5rFXe/voLHLz5gSO1fMHkypM95PTK9R8ZO5g1m4qYkOb3IzthmDsxnkMgMwpjgr46nLEYVW7EYNwXAUrVpJOE2FEICht2H2qr0daa8D1LR7cQfCKHoC/PXtLWnXtHuCrNnXQWGWgcYuP+c+vAx/KJq05sPtLTz8yW6uP2IIWrWKmnYvp967hMZuf2LNcytrueHIKs6dUoqlN/Rp6vbz3Ip9PPrpHrp8ISZXOLjp6KEMdpnRa/ZXCfpDEVp6AnR4g+g1KhwmbdqJbEIIIYQQQojvjm81EDrttNNoa2vjD3/4Aw0NDYwYMYI333yT0tJSABoaGqipqUmsDwaD/OxnP6Ourg6DwcDw4cN54403mDdv3rf1EL7f7EVgPxVGnZr++s73k8Og/hb+Fs5+IV4xJMR3yEAVLFkmLTMrcxhdZCcQjmDWqzFokn8MljiMvHLlDJ5atpe3NzQmxs7PGpKDyxKvsMk2a7nusCH838JtSbfVa5T85cejcJh0BMNRTp1QxKOf7k27lxPGFvTeV+bgRK1UoFUpCYYj7GnL3Bxu1d4Ojh1VwOqajpQwqM/jS/dy7rQysgwa/u+drUlhUJ+/LdjKkcPzsBg0tPQEuPrpNUnVS4t3tHH8XYt54fJpjCm2A9DqDvDo4t3c/9HuRJ+n6jwLd505LhGgAbgDYRq7/Ly9oYE2T5BDh+ZS6TInVS316faF8ATDqJUKciyp14UQQgghhBD/u2+9G+kVV1zBFVdckfbao48+mvTvP//5z/n5z3/+DexKALDn48zXmjZCKPUNpRDfB/HQKH1wpFAoKHEYuf6IIVw4oxyVUonDpE1aY9FrOGdqKZPKHdz74U6augNMKncwf1opxVnxaiOtWsnFMyt4b0sLNe3JYc7FM8sptMUr8cYU2+OhTyQ1yDl2dD4Ok5aeQBiXRUdzTyDtnqt6ewgd2EOpP28wQigSpcMb5I3PGjKue29LE4NdZva2edIeZYtEY/z+tY08fN5EbHoNr39Wz53v70xas6WxhzMeWMorP5lOvt2AOxDmlbV13PzShsSaRxbvYXiBlQfnTyC/97nwhSLsbHbz1wVbWbWnnWyLjstnD+LQobnkWJKDs8ZuP+3uAMFIDKdJi8uiQ6dJ39ssHI2iVkqPJCGEEEIIIfr71gMh8R3mGg78N/01WxGo+r18ehqhfRfUrQF7MRSMAUtB8hohvkc0KhU5lszN0+1GLZMrnIwotMWrjXRqtOrk9YVZRp65ZArLd7fz6rp67AYNZ08tpdxpwt4bMuVaddx/7ngufmwlocj+M2iVuWZuOLIao06NQaviqkMG8+tXknsIARg0KqYPzgZgXKk9436LsgwYNCqC4SjhARpn+3qPuH24LfNUtjU1nbj9YfyhCP9etCPtmuaeAFuaesi3G2jq8ieFQX021nfzyCe7+dmRVWjVKtbXdnL6/UsTjb89bV5ufHE9x49u43fHDyfLqCUSjbGxvovLn1hNXWc8ANOplVx/+BBOmVhMlnF/eFfb4eXDrS18uK2FEoeRUycWU2g3YNIl/1zyBsO0e4JEojEsenXGBtx90g0qEEIIIYQQ4vtG3q2LzIb9CD74M0RCqddm/WJ/8+nOGnjyZGjZuv+61gznvASF42UimTiomXTqlIChvwK7gRPGFjJvZD5KJSmVKlq1iqkVThZdN5slu9qo7/QxudzJoH7HqRQKBUePzGdni4fHluxJBCYOk5YHz51Avi2+riLHTEW2iV2tnpR93HR0NblWPZ3eIJPLHRkbWc+tdgGkNJfuT6dWolQqCISitHmCGddtru9mbpWLtzdkrkh6clkN508vR6NWcvNLG9JOgXtlXT1XzB1EllFLfaePM+5fmtQ0OxCOcstbWyhxGjlqRHzIwM5mN6fct4T2fvt7aPFu/nHqGI4ckYeht5qopt3LX9/ewtsbGglHY4wstPGH44czNN+a1CeppcdPTbuPzQ1dOPKG0tQTosCuRqlUJO01Eo3R5g4QjUGWSYNOLT//hBBCCCHEd5MEQiIzWxGc+V947lwIdMe/plDClCug8rD4vwd64O2bksMggKA7HhJdtjheMSTED5xWnfnIkk6josRposRpyrgm26zj+iOGcN60Mmo7vBh1avKsevKs+kQokWvV89iFk/jj65tYuKmJaAxyzDpuPLo6UUVkN2r5zXHD+PHdnxIIJx9TO2JYLoX2+PGtQ6pd/OmNzWn3ctK4IpwmLe2eIHajhk5vmtAYGNJ7lK11gNDIE4wQjcXo8YfY3uzOuG757naq8qx8sLU5KQzq728LtjGh1IFapeCXL61PCoMg3gT8hufXMa40ixKHMREu9VUaAayv6+Lke5fw6pXTGV4Qn6RY1+njwkdXsKWxJ7HOalDz5IWTGV5gSzz/jV0+XlpTz5PL9uIPRThqeB4Xz6qgxGFEodgfHHV6g7S5gzT3+LEZteSYdSlH4vqvjcXAbtQk3YcQQgghhBD/KwmERGZqHZTNhMs/hc69EPKCYxCYXKCPv9HD0wpb30x/e38XtG6XQEiIr4hFr8Gi11CWnTk4Ksoy8vdTRtPuCRIMRzHr1eRa9EmVLENcFl6/agZ3vr+DxTtasRu1XDyznEOqXTh7m1y7rHr+fOKIlKNe5dkmfnLIYPQaFbkWHZfOquC2tw8IhIEso4ah+VYADhuayyOL96Td7+TyLEw6NRF/OOPkNgBzbxXWun1dGR/77lY3oUgUdyCasQIqFImxoa6LEoeRlXvak8KgPpFojL+9vZV/nzkWBQr+8NrGpDAIoNsX5tyHl/PG1TMpsMcnvF3wn5Vsqu9OrHliWQ2vfdbAq1dOp7Q37Gvs8nPTi5/x/tb9R/IqXWYeOHdC0p9rU7efJTvbeGzJHoKRKCeMiVeZFfQGdn3c/jCt7gDd/hAmnZpskxabMbnnVR9vIEyUGGZd5uovIYQQQgjxwyGBkBiYSh0PdDKFOmE/xNJPNQLA07z/n73t8eNla5+OVxyNPBlyh4Ml76vdsxA/cH3BUSYatZLKXAt/OXEk3f74NK/sAypUzDo1PxpdwMQyB6+tq6ex288Rw/IYWWglr7cJtEql5JTxxdR3+Xly6d7Eca9ih4EHzp1AgT1+lG2wy8yIAisb+oUlACqlgpuPGYbdqEWlVDBnSE5SUNJ/3bjSLABGFdt4fnVt2sdVnm1Co1JmrCDq4w2GicViLNjYmHHNst3tuANhguEoCzc1pV3T4Q1R0+alwG7gs9rOpDCoT5cvxAMf7eLXxw0jHIlx61ubUx7j9mY3Fzy6gmcumYLLqqep258y4W1DXTf/WbKHZy6eSmFW/Plv6vZzy5ubeW1dfeK5nzbIyd9OHp1YA9Dc7WfNvk4eW7KHSDTGqROKmTrImWjm3ccdCNHmDtLjD2PSqXGatBmn9nkCYSCGScIlIYQQQojvLQmExP9GZ42Pnve2pb+eOzz+/952+OQf8Okd+6+tewoKJ8BpT4A1/+vfqxAiiVGnxjhA/6O+YOn6I6oyrsm26PjFkVVcNKOclp4ARq0Kp1mXNE4+16rnwfkTeGTxHp5cVoM7EGZyeRY3HzMscazMotfw2+OGs6F+CS0HTFO79ccjE0eq5lS5MGq34E0T+lx/RBXZFh3RWIwyp5E9bd6UNQBjirNQKBQp1Tb9OUxaVAoF/lA0bV+jPi3uAOFIlOdXpQ+pAN7a0MiVh1QSCEd4LcOEt12tHhq7/bisetbXdaWtcNrX7uO/q/Zx1dzB+MNR/rZgK6+srU9a8+nONq56ejUPzJ+A06SjudvPtc+tZfGO/T+jl+5qZ2i+hYfPm5gIhZq6/dz61mZeWRsPlxQKOHxoLr8/fnhScNTU7Wflng6eXLaXGHDGxGImlTsSIWGfbl88XOr2h7Do1WSbdRnDpU5v/GifPUNlkxBCCCGE+HpIICT+N5Y8OPS38NrVqdcq5oKlN+jp2J0cBvWpWwmfPQPTrpbm00J8T5n1Gsx6TeJYVDp5NgM/OzLeAykKmLSqlACgLNvEy1dM49OdbSza0kxxloFTJhRTYDdg1Mb/uiqw6Xn64ilc9sQqGrr8QLzJ9bWHVTKlwgn0HXcbyTkPLUsJc86YVEy2Of59Tx5fxAMf706734tnlpNj0RGOxrAa1HT7wmnXDXaZUSoUGLSZf37p1EoUCvAGI0QGSJcau/xU5UV4allNxjXPr6rlzMkl+IIRXlpTl3bN6ppOWnsCOE061u7rTAqD+mxu6GHBhkbmTyvDE4jwl7c28/Ka/eFSLAbvbGrCF4rw7zPGYjdqaer2c+VTq1mxpyOxbsnONkYVWrn/3AmJUKihy8dvX9nIws1NiSOAhw118ccTRiSFSw1dPt7f0sKzK+KP94zJJcwZkpMSLrW5A7S5g7R7gzhNWpxmHQ5TangUikRp9wRRKMBp0qFSSs8lIYQQQoiBSCAk/jdKFQw9Lt5v6N3fQU8DaAwwdj7MuAZM2fF3FqsezXwfyx+A0WfsPzrmbobuemjdBtYCyCoHW+E38GCEEF8njUpF/gBVOQCFWUZOmWDkpHFFKRO8ANQqJaOL7bx8xXRaPQFCkShOU7wpc/+pYGNL7Lzyk+n8dcFW1tZ04rLq+cncQcwakpMIogrsBv584gh+9fKGpN5Fh1a7mDcqH4VCgcui49rDhvD71zal7GX6YCcuiw6lUsHZU0pTqnX6nDW5hGyzjkA4ilalJBhJf8y2/zGvTPr6Svf4wwOGS03dAYodYR5fujfjmieX1XDs6ALc/jCvZtj7x9tbaXUHsRu1LNvdnhQG9fmsrpsPtrVw+sQSunwhfv3yBt7d3Jy05t3NzUSi6/nHaWOwG7U0dPk4/5HkRt3ratczrMDKw/P3h0u1HV6ufGo1a/v1jppcnsU/ThubVOFV2+HliaV7eXVtPUqlglMnFHPy+KKUKrCGTh9727zs6/RSkW2mKMuQVM3Wp8cfotsXQqFQYDdqEoGkEEIIIcTBRH7DEf87owNGnQblsyHkAZUOzK54SATxQMjXmfn2Qc/+PkRdtfDsOVC/ev91c258hH3f8TMhxEEvXRjUX65NT64t9Y18H6NWzcgiO3edOQ5PMIxGpSTbnNwnyaLXcMKYQqYNyuaTHa24/SFmDM6mwG5INNdWq5QcP6YQrUrJ7Qu30eYJolMrOXl8EVcdUplYV5Ft4tTxRTx3wNGxofkWfjy+CJVSQY5Zy5mTS3j00z0p+x1VZCPXqkenVnHW5BLe29KcsgbglHHFOI1avIEISgUZj7PlWHTEYhAeIDSKRGMQg25/aMBjcW2eALl+HU8MEC49sXQvRw7Lo8MbTAmD+ry/tYW23nDpvc3NKY26ATbVd/PJ9lZOnlBMuyfAVU+vSQqDAJbt7uDGF9dzx+nxcKmuw8vJ9yyhsdufWHP7wm28vKaOJy+enKhK2tHcw9kPLk9aNyjHzKPnT6TYYQQgHImyq8XDLW9u5sPtLagUCo4bXcC1h1dS4thfAReMRGjo9PP+1ha2N/UwsczBxLIsCrOMSXuNxWI0dfvp9IVQKxRk9VY4peMNhPGHo5h16gGnEgohhBBCfFUkEBJfDYUicx8gpRJGnQqbX01/fciRoLf3jrC/MTkMAnA3wRM/hoveS60UCrjjYZLe+j8/BCHEwcdq0GTsXQNg0qkp16kpH2Bym8Ok5YxJJRwy1IUnEMbv7qG8IBuTfv+xJadZxy+OruaUicU8sXQvnkCYk8cXM6bYTl5vcGXQqvnJ3EGEI1GeWbEvEdbMGOzktpNGJQKrkYU2pg1y8OnO5D5CJQ4jJ08oQtUbbs0bmc/raXoSDcu3kmPWYdKpOX1iMUt2pu/xdtK4QrJMWrr9oYyPHSDLoI2HS5GBw6UYMbp8A99Xtz9EhzfIMyv2ZVzz1PIaDh+eR6s7yJqazrRrPtrWQpsniEWn5vlVtUkhT59drR4+3tbKqROLae72c8GjK1PW7Wxx87P/ruO+c8ZjN2rZ1+HlhLsXJ3pUhWMxXlpTx6c7W3nx8ukUZhkIR6Ks3tvJ/IeXEwjHP8x4clkNDpOW5y6dwmBXvC+WJxBm6a42bn5pQ+L7VudZ+L9TRzM0z5oIPbt8QXY2e7jvw53UdvoYV2znvOnlFDsNaFX7q956/PG+TDua3Ri0KkqdRlxWXdIagEgkGu9tFY2h16hSglAhhBBCiD4SCIlvRuF4yBkKLZuTv641wawbQGuE9l2w5Y30t+9phK59+wOhniaoWwXL7oVIAEadDpVHyNEyIcTXQqlUkG8zEAqFeHPJe1QVz0tZ4zTrcJp1jCuxE4mStsojx6Lnl/OGcvGsCrp9YYw6FU6TNqmfksuq5x+njWXF7nYe/TQ+dv7H44o4Ylhu4giUWa/mV8cMxRsM896W/VPLRhbauPuscYmpcZPLnQwrsKZMQCvKMnDCuHjlktOsY/aQHD7cljrhbWShDac5Pm3stIlFrK5JPTIGcMr4YrKMWjo8AwdCA02/O1D354RLbn+YDl+IV9elb9QN8PzqWo4emUdzT4Ca9vRNxpftbqfNE0SvUXH/h7vSNixv6g7w3pYmzplaRnNPgEseX5kIg/q0e4Jc++w6/nPBRBwmHTua3Vz02Mqk44hbGns47b6lvPnTmZQ4jHiDYV5aU8/vXt2YWLOxvptnV9by9CVTGN87Xa/NHeDeD3fx4Ce7Evdn0Ki488yxTB+cnTgu2dzj57kV+3jwk910ekNUuszcfMxQxpdkYekXjDZ2+dhY381r6+qxGTScMqGYoixDSl+vVneANncAV/VE6ruD5JgVaRvRewNhuv1hlArINus+t8JPCCGEEN8NEgiJb4a1AM5+AVY8CKsegZAPhhwNc38Z7xEE8a8NNMLe3Tv6uacJXrsKti3Yf61mKTgqYP5rYCv6+h6HEEJ8DpVSiWqAEz9GnZrSAaa7QXwy27GjC5g1JIdoNIbNqEGhSH6TnWczcPupY2hzB+nwBrHqNTjNyUeS8mx6Hp4/gXc2NfHk0hrC0RgnjSvk+LGFFPaGSzaDhr/8eCTXPruGZbv3Bz7DC6zcc9a4xP3NGpJDpcvM9mZ30j7KnEaOHpGHQqHAadYyY3D8CN6BplQ4cJq1ZBm1nD6xmPV1XSlrAM6cVILNoBlw6phCEd+3UhFv2p2JVqVEpVB8buWSNxih2xdKG4r1eWtDIyeNL6K2w5uxyfj6ui7aPSE0KiV/f2drUhjUxx0I89b6Bi6dPYjWniB/ej21P1UwEuXnz6/jmUumkmPR8enONh74eFfSGl8owiWPr2LhtbOoyDHT4Qnym5c38PbGpsSa7c1uzntkBXedOY55I+N/Run6N/1nyV6uOmQwF84oTzzvu1vdXPnUGjb2holqpYJzppbykzmDE4FjOBJlT5uXf727jY+2t2LRqzlvWhnHjS5I6s3kD0Vo7PLz/tZmGrr8TB/spCrPSt4B/ZtCkQjN3UE6vUG0GiVOkxaHKX2FU6s7QDgSw6ofeFqiEEIIITKTv0HFN8dWGA+AJl0c7ytksMcrhProLKA1Q9Cd/vaOQfH/b96YHAb1ad8Fa56AmTdAXwl9dz20bIWGteAcDPmjwVoUP8YmhBDfcQMdd4P4qPbPG9eeZzNwzpRSjhmZTwzIMmpTJnAV2A3cc/Z4Wt1B2twBskxask26xBt/gHybgccunMRbGxp5ZnkN0RicOqGIY0cVJJqF241a/nryKK57bi1Ld+0/8ja5PIvbTx1DVu9eDx3q4ollFjY3JPcRGl5gZUZlNgBOk5ZZldl8tD01XDpmZD5OsxaLXsM5U0u56cX1aR/7edPLMOrUiWN76ejUSuwGDWqVAptRQ31X6vEzAKdZi1qpxBNIrSDqLxiO4glEEkFKOkt2tXHe9DK2NnVn7PO0s8VDpzeIArhj0fa0ayLR+JG264+oorknkBQG9ffH1zcxvtSO0xzvBZWuf9O/39vB0SPysBu1NHb5OfvB5dR1+hLXw9EYjyzeQ5ZRy+VzBqFRKdnZ4uH4uz7BH4p/mNPlC/GnNzbz7uYm/n3GWHIsevyhCB9ua+GKJ1cnGqHf/9EuBuWYeOzCyYlgssMT5JV1dfx9wTbcgXjgNrzAyr9OH8tglzmxj5aeAB9ubea+j3bR4Q0yfXA2V84dTKnTiFa9//hcU7efHc1uPt7eQp5Vz5wqF7lWHYYDGoS3ugO0e4IEwlGyjBpcFl3S/fTp8YdwB8KolApclsyvJyGEEOL7RAIh8c1SaeLVQulY8mH6NfD+n1Kvlc2ITyGLhGDFw5nvf80TMP68+Nr23fDY8dDZrxGq3gbnvhoPhhRS0i6E+GGIV+8M3EvGYdLFqzFyLRnX5NsMnD+tjONHFxADHEZtyvGgAruBu88aT7snXulhN2pwmnRk9RsVn2cz8Mh5E/lgWwvPLN+HAjhzcgkzK7MTE8ayTFpuO3lU0gh7pQLmjcznV8cMSxw/O6TaxfjSLFbtTT7Odki1i9FFNiAeLh09Io+3NjSmPKbzp5clptRdMrOCa59bl/axnzetHK1aSVm2CYWCtNU/dqMGu1GDVq2kwK6n3RNMe1+DckxovuAHE6FolPp+wcyBtjW5iUZjbKxPX3EF0Njtp8cfD1meXFaTcd0Lq2sZVmBjd6s7KQzq78GPd3HSuCKsBjW3vbU5EQb1t3RXO7taPeRY9DR3+/lJvzCoz84WD/+3YCt/OnEERq2aT3a08rtXk6ulNtZ3c8b9S3nlyukU2A20ewL89tUNvLl+/5/jK2vreXtDIy9eMY3hBfE/7/pOH+c/upytjfs/YFK+vol/nzGOQ4a6MPQesdve1MNVT69JBGRGrYrrDh/CSeOKEq9XfyjCzmY3f39nKyv2dOAwabl0VgVHDM8lp18w1O0L0dDl46U1dbR7ghw9Mp9h+daUKXZ9vaBa3QFMOjVOszZtwOQPRWjzBInFYph16ozBbyQawxeMoFUrpRm5EEKIL00CIfHdodLAhPPio+w/+QcEukGphhEnw2G/jY+wDwchNsCns7EIEANvO7x8eXIYBODvgqdOgYs/2N9vyNsOnTWw/r8QDsCIk8A5KD4pTQghRJIvFi5pcZg+v3Lp9IklHDU8DwVgS/OGN99m4O+njKbNHcAdCGPRa8g26zDr9//6kmvVc/dZ4/istotnVtSgUio4Z0op1XmWxBt2u1HL7380HJdFxzMr9hHoneZ18cxyzppcmujBM6MyhyOH57LggEqby2dXUNHbeDzbrOWcKaU8tiR16tqv5g0l16JDpVLy00MrufixVSlrlAo4fWIJSqWCqlwLaqUibZXQoBwTdqMWjUrBsAIrK/ak7980fbATpVKBfYBqMoUCNGolMcA7QIVTlzceGu1ozlCpC3T7w/hDERQK+GCgI3brG5lc7mTF3o6MVVCvfVbPtYcPwa0O89cFW9KuaXEHWFfbSYHdQH2nPykM6hMIR/nDaxu575wJ6DUq7nxvR1IYBPGJfFc/s4b3rp9NqdNEXYeP0+9fSlu/0M4bjPCnNzbjsuj50Zj4h1cb67s49b6liUDLHQhz88sbWLyzlT+dMBKHSUuPL8QzK/Zxy5v7+yQ+t7KW6jwLj5w/MTHprrnHz9/f3sp/V9cmAsWKbBMPnDuBQf2qoOo6vNz1/k5eWF1LIBxlQlkWvz12GFV5lkT1UiQao7bDy4ur61iyq41Cu4ELZpRT5jQm9eryhyI09wTYUNeFNxhmTLGdHLMu5b+3YDi+zu0PY9CqcJq1mHWpr6lINEabO0A0BlkmDbo01VRCCCG+PyQQEt8tphyYdhWMPCV+dExtiH9N13u0TK2NVwBtfTP97UeeCsZs6NgDNUvSr3E3x4+S2QrB2wbv/wVWPLD/+ooHYPDhcPyd8UqjpNu2QCQYD6osuf/roxVCiB+8zzvy9nmT4iAeCh0+TM/sITlA+obeLquem+YN5aKZFfhDEYxaNS6rFk2/KV05Fh23nDiSn8wZzIJNjehUKo4ckUuezYCtdw8WvYarD62kKtfCne/voKHLz5BcMzceXc340ixUvQ2kxpdmceXcwdz9wQ768hC9Rsk/TxtDYVY8IMi26PjlMUP5w2vJlTFalZLbThpFTu+RvV8cVc3J96b+nWY1qJlbFf/wYkieBYNGhS+UGvjMGZKD06RFoYC51S4WbEwNVYBECFKRY057HcCsU6PXKFEoQKdO//3i6+LPa7s7fZUUQCgSi4dF4Sj72jNXQa2t6eToEfl8uDVzALVsdwc9/jCeQJgXVtemXROJxvh0RxulThNr93UkhUH9/XXBFqZUOFApFfzq5Q0p1U0Ab65v5KpDKnGYtDR0+ZPCoD5bGnt4dPEefnbkEGIxeHTxHp5blby3Xa0eznxwKS//ZDr5NgMNXT7Ofmg5u1s9iTUr93Rw4t2f8uqV0xnWWwW1tbGHU+79FE+/JugvranjzyeO4IQxhZh0aryBMAs3N/Gz/64j1G9K4OkTi/nZkVWJCXSt7gBPLN3L/R/Fm6r3VeLdPG9o4jgoQEOXjxdW1fLUshqCkShHDc/j4lkVlDiMiR5nsViMuk4fH2xtYemuNqrzLBwzqoBCuz7pKF5fAFXT5iUUjVLuNJNt1qb0gwpFojT3+PEFI+g1KlwWfdr/vvuCKogH0uqBGrl9QRrNF2+CL4QQ31cSCInvHpUG7MWZr+ePhpKpqYGPtQAmXhi/fSjzL5YA+Dvj/9+8JTkM6rNjIex8D8acGf93XwfULINFv4OWLfFG2LNvhMGHxiuXhBBCfOs+78iMXqOi2GEccE3ftLhRxfaMa7LNOs6cXMLhw3IJR2No1cqU8e4Ok47LZldwyoQidjS70aqVlGebknrUGLVqTh5XxOgiG/d+sIvaTi/jS7I4f3o5xY79b8Sr8yzcd854fv3yBpp74m96hxdYuf3U0RT1hkuu/9feeYdJUWVt/O3c02F6cp4h55yDJBMiYgIUI2ZBRde06qq7uu766aprWnPArBhRRERRAUEygiBIzmECk/N0qO+Pt2uqQ9XA7rqKcn7PMw86fae6wq2qe997znu8DrwwuR8uf3Vl1OQ/LzkBfz2ze3PUyK2jO2LhluK4VK8euYnonMV0wbZpbmQmOlBU1Rh37Jcd1xoZiQ4oigkT++fhDZ1IKQAY14vi0sA2KYbnsV26Gx6HFcGQgjSPHYcMxKMO4TRGp834+lrMJphM9DqKrQAXyaGwaPDD3grDNvvK69EUDCHQpMT5XEWydHspumQn4tN1BwzbvLV8Dy47rjUCIQWvLtml26aoqhE7S2qR7UvAun2VUWKQSiCk4KG5m/Hk+X0QCIVw24c/RIlBKvd8sgHD26fB7bBif0U9bnx3bVx644yVezGgdQom9MtDUyCIN5ftxuNfaT5VIQWYve4giqoa8NxF/ZDqcaBQx4z8zeV7MHv9Qcy67jgUpHLhbnNhNc59fimqwimKs9cdxBNfb8X0SwdgSNtUWC1m1DUG8M3mYtz6/g/N/dBqNuGPp3TCpAH5zSLxoZpGzFixB88v3IHqxgCcNjMuGFiAqSPbISMiFe9ART0++n4f3l21F4oCnNk7FxcMLGgWXgEKRvsr6jF/UzHW7ClH91wfTu6aidykhCjxqL4pgEM1TdheUgNzbnccrGpCutcU5z3V4A+ipLoR9U1BJNgtyEh06EZLNQVC4dRRBSluu64/lbp//mAQdotFqvQJgvCLIoKQ8NvDmwVMfAXY/jWw4kUg0MCIop7nAkkFbJOQ3LJBdXJrpoctf874e5Y+zVL2Th+w4WNg9o3aZ2U7gJlXA8NuBobfAjjCq6l15UD1AWDTHKavdRoDJOYD7tSf4cAFQRCEowWTyRQ1KdXD47TB47ShVarbsE1igg39WqXg8fMS0RgIwuOwxQlbHqcNo7tmoleeDxX1fljNZqS4bVEVuOxWCwa1ScFXN4/Et1tKsKesDoPbpqJrdmJUlEebNDdmXz8Mj87bgvmbSuBxWHHR4AJMGpDffDzZSQl4+8rBuPqNVdheQnHCbALO7Z+PyUNaNUdVTR3ZDou2lGBXaV3U/t5wQntkh428c5MTMLhtSpTJuMo9p3dDuteBUEjBtce3j4uUAujrMygsKo3qlIG/fRYfiQMAY7plIdllR70/iE6ZXmwu0hdyhrbnIk7HrETdzwGKazazGYoSgtkEGGS8NacuVtQZR0HVNgUQUoAGfwh1OgKOys5DtRjaPg1zdXyuVJZsL0VtYwD1/iB+3K9vWh4IKdhwoAoFqW68v3qfrtcVADyzYBtGdExHYyCIF77dodtm5a5yFFU1ItXjwOrdFbpm5BV1fry8eCfuOq0rqhr8uPHdtc1ikIo/qODaN7/H3JtGIDcpAXvL63D9O2ui9i0QUvDA55vQLdeHYe3T0OAP4qVFO/DcQm3fGvwhTP9uF0pqGvH3s3rAl2DDwcp6XPzy8uZ+CgBPz9+Gmd/vw/tThzaLQhsOVOK8F5Y1X4OP1x7Aw19sRgc0KQAAlR9JREFUxttXDULfgmSYTCZU1/sxa90B3DtrQ7OoarOY8JdxXXFm79zmSMXiqgY8u3A73l6+B42BEBxWMy4e0gpXj2gb5Qe1p6wOLy3agU9/OACTyYQJfXNx6dDWyE3WROlGfxD7yuvx7qq92HSwCr3ykzChbx5ykxJgi3gOVNb7UVLdiJW7ymAzm9CvdQrSvQ54YiKqKuuacKi2CbWNASQ6bUjz6qf+VdQ1obohAJOJhQbcBpX6qhv8aPCH4HZY4LLLtFEQfo/InS38NknMBvpcBHQay1L1Ccn0HlLxZjGCZ97d8X/b/RymoYUC9BQyorGKbaoLgXl/0W+z5Amg72QKQrWlwKJHgGXPaJ8veADoeR4w+m/RnkR1ZUBtCSOPEpIZZeQS0UgQBOFYxe2wGk7KAApQWb6EZtNtPexWC1qlunHxEGMBymoxo32GFw9P7IWqBj9MANI9juZUN5V2GR7MuHowDtU0oayyBjmpiUjzOqL8aXKTEvDOVYOxenc5Pl13AMkuOy4YVICCFBd8CYzySPM48PikPnhj2S68vmQ3qhsD6JqdiD+P64KeeUkAALPZhDN65WBHSQ3eWr6nWShIddvx8iX9m8Wl9EQHbjulEx76YnPUvmZ4HbhtTKfmc/jXM7vh/BeXxYkhfQqSUBCOEBvUJgVuu0U3yub6E9ojI9GB2sYgTuySgXkbi+PamE3AwNYUqk7pno03lumbdQ9vnwaPwwoFgNdhRXVjQLedWkktI9HYn8vnssFsNiFkpPKE8YcUBEMh7C6NjzRSKapqRCAUQk1DoEWhaldpLdpneAzT8ABgzo+FuHZUe1Q1+HVFIwCobgxgX3kdMrwOvL5kt6FQ9eTXW9Aj14eqej+mL96l2+bTHw7ippM6wpdgw8ItJVFikMqBygbMXLMP14xqj0M1jbj2re/jjrMxEMLUN7/HrGlM19teUoO7Zv4Y1cYfVPDnTzagW64PfQuSUd3gx4Ofb8JHa/ZHbeelRTtR0xDA3eO6wOOwYV95HSY8uwQl1VqU3YuLdmLO+kK8N3UIcpMSEAiGsGxHKS5/bVVzWuK3Ww/hhW934O2rBqFfK/av0tpGPP3NNkz/TjsfJhNw19guOKd/XvO9tr+iHre9/wO+214KgH30rN65uOPUzs1irz8Qwpbiatz36QYs31kOi9mE0V0zccepnaOE64q6Jmw8WIV/fbMNByrq0TPXh2uPb482ae5mzzWA1fw2F1bjk7X74bZbMbF/HgpSXFGpwIqioLCyAbtL63CwqgHtM9zI9iXERVUGgiEUVTeiorYJVosJKW5Hc9ps9DUJoaS6EYGQggSbRbcNwLTEynpWBjycp10wFIJFKhALxygiCAm/bVwGoegWG9DnAsCZCMy/H6gpAhyJwKCpwIArWfIeALqdDexcqL+NjmMo1hT/RHFIj1AQqNoPpLQBSn6KFoNU1s0AuowDupzO/6/cT8PryO8tGAKMfzE+Va7qIFBfBijhY03MNjoTgiAIgnDEHE6AAoB0rxNJTgvmrJiPgWPH6nqqZCclYFxSAsb0yILFZGr2kokky+fEjSd1xEWDWiGocBIXa0ye5nHg9jGdceWwtthbXgePw4qsRCcyE53NKTSJThsuHNwKwzqk4c1lu1Fc3YjRXbMwsmNaVNRFz1wfZlw1GPfN3ogNB6rgtltw4aACXD6sbfPkMScpAW9fNRhXvr6qedJuNgGXDm2NU3tkw2QyweO04u7TuuKHvZXNqXoq95/dAxnhbXXM8KBnbiLWxUTt2C1m3HFqFyQm2JBgt+CqEW3x6LwtcecnLzkBrVK5/+P75OL5hfoRO5cf1wZpHgfMJhPapbt1hRCTCeiR64PFbMbIjhlxBukqfQqS4LZb0RRoOQoqM9EJs4mRWkY4bWaYzIhKVdSjvimIpkAIO3RS4lT2ldWj0R9ERb0fTUHj1L+iqgakex34cLWxUPXx2gM4b2ABSmuasK9c30qgpLoRh2qa4Euw4blvtxtu67kF2/H4eb1RWtOEmWv367Z5b9VeTB3VDglWCz5cvS9KDFLZX1GPrzYWYfKQViiubsT1M9bEeVQ1BkL4w4y1+PCaochMdGLN7oooMQhglcO/f/YTBrROQa98O0prGjHt7e+xZk9Fc5uQAny0Zj9sFhPuOaMbXHYrdpfVYfwzS5rTKoMhBZ//WIhVu8sx89qhyEt2oa4xgHdX7sUDn2tG77tL6zDnx0K8fvlAHBeOsiusbMA1b62O+s7Xl+3GlcPa4Lrj2yPZbYeiKPjpYBUufnlFlGdX73wfnr2wX3P0YlW9H19uLMJ9szegqp6iabt0N548rw+6ZCc2PwOKqhrw+pJdeG3pbtQ0BtAmzY27TuuCga1TmiO4QiEFe8vr8PrSXZi3sRhepxWXD2uD4e3ToqI6axr82F/B6Kz95fU4sUsmjmuXFpVqCAClNY0orGrA93vKkeyyo1deEjK8Djhs0fdEcXUDSmua0OAPItVtR5rHEeeJBQBFlQ2obgzAbjUh1W2HWyeCKxRSUFLTiFC4ymCkEB9JIBhCTWMAdqv5Z4vgsttbFs+E3x8iCAlHhqLw57eknrtSGb3T4WSmlVnsgCeTYpFKh5MAXx5QGTOgcCQCg68BrA4aWbeENQHw1wFLnjJu890TQOvhABRg1g3xItSepcBHVwOT3mR6mb8B2LeCwpG6b4m5wFnPAPmDAVtEmkJDFaONGqspgLnTAYdx2WhBEARB+LmxHmZ8YLOYo1LX9PA6bfA6bWidZhzh5EuwoWdeEh44OxGBkBI3KQMAl8OKQW1T8frlA1HXFITFbEKaJ9q/xWI2oWeeD59OOw5FVY2oawogJykBqW47PBGTr1apbsy89jgs3VGKr34qQm5SAs7tz5QedbKXkejEC5P74+0Ve/HG0l2obghgeIc03DamM9qlu5uP//yBBais9+P1pbuaxZPuuYl46vy+zZFf2UkJuPeMbrh31oaoYxrcNgXj++bCYjYh3evAg+N74vwXl8VVcLtuVHukeThuGdkxHSlue9jDRsNsAv54SickJthgMdNAeva6g3HnMdvnRE6SE1aLGRcPbqXbBgAuHtwKaW4HAkFF9/vU71SjS/q1SsLSHaW62+qe64PLboFL57pGkphgg9lkgq0F82iH1QyzCQiEjIUlgFEzjf6Wjc33lNWhwR9EWV2TYXRTSGEKnddhxWfr9c8VAHyydj/O6pOLoqqGZvEjln3l9SirbYLDasYzC7YZbmv6dzvx8MReKKlpjBJmIvnw+/249vj2SPcCT83fquuxVVLdiAWbS3DR4FYoqWmMi8IDKB7d/uE6fHjNUKR7HPhk7X7d73xp8U6c1jMbyWHD9cnTV8QZuK/dW4n/+3wTHhzfA26HFev2VeDW93+IarO9pBaTXliGz/8wHPkpLpTWNOL2D9ZFVTfceagWV762Ck9f0Bdje2TBZDJhd1ktznz6u6hze8t7P+D4zhl4eEJPpHkdqGsK4LP1B3H7h+ub23yxoQjpXgfenzKk+RlUVNWA2z9chwURhvZ2ixnPXNQXw9qnNUdLbSmsxpQ3Vzf7f1nNJlx6XGtMHdmuORKqut6PxdsO4W+zN+JAZQPMJmB01yzcPa4L8iIE7aKqBny8Zj+mf7cTFXV+DGmbitvGdEb7DHfzMywUUrCvoh7vrdyLhVtKkOax4+oR7dA5y4vkiGio6gY/DlY24NMfDqC0pgmju2WiS1YiMn3R6c6q6LXpYBW8ud1QVO1HdpIVlhg/q6KqBpTVNqEpEEKq2450HWEsFFJQVN2A2sYgHFYz0rx2JNjiJQd/MITSmkYoCuBNsOqmNgJAYyCI2sYAHFazrngW+93iwfXvI4KQ0DJ15UDFLmD1a4xU6T4RyOtPA+ffAiZTy/vqywcunQN89zjwwztMEes8Djj+LiCpNdu4UoH0TkBJ/MsR7jSmpwX9QL3+4AYATayDTUxR2/6Vfps9SyjsuFOBit3AG2dzf1Sq9gNvjgemfgdkdAn/7gAw9w7gp1kU7ExmoOvZwCn3R0cT+etZXa1yL9v48iiOWVsuHS0IgiAIRyMWixmWljUDGoS38PmRpOEB9EGa2C8P4/vkGk42snwJuOGE9rhgYAEU6K/qp3sduGV0R1wypBXK6/xw2S1IcdujoqUSnTZM6JuLYe3T8M2mIlTWBXBClwwUpLiiUmN65vnw2Q3D8cyCbfh+TzkyvU5cf0J79MxLav7e3OQEvD9lCO76eH2zh1PrVBfuP7tHc4qa22HDXWO7oLCyAat2l2vHk+jEa5cPRHb43LTP8GBi3zx8EJM61j0nEWf04nnJTHTintO74g8z1sadn6uHt0Wq2w6L2YSJ/fLx0uKdccbmZhNww4kd4HHa4A8p6N86Gat2lcdtqyDFhTSPA26HFZcObY0l2/XHXxcPaYUUtwN1TUG47Bbd1DiH1Yx0L7fVJz8JGw7oR4T3yU9iVN1hojDcdgssZhMSWhC0EuwWWM2IE/NiCYYUNAVDcdFpkRRWNqApGNQ1gFcJhBTUNATgtFmwZJvxWPXLDYWY2C8X20tqdCvrARSqKur8AIDXDQzlAeDt5XvQKy8Je0rrDM3i56w/iD+O7ojGQAj/mKszxgZQ0xjA/M3FmDykNYqqGqPEoEj+/tlG9GuVjESnFY9+uUVXaJu/qRi7SmuR5nWgpLoRf/pofVybkupG/O2zjXh8Um+4bBa8t3JvlBgEAE3BEKa8sRpf3zwSrdPc2F9Rj/NfXBYlegVCCl5atBNZiU5cdlwbWMwmrNhVhmve+r65TUgB5m4oxOaiarxz1WBk+Zw4VN2Im99d25z2BwALtpRg8bZD+Ojaoc1ptttLajDh2SVRfl3zN5fgmpFtMXVUO/gS7Khu8OPD7/dHictvr9iDzllevHLpgGaBvrCyATe+uybK5y3RacVrlw9Ez7wkWMwmBEMKNh6swjVvrm6OtnPazLh1dCdM6JvXLEKV1zbhiw2FeOTLzThU0wSbxYSzeufi5tEdm58lAHCwoh6vL92Nt1fsQX1TEKM6peOPp3RCmzR3s8l7UyCIPWX1mL54J1btLkNuUgKuGdUenTI98EWkJJbVNmF3aS1mrNyL2sYAxvfNQ7ecRGTGePwVVjZgR0kNfjxQiVapbnTLSUSOLyHqmd4UDKKkqhEHKhsQCIaQm+xi9cPfuX/W7/vohP+O+nJg6VP0xVHZ+AmQ1gG4+GOKCr8HklsBYx4ARvyRokpCEmCPWJ30ZAITpgOvnqZVJwMAqxOY9Fa4NL2JfkZ7V+h/R/uTaU5dubflfWmspNn10qejxSCVUJCRSKf9k1FPs28CtszVPldCwIYP+bdn/ovfWV8JbJwJfH47/wYAbC7g9CeBTqdqhtihEFC1D9i7EijeCOT0BnL66F9nRYG5sQJd20gKmyAIgnBscLiVZ6vFjCxfy0bjLrsVBalWFLSgVKmRUqpoo4fDZkGnLC8eGN8DNY0BOKwW+BLiV8/bZXjw3EX9UFHnRzCkwOu0xpmhZycl4PmL+6GoqhG7SmuR4XUgNzkhagKX6nHgT2M7Y9KAfLy1fDfq/UFM7JePnnm+5omXxWzC8Z0z8PZVg/DQ3M346WAV8pITcMOJHTC8Q1pz5FVecgJmXD0EN7+7tjl9LCvRiQcn9EDbcERVssuOR8/tjUumr4iqupbhdeDlS/o3f2fvgiSM6pQeN2nvW5CE4ztmNP/N7WM6456YqCsAuPGkDkj3OmC3mnHZcW3w7qq9calvNosJVwxvA4fVglSPHV2zE7HxYLxw1DPPh1SPHUkuOy47rg1ufHetzpVj6p/bYUNWohMOq1k3YifJZUOK2w6v04pBbVKxr1w/NW54hzS4bFake4yj2c0mGqBbzSYku+yGAlOa1wGr2RwXFRKLyURfoNom/egmgCbYITBSxIhgSEG9PwSbNYgtBibwALBiZxkmD2mN9fsrDNscrGxATWMAiqIYpkkCjM7q3zoFK3eVGaZJfrOpGOV1ftRaAnhp8U7DfZ+/uRiXpbXBTweq4iKgVJ5ZsB2n9cyG1WzG/83RN8TfeagWW4urkeVzYk9ZXZQYpBIIKbhv9ka8NLk/zCYT7pu9Mc68HQCeXbgDE/rRV6qoqiEu0hAANhVW46XFO3H7mE4IKcDT32yNM/2vagjg4pdXYO6Nw5GX7MKBinqc9/zSKM+1Bn8If//sJ+SluDCmWxZCIQVzNxRGCW3+oIL3V+/DjkO1eP6ifkjzOlBY2YBLX12BzYVa4Z8vNxbh260lmH39MLTPYJbD+v1VOP+FZc2po1uKajB/cwn+dGpnXDS4FdwOK8pqm/DYvC14Y5kmTs5edxA9cxPxwuQBzc/jPWV1uPjl5dgdUQDB67DirasGoXuOD2azCfVNASzeVoqb3l2LmrDXm81iwm2ndMY5/fOifLF+b4ggJBhTuS9aDFI5tBVY9ixw4j2HT6f6rWB1thxJlNkNmLoI2LGAok9mN3oM+fI1M+vuE4Al/wLqYh7kDi8w8CpG4ziT1Dep/vc4k1kZ7cAa4305uBZoqmXEVqQYFMmmWcBJf6EgdGgz8Okfoj/31wEfXQlMWQRk9+T+FK4DXjs92i/JnQ5c+hkjpFQq9wEbZ8HywzvoYLFCCV4BtDsx3t8o0EjvJn8DYHcBnmwcdjlXEARBEIQjxmW3Hnb1OsllP+xkJtXjQKrHga45xtXX1DZ9WyUhpEA3XSvRacPQdml45dJENPiDsFnMSIsx/bVazOidn4QZUwY3C1XJLhsyE51RHlQFKS7MuHow9pbVYVtxDQpSXGiT7o4SqjK8Tjw8sSc2HqjCm8t3IxAELhiYj575Sc2ikd1qwZm9c5CfnICHvtiMHSW1KEh14ZbRHTG4TWpz2k9+Cqvr3frBD80Tx4IUFx45p2ezGXmax4FnLuyLS15ZETW5bJPmxr/O79Nc+W9ou1SM6JCGb7ceijr2Md0y0TPPB4ARY38a2xn3zoqvrnffGd2Q4XXAajHjmlFt8ekPB+I8lRKdVpzZm9FZ6V4nOmd5dU29x/bIRqqHFcmuHtkWt7z3Q1wbgP5ZVosZbdM8hkJVu3QPkl12eJwWnNg5Ax9+r++ndFafXFjNZrRPNxY1E51WeJxW2Cxm5Ke4sK1YvzJw12z2yZaMoc0mwG5h37GYTYCBT7paua0lI3VFocl00GRGZb3fsJ0aKbOp0MBnFIxeaQyE4Dcpup5fKit2lmF4h3Qs2BxvYK+yalc5qhsCUAAsiulXkSzaegjtM7wtVix8Z8UeXDm8DYIhBe8Z+HDVNAbCoq4L324p0TXgB4BHvtiM/gXJ8AdDeEQn1RAAVu8ux8HKeqR5HVi/vzJKDFJp8Ifw2LyteGhiT9Q1BXHbBz/o+og99MVmjOmeBbfDip2HaqPEIJV1+6vw8Zr9uHpEW1Q1+HHHh+ui7leARveXvbISs68fhuykBOwrr8eUN1ZFCYX+oIL75/yEzlleDO+YrntsvwdEEBKMWfee8Wffvw4MuS5aRPE3UEywOull83vCZGJJ+76T+aNHUgFwxTzg6/uATZ8yWqf9ycDovwNJrdjGncaUtJ8+jf/7tsfzc5sTSGlLgUaP5LZsUxYfRt2MojAyqLEGWPRP43ZLnwLOCItYM86PN8+uLQE+uAy4+BPAk04x6LXTgTLN8NK0/3sgdwAw6Q1NFKouBL57Elg9nelqCcnAsFuA3udRZFKpL2cq297lFMzyBrAam11nAFFXDgQb+ZnDeIAhCIIgCML/DovZjMMt7yQfpqoTQDEnsky7HplhY/H+rQ2KiIDm5yM7OTGkXRoURd9XKsllxwldMtErPwlNgRBsVnNclSu71YIBbVLw/tQhKK9tQk1NLfLSfcj0uaLatU5z470pQ7C/vB57y+tQkOJCTlJCVIpKRqITj5zbC9uKavDuqr0wm0w4b2A+2qV7mr/XabPgrN65aJ/hxeNfbcHuQ3XomOnBzaM7omOmtzl1piDVhfenDsGdM9c3p7QNapOCv53VHXlhA+R0rwMvTO6Pa95cHZX2dkLndNx9Wpfm8vQjOqRhXM94z6g/ntKpWfRK9zpw/9k94jx9HFYz/nlOz+bUxWnHt8fcHwvjhIJ26R70LUgGAGT6nOjfKjkqHVFl2gntkRkWvW46qQOuezt+MdRuMWNsD44tu2QnIsFmQb0/XpgY3TULqR47LGYzxvfJxVsr9Kv+ndU7FwAwoIX+1DnLi8RwNFu3nETDNMLj2jHMr3N2CyKq2w6H1QxFATwOa3PkSSzqdTQyjwZ4LsxmE4KH8cRSBQ09Ly+VuqYgQgrQFAjpCn8q+ysoeq3dW2HYZkdJDfxhc2ujSCkA+KmwGt1zffj0B30REQDmby5GVYMfNY0BQwEtGFKw6WA18pNdeEtHDFJ5c/lujO+bi9rGgGFaaWltE/ZX1CPD68DbK/YYRo098c1W9Mjz/W6jhEQQEoxpNA7fhL9Oi3IJNgFluxgds3cp4MkCht3MlCOjKmC/V1LbAWc+TREICiOCIsUxpw849SEAprBoFD6HHU8BTntMO1/DbgQ2fqz/HcNuZErb4UQ3h5diTIR4E0fpVl7LmmL6EelRtAGoO8R9W/ee/vb2r6So0+0sijxzbgN++kT7vL4cmHc34K8Fht1E8ae2BJj/ALDqZa2dycx0uO4TteOrK2PE1MJ/0Ecpuzcw8nYgtT0jj1TUiKTaQ4DZGvZ3yqaYF0ugielzNrdELQmCIAjC7wC79fCFT2Kr2+mR4XUi2WnBnOXz0XPsWN02qlDVt1Vyi9vJ8DoxuG0qTCboVuBLctkxrH0auuckotEfQoLd0lwtS8VusaBXfhLeuGIgKusDMIEpZbGT04IUF167fCDKappQ2eBHisuONI89ym8l3evEfWd2wzUj22HB5hI4bWaM6pSBdK+j+XudNgvGdMtEl+xhmL54J3aX1qF/62ScN6CgWbgAgIJUN2ZNG4bHv9qCeT8VIcFmwfkDC3DR4FbNqTppHgf+dX4fPPj5JsxefxDBkIJEpxXXn9AB4/vmNoteQ9ql4oYTO+CZ+duavZV8CTY8d1Ff5CRxW5leJ166pD8ue2VlVORI61QX7jqtS7Ph8DWj2mH+5mIcqIxOV7tgYD7yw+bNWYlOnNErB7N+iB77Wswm/O2s7s395O7TuuD8F5fHXbeCFBe65jDSq2t2ItI8dl2vpOuOb49MrxNBRcElQ1vh6fnxlezsFjOGtGXlthO6ZOB+g9Sys/rkINVtR4M/iMFtU+LSvFSGd+C2Tu6aGVedTmVw2xS47RaYTRQA9SriATR5B4AeeT68bxBJ1DrVDZvFDIfNAqvZZOiNlel1wGQywZdgLKq4HVaYTSaYcBhjaBMQUhRDgQ1QRS8FDS0IXgBQXudHU1DB1iL9CDUA2FNa16Jw9ltHBCHBmG5nA6tf0f+s4ynahL1wPTB9DIUhgClluxbRk2foDb+/aKHD4ThMBEtiDnDmU8BJ97BCmDMRcKXRu0glpT1w1rP0CFJ9f6xOYOwj9HACAFc6kD+IQkwsrYdr0UZZPYFD8WVuAQA5/SiK+Ov0P1cJNDCK6Ie3jdusfpUV3WpLosWgSL57HOh9PiOmdn0XLQYBjKqafROQ25+pbI01wKrpwDd/09pU7gM2zwEu/BBofwJ/V18B/PghMO/PTKcDKAZNfIXbsoYHVw1VFLSWPUvj7lbDgD4XAL4CwBLxOAwGgJpCCllmK43FPRn6xxQMMHLJmvDbqsInCIIgCML/nCOpenQkkQcpbkdzSpoRaR5HXOST0Xa6hSf7enicNnTL8eGB8T3RGAgiwWZpFm9ULGYT2mV48I+JPXFnvR8mmJDqscelEmYnJeCB8T1wyykd0eAPwe2wNkcGRe7T1BFtMbFvHvZX1MNhMyMrLLqpnkY2qxkDWifjq1tGYvmOUuwpq8PANinokOGN8u7KS3Hh/WuGYv6mYsxedwBepxVXHNcWHTI9zZFryW47/jyuK45rn4rnFu7AoepG9G+djFtHd0K7CO+uHrk+vHLpANwzawP2lNXBbAJO6ZaFO8d2af7OnKQEvHPVYEx9c3VzVIvNYsLlx7XBmb1zYDabYIaJPkj7KqPSCJ02M16a3B9ZPl6zTK9Dt8pgq1QXbjixA5w2C5w2C/56RjeMf2ZJXHTWZUNbIyMcwdUu3YPe+Ulx0T1Wswl3n9YVSS47fIqC207phD9+EJ+V0DnL2xw1dnynDLjsm3RT7W4Z3ZGV2xoDGNcrGx+viV9gTnRam72BJg3I103zAsIVCz0OWMwmdMjwYKtOGqHFbEKXLEbQnd0nF19u1PeMOrlLBpJcdnqnOayoNhCP2qS54bCa0acgCYu36afidclOhMv++11AFkFIMCa9E0uc710W/XtbAnDCXxiBUlvCMupBnRDBRY8Avc6PF4RCARoY/178h/4TnD7+GH7uBbqNB1odRyNqRWFKmidTKznvTgUmvAy8fwmwf7X2t/mDKCap0UbDbwY2fESxJRKLDRh4Na+DN4vRObFtABpQu1qq0xJGXfmq0A/TBcCIpfpKwFbacirbypeA0x4FaouBBf8X/7kSAj69AbhyHoWfA2uAz26OblN9EHjjTODaZUzBa6rleYj0U9qzFFj+DHDZ50B2L/6uoZLeTJ/fTkEIYFW38S8CGd000aehCijfBSx/nteo3fEUUZNaRUclBf1MoasvAyz2lsWlpjpGOjm80QKVIAiCIAjCL4zdaj5s5NWR+Fi5HFYUOI6sTUGqy7CN3WpBQYqrWagwIjcpARcNboWz++TAYjY3+0RFku51YNKAApzQORPBEIWq2JQtj9OG4ztnoFtOIqobA7BZTEhx2+NKpHfI9GLG1UNQWtOIhkAIKS4b0ryOqPOSmejEY5N6o6iqAT/sq0SKmwblmYmO5nLyHqcN4/vmYkjbFHz4/X4UVtbj1O7Z6F2QFOWd1T7Di89uGI43lu3Goq0lSPVQUOuRm9QsLmYkOvHcRX3x5rI9eGPZblQ3+DG0XRr+NLYzOoRFL5PJhJO6ZOKB8T3w8BebUVbbBIvZhFO6ZeKu07o2p3Rm+5x4+6pBmPLG6uaKdnaLGX84sQOGtEtrvn63ndIZO0tq8cO+yuZ9TXRa8foVA5sFtLzkBEw7vj2emr8t6hz2yvPh3P75sJhNSPM48PA5vTDp+aVxkTl/Htel2ZesT0ESOmV54jyJvA4rpo5qD6fNgoxEJ248uSP+Njveq+vU7llI89hhNpswoW8eXvh2h24k0E0nd2gxne+3jklRjNxtf59UVVXB5/OhsrISiYk/T+SK3+/HnDlzMHbsWNhsv7POUnUQWPcusPJFppC1PwkYeQcn2BYro4Ge6m/892c/R1EIAGpLgdJt4W1VAT3PAwoGAYm5v8yx/F6pPURhrraE/jzudEYHqfjrgd3fAZ9cR2ECoBn2Wc8C+QOZvtVQDXzzd2DFc/HbP/EeYPB1FJCW/guY9xf9/Zj0FtBlHMWpF08w3t9pq+gD9MJIpnjp0e5E4Ly3gJ0LgbcnGW/rmiUUhN6aGC2KRXL8XcDI2yje/KuffvW2rJ7AxTN53nYsBF4/I76N00cT7uRWFJfWvctoptg2l39BAQmgoLThY54z1Z8pvTMwcTqQ0VUTjurKgJJNTLusKQTangD0uYjiUmTUUVMtUFPCNrYEXmujtLiaEh6rMzG6ap7wX/G7ft4Lgg7S54VjEen3wm+BpkAQNY0B2CxmQ8EiEAzhUE0TQooCj8Mal5II0JenqKoBNQ1+NNbXoiAzBT5XdKSZorBNaU0TmoIhpHkcSPc64sS2kuoGHKhowIYDlcj2OdEx04ssX0JU9bqKOnr3zPx+P6rq/RjXKwedsrxRPlz+QAj7KurwxtLdWLmrHLnJTkwZ0Q5t091RaWcHK+sxY8VevL1iDxqagjilexauO749WqW4mqPzymqb8OXGQvzzyy0oqW6E227B5KGtGVEV/s5AMIT1+ytx47trmw2o0zx23H92Dwxrnwb3YQTNo41/R/P4bR2Z8MuTmM20r17nMSrD4QMcEZNLvYloJOZwF6srZaTHype0z7Z88fsrYf9r4E4LC0Bd9D+3JVBguWo+hQeYAHcKhQQVpxcYcSuQ0gpY9CjFpcRciikdxwC28Euh+0RgzRsUAiMpGALk9eN/e7N5PSt1co1bD2N6nNXO6DOj1LL2JzJFznyYKDKzhelspduM2xz4nlE6hT/qi0EADbzryhgl9dW9+m0aKoGt84CBV9Jzac6t+m0+vRE4/x1GaO1ZDsy+MbpNySbglbGsWpdUwEijFS9GR0Lt/x5Y8Txw+ZdAZlf+rvYQsPRpYMmT2nEk5gCT3mZ6nVrtrqYY2P4N8N0T9H5qPRIY+UcgpQ0jlFRqD9E36sBaRptldue1i43c8zewP4QCFPI8LVRZCIUkbU4QBEEQBOEXwG61IMXaciqT1WKOSqnTw2I2IScpAX6/FXPmzEdnHe8sk8mELF8CsiIilfRI9zqR7nWiV36SYRu18mG3HONsCZvVjDZpHtxxamfUNQbhsJuRYIuXLrJ9Cbj+hPa4YFABQoqCJJctrl2K245J/fMxqmM66v0h2K1mZHjtsEX4iFotZvQpSMb7U4agvK4pXP3QjsxE5xGlff6WEUFIODxmM1OK9HAmAzl9OemOxWSmRw1A0+lIMUjl0FZg5cvA8XcyAgXgpLL6IA2ILU5OQG0tP3yEw2AyUTyIrAoXiycdGDgV6HoWUwCtjmjRCAB8uaw4tvVLYO2bgNkGZcCVMLU+TmubmANc8D6jbGpLtL9NbU/DbVfYgHHU7cDmz+JFmoRkVmIzmWjSbXVqPkqRpHcGElIphKS2o4iiR3Yf9i0jMagZhdFUxfEhpc3sXkxBaP9qIGRQsnTvMkYGhYLA1/fqt2moAHZ+yyigmiL9tLjGaopO571Fc/LNc4DFj0a3qToAvDaOkVLJrSi8fnEnsP59rc2P71N4u2Iejd4BRop9fC2w/WutnS0BOO8dpimqolDlfuDbh+kdFWhk5NOpD/Gej/TJqtxHT6hNsxl91udC+jI5vdH7W11EkSrQSGHQk6mJjVHHXsOIKos9OtpNEARBEARBOGawWy3NKXVGWC3mqOgiPVRB63BkJDqbo4aOFUQQEv473KnAGU8C00/RzHxVTv6b5pWy5g3jbXz/GjDwKgoJtaXAT7OA+X9nBIPVAfS6kBEOLYkZws+D2Xz48+zLBfpfhmCXM7F12za069wnPpw6sytw9QKaWZftopCQ0jpaYEppB1w6hxE0qgjTehi9g5IK+P+eTIpIH12pVWQD6Gt09nNatMoJfwbeODt+X60OoMc5/O+sHhSZ9LJkU9tTiAL43UYm3Fk9+K+eZ1YkSpBtSjYZt9mzjILQ7iXGbXZ/R8PsQCOw4EH9Nk01wK7FFISqDkSLQSrBJmDOH4EL3qU/0YoXo8UggGLY2+cC01YCya0pGr19LlD0o9am+CfgtdOBS2fTuBwAynYCr57GCnAqy54Gxj0G9DiXwpGiAEUbgfcvBkrDFTZsCcCoP/EcqB5V/gagbDuPdc9SPj+G3QS0GRntu9RUy/3b+S3FtTYjKUTFRi8FAxSXm6opLLrTefx6qCKeM/mwleccjsNXqREEQRAEQRCEox0RhIT/noyuwNTvgO9fB3Z9CyTmAUOmMR1MjSJoMi7lh0C41GEwyEpRn/8x+rPV0zlJnDg9Olog0MiICCVE7xajiZ7wPyFk92LzroNo17WPfgNfHn/aGWzA5qSH1ORZnNSbLRRlVGFGbdNxDPvXihfZDwqG0JfKl6+1y+kDjP0nq4ypFdM8mcA5rwJJ4XREdwYw4nZgYYywYrYCZ/xLExxG3QF8cHn8/lpsjJ4CgLwWfLMyulBUUEL0ACrfpd8uszv/1TPyjkRRKOhECi6xFK7nv9u/MW6zbwVT2vz1wIoX9NsEmyiyJLdm9F6kGBTJ53cAkz+hyPLVvfr79tnNFGocHppuvzqW11nFX09vpcRcoMfE8HGsA145VYvmqi0BPrwS6HMxcPJ9TMNrrKFo/Ml10eeu7fEUCdVoxtpSYN0MYOE/eNwmMyPPxjwQnaJaXcSqiMufpal31zOB3hdoomRku4pdsBaux8icdFhqDnI7sSlydWU0EA8F+Vwyiq5squdz0eaUZ5cgCIIgCILwqyCCkPDfY7bQn+T4u4CmPzAqIzbFq9d5+pELACdpziSg5qB+6gxAc+Hqg5ogVLmPBrxr3mQ6UcdTWPkstb1UZ/qt4Ulv2ZfG4QEyuwFjH6YIaEvQ/HJUEpIpGnQcTQ8di5UCUKThstMLDJpCI+1F/2Q0Td4AYPhNQHJbbVttRgHDbgaWPKGlhTl9wDmva0KCOwMYfC2w7Jno/TBbgXGPa8cz8nbg42vij8nqZJ8FgFZDjY89bwCQkEQPpOTWxuJSbl/+21JqpcnMn5BfM7jWo2Iv/90+37hN0Y+M0mmqBTZ9qt9GUSgupbYDdi+NFoMi+ebvjDYym2nSrZfat+YNYMh1FISq9uuf0x3zgR9mAEOvBxTwefPFnRH7E6KQVL4buOgDCoA1xcAn04BtX2rtijcCq15mil1ya+2cvD0JKN4AE4AEgM+syR8DWb2474rCyLJZ1wN7l/PvUtoCpz3GPmcPV0TxNwDlO+nxtH81RcPht1BITEjS9qOxmvu381v2+zYjKC6p1QNV/PVs11hN83B3enQ6n0owCNSVAFCYrmexxbcRBEEQBEEQjilk5iz8fFis0ROaSDK7A3kDGaUQiSOR6WB2F1CxSyvzrUfJZqbsVO6nP42aegIAmz7jBHbKQiCto/b7QANX9hurmWbkTmPVJeG3h8XW8iTW5mBUR2xkRySuFBpW5/bTyrurE3UVdyon6H0vpgBjSwinI2VpYmNCEtu0HgYseoR9LH8QMOKPFAFUOowGjruR1dlUccmVQiNoNcLJk0kRY8m/Yo4ngelzqgBw/N1MnYslIZlRUwCjZIzoNJbb8tcxei/WGFxF3VZitv7nAIUHs4URRUZeSoAmPBlVgAMojgSbgKZG44gkgKl1GV2AHz8ybrP0KaDnJKbsxUaCqRT+wIglTwafKZFikEpNMfDdv4Ax91OMm3sHULwhuk1DBfDmeFae8+VRNJp+SvQzrGwH8ObZwFXfMIoNAPatBN44SxO+Dm0Bts0DxvwD6DuZ/bGhEvj+TWDeXdEpjr0vAk66R4tmqykCFj8BrHqJ/dlsYRTb6L9Hp35W7gfWvkVhLRSgOfyAq4DkiHtFUXhedi0G9q3is7bd8Yz4jBTZgwGK9zVhccmdQaEq9t5UFKb1BZv4mVE1PIDPZ5j0hSxBEARBEAThf4YIQsIvgzcLOPd1YMNMpqv4a4GOY4HjbgCS27CNNYERDEYpNOokaO/yaDFIxV8HfPsIIzTsLk7qlj7DVJBAA7fd6TTg1H/QByeWQBMAhRFOwu8bI+FSxeHhT6S4E4s7Deh8GgWUYBNg90ZX4FPbjPgj0O8SRrXZXJwYe7O0KKeEJPrktD0eWPw4UFvMaJCBU7QIFQBofwJw0n3AwgcYFQIwIu7ciMglTya9u+b9OXo/PBlMuXJ4+TP6fvoDxZLajqILQOHMbNEXfPpeSiGgsRrI7g0cXKt/jtqO4r/ZPfU/B7jvR2L6rUY/6VWvU1FTSJtqWxaXizZQFFzzlnGbH98HRtzCZ8fmOQbfV0YPJV8esOVz/e9UQoyCmvgKn1GfXKd/rPPuBjqNAeytuc0v74xvs/ZN9oPuE8LPu0eBFc9pn4fCabf15cCEl+jNVLkfeOPMaAFwyZPA+vcYBaUKqMUbWf0uMpLL5gIu+ZTnymTied0+n8egtnN4gXFPMOJNFXRqD1GkX/ggI/G82YyW63J6dNpv1UH6ZK1+lf/f/3LeT7FiZOU+CmeHtrJ/praP9zpTFEaR1pVxX12pxul6NUUUtqyOlk3L/fV8b8g7QRAEQRCE3ykiCAm/HInZwOBrOJlRQoxssEW4uKsT7J90UlASkjk5DwaAHz8w/o6tX4b9aMzAsmeB7x7TPlNCTG+pLQbOe1ubCNQU0yx35UtAsJGr8Hn9xcRaODJiU3hiORJxyZVKASZvAPugPTG++pYrFRg0Feh2NoUPq4OpP94Is2VnIqNM2oyg8FpTSOG14+joyKn8wRSSvriTk23VX+eUv2uTcW82MPFV4INLo0Wh3P7A0GmsRGZNBcY+ArxySrxw1Gkc/YEApoTZPfpeYqPu5MS9voKi2A6dVDWTmfsMAJ1OpTCiR8FQisEhP0WmoF+/nRqdFev/E/udAFO8WvJ5qimmmNySf9P+1Tz2hgqgYrd+m6CfgkdinrHHE0DRsM0oGmWvflm/zfZvGMHjSgV2LNCPBqsuZBTSyNuA+lLgvcnxaX3+OmDGBTSIT8xhxNx7F0VHLTVWAx9ezjY5fejDtPx54NuHIr7rIM3jK/cxss7uolA048LoCpW7FgF5g4BzX9P6YclmGpnXFGntfHn0HksNG5Q11QF7ljD9r/ogf5fUCjj7eSCvH6vVARSqtn8DLHiA1yG9C3DiPUzpixSJqw5w4WHNG4DFAQy4khFTkcbmisL0xZIt3FZGFwq4sSJUKMhzXVfKlFJXKuDNjL8eoRBQW8T2FodxGq2iAA1V3FasAC0IgiAIgvBvIoKQ8MtiMukPhgGuNJ/yAFfHI1NHnEnARTMBb1igSWhhAu5IBEwWpvAsf1a/zd7lHKC70ziZ+/wOYMOH2udbvgCyerIiU6QoVFPMCU3pdk5IkluJaCT8vBwundHmYJpPZKpPLAlJQEJv4PQnGYkSKbo2t/HRPDlvYER59xjvGVsC0OEkYNpq+tjUFNEkOqVN9MQ4qwdw9ULg6/uY1uVOA4ZcD3SNiAbx5bEy2YwLONkGKNgM/YPmpZSQBIx9CJg+hpPnSMY+rH1nTh9GFZbvjG5jMgOj/0bx2OoAep6nX93QlcKUOYC+U2sNooR6TuLkPRTkNo0ijtI78ViSWxD8vNnhlCqDlKnIYwg2aedIj9oSCl4NlcaCF0CxwpcH/PCOcZsNHwADr6RQUrpNv01NEZ99rhRg6dP6VfoAYNGjNPWuPQR897h+myVPMBXT3hrY9nW0GKSybzmFoZ7n8jk+4/xoMQjgc/j9S4GLZ7KPle0A3jonWrir2M3U4muWAmntaUa+9Glg8aNam6IfgbfP4b3S+0KmxlUdoF9U4Tqt3eY5FDhPf0zrh0UbuP3IvprWAbjwQ74bAIpl274CPrtFa5fSltFbWb20VLyaYkZ2LX6Mx5rRlX05t3+0UFW5j5FXP37A6K1B19A/LPJ+DDQB1QcYeVW+h6msGZ3j31VNdVwcqSnSBChPdrxI6q+DpboYo3rkwVJXzO3opf756yjqmi2MHjRKDwwF+VySqCtBEARBOCoQQUg4ukjKBy76iIP5wvVcyc/owkgDdaDa/3LjMvaDpnBwXLRBS6vRo3wXkNWdkUGRYpBK4ToO0Adfx++t2Au8cz5QtF5r48ujUJUe6VnkZ1RG9UH6mHhzmMajNykXhP8lFuvhDdYTswG04BVkc1EASmnTQhsnRaEJLzMKxmThPRg5ITRbmFp25dcUNPwNFIbd6fQjUknryEiTzZ8z2s+XB/S/gpEXqljlywUumQV8/Xfeu6EAv//Uh7V0N5sLOP5Oika7Fmvbd6fx+aJGLqW2o+fOxo+jj8mXRxNrq4Nizqg/AZ/fFn/sbUYxIsRkAvpNBlY8qy+YDL+FxxoK8Tv1Ul6tDqZC2RLoPaUXKQUArYZRPG+pcqN6rCYzI7mMsDo1Eaol/PUUEIo3Grc5tJmiQO0h4+0F/fzc6QNWTTfe1sqXgA6nsK/onSuAz+jaEp6vbx/Rj+IKNtEg/OT72HbJE/rbmvdnoN0JvO4bZkaLQSqbZwMDLmckX9UB4K2J8cLloa3ApzcA57xGIaf4JwpXkZTtAF4dB1yzhPdVfTkr9UUKk8UbgTcn8J7qNl57B706FqjYo7XbsYDC7thHeM8FA/Tpe3O8Vr0ToAh18ceaUFVbyuqdC/+hiYqeTODcN5geqD43qvYD3/wfzOvfgy/YxHvhpL+yf7rC1SCDAd5ni/5J8cuZCAy6FugyLjpaqr6S7/VVL3O7HU8FOpwc7/lWW0Lha+8KRkDm9eP3xgpI1UVsG2hgX499ljS3O0gx0GJnO702ikJxTK0MqNdGbddUy221dF8JgiAIwm8IEYSEow9vJn/yB+p/ntyaniuLH4v+fauhQPfxnJzZXS37EXmzuJK68kXj/Vg1navUFgcw64ZoMQjgoPXtc4DL53LA2lTLAfrMqZqZrtUJjHmQ++X0aX9bU8yBasU+rrgmZhv7XQjCbwFnYssRTiZTuK8fJqouqYDCbt9LALMNsFj025z+GHDi3ZzEObzxXjCJOZyYVx9kWo83k8+OxFxNrPJkMPqo1/msGOevBbpNoNdNUjitzGKlCbPFDsz/OwUNqwNK7wthGnFbRBRUPnD2i8An10RH7gy4Cmg7kv/tzQTOepYpUJETdoAG4qqQ1nkczcpjBQeLHRhxKyesrnSg/Wh9U+zU9jRBt7voRbXta/1zPeBK7r+/jttsqo1vY7by+WR3szjAgTX628roBtjch4/8sDr4XFZaMCNXggBChxe9/PXc58IfjNvsX8Xjq9xrbIDeUAnUl3HfWhKqVrwItDqOvkxqalosOxawjwDAN38z2O86LjgMv4WihlGU2hd/AloN4bVe/ly0GKSy8ROmknoyGBn09rnxfatsB/D57cD4F1ltcde39LWKpKaIEU/XLqNQVVMMvDuZ50+l+iAw82rg7Bf4bjSZGFn24vE8JoDHM+cWpmePf5H71VjNSLW5t2vb2jqPn102V0v9qy4EZk7hOVSx2ClUtR2lLawUb2S6YdmOcBsbF2+GTqMwBPCa7lzEc1ixh/242wTgxD9r97b6nT99yvu/vpxpq6PuYMSfNWyUrijcxsaPud/ebD6jUttHR3A11VCo2jYPqCunyBgbUQnwe2pLuM2EZG5P77lYe4jPgFCAkdJenQgu9dr5G3iMniz9ZybANFIlxGg/owINisL+Y7HFV/MUBEEQfpeIICT89nClMNWk+wSWlm6s5ipqWkctHc2dDnQ5I37lH6C3RGIuB0aBBuPvCTSGVw4PATsM/EHKd3EA6M3m4O7di6JFqEADvTPSO3NgD7DdjIuiJzGp7YEL34/2makr40rqT59ym53HcdLpTo3fj8YaTozsbqnUI/w+OFxUnd1tvJKv4k7jT1YP4zaeDJo5tx4Wnnj54tNd3KkUqDqMhtJUg4qaBniz28PqjPh+h4dREfkDGN3YVMd0Hnd69KQxpw8w9TtGwexbwYnn0Ot576vG2ckFwOVfcDK77Ss+h3L6Aqf9U3tGJPgoir13SfSkPaUt013VZ2FOH6Y7bZ4dfUy5AxilATA65IQ/s5paLMf9gZEaVgejpta+FS+0m0wU6e3hSo4pbbXJeiTJrcPnI4VebQcNhJw+kzlRdqcbC/sWG7djS+B29b4PAFI7smCBem6NsNj4PS2l4QUb2SZWqIslUE+xqmiDcZu9yxjBVPSTcZuaYkbWwNRy6t/qV2nGXbxJX9QDgK1zgbpD3Lf5/2ew3w2MzhtyLQW0yH4VyVf3AG3CvmBf3auJQZHsWMDoLk8Gj+MLnb5VUwx8cReFI5uTglukGATwHL17ITBtJftVxV7g1dP4fmxu42eaoi8X6H8lRZPdS/l3KqEAsP5dRn9N/pgLMDUlwMfXAtsjBNMNHwGbPwOu/IZRxABQuhV4eXR02uj692jg3+8yimyNNRTnZl2nRQkufJDXZeIrmidWdSEw54/AT7O0bSXm8v2f2Y3/ryhAySYuLqmG/e504NSHgPYnacJ7fSWwdynw5d2MTktIBgZfy2dVZGp+1UFgy1xgxfPsl13OAAZcEV20IBQCKvcAGz5mymZqex5bUn70c7ahilHQW79if2l/An3PYgX52kPhNPtwRUe1mEIs1YW8lkqQKbqerHjRKxTid/rr+RyKrPgZiRqBCIXbMhKnAw18PttcLb5nTCYTsrJkoU4QhN8/IggJv01cyfwxmug5vMAp/8cByZ4l2u+TWgEXfqANznpfyBU/PbqdzQlHrH9FLHWlHIgsf8E4ImnhP2jiGwpyABq7ol26jSuekz/h4Kn2EI1PV76ktfn2YfqijP6btuLYWMPqO98+xMlAekdgxG1AWicOUiOpLuIqOEzhVUkDLydBOBY5nJBqNgO+XAT8fny7ZA7G5nWNb6OKE5ETrVgsdnrNjP47IwqsTn2xIq0DMGE671klBDh88WKwLw84fwYnSxV7tEiDyImXJ4PC0aCr+TwJ+Wk8ntOH7YGw59IkTky//iufR0mtGCnRYbR2bpJbAxe8xygOVRRJSAbO+BeQGhaqvFnApDc5aY+cQDuTgElvafvW+TROUGO9i9I70bsK4CS498XAmtfiz8+gqTRUt7n4zNMz9TaZgMFTmd7jzeZiQqSQEPmdrjQeS/cJ0T5DkfS5mKJXSymUdjdFRauDKVpG4lF6F/aFw/mGqYbYLRmbh0IUEVoSqpojP+zG4hmgCRBGkWAAI4WaarhPW78wbrfxEy6E7PzW2Htq61yamjfajM3UQwFg2zfAwLbcP71rCPAd2Xkc01b1qvQBQMlP7HPeLKa6RYpBKoFGClXnvs7/n3O7vofYV39hP3Z6GZ31ybXxbfYspWA34jZACQDfPREtBgFc+Hn9DHqx+fIoorxyavR31pYAH1zGqn9tRvB8bv+av1OpLwfm3w8cXAec8ST7e3Uh2+xZqrVb8iSF3Su/1vpy8UbglTFcYAMoRK94nmJWx1MpnNRX8Fi+ukfb1td/Zdrt2IcoLAOMoPvwyuixV2o7PjtS24fPsR84uAb46GrND86TQT8vVWwEOBba8DHFtdoSPkeGXMfKnZ6IMUzFXvafH95mv+w+ARgyLfpZ7K9n31/6DP3D0jszqiyljfZ9AMeNpdthWfs2BoSCMGUG+DyOjfSq3MdxV8lP9P1K7xxfwdZfz+1V7OHzKKmA+x0rVjVU8fiaauiF6cnQX/CoK+V1MJn5vDKqmFpdpHl1GVVSDAZ575nMLVdbDAYohlsTWi7EIAjCbxYRhITfL75cYNIbFHTKd/MlrKZnqeQPYhpEpIk1wJfjwKs5kXAm8aUaG4bf/D15XHE6tMl4X8p2cGDQWMXVNz2KN3JA4MlghEGkGKSybgbQ9QwOQoMBilkfXKp9Xr6TptjjXwS6ncXBf6AR2P89B6vqRCC1HXDmM4w6UL0QQkEOcHbM54Aytx+jJnz58YOA+gpY6ssxomdrmJtqAFuy8bELghCPxcYBfUscLg0PCJsBpx8+CsqTwWgFKPor564UPlsKBlHgNlvjV/RtCUyDmbKIzyqAz8rYFfuMrsCUb4F9q/gsye5BA3NfntbGl0sBfMPH4apxJgpVXc7QPJ6cicCJdwGJWUzpaazm8/i4P1CcsbnC39eFPjpf3Kn5F9lcwBlP0YAcoCA06S3gjbOin+VOH4U3dbLX/1JOKqsLo489sztQEK50504HOo2l2XQsw27m+bDagZF/YlpxLGYLzbVNJk6QjSrwFQxlpIPdxbRFoxTnvhfzGd1iH8jk+bTYGE1r5AeVF07VVos46GGxMZUaJvYlI78+9fq0FImrKJzAhwJaqrUelXv5b+F64zY1xdq1NfKeAmh+33oYsEnn+qnsXAA0VnLfdhr4eSkKxa7UdsCGT4y3teJ5ChihALD6Ff02tYe4uOPLY5SUkYn9vHuAiz7kOf3iT/ptNn0KnHAX7+miH6PFIJW6UmDJv4Ax/8eFpY+namJQ5PHNnApct4LiZvmuaDFIZePHFI77XEhh4/Pbo8UggNfj7XOBS+fwuVK5B3htXPS9WFNME/mrFgA5vZkGt2o6RS6Vhgr+f8VeVsV0+jhuefW06AqOK16kIHnl1xRhQkH6yb19riauHlzLqLFzXmf1SouN+zD7FmDTLJgQLgPww1thU/lHNRFKr/qhN5uCnVq0oL6SEWdzb9eO0+YCTn+Czw9VaK86wHO26VOec7MF6Hk+0xvVZ3CgiRGHn92kibWth/O5l95Ji2qtLeG4cOFD4eqHXYGT/xpvUF+xB1j7Ng3q1UqKHcdEj48ba7iNlS/x+hUMAXpNAnwF0c/7mmKKrBs/4bOs29nsx5HfFwpR+CzeyOuV1YPXJfYd01ijpVPanHwX6EWE1ZXxnvHX8Xs8mfoLK9WF7JMWG++HSOsGlWBAq/BocxmLY021TEXV80mMOoZqXi/1eWtEoBEwWY1TPAXhF0QEIeH3jZoyooZix5KYw1Wr9e9zoBZsArqezdV01YDTk8FqLnqVczqO4eTAmkBxZfeS+DYAJxN2N1cRW6K+gi+dpU8Zt/nuCfpYNNUAs/+g3+azm/nyTsrnIO7106NTIUq3czBzzXecHCgK0zdeG6elHKx6mS/PSz/TJhrBAM1jP78d5l2LkGwyQWl/MqOxUttrL8hQkC//3UtorJrbj+kzkRNCldpD4ZfsYVa81O8/nFGyIAj6HIkRbuSqux5mC8Wc2JXwSNSV8KQC+qcZ4ctjikuvSQBMFD9iB9meTGDEHykABRr4rPXGTBASkoA+F3FSWr6L+xi7Em+2AHkDgGuXU8gp/JECT9tR0cbGSa2AK74EVr5C03KLjakz3SdoPi+uFGDcY5wYff8q9yshmfvZc5J2nvP6AyfeCyy4X3v+OhJpFu0L+9h4soDz3mKVtEgzbm8WcOa/NPPmodMYWRIbsdruBFYRAziZ63CKftTO6Ps5YTWZgBP/ArxzXnwbu4dGzwDTpYyEqh7nUoQ0mYFeF/BdoYd67VsP1/8c4HvT6eMkPaOrsVDVZkR4vw4jfKoeVTaXfioboPXdlqICLXYeXyhgHN0EaNfMyFMKoIihhChwtFTsomwX0A4UmYwoWh9eXKqOFy0jOfgDI4XXvGncZsNH9CRrrDEW2gINTEdLzGvZc3HJk7z/Gqvi01NVSrdzn13p3C+9RTZFYUT1+Bc46TeK1lv7BjDsRt5Pm+dGi0EqNcX8nhG38b75eGp8pJ2iALOmMY03KR/YtxLYNCt+W5tnA73Po79cdRHTEWPvxeqDwHsXA5NnsS8e2kzLgEj8dcBHV1FUz+7JY/xkWnSkWihIkVwJ0ePO4eFz7ZVTos/ZrkXA9FMovie34nX87kleC5WiH2lQf+YzjDC3WCi2TD8luprl7BspGk16k88RfwMXFz+6Quv/OxcCS/9FUS+nd/iYCxkNFrnQuegRPgsHX8fnVyjE/vjGWbwXVDK7M8JV9fSqLaVX2uJ/an5vCcn0AiwYoj1Xy3cBH01h2i3Ae3XwtYwI84Q9xBqrmTY651b2DZMJaHciz2ekNUN1IbDyZYq2DZXcpzH/B+T0054PwQAXUxc+BOz4mosSg69lX4gUtGpLGf3/3RMc17Y7kQsMSa2jF1Ur9zLicdNs9pP+V3CfIse+jTXsTz99yn7c4WQgs6sW1auipmXuW82o/+zeYRP+iHd9MKBFETdWc6zuTosXxxprgdpiWOtKcVLPXJgbygCbznigriycGdFk7G2mKDy3/rAJvyeD0dCxBBq1NE+7l6nwwq+CzKwEwZcLDL2BxrIIAQmp0Q9TW4JWcWjpU+EqIzau4Bx/JycHANDvUoYsx1bYMZmAkbfx5eJM4sTEyNzUk8GJg9HqIMAXasjPVZSGSv02jdWsmuJJZ3i0ni9GsAlY9jww5gF6S7x7Ybz/REMl8N5kGn96M/lifflkrZ2iwLT1Sw6irl7IQUmzuHR69GTCnU5xKb0T/z/QRD+Hz27WvERaD6dPSlpHbWLor+eK0tq36avQaihfxL6C6JdQMMAXaF0pz7ErLXq1K5K6Mr6IHB6mFwqC8OtgNmtGwEZYbNFGwHrYEvj8UYV8o+2ktOHzvCWSWjHCYvBUPodc6fEDXm8WMPqv3FawgQKEJzt6tdeVwsWF7mdzMG6xayveqmGx1cZIoOtWsLLeoa2MXsnrHy2gJ7cGrvwKWPsOJ/L2cNn5NiM0Ec+VylShFS/yXdRYxYnGyX/jNtVnav5gToy+uld7lie3Ac55VftObw4jUd4cH/1eyOkDHH+XFv0z7EZOZst3RZ+fYTdpwktiDkWk9e/FX4+xj3C/AS4svHFW/PVIbUexCOCExyj1b/gfeW5Dfop4y56Ob2Oxc0EFYHqZkfF3z0ncL389FzP2f6/fThWqOp5iLIzlD6HhugJOcI3e76qwp1ZL1MOXTzHUauf1NBKrElL4uaUFk3eLDYCJqWwtEWjkOW1JgFLNr5tqWxbQaoo4Id230rhN4Tpup77cWEBTFAoa7jTgx/eNt7VhJo39a0s0s/dYGio5XnL6gKU6fUZl6dO83nWHeJ/qUfwTv8fmYvVDw209xfS42hL9tEWA0Usj/8iIlMWP6wtoDRU0qD/uRh6D0WLil3exuIEnE1g5PVoMUtm/CjjwPZB4Gq/TJ9fGX8umWgprk2fxub3hI/2o928fZiS7K5kLoW+eHS0GARSrvrgTOOsZjsN2LqT9QST15cBbE4BrVzAtufogn0mREYDBJi7YOryMHrXYKHBGRmcqCtMgXz0NuGIen3O1JYyAi6zoWfQj8NoZtJZQxfFDW4CXTtD6Yl0ZhabNc4Czn+e4vb6cx7z82ehtrZ7O71Pv6bKdrBYZef7XvEmRfsCV7INNNRT/I8//8meZZnzRB9ozuupAOB10mbYtq5Megq2GhjME/MD+laySrJ5/kwnoexnnL6qAVlPMSpErX4IpFIAb4DP33Ne1iDeAkXEfT9Weh+50YMw/mOatCkz15YxS++oe7qPVyQWd4TdHm+dX7qN4tuZNetu1OZ5Rf6kdtfej8IshyaCCAHCw782MV9ZVPBnA8FtZgeXapcC0VcDYf0QLDkmtWNo3chDvTgPOfVPLm/dk0BNDj05j2d7hBTqdZryvHcZQWIJBuKqKyUzFf38LA699K4Cmar4Y9QYIAFdG6g5xMLLsOX3T0vpyRlmFgnxhv3Ne/MpybQnwweVaqkn5TvokRBrLqiteajWdgJ+VYp4ZxJXCzXNooPncMKA4Is2voYqhz88OBV4Yyc9fOpEvykCEGFZbStPUtyaw3YdXAAfWxh9T7SGGk3/3BAdPpdu5YhNLYzXPT9FGhrAbGdIG/TQwNfK+EATh6MJio+jjyTT2zbA6aQCe1pHPfb3Qf7ubYk6bEYxISsqPH+xa7RSqBk0BTnuE6b560ZRJBXwPXTobuPBDVvqKTbnwZtH76dplwA0/UMzvMi569dmVDPS9lG2uXsDoiMu/4Kq/WlnKYmXEwLXLoJz3NhpPegDKFV8xojYyOiypgEL/2c9TFOl1PtN0ht6gpUS6UoBT7gfOep4+K+40oMuZwNXfasbNAEWwC97XVvDNVkZmXfyx9q715QGXfBa9ym+xcULc7WxeK6uDRu2thsacZ0fYcD08KfFmA8ffrX+eR/6RIqMrhRUA9dIs+12qnf+sHtETJxWTmZMcVzK/b9gt8W0AjhHUY+p6Fo9djxG3sU+6UhmBoIfdTXHJZOI+GtFncjhSIFm/v6n7n9mF6Tudxxlvq81IRus4EzXfKz18+TyXaR2N2yS1DnurHaawgMPL86SKk3rY3UdWLU1RNEHLiKaacBuDyDMVf9hUXvVG0qN0KyfBRiIVwPFUQyWF3d2Ljdtt+4qRGOW7jL3G6su1yI6WBLTVr3KsV7rdONWz+Cd629UUA8ufN97WqumMDirbYSyCbpqtGZAvfFC/TdCvFYgp32WcDvrdE5pJ+Zd36bepOqCJkZX7o8WgSD6/jZFgDZUcc+oJk9u/0a5xdWG0GKTSWA18fgfTBxtrgW/u1x9rf32fJrhWG4hxJT8Bix7jdQk0UiSMFIMAfvb2uTSSB4Dq/cAbMWKcolCo2vAR/zsYAL5/ndFZoQhxuHgj8PqZPE9A2NB/bLQ4XlsCfHi5lsYYCnGM/dFV2nEGGhhd+OGVWn+vOsBtr3iBUXOKwuI9Lx4PlMX4Cgq/CBIhJAhHitUenVqg93nr44ArvqKAooQrXXiztAGJ3U1V3urkAznYxAFNj3OAE+/RBtA9JnJ1M9Yk1OkD+l/GAbA7nYM5vQGFK4Wf25zcZ6NqN0mtmYJh5I+kEmjki3GHwUoWwDSFgVfxpWZkxF30I0UZmxv49p/x0VQABw4bZnJCURM2xIyNqGqsBj68ivn6ngxud+aU6DaqUec1y7iy1FjNF/a3D2tttnzBlYwLPwDahwfX1UXAZ+GyySomEzD2n7xOqqdL5T6ubqlV4ByJLCPd5yItB11RGFW16hUOfOwehhq3HRk9kQv4uYq2bwW3mz+Ik4PYyV4wCNQcZGqhxc7+pVd1DuAAKxTgfknlOUH4fWCxHFlEVUspfYD2PmvpnWaxAkkFCLiz8d2BRRie1Rs2m87KrS8P6HUeq32aLfoTcE8GU27anxh+Lnnjn0sOL9BxNJDdiwsVZhsjPR0R5romE1MnLpvLyUigIZwanh5twpuYTW+Yyr30svJkaEbq6qJPgo/vrA4n8xldW0wxpvVx0QJJRjem+Cx+jD407nRGQBUM0d7ZiTnARTMZFbLuHb4zc/oAp/5Diw6wWHgO/LWMaFAnma2HA2c+rT3vE3MpvL03WVtYMZlopK5GLTh9jKZ97XRtAQXge+G8txmtBgBp7RnttO7d6HOd0lYbSyRmA+MeZ0RF7CT0uJsYIQewwpk3Kz5SyOoIR0G7KSANuJKeX7G0Oo7XwWIDBl7JMZBeNNGo2yhghoI8h3oG5748CmN2N8+Lnqk8wM9cKZx0GkWWObxhj60kioqqsXosXc9mG3eacaS3xcb3ssPNfnxoi/62cvpzHHQ4Hzm7l/3Vk66fFgew71nsLQtjQFioMxmLjQDvOZj0x2aRhIKsDGcUpQ5w/KqEOKYyQq32a7HT69OIwnX8t8QgMgugcOav473Skin+9vm8znuXG7cp28ExY7DJuMowAGz8lOM1o/4H0I+soZyRXhtnGrfb8gUj6Ld+aRxlt/ZNYPiNjDZc87p+m0Ajjy25FVPTjIS9xY/Ss08JRKcZRlK1n+KlL5fPPiMBc95f+PwLNOj7jAHA7u+4PXcasH91fEEJdd+/+Ttw9nMSvf8LI4KQIPzcJGYbpyoBjEQ6+V5gyDWMOrG74ytKJLdimOk3fwd++oQvh06nAifdy0gkgAPbs1/gIC5yYGK2cCVWNeIbdjMVez2G/YGpB+ogTS/CxZbAQbkqQBitzrjS2aalFTaAL4zGKmDPd8Zttn/NgXrFbn0PC4DpY3Wl/M5v/m7wXY0cCI+6gxE6i/4Z30YJAZ/+AbhyHs/ZptnRYhDA8//ZzVzhd3aj2PLuRdGDjsYqvgjNVg5CLVauHr10YvQgdObVQPuTGSbtyaAYtG858/wjX9wZ3YAL39MmJvUVwKbPuPKlrrbl9OHKvJqGB3Dfts7jhKPuENNRRt3JtIvIFdeqgxxkbZrNwXD3iZyIxFanqzrAiVdjDfu1Kz2+jfq9TTUcUKpipB4N1UCoiVWzxA9KEH4TVFdXH77REXlUHUbMAsIVMA/jZeXNPHylTNVwPbevcZuEJCChNz2hlKC+CazVzmfsuEf5/FINamNJygdOfRAYeSvfyXZvvGDvTqfI0ut8TqZtCZwgRQoDNifQegQjuMp38bma1pF/G2kyn9wauHwu/bB2L2GUWdtRYYHApn3f6PtZUXV5OMK313mMWIsUvVoNBa6aT8PmA2sYyTPiNk521ed9Uj5w2efAV3/lOzIUDKcfPqSZt9sTmEYI0Iw42ESRqNM4nht1sSSpNQW7j6dqYwaLnWOcrJ7hfU8FJrzEFJ6q/RHXLJneM+o4K6cPhTw1ikSlzSieD4DjpTOfBmZcED/ZPv2J8MKdmb5Xy5+NF708mUDPczi+cqcD/a4AVr6AOAZOZZ+zuSga/vhhfNSOxcbxjdXObWX11ASPSNqdFO4bSRzHzbggvg3A8YbVETZyNkhJzOzG85mQwvQdo1TJAVdo/d1I9PLlcTvORO6jUcRRt/F8x6upkHokJFMYtjkpnBoJOWqaZ0pr423ZEsKV0Cy8XkYpjmplPVeq/ucAt2GxhdMu7caLpv/OYptqnm+E6nnWUtRYoIFROKFgy35k6v1Sstm4TXUh9yfQ0LKwV7KZ99GuFqLUCtdzO001HAsacXA9+/uPHxq32TGfUf8iCP2iyGhcEH4N1PLULZHaDjjzKeDk+/j/CUnRD0izmS/Ja5bSM6JwHQ3xBoYNsdXJdlpH4NSHWZFEfRlZbMCYB4HUcIi7OkiNzd8GgFF3hSs4ONhmxvn6+zt0Go/Ll8sBoF7ost3NgbTFDrgzGA2jhzeHwkJL1WmA8EuxjuaNRuxfxZd58U/G4dSVe8ODKDMrrxjx/etc8a3cbzxw+fZhoOuZHMh9+0/9Fclt87g64slgxM9b58Qfa/EGDrzHPc7Vxr0r4ssaH1jDtLurF3KwXlfGcsmRXh2bZgNb5nLikDcgfLz7GEYcuXr57cOMguo1if1MUWhg+s752nUymYH+lwMj74gwb6xhZNPnt3N7VicnH8NviY5SqD1Ef4LvnuTgo+MpjKZKahVtJFxdyHOzazEFqtbDOJiPFZiqC8MRAk3hSlcZ+lVGaoo4cDJb2Y+Nqn40VLI/OX0tphiYTCYkJiYafi4Iwm8QsxmHdVGwuQ4fhWFL0AzDDds4Wva6AphWmJR/eO+sxFz+dDzFuI0nHfCMpLijBPXLmdvdFFYmTOekzurUF71S2lJYGf03LTI2tp0nk54og6aEJ3YeLipFill2F9BpDE3eK/dybJLUKhzpFXGOU9tzsaZ4E8c4aZ2YnhcpZnky6EU1aApTnkIBih4ZXTXR0GxhWtuURUy1Kd7IsdGwm/gd6nshqQC4/Eu+p358H1AUKD0mwnTcH7RoOoeHKYWJWeH3WQWFjeNuAnpfoJ3flLaMPv7kOs10PKkAOOvZiKIl6ayGO+OC6Eju/MHAGU9oqZ75gzi2WxEhQplMwEn3RVgSZNEU+o2zoyN8EpKB8S9pkYW9zudCWWz0UscxHEMCbDvyjugKbwDHAKc/oYlxo26j4XasOJHSNlzVEnx/txlJj6BYRt0JeHIYPXfivcAbZ8a3cSTSsBwAUtrpR6kBQL/Leb3NNnoJzf1TfBuzhVExAMdDRguhXc/iuMJkpl/o96/GtwE41gOM0zcBoO3xTMtECGg1zDj9T72H259IY249cvoy0jzkpwhrlJaYP4j/FgwCVjyn3yatg5YK60g0rvKopnemt5Dm6cvjubU6Du+TajIB7hbEfEeicZq28D9DBCFBOJqxu/UHbyo2J1dyxjxAYcTmip/wqhV4Oo6m0m8y80XgztAGXnY3B1Mp7YAF/8fInJS2HNS1GckBLADkD6D3ROzLcdgt9IYAGEEy4CpWbYhl1J1aSebhNzPKRo9BU8O+Gu2MXy6eDA50bAncV6NVlawefEkdbvXaZGXobF0LqzNV+7kvhzYZt2moCEfKmJmjbcTad7gqW7jeuBrOho9obhuoA776i36bulJW20jKZzRPrHErwAHyZ7cAF33Ewezix/VD2efcArQdQUGoci/w6ukxuechrvomtaKZrtnCfPw3ztbaBBporrpvJQfD3kwKVV/fB3z/mtaucB23dcU8zXujch/w1rkUw1QsNmDS20yzszq4Olb0I6u5qEa2VicHr/0u0SYnDZXAnuXAl3fSANThBfpfCQyeEl2po6aY4dWqYXyXMymKxabSVO0HDq6HZfd3GOrOgbWqFQdBkf1K9dCqLuSAPDEn+j6LaleoTbyMxKxQkKKXotCDRK9KB8DPA40UWmUgJQiCHofz5AEo2jgPI3g7PIePjDiSRS+L/d8Tvdq3MOlWo8EKhoRLt+s8B+1ujgfO/Bd9gGyu+GczQLFmzP0IDbsZhw6VICWvA6zOmHGYJwMY+gem4wUaws/xGFN5WwKrAF71Dd+BJhPfT7GVopJb0yerpphpi95szRJAxZ1Gu4EBV3KxxGLn+MGToS0UWqxA/kAa1G+ew/dkwXF8p0eKlL5cft/OhcDat2g8PmhKuEJVeKLu8PC7cvuy6lvlPn4+6g5NgAKA5LaMLPvqXqY6WZ1Anwt5btQFIXcaU4AWPgz88BbfVe50mtN3PUM7Zzl9gLOe4+KlGuWU1hGY+LK2/75cGlq/PSlaDOk2ATjuBk3g6DYB2LsyegxmsQMTX9GMjT2ZNE1+96LoMWZqO0aqqWPvEbcwaiU2ZW/k7dq19GZxTBRrSu5I5OKrWj3r1AcZNR4bcdRpnHaMKe2A3AHx/p8mczjKLhzZNPrvLAYTS2Z3bgMA8gbyXKvenZGcdJ9WyGboNGD+/8W38WZpglCX0xlZpiegDb+VbdUxlN7Y1+HV0mf7XGQsVA2a2rJgJPxPMClKS+UAfn9UVVXB5/OhsrLyZ1vl9fv9mDNnDsaOHaufXy8IvyWqi7j6YLHpl6CuKwOqD0LZ9hWaAiHYu5wKkzcr2rS0poQvhEWPcJCT1Ao44c9A+xO0MN3aEmDBgxQFVEwmhrf3uYiRGo01NArUi1w693Wg8+kc+G2fr1+dxmzlCmRae+anPz1AP/Q3qwcHSBY7zfC2zNU/N2c9B/Q+n2WBXztdv43FRtNxix14epDxqkv/y5mmsHI68NlN+m0AYNpKDlwf62bcpt/lwOmPAcueBebeYdzuhjXcr6f6G4cbn/xXGrRu/IQeFnq4UoApi3msr53O9D09Lvucg9aD64Dnh+u36XI6z6vZDHz2R+bIx2Kx8zwkt+Z1fG6Y/nmdOJ0mtAC9nfQEx7ajWPbbncZ+Ovvm+DLD7nRWdFInNOW7dLw6bMAFHzBKz2pjpNLeZTxn6mDWYgNG/oleHapQVXuI4dILH+S9ZHUAvS6kB0dkqmnVAYqGq18Bgo1A5zM4aEturUVUhYLcpw0fAXuWcuDW9xIOLCMnOo3VvA/3LOV+thoaNqaN8a9oqNSqF9q9PEd6UQL1FeFjVOipoddGbeevYxh/7HdFot6Tesa9wq+OjHGEY5Fjot83VlNoaGnhsb6cz2h7C0JgQ1X4nWzie0PvWe6vD0f1NtI/SU3Ti0T1Sawr0/yYPBnx26ou5DutoZLbcadHj0GB8Fi1kCbICT6mKnkyo4VRfz0XcbbOo2ly25FMr4ushgVQENv1Hd+17nSm1iW1jn6v1ZUyffO7x/nf7U4E+k7m+Fc9zoAfKN9BcWznAi5qDr2BC7aR4+2qA4z8X/kSz2v+IFZhzOymLR7VV3IbX9zJ/bPYKISd+OfoCLpDW4CPpjBCG+B3nnwfI6XUc1ZTDCz4B/D9K5o4ltYROO8tTRAKNDI19d2Lor3N+l/OcY4aNV65F3hrUvTCnt1Nj6HcfhQu6yu4cPj1fdHnuWAwq13GiqbCf8S/o3lIhJAgCNEczpfBlQK4UhBM7YSlixfjuOR28YMlTzhKqMvpXE2wOuINkt3pwAl3s93uJWxTMDh6xcvhYenn7J5cparYy9WPE/9CY1H1JZvTh2lx8/6spV65Uhj+rq4+ejKBM58FProi2kPA4WUIt7oad8KfWbUjNtc7MQdoExY1Utoar7p0n8ioELOFkSYrXtQ/j73DKzst+Vsk5nAQZjJzhTTSRyESNUe/pXQGk0lL5Wsp97wuLGYUtxAFVVfGCJhgk7EYBLBCXKuhTFszYtNnmrigF90E8Hv2rqAYsnORscj2zd8Zkq2E9MPFAWDHAqBqH6932fZ4MQjgdV30GNMDg40sMRspBgHs1zPOB65bzmiiyr0shxu5ehb0A9/cx+vT+TT+/w8zoiugBBpprlq+i34Z7lT6O711Dld4VVa9BGz4kKuxqgdC4XpW/VA9OLbOoyh47hscYFrsHDCveZPfGdnv+18BHP8nLY2g6iDT/jbN0tq1GsaVXfUeCoVoMPnZLVqp4bwBNLfN6KalqTZUcmD8zd+ZzpnSlqvBOb2jvVKqC1llcNV0AAqFzZze8c+Kin2MKCv6keJtbMoIAPgbuLpeuS98v+Ro0YhR7erCfld1HKR6M/UjrxqrNV8FV4rxvdVYzfvpcNGcoSBo6CoRXIIgHCUciU/L4YyvgSOLLLMltGxiDzBayJdnXPVOxZsV/56IJTxWRWbXlvcppS0jpFrCl8fxXLezjY3zXakUlHL7cdzgSIyP2LfaGNV/+hNAY2U4lV1H8ErMYUTYwKv43rW74hdeEnxMWcsbyDGAWmwmNuotrSOjtetKOZZKSIqPZvNkcDFw6HVQaktRFwASUvNhTow4x1YHxwTXLqPpdlMtt+1J10rOA1yQuvgjjmn2f8/xQ1avsLdZeIyQkMSI7U5jgQ0fU1DsMo7RZ4ebgwj/E0QQEgThP0JRFFRWtmBEZzbHr7LEkpDMn5ZMB12pFJYKhvBlZnPFrwQlJHElpuMp9Iwx2/iS8mZrL26bk54FU5dwAlq2g/403c7WjLoBvpAu/4IiwIE1/PvOpzOEWB2kJOYCF8+kABBpoNfqOIpV6gt56A009I71Sup5nhZ9kpjLv9utY7I9+n5tpWTErcBsnUgiq0PLr289jMKPXuBnhzFAQiqjv/IHM5pFDzWPPbun/ucAB2JWBye5tgRjgelwA7ZIgv6WK5uolev2rzZuU7aDx+evo0BjxL7vGf7+wwzjNj++T3+EQCMFQj38dfSmSioA1n+gH0oNAAse4Aqfv57Cph47vuExulOZbhcpBqnUl7P64Oj7KVbMvDrexF0J8ffXLuN+le3gCmIsq15mtFTXMyhqfHk3Dewj2b2YVf7On0EBrXIP8PLJ0QaU+1YCL48Gpi5m6l/QD2yaQ7NYlbpSRvCd+jDvU5uTYtBHV0f7Smz5gvfChJe1aKnin4BXT4uuuOhOY+lx9bnRUMWIsDm3aH3R7gZO/xf7s7qqXXWQUYk/vBUWqp1Mixh6gzYIDYXoYfX1X5l2YbZS5B15mybEAVzhLP6J3lvlOzngHXELQ/UjB+TVBxkht+ZN3iv9Lgun7Eakg4SCFHsPrOW2sntzoB1bnKCplmJlxV6KfYk5fD7EmrM3VLGdv54TPvV+jaWulCbJZgufs3rpMwDMDWUY1LUAZn8tYEvSbQNFoVBrtrYsjAmCIPxWORLjfIcHwGFSKh3u6OqJelhshx9DAy0XsVFxpxpXpG3eJ0aABbz5+GrOHIwd2zveVe1Ivc1Uwa5gsHGbBB9/1DQy4VdFBCFBEH4bRE6g9LA5mfvfklmn3c3VojH/AEKNTGWJNDRWt5PXH7joQ058TeHJUmSotMnESKWrFjCvvKYovLKRHb2fSQUsj7z5c4Yaq2Xns3po7TzpnAB/9zg9dvz1FKhG/43+Ter+dT4dKNrISBFV8HEmMaRXzdX3ZAKnPsKJcSSeDOCU+7VqMWMe4MQ+NgoqfzDz5wHuoydDv2LEqD/xWINNQJ/J+n5RZisr2QBA53HGQkjn0ygKNtVypa5sh367/PDAIrcPYKQJJbehGGixt2xseLi+BAAw8SfQZFwCFgDqy8K+RuuN25Tt5HYaq4yjmwB6HaW2p6+DERs/oWdXQ4VxBZGmWqbWebOBZQZ5+gDLaLceRqHJyO9q30qKCwnJwA/v6lcjCTSwzPSYB5iG9/lt+tv66i80Lk0uYFSgnsno7u8YfdTzXKavzrggWgwCmHb33kXAJXMAbwZD4mMN15tqGQ149bcUN+sruF8/RUSEBRroHRVoBE76KwfoFbvo8aBep2AT8MPbFOyumMd72l8P/PgBI6VUynZQULvgPZbnNpkoQL17cbQXxLp3aeo6+m9czQ2FKBi9fkZ030huA0z+WBOO68qYPrjgAU14dPqYJtlqmJYGUbmP+7X1C/ZbWwIwZBowcIoW0u9voOA4549MIzBbWRHohLujn581JcDOhbAsegRZ1YVQ8gYwgjKtQ7TnVcUeYOMsHr/dCwy5lgJZZEWxplqKXj9+xL7ZcTSjy2IjAWoPsd3eFaxklNePkV6RaR6Konl1NVZzG7EVuACep+pC9m+rk89xvUlRUy2/N+Tn/hutUNdXsK3JzGetUbRXXRm35UwyToNUFArKZtuRTTIFQRAE4X+ECEKCIBx7WCyA5TDVYlypLZclNZkoxERW0tIjKZ9hv73Oo0iht3qemM2c7iHTOImxu+KjazzpjD4afA1TnewebtsTESHg8HAiXTAIWPUqU6M6juEENXJFJ6MrjS6//AuwexEnlgOn0H9GzWP35TEK44PLtGgVWwLL33Yex+O3OlhieN+K6KprZis9ntToJl8etx1pKg1QZDjxHs2kdMyDwNvnxp+fvIHaRLXNSB67msMeyfF3cjLXWEPPnY0z49tYnUB2L/53r/M5ydaj57mckAI8DrVKTCxZvTgxzB/EKBU9MjpzQhtIMI7gAniNTWb6KxhhTWAbI7FLJdhIMaP6gHGb2mK2aaw2rsAHUBRMzAG2G0RKARR3Gqpoym4kevnrgZpCrgpGVsuJZcXzQIeTKUQZCYSHtgJ1JRRxjCqyKApNPk9/gtuKFIMiWf0KDUEtORTQ9Pa/upARQwOn8HzoRV0pIWDW9by3vNksgx1rDAoAP7zDlNE26bw+b0+M/87yndzWuW8wAnLvini/hYZKmqteu4wiTU0xMONC4OBarY2/nlFMFhurIFntTPubfoomCIcCTNfcu4y+X748ih8LHmAkWRjT1i8ZLTd5lpY+W74LmD4m+v7Y/nVY9Po7xVd/HbB5bnS67g9vh58xs7XIq+pC4JNprMKoYrEB57xGc15bAv++cD3wziT6bAC8p3pdBJz0Fy39oq4MWPceMP/v7N8AK/SMf0EzsQcYbfX135iOGQpQlB7zAM14VQHdX89osHl/BvYs43th8HVMIYl8TtcU019u6VO8Nu1HM+U50kNEUcK+Xx/zPHmzwwUd2kZHvjZUhgW0mTyWLuO4kh77Xqgu4qLEgTVAYh6Q3YNVOiOjxoIBXp/KvbwWaspzbLpQYy2fCfUVfE+5Dd6BdWVh0SvAfTaKBK0upPio+hHGRrIBfN+pqdcJSS2kZtYC/lo+/5xe/TYABTtF+ffKgRtgMpmQnHwE6VKCIAi/cUQQEgRB+F9jMh0+v97qOHwYrpqnr0bxGLXJ6gGMfZgDdr3VZ1tYFDn3tfCKd7gMaGROOcAyo5M/5up5oIECSawpY2IOcP67nMDu+o6CTKvjokvFu1JodNjldGDJk5xwdBzDaiSR6XoFQ4ELPwS+uIMTfpuLQtJxN2gTPV8ecOlsGhuqqXgWOzDij1rpV4eHERhF65n+o2KxAee9owlVqW0ZGREbHePJZNlamxOwZnOC+P6l8eex8+naZKjL6ZxAx6ZwARS9XCkUyjqeSmEhFnc6z4XFSsPKDR/GtwFo4OhOpyDkydRS6SIxW5i6ZHMB7U7iJFWPgqH0OfDXaf5SerjTeY49LYSmq23MhxlWmK2MignqmLurBJq4L4EWvK4ATjb9dcaiEcDoIdXM1IhQgFEkNhcr5Rix8RMKORW79c3pAU6868p4nJGG+bGseIEiYuVe4wqJO7/lZ0qQfcto39e+QzGk6kC0GBTJd08CvS6g+Pv1X+OjAwEKFXuWAz3y2K8ixKBmlBAw+0YKR45Eem3piaU/vEMh3J1G0WLm1fFCaOU+elud/TxgdQHfvx4tBgEUDN67GLhuFe/Xyn2MplKN2wFud+0bFI2H3cR7aNvXwNzbo7d14HvgtXHAlV/zOVJ1EHhrQnSkXdkOimwXzWQRBIA+V6+cqt0fNUWMdtv5LTD+ubCf3CGmGW+MSLtc8RyFr6u+1oxZD20Fpo+O3v91M2gY2/cSPrsaKoHv34j2Glv1ElMJz39HSyOp3Ae8cz79tVTsHqYz5/TlefA30Ez+vcma6Ggys3DAkOu0aMmaImDBQ6wgqvaNvIH0NVPFeEXhuZo1jZGDACPYTnuMixDqYkddGbD9G/azij0U/gdfy+OLjL6q3Acsf4HXLujn83TErRSs1MjYplpek28f4XEmteKzPrNbtIBWXQQcWA2seClcdv4iRj9GptyEgrzftnxBYS+7N9D1dPYFS8R7sr4cqDoIy5a5GOxvgvVQMhd+Yj1cqg5SEC3dxndycuv4FB9/A4VCNYU5KZ8eg7EV3+orKKY3VPEe1Yt4A8IRbxU8PwnJ+v4zamRcMBwF7c3S97xprNa25UrVr3QJsG8bpes3f2eQ0bImc8upSYFGjiVsbn2BUCUUAGAWzzVB+IUQQUgQBOH3iNkMmA+TipCQZDzAU3Gna8bDRngz+dNSvrg7nVEf+YOYTuHwxQ8InV6gw0lA9mc0/VVNEiPTLswWmohf8RUn+cEmbR8jPVCS8hl9ULKJ6UlJ+Uxh8+ZoIpk7ncbRPc9hJElTLU0au0/QzC9NJqDtCTRl/PIuTogSkqEMuQ6mPhdrkwRfPiOqPrxcEyicSRSTssIRSc5E4NSHmDITWYEjIZkpiupkIr0ThYfY1LGsnoxcMps5yB/3GFOqYhlxO4/NZAK6nQV891j0BBTgBGj4LWGzyjSg61n6aWM5fRm5ZEvgBDLWZ0hl2M3sS/46YwN0VypFrIQkoOf5NJzUo9d5gDMZcKWHBSQd8UKtQGN3A5k9jNPncvqwTaTppR52D7fZUjtnMvfHpDO5isRkOrx5u7+WQk9dWcvbCjRwEhVb8jiS4g0U0SLFz1iaarSKQrsWG7fb9CnQfXzLXl2l25iyGPID6981brfuPRqs7luhfw0BptPWHuI9vuwZ/TahILDlc/a/g2vj+7LK0qdYBdJspZm7HtWFTNHz5dHw3KjffPEnIOtTnq85t+qLpdu/oqjhTuc9vVHn3misAr76K83ZQ0Gm6ent/5d3USR3eHjvRIpBKgfXAitfZunvYBNLfUeKQQCv85vjgWuW8plXtR94+5xofzMlBCx+lGnPPSawfy15iqJTJPtWAG9N5HPUm8loqlfGRO9/+S7grfHAld+wQEIwAGyYCXx2s9amvhyYfz/P9WmP8HlXuZ/CXul2rd0Pb1Msv3oBo8YUhc/ut8/Vzn/ZDpYAP/VhoO/FfC5VF9GzbPs32rZ2LuTxXfi+9lwtXE8/MjW6dMNHwIL7Kf4VDOa7pbaUEYfLnoEJgB0AFj3A1OiT/qK9C8t2AG+czeNXSSpgtVJ1wUb1NvvsZq3YhS2BAlqXcVqEVuV+iqyqGG0yMQr31Ie0ffc38J6cNU17v6R3Bs58hos76ru0poii2PJneb+7Uimg9Zio7XsoyHv4q3tZUdVsBbqfQ888NUUVYKruru/CZef3snDASfdQjIuMLqvYA6x9m9UzrQ5gwNV810d62zRUcb+XPcPFo/whQL9LtEUQlaqDwP5V9Peze4EBl3NxI1Jk8jcwsnLz59xmm5Hse7HppzUl4epg33K80WY4+7E9InosFOI9UrqV/SizK8957JinoZoRqeW7+D5JzI32qFSpLmY7f304RTUj3isoKpXVEW6nk8auRtwGwgbV3mx9gay6iH1aHS/pCXuBJo6XlBD3v4XKoJbGGgzonA+TfgtSU8z3lzPJWEgMNPL5Z3EePqovFGSfirVwiN2e2aovbgr/NSIICYIgCL8ch4uUAqLLrxqRmH14M0W1TbvjW/iuDFa6aDU87Pvhix9wJPg4wM3uhZC/HofKKpCS3xlWe4xQlduHnlF1hzgBdqXS/yRywJuUzxX8ij1MxUsqYPSAL08bDLnTmELY52JOAAN1FIhy+mrHbDZzIHzl18A39wNF6wBfATDydiB/oJYykVSgmaSrkULZvYDTHuVKPMBrcsr9nLRERi/lDwpXPgsPjtM6AsffzTScSAZN4cQf4KB14nRO9iKjaCw2/t6bFZ7wjOWkJTa6J6kVRTmzmedh0DXA0n/FX7fB1/Ha2VyMCtnwUfyk3WzlvlntFJfSO+tXxSsYyu9ypQBDpwEfXhnfBqA3ji2B19DmovgVS1IrbichmVFjyw08nHpdwG2lttf/HGBfdPr4XeldgD1L9NvlD+YxJraQvmq2cjuqgXSs0b1KYi6vj9EgX8VkARS0nGoYDItADS34ZikhTgZCQWOhB6AYATDCxoiGCk58zIH4qoCR7FvF/rdzkXGbkk28vmqKmhE7FlB0NEpHBHhP1VfwmbBzgX4bRQF2L6WYsO4D422tepkRhMEmY9+vxuqw2X0+xRkjs/uFD3KS7K8HVr6o3+bQFooB3kyKcnrXSFGYdnfuq5wAxqY2qvz4ATDqdt4buxZHi0EqDRUU50+5n4LErGn6fezLu2gYn9yKkUGRYpBK0Y+8LgOnUCj54LL4VONAIyPQpixiFFDxBn1hcs3r9LvrNIYT6/cuiRaDAPa5dy8CJn/CZ1PptnhvM389xauMhayoWFcGfHIdRS4VRQmnH5uAM5/iM6B8J5+pkcJqySZWmbxmCftNQyUw714Kayp1pcDcO/jZsBuZMl2+C3jxBO1cBJtotL9zPnD5l+w3jTVMn/32IW1be5Yw1fTc1xnNZTbzmF8eHR0l+On1fCad+yrfB/56ps/Oul5rs3cFsPIF4NLPtHdH1YH46prr3mFFzBPu4nMr0ESPuXfO087Fypco4lz6mfZOqy4EPrke2BYR8WkyA2f8i+8Xh5fPnANrKaA2VGjtWg0NFzYIi3G1JYxQW/G8FuWYkAyc9zaQO4BGywAFz3cv4j0D8Jk74CouvKh+anVlLEDxzX1aKmt2L2D8S4zIVinfDXz+R4qEisJ38Ml/Y/9Tq741VDH6b+4dfI9abECPSaweGimOVR3gPbX6FYovuf25UJXZXVtE89ezP331V5j3LEWOOx3K0Ou5UBQZ1VddSBFx2TP8/vajgWE3hP0bw+OmYIB9bNmztCTwZPEdnd0zOgW1poSC9rJn2Re7nc2xWGSkvJpiu+kz3iPJbYB+l3Jc8zOkhQoaEosnCIIgCE5vOK2rhdUnTwaCnhws/XEXFJPB69ObyRXU7F7hVASddRdvJpA/AOh/GdD+RA6AYlfG3GlAqyFMSZn4KicjsQKYw0MD9HNf5YTmog85YIxc/TOZGHF07hvADWuB678HLvqIfxeZTpiYA5z1LDBtFaOvrlvO9LrIMsGuZAos01YB4x4Hxj4CXLcCGHWntsJpMgE5/YBrlgEj76CQNuwWRiwUDNHOry8PuORT/m1yawopI28HLvtMG8w6PEwXPOUBbSDpTqMp/NBp2mA2pS3NnCOFxMQcHqeakujN4AA+OaJSGEA/rbOf185Z6xGc7MQy8GqtGoonEzjjqfhrZrEzEsSbzZXfwdfol2xO68hrC3AFucuZ8W2AsHl7FiOqTvyLfhu7mwNpgGbdRlVpepzDSYk7g5E2RvS+kP/m9DFO/2s1TBO9up5lvK2e5/DfgkHGbdI68t6zJWjeXnq0HcV/s3oat1HTWS32lv3f0jvxX18LKbp2j7Ya3VIapDOJ/5ptxm3MFi1qrCXUNMpYE/VIGqs4SQo0tuwjVlPIf/WqFapU7KFY5K9tOZqtbCfbRYoWsRxcw8lmfWX05DqWQ1sZ4dFSZNnmzzSfoupC/TbBJk46m2oZEWPEqumMQKstNU4trSulYNRUy0gpI757nMdXeyg+MkuleCM/b6plOqXhtp6g4Fh7yPi8bvqUn/vruC29KLtAA7D6NU7Caw9RQDHa9+qisJH+0/oefFUHtCil2hJg8T/1t/XZLRSAgn6ee72U0b3LGIkHMJokMmJMxV8PfHwtPw8GmSap119Xvcw+CPC73rs4/lxUHQBm3xwWXkMUXSLFIID33yfXMSJL/Zs3z47vr7uXAAv+ATTV817bNIfCfmTKa305I8SqwsJ65T7gtdM1MQjgPi5/lpG+wfC9umMBhR5VDAKYkvraaZpIX3WAVTm3fKF9Z20JhcTI9O+9Kxg9p/broB9Y+ybw1rnafVNdyLTSpU9p6ez7V1HYizzXB9ZSJNwxn32kci9Mn9/Gc1obfh7VFAMfXwd8+geKX9UHgTWvAc+PjBZ3i34EnjuOEYclmxmt98ZZwJKntcWB2kP0ZHtzPNOE9yxl0YdXxkSL+SWbgedHMGJz65cU5Z4dAmya3fIzS/i3kQghQRAEQThaMVsPv3SjRpK0xJGkBx5JG9XHKtKYNxarjX4vamqLxa4fCu7LA4bfyhU/gKlrsT5WngyKUN3O5CTY6uSKY2TovN1F/6irF2iTaVcqhZnI701tR++bqn0cfCe1YlRApJDkzQROf4yr6Rs/Ztplt7OjPUSsDkYnTFnEVfTSLRTBBlwR7YmV1Aq4aj59szZ+DFgcQN/J9FJRo3lcycDYh3i+VrzIiZo3i5FYncdy1RegyDhhOvD5rVqaWUpbrmSrAlpiLkWwtyZGRwC1PZ6Ckurx0m08sO2beL+e0/6pbcudQdHr46nRbVwpwLhHNaFr1B3cTmzqW6dxTPVQ96vTOGDz7Og2JhNFRfX8n3I/8Oo4xJHchqvLAEU5o5TEUXewb0ChR868P8e3sbu11Na2I41TEgdcyf0KNPF8rX8vvo3JrFVS7HoGsOjh+DYA0G0C/df89fStMfJ5anUc/+1yOr189Gh7vLYyblQFEtCEs1bDGCWkR2ZXCnEhP+/RYJN+u+QCnic1+kIPbzb7qlFVNZWEZJ43ewuRomokW0vpI4AmLhulIzZ/pgAhg2NTCTTw+OsM/LyAcEXJJqYzt0RTLUWvcp0IKJXSbewPLUXFKQrFCocXOLDKuN2eJVoVP6OCBep3WR2H8Un7mCm7ZduNBcfaEm7LbNa/L1RWv8r+WrLJOEqtZBO3pQSB1dNb3lZuP0a+GQkBO+bzOeSvpwBixPr36WlYvFG/aibAKKvhN/N8RUZJRRJooMn+wKuA4k36fn4AxbgeEykaG0XP1RQzJdCXRxHESLyc9xdG7ppM9FrUo3gD+5c3i//qPW+UECOLLnyf/z3nFn3BevNsoOp2puyV7dAvLNFUQ7+ws5+nqD37Ri1FMpLF/wR6X8DxQ/ku+szFUrmP78vR97NPz7peX2CeNY3P8cgUR+G/QgQhQRAEQRB+ftRKdC1hsRiX+VYxW1pOhwI4OUnMMY6QUVHTCPMGGLdRPany+hu3cXho3j7uMU5A7C5NvFExmeiFMuYB+niYzExdixW9vFnA8XcxNSLYxEl6rJjlTKQfVMEgzbTalRp/7jK6AFfM4ypz7SFO5t2Z0R4c3izg7GeZhrXta0botDuJ21K9QewuChPZvaB8/xpM5TuhtDsRpk6nRkeNJbeh6LX6Na7aOrysltjqOC1NwpVKEan1UGDJv1jJKncAq5BldtW2ld2bXl2f38bJh9nCaK2T79Ouqy8XuGQW8OFVNIkGKCCMuBXocoYmFPY6j5OhNa9rk2R3Gg3wVdHLm80ouHcvjBZDWg0DBk3l9bTYgBPupp9ObIrQmU9r59+Xxyiy2Op5nkwKVXYXf8Y9yqpsseJL/8s1YSyzG32ximJS1Sw24KS/Uvy1e4ET741PSQIYiadWv+xwMtvrTXxPuo8Cny2BIqVe2lhya6aimkz00Vn2jL7oMPzWsG+Zledvt45PVUIy+47VDgy6Wr8KJEAB2J3OCWpSK33/LJuL27K76SW0c6H+tnqeBySkaj4sehUELTb2L0ci0OEUY/+sdifRi0aNJNUTTExmzdssqxdQtCG+DRD2NvMcXsh3JFIE9+Xrp9gBvEY2J9u2hC2Bzw2nTzO5jiUhlW2sTv3PVcxWAKaWI2rN1iOLjFNC7FN+HRFBRY2Mayn6DOB9ZXW0LOypx16pIypHbifQyOMzSq8FgKKN/Ld4o3Gb+nIKJJYQU/+M2LuS6Wx7Vxi3Kd+lCWItpc/u+o6m6lvnGbfZv5qiS9Bv3E8BptZm92RlRCO2fB5O2W2Mrjgby56lQFp7FkIw4ocZ9CT01/G5q0fQz1ReEYR+NkQQEgRBEARB+E+w2vUr+UW1cR5eqLLYDl9l0Gyh8BBrnhrLkQhjquiV29e4jcMDZHZF8KS/Y/26NejRqy+s1phho8nEQfnxd7KSlMWqnybnzaQfVPcJnEjbXIyOivo+LwWMrLlhM1Ibo8ZivSJS21M4qjsUNm9NoehlixAfPRmsNHjcDfTjcCTynEQas9qcjBKatopVs2pL6H3iy9PELIA+NZfO4QRqy1yKkz0m8l/VoNaVwpTHrmcCS59hNEmXM2geHCmgZfZgZNmifzKyw53OyU+rIdr5SMwGLngXWP582PejBmgzChh9n1atzGwGOp3KVfmv7mX6htVBb6qRt2m+X7587vtHV2mTVlcq0y7VqCtbAgW1urLo6obpnZlmqaaqJuUB419m1FikoDXwap5HgMdw5r+A186IFh3sbqZ1qhUe0zoyMnD1q9HXtmAwRUCTicLl+BeYihP5fSYTxThVQGt1nL6A5ssHep0fFp2z2B8+/QPiGHEbI+LMFgqJy5+Nj9xxeBkJYrXz3Pa9hOlosfS+MGzC7wSOu56pcbHCkdnKe8Xq4LbyBzPFKpZ2J2nVxobfynQjPYZM47Y8GTxmPbEntx/vJXcqMOR64OMp+tsaPCVc8bQV+7ZeallGF/ahhBT63BlVQOx/Be/h9M7GAlpKW27H6QU6nUYvIz16XcA+n91b/3OA96Mzkc+WgiHG1TU7jeW/WT2Mt+VOZ5+12JliamQ+r0YbZnTV/xzg89DqpFjYUlSfmpLcksjhSAwvPCjGPnaA9vxvqSCIzcV9MltbrjKq+j7GVsaLxGwDWrahJmqqfUsRe6Egxb+WUmIBSRn7mRFBSBAEQRAEQdBFAbBn30F072mQjgJwkuJpYfIBaNXxDodatbAl3Kktl7cGtFTKloy7rQ4KPmppdSN8ufzpekYL+5QGuIdx8h3061fNsdqBjM7A6U+ERS+7fsUfXy7TWgZPDVcG8tLcPhJXCtBzEtPWmmo1gSHSENxsBrK6A5NnMZ0y5OcEPLYUuVq18IQ7afbqTOS2Isua2z30Mpu2iuJSUy19nzwZ0ZEuKW2BK75g9MS+VUzVzB/ECbv6ne404IS/UFBY8wbTsHqfz4l1ZB/J7Uv/sdWv0PsktQMjiJLbaNGHiTnAhe/RQHrVK0wT63kexR1VZLXY6Hfly2d6S8lmTchsPVzzI0sqYITdvL9Q/IPCyLjR92vpoA4P/b2cSfSW8ddxcj3gSoozapRdchvgwg8ZxVV1ILyvucBZz2iTfncqjfs/vALYu1w77jYjgTOe1FJ4s7ozOuyb+7SJssUGjP2nlsqXmEMh8bXTo32ofPnA+Be1+6Xd8RRFIgsIAPQWUwVHTxYw8RVgxnnRE3OHlyKdeq/3uYhpY7HRSx1P1aL/3Om81l/dE93GbOUxqvf6iFvomxQbxZXdS/MX82RQVP7xQ8Rx6oNaZOXJ99ETJ1bkSCrQokOTC5haqecHdcLdmnh80l9pYh2LK4UG1ADFHE+mftrYcTcCnvB+DbsFmHt7fBubixE9AEUmW4K+4DHwan6PEqIoufzZ+DYWm7atTmOAeXfrR/X1vYTXJuhnVTs9Y3yTGWgdTmXtNgFYbOCL1fsCioT+Op7ffSt1tmXSBLSe5wHfv66/ra5nh6PwwmmqRulzOX30fy/8R5gUxSjh9PdJVVUVfD4fKisrkZh4BNVujgC/3485c+Zg7NixsNlaMBYUhN8R0u+FYxHp98KxhvR54X+OorTsGRT0c7JpTTCOyFMUpklCYepTbGqmSm1pOIXHbixiNlYjVFeGqspKeDPyYYmNZgPoL1VTyIm7LYET9dgUWUVh9FZdGQATJ7p61TFrD/GnoYIRJe70eKGwsYZRbMUbKayldwlXWowQABWFXkJFG4BD24CsbhR5YiMGa0qYirfxY5YF73YWxarI4/TXM9rohxn0+ikYyog3X0G0h1vlPnqSrXuHkTCDpjKSJ1LUrS8HCn8Evn2YHm45/YHhNwLJbbXIk1A4pWrxYzQWt7kYZdTrvOj9rykC1r0PLHmC0TZZPRn9ldNXi2bx19HUes6tTC0yW2jef9K90eJv5T7gyz8DP31C4cuVApzwZ4qH6vmvLwc2zqJIqKasZfVgZbCMztq2jqTKWE0xsOBB+iVFprKeN4MCh8UKBPzA/pU0jI40n+4wBjjjCU0wrToAvHcpsC9CSLTYgUlvUSS2ORnhtfFT4JNrokWhrJ7A+TO01NKyncCrp8V7s535DPuG3Q3UlTOyMbbqpy+fxSBUwbTwR5pWx0aXnfgXYMDVjAZTDapjjb9dKaycqoqcO8KG1LHC3qApLEhxOM/DY5x/R/MQQehnQAZLwrGI9HvhWET6vXCsIX1eOBaRfh9BMKBfMTOShioKL6p5vVGbQAOjrGwu/TaqAbbJTGFMz6coFKIwpAQpQqlVLmOpPcSII1PYc82hs2+NNWyn7pc3O/47gwEKew0VWhVDve+sKQpXhqsPt0mPT3ltqKKwV7GbkX+xqayR33doC6O9MrtTcIyNiqwp5nb2LKc4mD9Qq3Kp0lQDVB0ENn/O9h1OZhpcbLRm5T5gzzIomz9H0JMDS98LYPLlR+9/XRlQuhVY/iLQUAZ0HQ+0GxWdxhwKslLY6teAXQu5P0NvANI6RQuO1YUUfJY/S+Gr8+lA/0spLKnisL+e52D+/UzZ9WZTYGs93PiaC838O5qHpIwJgiAIgiAIgiAI8RxODAK06JzDtjkC8+vIqCc9zGb9SKtY3GmHFw4cnnjRJhaLNZx+eBifN09mdNVKPdRKnantDv99h/OV82Twp6UiCXYPq4K2VBkUoKjTYyKCXc7CihUrMCC5fbwQ6koBXIMYjRUK6F8ns4XFFE64G2j6A6tr2nXEP28W0GsSBapQgJFxsYUZbAlMFxz/EoUti12EoP8RIggJgiAIgiAIgiAIwjGMoigoKSlpuZFagbHFNgYFBmLR81CLRRXRhP8Z5sM3EQRBEARBEARBEARBEH5PiCAkCIIgCIIgCIIgCIJwjCGCkCAIgiAIgiAIgiAIwjGGCEKCIAiCIAiCIAiCIAjHGCIICYIgCIIgCIIgCIIgHGOIICQIgiAIgiAIgiAIgnCMIYKQIAiCIAiCIAiCIAjCMYYIQoIgCIIgCIIgCIIgCMcYIggJgiAIgiAIgiAIgiAcY4ggJAiCIAiCIAiCIAiCcIwhgpAgCIIgCIIgCIIgCMIxhghCgiAIgiAIgiAIgiAIxxgiCAmCIAiCIAiCIAiCIBxjiCAkCIIgCIIgCIIgCIJwjCGCkCAIgiAIgiAIgiAIwjGGCEKCIAiCIAiCIAiCIAjHGCIICYIgCIIgCIIgCIIgHGP86oLQM888gzZt2sDpdKJfv35YtGhRi+0XLlyIfv36wel0om3btnjuued+oT0VBEEQBEEQBEEQBEH4ffCrCkLvvvsubrzxRtx1111Ys2YNhg8fjlNPPRV79uzRbb9z506MHTsWw4cPx5o1a3DnnXfihhtuwIcffvgL77kgCIIgCIIgCIIgCMJvl19VEHr00UdxxRVX4Morr0SXLl3w+OOPIz8/H88++6xu++eeew4FBQV4/PHH0aVLF1x55ZW4/PLL8cgjj/zCey4IgiAIgiAIgiAIgvDbxfprfXFTUxNWr16NO+64I+r3o0ePxpIlS3T/ZunSpRg9enTU70455RS8/PLL8Pv9sNlscX/T2NiIxsbG5v+vrKwEAJSVlcHv9/+3hwEA8Pv9qKurQ2lpqe4+CMLvEen3wrGI9HvhWEP6vHAsIv1eOBaRfv/7obq6GgCgKMph2/5qgtChQ4cQDAaRmZkZ9fvMzEwUFhbq/k1hYaFu+0AggEOHDiE7Ozvubx544AH89a9/jft9mzZt/ou9FwRBEARBEARBEARBODqprq6Gz+drsc2vJgipmEymqP9XFCXud4drr/d7lT/96U+4+eabm/8/FAqhrKwMqampLX7Pv0NVVRXy8/Oxd+9eJCYm/izbFISjHen3wrGI9HvhWEP6vHAsIv1eOBaRfv/7QVEUVFdXIycn57BtfzVBKC0tDRaLJS4aqLi4OC4KSCUrK0u3vdVqRWpqqu7fOBwOOByOqN8lJSX95zveAomJiXLzCMcc0u+FYxHp98KxhvR54VhE+r1wLCL9/vfB4SKDVH41U2m73Y5+/fph3rx5Ub+fN28ehg4dqvs3Q4YMiWv/5Zdfon///pLnKAiCIAiCIAiCIAiCcIT8qlXGbr75Zrz00kuYPn06fvrpJ9x0003Ys2cPpk6dCoDpXpMnT25uP3XqVOzevRs333wzfvrpJ0yfPh0vv/wybr311l/rEARBEARBEARBEARBEH5z/KoeQpMmTUJpaSnuu+8+HDx4EN27d8ecOXPQqlUrAMDBgwexZ8+e5vZt2rTBnDlzcNNNN+Hpp59GTk4OnnzySUyYMOHXOgQATEu755574lLTBOH3jPR74VhE+r1wrCF9XjgWkX4vHItIvz82MSlHUotMEARBEARBEARBEARB+N3wq6aMCYIgCIIgCIIgCIIgCL88IggJgiAIgiAIgiAIgiAcY4ggJAiCIAiCIAiCIAiCcIwhgpAgCIIgCIIgCIIgCMIxhghCYR544AEMGDAAXq8XGRkZOOuss7B58+aoNoqi4N5770VOTg4SEhIwatQobNiwofnzsrIyXH/99ejUqRNcLhcKCgpwww03oLKyMmo75eXluPjii+Hz+eDz+XDxxRejoqLilzhMQWjm5+jzsW1PPfVUmEwmfPzxx1GfSZ8XjhZ+zn6/dOlSnHDCCXC73UhKSsKoUaNQX1/f/Ln0e+Fo4efq94WFhbj44ouRlZUFt9uNvn374oMPPohqI/1eOBo4kj7/0Ucf4ZRTTkFaWhpMJhPWrl0bt53GxkZcf/31SEtLg9vtxhlnnIF9+/ZFtZE+Lxwt/Bz9Xuazxx4iCIVZuHAhrrvuOixbtgzz5s1DIBDA6NGjUVtb29zmoYcewqOPPoqnnnoKK1euRFZWFk4++WRUV1cDAA4cOIADBw7gkUcewfr16/Hqq69i7ty5uOKKK6K+64ILLsDatWsxd+5czJ07F2vXrsXFF1/8ix6vIPwcfT6Sxx9/HCaTSfe7pM8LRws/V79funQpxowZg9GjR2PFihVYuXIlpk2bBrNZe61KvxeOFn6ufn/xxRdj8+bNmDVrFtavX4/x48dj0qRJWLNmTXMb6ffC0cCR9Pna2locd9xxePDBBw23c+ONN2LmzJmYMWMGFi9ejJqaGowbNw7BYLC5jfR54Wjh5+j3Mp89BlEEXYqLixUAysKFCxVFUZRQKKRkZWUpDz74YHObhoYGxefzKc8995zhdt577z3Fbrcrfr9fURRF2bhxowJAWbZsWXObpUuXKgCUTZs2/Y+ORhAOz3/T59euXavk5eUpBw8eVAAoM2fObP5M+rxwNPOf9vtBgwYpd999t+F2pd8LRzP/ab93u93K66+/HrWtlJQU5aWXXlIURfq9cPQS2+cj2blzpwJAWbNmTdTvKyoqFJvNpsyYMaP5d/v371fMZrMyd+5cRVGkzwtHN/9Jv9dD5rO/byRCyAA1LC4lJQUAsHPnThQWFmL06NHNbRwOB0aOHIklS5a0uJ3ExERYrVYAXFX2+XwYNGhQc5vBgwfD5/O1uB1B+F/zn/b5uro6nH/++XjqqaeQlZUVt13p88LRzH/S74uLi7F8+XJkZGRg6NChyMzMxMiRI7F48eLmv5F+LxzN/KfP+2HDhuHdd99FWVkZQqEQZsyYgcbGRowaNQqA9Hvh6CW2zx8Jq1evht/vj7ovcnJy0L179+b+LH1eOJr5T/q90XZkPvv7RQQhHRRFwc0334xhw4ahe/fuAJg3DwCZmZlRbTMzM5s/i6W0tBR/+9vfMGXKlObfFRYWIiMjI65tRkaG4XYE4X/Nf9Pnb7rpJgwdOhRnnnmm7ralzwtHK/9pv9+xYwcA4N5778VVV12FuXPnom/fvjjxxBOxdevW5u1IvxeORv6b5/27776LQCCA1NRUOBwOTJkyBTNnzkS7du2atyP9Xjja0OvzR0JhYSHsdjuSk5Ojfh95X0ifF45W/tN+H4vMZ3//WH/tHTgamTZtGtatWxe12qsS65GiKIqub0pVVRVOO+00dO3aFffcc0+L22hpO4LwS/Cf9vlZs2bhm2++ifKP0EP6vHA08p/2+1AoBACYMmUKLrvsMgBAnz598PXXX2P69Ol44IEHdLcRux1B+DX4b8Y4d999N8rLy/HVV18hLS0NH3/8Mc455xwsWrQIPXr00N2G3nYE4ZekpT7/nxDbn6XPC0cjP0e/l/nssYFECMVw/fXXY9asWZg/fz7y8vKaf6+mwsSqnsXFxXEratXV1RgzZgw8Hg9mzpwJm80WtZ2ioqK47y0pKYnbjiD8Evw3ff6bb77B9u3bkZSUBKvV2hxKOmHChOYUAunzwtHIf9Pvs7OzAQBdu3aNatOlSxfs2bOneTvS74Wjjf+m32/fvh1PPfUUpk+fjhNPPBG9evXCPffcg/79++Ppp59u3o70e+FowqjPHwlZWVloampCeXl51O8j7wvp88LRyH/T71VkPnvsIIJQGEVRMG3aNHz00Uf45ptv0KZNm6jP27Rpg6ysLMybN6/5d01NTVi4cCGGDh3a/LuqqiqMHj0adrsds2bNgtPpjNrOkCFDUFlZiRUrVjT/bvny5aisrIzajiD8r/k5+vwdd9yBdevWYe3atc0/APDYY4/hlVdeASB9Xji6+Dn6fevWrZGTkxNXynXLli1o1aoVAOn3wtHFz9Hv6+rqACCqkh4AWCyW5qg56ffC0cLh+vyR0K9fP9hstqj74uDBg/jxxx+b+7P0eeFo4ufo94DMZ485fkED66Oaa665RvH5fMqCBQuUgwcPNv/U1dU1t3nwwQcVn8+nfPTRR8r69euV888/X8nOzlaqqqoURVGUqqoqZdCgQUqPHj2Ubdu2RW0nEAg0b2fMmDFKz549laVLlypLly5VevTooYwbN+4XP2bh2Obn6PN6IKbKmKJInxeOHn6ufv/YY48piYmJyvvvv69s3bpVufvuuxWn06ls27atuY30e+Fo4efo901NTUr79u2V4cOHK8uXL1e2bdumPPLII4rJZFI+++yz5u1IvxeOBo6kz5eWlipr1qxRPvvsMwWAMmPGDGXNmjXKwYMHm9tMnTpVycvLU7766ivl+++/V0444QSlV69eMq4Xjkp+jn4v89ljDxGEwgDQ/XnllVea24RCIeWee+5RsrKyFIfDoYwYMUJZv3598+fz58833M7OnTub25WWlioXXnih4vV6Fa/Xq1x44YVKeXn5L3ewgqD8PH3eaLuxgpD0eeFo4efs9w888ICSl5enuFwuZciQIcqiRYuiPpd+Lxwt/Fz9fsuWLcr48eOVjIwMxeVyKT179owrQy/9XjgaOJI+/8orr+i2ueeee5rb1NfXK9OmTVNSUlKUhIQEZdy4ccqePXuivkv6vHC08HP0e5nPHnuYFEVRfo5II0EQBEEQBEEQBEEQBOG3gXgICYIgCIIgCIIgCIIgHGOIICQIgiAIgiAIgiAIgnCMIYKQIAiCIAiCIAiCIAjCMYYIQoIgCIIgCIIgCIIgCMcYIggJgiAIgiAIgiAIgiAcY4ggJAiCIAiCIAiCIAiCcIwhgpAgCIIgCIIgCIIgCMIxhghCgiAIgiAI/yELFiyAyWRCRUXFr70rgiAIgiAI/xYmRVGUX3snBEEQBEEQfguMGjUKvXv3xuOPPw4AaGpqQllZGTIzM2EymX7dnRMEQRAEQfg3sP7aOyAIgiAIgvBbxW63Iysr69feDUEQBEEQhH8bSRkTBEEQBEE4Ai699FIsXLgQTzzxBEwmE0wmE1599dWolLFXX30VSUlJmD17Njp16gSXy4WJEyeitrYWr732Glq3bo3k5GRcf/31CAaDzdtuamrCbbfdhtzcXLjdbgwaNAgLFiz4dQ5UEARBEIRjAokQEgRBEARBOAKeeOIJbNmyBd27d8d9990HANiwYUNcu7q6Ojz55JOYMWMGqqurMX78eIwfPx5JSUmYM2cOduzYgQkTJmDYsGGYNGkSAOCyyy7Drl27MGPGDOTk5GDmzJkYM2YM1q9fjw4dOvyixykIgiAIwrGBCEKCIAiCIAhHgM/ng91uh8vlak4T27RpU1w7v9+PZ599Fu3atQMATJw4EW+88QaKiorg8XjQtWtXHH/88Zg/fz4mTZqE7du345133sG+ffuQk5MDALj11lsxd+5cvPLKK/i///u/X+4gBUEQBEE4ZhBBSBAEQRAE4WfE5XI1i0EAkJmZidatW8Pj8UT9rri4GADw/fffQ1EUdOzYMWo7jY2NSE1N/WV2WhAEQRCEYw4RhARBEARBEH5GbDZb1P+bTCbd34VCIQBAKBSCxWLB6tWrYbFYotpFikiCIAiCIAg/JyIICYIgCIIgHCF2uz3KDPrnoE+fPggGgyguLsbw4cN/1m0LgiAIgiAYIVXGBEEQBEEQjpDWrVtj+fLl2LVrFw4dOtQc5fPf0LFjR1x44YWYPHkyPvroI+zcuRMrV67EP/7xD8yZM+dn2GtBEARBEIR4RBASBEEQBEE4Qm699VZYLBZ07doV6enp2LNnz8+y3VdeeQWTJ0/GLbfcgk6dOuGMM87A8uXLkZ+f/7NsXxAEQRAEIRaToijKr70TgiAIgiAIgiAIgiAIwi+HRAgJgiAIgiAIgiAIgiAcY4ggJAiCIAiCIAiCIAiCcIwhgpAgCIIgCIIgCIIgCMIxhghCgiAIgiAIgiAIgiAIxxgiCAmCIAiCIAiCIAiCIBxjiCAkCIIgCIIgCIIgCIJwjCGCkCAIgiAIgiAIgiAIwjGGCEKCIAiCIAiCIAiCIAjHGCIICYIgCIIgCIIgCIIgHGOIICQIgiAIgiAIgiAIgnCMIYKQIAiCIAiCIAiCIAjCMYYIQoIgCIIgCIIgCIIgCMcY/w8tFmsdpdK+pgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -863,176 +595,44 @@ } ], "source": [ - "tlca.plot_dynamic_characterized_inventory()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can go one step further though. Instead of GWP, we can directly assess the radiative forcing (which gets aggregated and normalized in GWP):" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dateamountflowactivity
02023-01-01 05:49:121.512067e-14395399
12024-01-01 11:38:241.419411e-14395399
22024-12-31 05:49:122.322610e-14395400
32024-12-31 05:49:124.941608e-15395401
42024-12-31 17:27:361.343660e-14395399
...............
4902124-01-01 06:00:001.400972e-15395401
4912124-01-01 06:43:123.302104e-15395402
4922124-12-31 12:32:243.294094e-15395402
4932125-12-31 18:21:363.286213e-15395402
4942127-01-01 00:10:483.278458e-15395402
\n", - "

495 rows × 4 columns

\n", - "
" - ], - "text/plain": [ - " date amount flow activity\n", - "0 2023-01-01 05:49:12 1.512067e-14 395 399\n", - "1 2024-01-01 11:38:24 1.419411e-14 395 399\n", - "2 2024-12-31 05:49:12 2.322610e-14 395 400\n", - "3 2024-12-31 05:49:12 4.941608e-15 395 401\n", - "4 2024-12-31 17:27:36 1.343660e-14 395 399\n", - ".. ... ... ... ...\n", - "490 2124-01-01 06:00:00 1.400972e-15 395 401\n", - "491 2124-01-01 06:43:12 3.302104e-15 395 402\n", - "492 2124-12-31 12:32:24 3.294094e-15 395 402\n", - "493 2125-12-31 18:21:36 3.286213e-15 395 402\n", - "494 2127-01-01 00:10:48 3.278458e-15 395 402\n", - "\n", - "[495 rows x 4 columns]" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ + "from dynamic_characterization.timex import characterize_co2 # <- dynamic characterization function\n", + "emission_id = bd.get_activity((\"biosphere\", \"CO2\")).id\n", + "\n", + "# defining which characterization function to use for which emission\n", + "characterization_function_dict = {\n", + " emission_id: characterize_co2,\n", + "}\n", + "\n", + "# characterizing the inventory\n", "tlca.dynamic_lcia(\n", " metric=\"radiative_forcing\",\n", " time_horizon=100,\n", " characterization_function_dict=characterization_function_dict,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "...and plot it:" + ")\n", + "\n", + "tlca.plot_dynamic_characterized_inventory()" ] }, { "cell_type": "code", - "execution_count": 44, - "metadata": {}, + "execution_count": 14, + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/dynamic_characterization/dynamic_characterization.py:262: UserWarning: Using bw_timex's default CO2 characterization function for GWP reference.\n", + " warnings.warn(\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1042,36 +642,69 @@ } ], "source": [ - "tlca.plot_dynamic_characterized_inventory()" + "from bw_timex.utils import plot_characterized_inventory_as_waterfall\n", + "\n", + "tlca.dynamic_lcia(\n", + " metric=\"GWP\",\n", + " time_horizon=100,\n", + " characterization_function_dict=characterization_function_dict,\n", + ")\n", + "\n", + "plot_characterized_inventory_as_waterfall(tlca)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We essentially see the decay curves of our individual emissions. \n", - "\n", - "In this sense, the overall impact is represented by the cumulative sum:" + "## Quick Recap\n", + "This might have seemed quite lengthy now. But essentially, calculating a `TimexLCA` is just this:" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 15, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting graph traversal\n", + "Calculation count: 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timex_lca.py:216: UserWarning: No edge filter function provided. Skipping all edges within background databases.\n", + " warnings.warn(\n", + "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/bw2calc/lca_base.py:127: SparseEfficiencyWarning: splu converted its input to CSC format\n", + " self.solver = factorized(self.technosphere_matrix)\n" + ] + }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "32.96019709827539" ] }, + "execution_count": 15, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "tlca.plot_dynamic_characterized_inventory(cumsum=True)" + "tlca = TimexLCA(\n", + " demand={(\"foreground\", \"A\"): 1},\n", + " method=(\"our\", \"method\"),\n", + " database_date_dict=database_date_dict,\n", + ")\n", + "tlca.build_timeline()\n", + "tlca.lci()\n", + "tlca.static_lcia()\n", + "tlca.static_score" ] }, { diff --git a/tests/test_starting_datetime.py b/tests/test_starting_datetime.py new file mode 100644 index 0000000..d6088e3 --- /dev/null +++ b/tests/test_starting_datetime.py @@ -0,0 +1,119 @@ +import math +from datetime import datetime + +import bw2data as bd +import pytest +from bw2data.tests import bw2test + +from bw_timex import TimexLCA + + +@pytest.fixture +@bw2test +def ab_db(): + bd.Database("bio").write( + { + ("bio", "CO2"): { + "type": "biosphere", + "name": "carbon dioxide", + }, + }, + ) + + bd.Database("db_2030").write( + { + ("db_2030", "B"): { + "name": "B", + "location": "somewhere", + "reference product": "B", + "exchanges": [ + { + "amount": 1, + "type": "production", + "input": ("db_2030", "B"), + }, + { + "amount": 10, + "input": ("bio", "CO2"), + "type": "biosphere", + }, + ], + }, + }, + ) + + bd.Database("db_2020").write( + { + ("db_2020", "B"): { + "name": "B", + "location": "somewhere", + "reference product": "B", + "exchanges": [ + { + "amount": 1, + "type": "production", + "input": ("db_2020", "B"), + }, + { + "amount": 15, + "input": ("bio", "CO2"), + "type": "biosphere", + }, + ], + }, + }, + ) + + bd.Database("foreground").write( + { + ("foreground", "A"): { + "name": "A", + "location": "somewhere", + "reference product": "A", + "exchanges": [ + { + "amount": 1, + "type": "production", + "input": ("foreground", "A"), + }, + { + "amount": 1, + "input": ("db_2020", "B"), + "type": "technosphere", + }, + ], + }, + } + ) + + bd.Method(("GWP", "example")).write( + [ + (("bio", "CO2"), 1), + ] + ) + + +def test_starting_datetime(ab_db): + method = ("GWP", "example") + database_date_dict = { + "db_2020": datetime.strptime("2020", "%Y"), + "db_2030": datetime.strptime("2030", "%Y"), + "foreground": "dynamic", + } + fu = ("foreground", "A") + tlca = TimexLCA({fu: 1}, method, database_date_dict) + + tlca.build_timeline(starting_datetime="2020-01-01") + tlca.lci() + tlca.static_lcia() + assert math.isclose(tlca.static_score, 15, rel_tol=1e-9) + + tlca.build_timeline(starting_datetime="2030-01-01") + tlca.lci() + tlca.static_lcia() + assert math.isclose(tlca.static_score, 10, rel_tol=1e-9) + + tlca.build_timeline(starting_datetime="2025-01-01") + tlca.lci() + tlca.static_lcia() + assert math.isclose(tlca.static_score, 12.5, rel_tol=1e-3)