diff --git a/bw_timex/timex_lca.py b/bw_timex/timex_lca.py index 86067a3..bd464e2 100644 --- a/bw_timex/timex_lca.py +++ b/bw_timex/timex_lca.py @@ -1154,6 +1154,39 @@ def create_labelled_dynamic_biosphere_dataframe(self) -> pd.DataFrame: return df + def create_labelled_dynamic_inventory_dataframe(self) -> pd.DataFrame: + """ + Returns the dynamic_inventory_df with comprehensible labels for flows and activities instead of ids. + + Parameters + ---------- + None + + Returns + ------- + pd.DataFrame, dynamic inventory matrix as a pandas.DataFrame with comprehensible labels instead of ids. + """ + + if not hasattr(self, "dynamic_inventory_df"): + warnings.warn( + "Dynamic inventory not yet calculated. Call TimexLCA.lci(build_dynamic_biosphere=True) first." + ) + + df = self.dynamic_inventory_df.copy() + df["flow"] = df["flow"].apply(lambda x: bd.get_node(id=x)["name"]) + + activity_name_cache = {} + + for activity in df["activity"].unique(): + if activity not in activity_name_cache: + activity_name_cache[activity] = resolve_temporalized_node_name( + self.activity_time_mapping_dict_reversed[activity][0][1] + ) + + df["activity"] = df["activity"].map(activity_name_cache) + + return df + def plot_dynamic_inventory(self, bio_flows, cumulative=False) -> None: """ Simple plot of dynamic inventory of a biosphere flow over time, with optional cumulative plotting. diff --git a/bw_timex/utils.py b/bw_timex/utils.py index bf9fb83..7e5556c 100644 --- a/bw_timex/utils.py +++ b/bw_timex/utils.py @@ -306,3 +306,34 @@ def plot_characterized_inventory_as_waterfall( ax.set_axisbelow(True) plt.grid(True) plt.show() + +def get_exchange(**kwargs) -> Exchange: + """ + Get an exchange from the database. + """ + mapping = { + "input_code": ExchangeDataset.input_code, + "input_database": ExchangeDataset.input_database, + "output_code": ExchangeDataset.output_code, + "output_database": ExchangeDataset.output_database, + } + qs = ExchangeDataset.select() + for key, value in kwargs.items(): + try: + qs = qs.where(mapping[key] == value) + except KeyError: + continue + + candidates = [Exchange(obj) for obj in qs] + if len(candidates) > 1: + raise MultipleResults( + "Found {} results for the given search. Please be more specific or double-check your system model for duplicates.".format(len(candidates)) + ) + elif not candidates: + raise UnknownObject + return candidates[0] + +def add_temporal_distribution_to_exchange(temporal_distribution: TemporalDistribution, **kwargs): + exchange = get_exchange(**kwargs) + exchange["temporal_distribution"] = temporal_distribution + exchange.save() \ No newline at end of file diff --git a/dev/your_own_timex_lca.ipynb b/dev/your_own_timex_lca.ipynb new file mode 100644 index 0000000..d50617b --- /dev/null +++ b/dev/your_own_timex_lca.ipynb @@ -0,0 +1,582 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Your own time-explicit LCA\n", + "This notebooks is your playground! Create your own foreground system, link it to ecoinvent, add temporal information and use `bw_timex` to re-link your processes throughout time to prospective `premise`-databases." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import bw2data as bd\n", + "bd.projects.set_current(\"bw25_ei310_premise\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a new foreground process:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "if \"foreground\" in bd.databases:\n", + " del bd.databases[\"foreground\"]\n", + "foreground = bd.Database(\"foreground\")\n", + "foreground.register()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "some_stuff_i_do = foreground.new_node(\n", + " code=\"some stuff i do\",\n", + " name=\"some stuff i do\",\n", + ")\n", + "some_stuff_i_do.save()\n", + "some_stuff_i_do.new_edge(input=some_stuff_i_do, amount=1, type=\"production\").save()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Select some activities from ecoinvent to link to:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "house = bd.get_node(database=\"ecoinvent-3.10-cutoff\", name=\"building construction, multi-storey\", location=\"RER\")\n", + "work = bd.get_node(database=\"ecoinvent-3.10-cutoff\", name=\"operation, computer, laptop, active mode\", location=\"CH\")\n", + "co2 = bd.get_node(database=\"ecoinvent-3.10-biosphere\", name=\"Carbon dioxide, fossil\", categories=(\"air\",))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create edges and add temporal information:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# A process took place a while ago:\n", + "\n", + "import numpy as np\n", + "from bw_temporalis import TemporalDistribution\n", + "\n", + "edge_house_building = some_stuff_i_do.new_edge(\n", + " input=house,\n", + " amount=3, # m3, more like a dog house\n", + " type=\"technosphere\",\n", + ")\n", + "\n", + "td_house_building = TemporalDistribution(\n", + " date=np.array([-40], dtype=\"timedelta64[Y]\"),\n", + " amount=np.array([1]),\n", + ")\n", + "\n", + "edge_house_building[\"temporal_distribution\"] = td_house_building\n", + "edge_house_building.save()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Something that happens regularly:\n", + "\n", + "from bw_temporalis import easy_timedelta_distribution\n", + "\n", + "WORKYEARS = 30\n", + "edge_working = some_stuff_i_do.new_edge(\n", + " input=work,\n", + " amount=2080*WORKYEARS, # h, \n", + " type=\"technosphere\",\n", + ")\n", + "\n", + "td_working = easy_timedelta_distribution(\n", + " start=0, # (inclusive)\n", + " end=WORKYEARS, # (inclusive)\n", + " resolution=\"Y\",\n", + " steps=6, # Includes both start and end\n", + " kind=\"uniform\", \n", + ")\n", + "\n", + "edge_working[\"temporal_distribution\"] = td_working\n", + "edge_working.save()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# A specific emission profile\n", + "\n", + "planting_a_tree = foreground.new_node( \n", + " code=\"planting a tree\",\n", + " name=\"planting a tree\",\n", + " unit=\"unit\",\n", + ")\n", + "planting_a_tree.save()\n", + "planting_a_tree.new_edge(input=planting_a_tree, amount=1, type=\"production\").save()\n", + "planting_a_tree.new_edge(input=co2, amount=-1000, type=\"biosphere\").save()\n", + "\n", + "some_stuff_i_do.new_edge(\n", + " input=planting_a_tree,\n", + " amount=1,\n", + " type=\"technosphere\",\n", + ").save()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# oops, forgot to save the edge object or working with existing models? \n", + "# there's a utility function to help you out ;)\n", + "from bw_timex.utils import add_temporal_distribution_to_exchange\n", + "\n", + "td_co2_uptake_tree = easy_timedelta_distribution(\n", + " start=0, # (inclusive)\n", + " end=100, # (inclusive)\n", + " resolution=\"Y\",\n", + " steps=11, # Includes both start and end\n", + " kind=\"triangular\", \n", + " param=60,\n", + ")\n", + "\n", + "# only works if this is the only edge between these two nodes - otherwise, you need to specify the edge object directly\n", + "add_temporal_distribution_to_exchange(\n", + " temporal_distribution=td_co2_uptake_tree,\n", + " input_code=co2[\"code\"],\n", + " input_database=co2[\"database\"],\n", + " output_code=planting_a_tree[\"code\"],\n", + " output_database=planting_a_tree[\"database\"],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Provide some info on the prospective `premise`-databases:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime\n", + "\n", + "database_date_dict = {\n", + " \"ecoinvent-3.10-cutoff\": datetime.strptime(\"2020\", \"%Y\"),\n", + " \"ei310-SSP2-RCP19-2030\": datetime.strptime(\"2030\", \"%Y\"),\n", + " \"ei310-SSP2-RCP19-2040\": datetime.strptime(\"2040\", \"%Y\"),\n", + " \"ei310-SSP2-RCP19-2050\": datetime.strptime(\"2050\", \"%Y\"),\n", + " \"foreground\": \"dynamic\",\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And create your TimexLCA, just as you've seen before:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/scikits/umfpack/umfpack.py:736: UmfpackWarning: (almost) singular matrix! (estimated cond. number: 1.40e+13)\n", + " warnings.warn(msg, UmfpackWarning)\n" + ] + } + ], + "source": [ + "from bw_timex import TimexLCA\n", + "\n", + "tlca = TimexLCA(\n", + " demand={some_stuff_i_do: 1},\n", + " method=(\"EF v3.1\", \"climate change\", \"global warming potential (GWP100)\"),\n", + " database_date_dict=database_date_dict,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timex_lca.py:195: UserWarning: No edge filter function provided. Skipping all edges within background databases.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting graph traversal\n", + "Calculation count: 3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timeline_builder.py:475: Warning: Reference date 1984-01-01 00:00:00 is lower than all provided dates. Data will be taken from the closest higher year.\n", + " warnings.warn(\n", + "/Users/timodiepers/Documents/Coding/bw_timex/bw_timex/timeline_builder.py:482: Warning: Reference date 2054-01-01 00:00:00 is higher than all provided dates. Data will be taken from the closest lower year.\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", + " \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", + "
date_producerproducer_namedate_consumerconsumer_nameamountinterpolation_weights
01984-01-01building construction, multi-storey2024-01-01some stuff i do3.0{'ecoinvent-3.10-cutoff': 1}
12024-01-01operation, computer, laptop, active mode2024-01-01some stuff i do10400.0{'ecoinvent-3.10-cutoff': 0.6000547495209416, ...
22024-01-01some stuff i do2024-01-01-11.0None
32024-01-01planting a tree2024-01-01some stuff i do1.0None
42030-01-01operation, computer, laptop, active mode2024-01-01some stuff i do10400.0{'ei310-SSP2-RCP19-2030': 1}
52036-01-01operation, computer, laptop, active mode2024-01-01some stuff i do10400.0{'ei310-SSP2-RCP19-2030': 0.4000547645125958, ...
62042-01-01operation, computer, laptop, active mode2024-01-01some stuff i do10400.0{'ei310-SSP2-RCP19-2040': 0.7998905009581166, ...
72048-01-01operation, computer, laptop, active mode2024-01-01some stuff i do10400.0{'ei310-SSP2-RCP19-2040': 0.20010949904188335,...
82054-01-01operation, computer, laptop, active mode2024-01-01some stuff i do10400.0{'ei310-SSP2-RCP19-2050': 1}
\n", + "
" + ], + "text/plain": [ + " date_producer producer_name date_consumer \\\n", + "0 1984-01-01 building construction, multi-storey 2024-01-01 \n", + "1 2024-01-01 operation, computer, laptop, active mode 2024-01-01 \n", + "2 2024-01-01 some stuff i do 2024-01-01 \n", + "3 2024-01-01 planting a tree 2024-01-01 \n", + "4 2030-01-01 operation, computer, laptop, active mode 2024-01-01 \n", + "5 2036-01-01 operation, computer, laptop, active mode 2024-01-01 \n", + "6 2042-01-01 operation, computer, laptop, active mode 2024-01-01 \n", + "7 2048-01-01 operation, computer, laptop, active mode 2024-01-01 \n", + "8 2054-01-01 operation, computer, laptop, active mode 2024-01-01 \n", + "\n", + " consumer_name amount interpolation_weights \n", + "0 some stuff i do 3.0 {'ecoinvent-3.10-cutoff': 1} \n", + "1 some stuff i do 10400.0 {'ecoinvent-3.10-cutoff': 0.6000547495209416, ... \n", + "2 -1 1.0 None \n", + "3 some stuff i do 1.0 None \n", + "4 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2030': 1} \n", + "5 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2030': 0.4000547645125958, ... \n", + "6 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2040': 0.7998905009581166, ... \n", + "7 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2040': 0.20010949904188335,... \n", + "8 some stuff i do 10400.0 {'ei310-SSP2-RCP19-2050': 1} " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tlca.build_timeline()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/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", + "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/scikits/umfpack/umfpack.py:736: UmfpackWarning: (almost) singular matrix! (estimated cond. number: 7.43e+12)\n", + " warnings.warn(msg, UmfpackWarning)\n" + ] + } + ], + "source": [ + "tlca.lci()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Characterize the inventory, looking at radiative forcing:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/dynamic_characterization/dynamic_characterization.py:80: UserWarning: No custom dynamic characterization functions provided. Using default dynamic characterization functions from `dynamic_characterization` meant to work with biosphere3 flows. The flows that are characterized are based on the selection of the initially chosen impact category. You can look up the mapping in the bw_timex.dynamic_characterizer.characterization_function_dict.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJAAAAIcCAYAAACpclSwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gUVd/G8e/uZnez6b2SECDU0IvSBVERFMWKFbCgKAKKivLYwF5AsctjIaiIDfW1PTSlKCA9gnRC6KGFkF42u/v+EVlYAgFCIAncn+vKJVN25jczJ4HcnnPG4HK5XIiIiIiIiIiIiByHsaoLEBERERERERGR6k0BkoiIiIiIiIiIlEsBkoiIiIiIiIiIlEsBkoiIiIiIiIiIlEsBkoiIiIiIiIiIlEsBkoiIiIiIiIiIlEsBkoiIiIiIiIiIlEsBkoiIiIiIiIiIlEsBkoiIiIiIiIiIlEsBkoiIiIiIiIiIlEsB0imYN28effr0ISYmBoPBwA8//FCl57Pb7Tz22GM0a9YMX19fYmJi6N+/P7t27TqjdYmIiIiIiIjI+UUB0inIy8ujRYsWvPPOO9XifPn5+SxfvpynnnqK5cuX891337Fhwwauuuqqs1KfiIiIiIiIiJwfDC6Xy1XVRdREBoOB77//nr59+7rXFRcX8+STTzJ58mQOHjxI06ZNeeWVV+jWrdsZOd+xLFmyhAsuuICtW7cSHx9/2ucVEREREREREfGq6gLOJXfccQdbtmzhyy+/JCYmhu+//57LL7+cVatWUb9+/bNSQ1ZWFgaDgaCgoLNyPhERERERERE592kIWyVJTU1lypQpfPPNN3Tp0oV69erxyCOP0LlzZyZOnHhWaigsLOTxxx/nlltuISAg4KycU0RERERERETOfQqQKsny5ctxuVw0aNAAPz8/99fcuXNJTU0FYMuWLRgMhnK/HnjggQqd3263c9NNN+F0Onnvvfcq89JERERERERE5DynIWyVxOl0YjKZWLZsGSaTyWObn58fALGxsaxdu7bc4wQHB5/yue12OzfeeCNpaWn8/vvv6n0kIiIiIiIiIpVKAVIladWqFQ6Hg71799KlS5dj7mM2m2nUqFGlnvdQeLRx40Zmz55NaGhopR5fREREREREREQB0inIzc1l06ZN7uW0tDRSUlIICQmhQYMG3HrrrfTv359x48bRqlUr9u/fz++//06zZs3o3bt3pZ4vPj6ekpISrr/+epYvX87PP/+Mw+Fg9+7dAISEhGCxWE7/okVERERERETkvGdwuVyuqi6ippgzZw7du3cvs37AgAEkJydjt9t5/vnn+fTTT9m5cyehoaF06NCBMWPG0KxZs0o/35YtW6hTp84xPzt79my6det2yucUERERERERETmaAiQRERERERERESmX3sImIiIiIiIiIiLlUoAkIiIiIiIiIiLl0iTaJ+B0Otm1axf+/v4YDIaqLkdEREREREREpFK4XC5ycnKIiYnBaCy/j5ECpBPYtWsXcXFxVV2GiIiIiIiIiMgZsX37dmrVqlXuPgqQTsDf3x8ovZkBAQFVXI1UlN1uZ8aMGVx22WWYzeaqLkfkhNRmpaZRm5WaRm1Wahq1Walp1GZrhuzsbOLi4tzZR3kUIJ3AoWFrAQEBCpBqMLvdjo+PDwEBAfrhJTWC2qzUNGqzUtOozUpNozYrNY3abM1yMlP2aBJtEREREREREREplwIkEREREREREREplwIkEREREREREREpl+ZAEhERERGRasvhcGC326u6jCpnt9vx8vKisLAQh8NR1eWInJDabPVgMpnw8vI6qTmOTkQBkoiIiIiIVEu5ubns2LEDl8tV1aVUOZfLRVRUFNu3b6+UXwRFzjS12erDx8eH6OhoLBbLaR1HAZKIiIiIiFQ7DoeDHTt24OPjQ3h4+Hn/C6jT6SQ3Nxc/Pz+MRs1EItWf2mzVc7lcFBcXs2/fPtLS0qhfv/5pPQsFSCIiIiIiUu3Y7XZcLhfh4eHYbLaqLqfKOZ1OiouL8fb21i/jUiOozVYPNpsNs9nM1q1b3c+jovQURURERESk2jrfex6JiJyuygrwFCCJiIiIiIiIiEi5FCCJiIiIiIiIiEi5akyA9NJLL9GuXTv8/f2JiIigb9++rF+//oSfmzt3Lm3atMHb25u6devywQcfnIVqRUREREREji0hIYHx48ef8fNs2bIFg8FASkrKGT+XiJz7akyANHfuXIYMGcJff/3FzJkzKSkp4bLLLiMvL++4n0lLS6N379506dKFFStW8J///Idhw4YxderUs1i5iIiIiIjImTVw4ED69u3rsS4uLo709HSaNm1aNUWVY86cORgMBg4ePFjVpYjISaoxb2GbNm2ax/LEiROJiIhg2bJldO3a9Zif+eCDD4iPj3en+40bN2bp0qWMHTuW66677kyXLCIiIiIiVczhdLB873L25e8j3Cec1hGtMRlNVV3WWWEymYiKiqrqMk5LcXExFoulqssQEWpQgHS0rKwsAEJCQo67z8KFC7nssss81vXs2ZOPP/4Yu92O2Wwu85mioiKKiorcy9nZ2UDpa0TtdntllH7WlThdFJW4sJkNGM/Tt1gcenY19RnK+UdtVmoatVmpadRmqz+73Y7L5cLpdOJ0Oit0jFnbZvHqklfZk7/HvS7SJ5KR7UZySfwllVWqh4svvpikpCQAJk+ejMlkYvDgwTz77LMeb5Q7dG0Ab7zxBsnJyWzevJmQkBCuvPJKXnnlFfz8/ABITk5mxIgRfPzxxzz55JNs376dTp068cknnxAdHc2YMWOYNGkScPitdb/99hsJCQnUq1ePZcuW0bJlS+bMmUOPHj2YMWMGo0aNYs2aNbRs2ZKPP/6Yhg0bumt74YUXePvttykoKODGG28kLCyM6dOns3z58mNes8Ph4N5772X27Nns3r2b+Ph47rvvPoYNG3bM/bds2UL37t0BCA4OBqB///5MnDjRff8sFgufffYZSUlJzJ49mzVr1vDoo4/yxx9/4Ovry6WXXsrrr79OWFiY+36OHTuWCRMmkJ6eToMGDXjiiSe4/vrrK/Yg5bS5XC73fyv6PSyVw+l04nK5sNvtmEyeAfqp/D1YIwMkl8vFiBEj6Ny5c7ndMXfv3k1kZKTHusjISEpKSti/fz/R0dFlPvPSSy8xZsyYMutnzJiBj4/P6Rd/FkXF1QG/cCYv3UV6dhHt4gO5IimcvZvXkJ2dVdXlVYmZM2dWdQkip0RtVmoatVmpadRmqy8vLy+ioqLIzc2luLj4lD8/d9dcnlzyZJn1e/L38PDch3m+3fNcFHNRZZTqoaSkhE8//ZTbbruNmTNnsmLFCh566CEiIiIYMGAAUPrLXGFhoft/VhcXF/Piiy8SHx/P1q1beeSRR3jooYcYN24cAIWFheTn5/POO+/w3nvvYTQauffee3nwwQf58MMPGTRoEKtWrSI7O5t3330XKA1mdu/eDUBeXh7Z2dnk5+cD8J///IcxY8YQGhrKiBEjGDhwINOnTwfg66+/5sUXX2Ts2LFceOGFfPfdd7zzzjvUrl3bXe/R7HY74eHhfPzxx4SGhrJo0SIeeughAgMDueaaa8rsHxgYyKeffkr//v1ZsmQJ/v7+eHt7k52d7b5/d9xxB//73/9wuVxs2LCBbt260b9/f8aMGUNhYSGjR4/m+uuv58cffwTgueee4+eff+a1116jXr16LFiwgP79++Pr60unTp0q6/FKBeTk5FR1Cee94uJiCgoKmDdvHiUlJR7bDv1cOBk1MkB64IEHWLlyJX/++ecJ9zUc1ePmUAp69PpDRo0axYgRI9zL2dnZxMXFcdlllxEQEHAaVZ9dBXYnP6Sk8/TXh/8vwZItmUz6azvfDO5A5/CaFYadLrvdzsyZM7n00kuP2fNMpLpRm5WaRm1Wahq12eqvsLCQ7du34+fnh7e39yl91uF08Pbqt4+73YCBt1e/Te8GvSt9OJuXlxdxcXG88847GAwG2rRpQ2pqKhMmTGDo0KEAGI1GvL293b9fPPbYY+7PN2vWjIKCAoYMGcKHH34IgLe3N3a7nddff53mzZtjMBgYOnQozz33HAEBAQQEBODv74/D4aB+/fruY+Xm5gLg6+tLQECA+3+Iv/jii/To0QMoDZP69OmDxWLB29ubTz75hDvvvJP77rsPgNatWzNv3jxyc3PL/X3opZde8riGlJQUfv75Z3dodrTY2FgA6tatS1BQkMf9S0xM9Jhk/JlnnqF169aMHTvWvS45OZnatWuze/duYmNjee+995g1axYdOnQAoHnz5ixbtozPP/+cXr16HbduOXNcLhc5OTn4+/sf9/dvOTsKCwux2Wx07dq1zM/T4wXDx1LjAqShQ4fy448/Mm/ePGrVqlXuvlFRUe7U/ZC9e/fi5eVFaGjoMT9jtVqxWq1l1pvN5hr1j4td2XmM+XlNmfV5xQ4e/24VyXdcQIjv+TeWuKY9RxG1Walp1GalplGbrb4cDgcGgwGj0YjReGrv/lm2d5nHsLWjuXCxJ38PKftTaBfV7nRLLaN9+/Yew0Q6duzI66+/jsvlcq8/dG0As2fP5sUXX2TNmjXuXjiFhYUUFBTg6+uL0WjEx8eHOnXquD8XExPD3r173ccwGAwexwTcfz50Dw8tt2zZ0v3nQ0HO/v37iY+PZ/369dx///0ex7ngggv4/fffy30OH3zwAR999BFbt26loKCA4uJij/Mc7ejajtS2bVuPdcuXL2fOnDnHDLDS0tLIycmhsLCQnj17emwrLi6mVatWp9x+pHIcGrZ2dLuUs89oNGIwGI75d96p/B1YYwIkl8vF0KFD+f7775kzZw516tQ54Wc6dOjATz/95LFuxowZtG3b9pz/h8KqnVk4nK5jblu5I4uD+cXnZYAkIiIiIue+ffn7KnW/M2nr1q307t2bwYMH89xzzxESEsKff/7JXXfd5TE3ydG/vxgMBvfoilN15LEO9Qw5co6a443iOJ6vv/7aPeSuQ4cO+Pv789prr7Fo0aIK1efr6+ux7HQ66dOnD6+88kqZfaOjo/nnn38A+OWXX9yB2CHH6hwgIhVTYwKkIUOG8MUXX/B///d/+Pv7u3sWBQYGYrPZgNLhZzt37uTTTz8FYPDgwbzzzjuMGDGCQYMGsXDhQj7++GOmTJlSZddxtpQcJzw6pIJ/14iIiIiIVHvhPuGVut+p+uuvv8os169fv8zktQBLly6lpKSEcePGuXtpfP3116d8TovFgsPhqFjBR2jYsCGLFy/m9ttv96ixPH/88QcdO3bk/vvvd69LTU0t9zOH3qx2MjW3bt2aqVOnkpCQgJdX2V9hmzRpgtVqZdu2bVx0UeXPayUipWpMP7L333+frKwsunXrRnR0tPvrq6++cu+Tnp7Otm3b3Mt16tTh119/Zc6cObRs2ZLnnnuOt956i+uuu64qLuGsahEbyPGGmdaP8CPQ59zugSUiIiIi56/WEa2J9InEwLH/QWzAQJRPFK0jWp+R82/fvp0RI0awfv16pkyZwttvv83w4cOPuW+9evUoKSnh7bffZvPmzXz22Wd88MEHp3zOhIQEVq5cyfr169m/f3+F3zA4dOhQPv74YyZNmsTGjRt5/vnnWblyZblz2CQmJrJ06VKmT5/Ohg0beOqpp1iyZEm556lduzYGg4Gff/6Zffv2uedrOpYhQ4Zw4MABbr75ZhYvXszmzZuZMWMGd955Jw6HA39/f/fE45MmTSI1NZUVK1bw7rvvut9OJyKnr8YESC6X65hfAwcOdO+TnJzMnDlzPD530UUXsXz5coqKikhLS2Pw4MFnt/AqEuZv5f6LEsusN5sMvHRtM8L81JVTRERERM5NJqOJxy94HKBMiHRo+bELHqv0CbQP6d+/PwUFBVxwwQUMGTKEoUOHcs899xxz35YtW/L666/zyiuv0LRpUyZPnuwxIfXJGjRoEA0bNqRt27aEh4czf/78CtV+6623MmrUKB555BFat25NWloaAwcOLHci88GDB3PttdfSr18/LrzwQjIyMjx6Ix1LbGwsY8aM4fHHHycyMpIHHnjguPvGxMQwf/58HA4HPXv2pGnTpgwfPpzAwEB3r63nnnuOp59+mpdeeonGjRvTs2dPfvrpp5Oa+kRETo7BVdGBs+eJ7OxsAgMDycrKqlFvYQPIzCtm5c6DvDs7lT3ZhbSJD+a+bvWoHeqDxevM/GVZXdntdn799Vd69+59zs9/JecGtVmpadRmpaZRm63+CgsLSUtLo06dOqf8FrZDZm2dxcuLX/aYUDvKJ4rHLniMS2pfUlmleujWrRstW7b0eItYZXA6nWRnZxMQEHDWJyS+9NJLiYqK4rPPPjur55WarSrbrHgq7+fpqWQeNWYOJDl1wb4WLmoQQcu4YIpLnPh5m7CZ9chFRERE5PxwSe1L6B7XneV7l7Mvfx/hPuG0jmh9xnoenQvy8/P54IMP6NmzJyaTiSlTpjBr1ixmzpxZ1aWJSBVTmnAeCLTp/6qJiIiIyPnJZDTRLqpdVZdRYxgMBn799Veef/55ioqKaNiwIVOnTuWSS85Mjy0RqTkUIImIiIiIiFSSo+dkrWlsNhuzZs2q6jJEpBrSQEQRERERERERESmXAiQRERERERERESmXAiQRERERERERESmXAiQRERERERERESmXAiQRERERERERESmXAiQRERERERERESmXAiQREREREZHznMFg4IcffqjqMqQcycnJBAUFVXUZNcLAgQPp27dvVZdRaarL9ShAOg/ZHU4O5heTX1xS1aWIiIiIiMhZNHr0aFq2bFlmfXp6Or169Tr7BdVgCQkJjB8/vqrLOG01OTzcsmULBoOBlJQUj/VvvvkmycnJVVLTucyrqguQs6fE4WRHZgFTFm9j4eYMogO8ubtrXRpE+BHoY6nq8kREREREKp/TAVsXQO4e8IuE2h3BaKrqqipdcXExFkvF/00fFRVVidXIqTjdZydlBQYGVnUJ5yT1QDqPbNiTQ683/2DCvM2s3JHF9DV7uOGDhXyxaBu5hfaqLk9EREREpHKt+RHGN4VJV8LUu0r/O75p6fozpKioiGHDhhEREYG3tzedO3dmyZIl7u1z5szBYDDwyy+/0KJFC7y9vbnwwgtZtWqVx3EWLFhA165dsdlsxMXFMXz4cPLy8tzbExISeP755xk4cCCBgYEMGjQIgMcee4wGDRrg4+ND3bp1eeqpp7DbS/+tn5yczJgxY/j7778xGAwYDAZ3L42je6GsWrWKiy++GJvNRmhoKPfccw+5ubnu7YeG1IwdO5bo6GhCQ0MZMmSI+1wna8eOHdx0002EhITg6+tL27ZtWbRokXv7+++/T7169bBYLDRs2JDPPvvM4/MGg4EJEyZw5ZVX4uPjQ+PGjVm4cCGbNm2iW7du+Pr60qFDB1JTU92fOdQLa8KECcTFxeHj48MNN9zAwYMH3ft069aNBx980ONcffv2ZeDAge7tW7du5aGHHnLfy0OOfnbDhg07qWd3qlJTU7n66quJjIzEz8+Pdu3aMWvWLI99EhISeO6557jlllvw8/MjJiaGt99+22M7wDXXXIPBYHAvw8nd+/fff59evXphs9moU6cO33zzzSldQ0ZGBjfffDO1atXCx8eHZs2aMWXKFI99nE4nr7zyComJiVitVuLj43nhhRcAqFOnDgCtWrXCYDDQrVs3wHPI14QJE4iNjcXpdHoc96qrrmLAgAHu5Z9++ok2bdrg7e1N3bp1GTNmDCUlxx+1c+gcL774IpGRkQQFBbk/8+ijjxISEkKtWrX45JNPPD53ou8th8PBiBEjCAoKIjQ0lJEjR+JyuTyO4XK5ePXVV6lbty42m40WLVrw7bffnsQdPz0KkM4TB/KKefy7VRTYHWW2vTpjPftzi6ugKhERERGRM2TNj/B1f8je5bk+O710/RkKkUaOHMnUqVOZNGkSy5cvJzExkZ49e3LgwAGP/R599FHGjh3LkiVLiIiI4KqrrnKHL6tWraJnz55ce+21rFy5kq+++or58+czcuRIj2O89tprNG3alGXLlvHUU08B4O/vT3JyMmvWrOHNN9/kww8/5I033gCgX79+PPzwwyQlJZGenk56ejr9+vUrcw35+flcfvnlBAcHs2TJEr755htmzZrFAw884LHf7NmzSU1NZfbs2UyaNInk5ORTGjaUm5vLRRddxK5du/jxxx/5+++/GTlypPsX/e+//57hw4fz8MMP888//3Dvvfdyxx13MHv2bI/jPPfcc/Tv35+UlBQaNWrELbfcwr333suoUaNYunQpQJnaN23axNdff81PP/3EtGnTSElJYciQISdd+3fffUetWrV49tln3fcSjv3s/vzzzzLnP9azO1W5ubn07t2bWbNmsWLFCnr27EmfPn3Ytm1bmXM1b96c5cuXM2rUKB566CFmzpwJ4A43J06cSHp6unv5ZO/9U089xXXXXcfff//Nbbfdxs0338zatWtP+hoKCwtp06YNP//8M//88w/33HMPt99+u0eIOGrUKF555RWeeuop1qxZwxdffEFkZCQAixcvBmDWrFmkp6fz3XfflTnHDTfcwP79+z1qz8zMZPr06dx6660ATJ8+ndtuu41hw4axZs0aJkyYQHJysjuoOp7ff/+dXbt2MW/ePF5//XVGjx7NlVdeSXBwMIsWLWLw4MEMHjyY7du3Ayf3vTVu3Dg++eQTPv74Y/78808OHDjA999/73HeJ598kokTJ/L++++zevVqHnroIW677Tbmzp170ve+QlxSrqysLBfgysrKqupSTsvmfTmu2o/9fNyv75Ztr+oSz6ji4mLXDz/84CouLq7qUkROitqs1DRqs1LTqM1WfwUFBa41a9a4CgoKTv3DjhKXa1wjl+uZgON8Bbpc4xqX7leJcnNzXWaz2TV58mT3uuLiYldMTIzr1VdfdblcLtfs2bNdgOvLL79075ORkeGy2Wyur776yuVyuVy3336765577vE49ty5c11Go9GVl5fncrlcrtq1a7v69u17wppeffVVV5s2bdzLzzzzjKtFixZl9gNc33//vcvlcrn++9//uoKDg125ubnu7b/88ovLaDS6du/e7XK5XK4BAwa4ateu7SopOXwPb7jhBle/fv1OWNMhEyZMcPn7+7syMjKOub1jx46uQYMGeay74YYbXL179/ao+8knn3QvL1y40AW4Pv74Y/e6KVOmuLy9vd3LzzzzjMtkMrm2bz/8O9D//vc/l9FodKWnp7tcLpfroosucg0fPtzj3FdffbVrwIAB7uXatWu73njjDY99jvXs/vjjD5fRaHS35ZN9dkebOHGiKzAwsNx9mjRp4nr77bc9arz88ss99unXr5+rV69e7uUjn/0hJ3vvBw8e7LHPhRde6LrvvvtcLpfL5XA4XJmZmS6Hw3HCaztS7969XQ8//LDL5XK5srOzXVar1fXhhx8ec9+0tDQX4FqxYoXH+gEDBriuvvpq9/JVV13luvPOO93LEyZMcEVFRbnbb5cuXVwvvviixzE+++wzV3R09HHrPPQ9cOT1NWzY0NWlSxf3cklJicvX19c1ZcoUl8t1ct9b0dHRrpdfftm93W63u2rVquW+ntzcXJe3t7drwYIFHvXcddddrptvvvmYtZb38/RUMg/1QDpfuMrf7HSdYAcRERERkZpi64KyPY88uCB7Z+l+lSg1NRW73U6nTp3c68xmMxdccEGZXhkdOnRw/zkkJISGDRu691m2bBnJycn4+fm5v3r16oXT6SQtLc39ubZt25ap4dtvv6Vz585ERUXh5+fHU089VaZHyomsXbuWFi1a4Ovr617XqVMnnE4n69evd69LSkrCZDo8n1R0dDR79+496fOkpKTQqlUrQkJCjlvHkffyUB1H38vmzZu7/3yoZ0qzZs081hUWFpKdne1eFx8fT61atdzLHTp0KHN9FXGsZ9ezZ8+TenanKi8vj5EjR9KkSROCgoLw8/Nj3bp1ZZ73kW3t0PKJegmd7L2vyLGP5HA4eOGFF2jevDmhoaH4+fkxY8YM9zWsXbuWoqIievTocdLHPJZbb72VqVOnUlRUBMDkyZO56aab3O132bJlPPvssx7PbdCgQaSnp5Ofn3/c4yYlJWE0Ho5VIiMjPdqeyWQiNDTU/X1xou+trKws0tPTPe6rl5eXR3tZs2YNhYWFXHrppR71fvrppx5DNc8ETaJ9ngj0MZMUE8DqXdllthkM0Lp2cBVUJSIiIiJyBuTuqdz9TpLr3/8pe+R8OIfWH73uWA7t43Q6uffeexk2bJh7m9PpJDc3l3r16rnXHflLKMBff/3FTTfdxJgxY+jZsyeBgYF8+eWXjBs37pSv43j1HrnebDaX2Xb0PDPlsdlsJ9znZO7lkXUc2nasdeXVdmifQ/81Go1l5p05mfmdjvXsDomPj3f/+ehnVxGPPvoo06dPZ+zYsSQmJmKz2bj++uspLj7x9CSn0h4POdV2fDLGjRvHG2+8wfjx42nWrBm+vr48+OCD7ms4mTZyMvr06YPT6eSXX36hXbt2/PHHH7z++uvu7U6nkzFjxnDttdeW+ay3t/dxj3us74Hyvi9O9nurPIeO9csvvxAbG+uxzWq1ntQxKko9kM4TIb5WXrq2GVavso/8ge6JhPmd2YYmIiIiInLW+EVW7n4nKTExEYvFwp9//uleZ7fbWbp0KY0bN/bY96+//nL/OTMzkw0bNtCoUSMAWrduzerVq0lMTPT4qlu3brlv65o/fz61a9fmiSeeoG3bttSvX5+tW7d67GOxWHA4ys6LeqQmTZqQkpLiMfHz/PnzMRqNNGjQ4MQ34iQ1b96clJSUMvNDHdK4cWOPewmlE1QffS8rYtu2bezadbiX2sKFCz2uLzw83D2vEZT2lPnnn388jnGse3m8Z3eobVSmP/74g4EDB3LNNdfQrFkzoqKi2LJlS5n9jmxrh5YPtTUoDUGOvo6TvfcnOvbJXMPVV1/NbbfdRosWLahbty4bN250b69fvz42m43ffvvtmJ8/dE9P1KZtNhvXXnstkydPZsqUKTRo0IA2bdq4t7du3Zr169cf87kd2cPodJ3oeyswMJDo6GiP+1pSUsKyZcs8jmG1Wtm2bVuZWuPi4iqt1mNRD6TzSOOoAP43vAsT56exKO0AEf5W7uuWSJOYAPy9zSc+gIiIiIhITVC7IwTElE6Yfcy5HAyl22t3rNTT+vr6ct9997nfwBQfH8+rr75Kfn4+d911l8e+zz77LKGhoURGRvLEE08QFhbmfmvUY489Rvv27RkyZAiDBg3C19eX1atX8+uvv/LBBx8c9/yJiYls27aNL7/8knbt2vHLL7+UmXw3ISGBtLQ0UlJSqFWrFv7+/mV6Ldx6660888wzDBgwgNGjR7Nv3z6GDh3K7bff7h4iVhluvvlmXnzxRfr27ctLL71EdHQ0K1asICYmhg4dOvDoo49y44030rp1a3r06MFPP/3Ed999V+ZNYxXh7e3NgAEDGDt2LNnZ2QwbNowbb7yRqKgoAC6++GJGjBjBL7/8Qr169XjjjTc83tIGpfdy3rx53HTTTVitVsLCwo757NauXcvMmTM93n5WGRITE/nuu+/o06cPBoOBp5566pi9rObPn8+rr75K3759mTlzJt988w2//PKLx3X89ttvdOrUCavVSnBw8Enf+2+++Ya2bdvSuXNnJk+ezOLFi/n4449P6RqmTp3KggULCA4O5vXXX2f37t3uoMrb25vHHnuMkSNHYrFY6NSpE/v27WP16tXcddddREREYLPZmDZtGrVq1cLb25vAwMBjnuvWW2+lT58+rF69mttuu81j29NPP82VV15JXFwcN9xwA0ajkZUrV7Jq1Sqef/75k76eEzmZ763hw4fz8ssvU79+fRo3bszrr7/u0fb8/f155JFHeOihh3A6nXTu3Jns7GwWLFiAn5+fx5vlKpt6IJ1HzF5G6ob78dSVSUwZ1J73b2tDp8Qwgn0qNwkXEREREalSRhNc/sq/C0cPC/l3+fKXS/erZC+//DLXXXcdt99+O61bt2bTpk1Mnz6d4ODgMvsNHz6cNm3akJ6ezo8//ujuTdG8eXPmzp3Lxo0b6dKlC61ateKZZ545YXhz9dVX89BDD/HAAw/QsmVLFixYUOYNX9dddx2XX3453bt3Jzw8vMwr0wF8fHyYPn06Bw4coF27dlx//fX06NGDd95555TuxejRoz1eC380i8XCjBkziIiIoHfv3jRr1oyXX37ZPS9N3759efPNN3nttddISkpiwoQJTJw40f2q9tORmJjItddeS+/evbnsssto2rQp7733nnv7nXfeyYABA+jfvz8XXXQRderUoXv37h7HePbZZ9myZQv16tUjPDwcOPaze+qpp4iOjj5hTd26dWPgwIEnfQ1vvPEGwcHBdOzYkT59+tCzZ09at25dZr+HH36YZcuW0apVK5577jnGjRtHz5493dvHjRvHzJkziYuLo1WrVsDJ3/sxY8bw5Zdf0rx5cyZNmsTkyZNp0qSJe/uVV17JHXfccdxreOqpp2jdujU9e/akW7duREVFuYPUI/d5+OGHefrpp2ncuDH9+vVzzynk5eXFW2+9xYQJE4iJieHqq68+7rkuvvhiQkJCWL9+PbfccovHtp49e/Lzzz8zc+ZM2rVrR/v27Xn99depXbv2cY9XESfzvfXwww/Tv39/Bg4cSIcOHfD39+eaa67xOM5zzz3H008/zUsvvUTjxo3p2bMnP/30E3Xq1KnUeo9mcB09sFM8ZGdnExgYSFZWFgEBAVVdjlSQ3W7n119/pXfv3mXGpIpUR2qzUtOozUpNozZb/RUWFpKWlkadOnXKnYOkXGt+hGmPeU6oHRBbGh41uapyCj1Fc+bMoXv37mRmZhIUFHTSn3M6nWRnZxMQEFCpQ2rOpENhSHJycpXWcbTRo0fzww8/kJKSUtWleEhISGD06NGnFCKdzDEffPBBHnzwwUo75iEGg4Hvv/++TOBziNPpdF/TnXfeWennl5NX3s/TU8k8NIRNRERERETOTU2ugkZXlL5tLXdP6ZxHtTuekZ5HUtbcuXOZN29eVZdRI6xbtw5/f3/69+9f1aVUmnXr1uHn53dOXdP5TgGSiIiIiIicu4wmqNOlqqs4Lx352nopX6NGjVi1alVVl1GpGjVqxIIFC2pMjzk5MQVIIiIiIiIiZ0m3bt3KvB5ezq7Ro0czevToqi7jrDjWW9kqi9rx+UdRoIiIiIiIiIiIlEsBkoiIiIiIiIiIlEsBkgDgdLpwOtUFUURERERERETK0hxI57l9OUVs3JPDV0u3A9CvXRz1I/wJ97dWcWUiIiIiIiIiUl0oQDqP7c0u5LHvVjF73V73uv9L2UWPRhG8dF0zIvy9q7A6EREREREREakuNITtPLZkS6ZHeHTIb+v2snxrZhVUJCIiIiIiIiLVkQKk81R2gZ2J89OOu/2T+VvIKbSfxYpERERERGq+bt268eCDD57WMbZs2YLBYCAlJQWAOXPmYDKZyMrKOu5nkpOTCQoKci+PHj2ali1bnlYdcnLOtXt9dFs6HoPBwA8//HDG65HqQwHSecrhdFFgdxx3e35xCSUOTaotIiIiIjWbw+liYWoG/5eyk4WpGThqwItj4uLiSE9Pp2nTphU+xiOPPMJvv/1WiVVVTwMHDqRv375n7XzHCk3O9Xt9vIAsPT2dXr16VeiYR4ekUjNoDqTzVKDNTJ/mMazelX3M7Ve1iCHQZj7LVYmIiIiIVJ5p/6Qz5qc1pGcVutdFB3rzTJ8mXN40ugorK5/JZCIqKuq0juHn54efn18lVVTz2e12zOYz8/vN+XqvT7eNVpYz+WzFk3ognaeMRgN9WkQTFVB2ouzoQG+uaBaD0WiogspERERERE7ftH/Sue/z5R7hEcDurELu+3w50/5JP2PnLikp4YEHHiAoKIjQ0FCefPJJXK7DPZ+O1YslKCiI5ORk4OR6ZyQnJxMfH4+Pjw/XXHMNGRkZHtuP7jVyqKfO2LFjiY6OJjQ0lCFDhmC3H562Ij09nSuuuAKbzUadOnX44osvSEhIYPz48eVe7yeffEJSUhJWq5Xo6GgeeOAB97Zt27Zx9dVX4+fnR0BAADfeeCN79uwpU+dnn31GQkICgYGB3HTTTeTk5Lj3+fbbb2nWrBk2m43Q0FAuueQS8vLyGD16NJMmTeL//u//MBgMGAwG5syZ475/X3/9Nd26dcPb25vPP//8mD1pxo8fT0JCwkldz6H9rrnmGgwGg3v56OM6nU6effZZatWqhdVqpWXLlkybNs29/VB93333Hd27d8fHx4cWLVqwcOHCcu/z0Q490xdffJHIyEiCgoIYM2YMJSUlPProo4SEhFCrVi0++eQT92fmzJmDwWDg4MGD7nUpKSkYDAa2bNlS5hzJycmMGTOGv//+232PD7XTEw1hy8zMZNCgQURGRmKz2ahfvz4TJ04EoE6dOgC0atUKg8FAt27dTuneHf1sASZOnEjjxo3x9vamUaNGvPfee+7PXXzxxR7tEiAjIwOr1crvv/9+wnstpRQgncdig334ZnAH7uqcQIivhRBfC3d1TuDrezsQG2yr6vJERERERCrE4XQx5qc1HGuw2qF1Y35ac8aGs02aNAkvLy8WLVrEW2+9xRtvvMFHH31UacdftGgRd955J/fffz8pKSl0796d559//oSfmz17NqmpqcyePZtJkyaRnJzsDgMA+vfvz65du5gzZw5Tp07lv//9L3v3ln3pzpHef/99hgwZwj333MOqVav48ccfSUxMBMDlctG3b18OHDjA3LlzmTlzJqmpqfTr18/jGKmpqfzwww/8/PPP/Pzzz8ydO5eXX34ZKA21br75Zu68807Wrl3LnDlzuPbaa3G5XDzyyCPceOONXH755aSnp5Oenk7Hjh3dx33ssccYNmwYa9eupWfPnid1b8u7niVLlgClQUV6erp7+Whvvvkm48aNY+zYsaxcuZKePXty1VVXsXHjRo/9nnjiCR555BFSUlJo0KABN998MyUlJSdV5yG///47u3btYt68ebz++uuMHj2aK6+8kuDgYBYtWsTgwYMZPHgw27dvP6XjHtKvXz8efvhhkpKS3Pf46Od3PE8//TTr16/nl19+Ye3atbz//vuEhYUBsHjxYgBmzZpFeno63333HXDy9+7oZ/vhhx/yxBNP8MILL7B27VpefPFFnnrqKSZNmgTA3XffzRdffEFRUZH7GJMnTyYmJobu3btX6N6cjzSE7TwXF+LDY5c3YlCXemCAEB8zFi9TVZclIiIiIlJhi9MOlOl5dCQXkJ5VyOK0A3SoF1rp54+Li+ONN97AYDDQsGFDVq1axRtvvMGgQYMq5fhvvvkmPXv25PHHHwegQYMGLFiwwKOnxrEEBwfzzjvvYDKZaNSoEVdccQW//fYbgwYNYt26dcyaNYslS5bQtm1bAD766CPq169f7jGff/55Hn74YYYPH+5e165dO6A0HFi5ciVpaWnExcUB8Nlnn5GUlMSSJUvc+zmdTpKTk/H39wfg9ttv57fffuOFF14gPT2dkpISrr32WmrXrg1As2bN3Oey2WwUFRUdczjVgw8+yLXXXltu/adyPeHh4UBpb7Hyhm+NHTuWxx57jJtuugmAV155hdmzZzN+/Hjeffdd936PPPIIV1xxBQBjxowhKSmJTZs20ahRo5OuNyQkhLfeeguj0UjDhg159dVXyc/P5z//+Q8Ao0aN4uWXX2b+/Pnuek6FzWbDz88PLy+vUx6ytm3bNpo3b07btm0xGo0ePb0O3cvQ0FCP457svTv62T733HOMGzfOva5OnTqsWbOGCRMmMGDAAK677jqGDh3K//3f/3HjjTcCpUHgwIEDMRg08uZkqQeSYPEyERXoTVSAt8IjEREREanx9uYcPzyqyH6nqn379h6/lHbo0IGNGzficBz/JTanYu3atXTo0MFj3dHLx5KUlITJdPjf+9HR0e4eRuvXr8fLy4vWrVu7tycmJhIcHHzc4+3du5ddu3bRo0eP49YZFxfnDo8AmjRpQlBQEGvXrnWvS0hIcIdHR9fVokULevToQbNmzbjhhhv48MMPyczMPOG1Au4g7GSd6HpORnZ2Nrt27aJTp04e6zt16uRxzQDNmzd3/zk6Otpdw6lISkrCaDz8a31kZKRHwGYymQgNDT3l456qXr16ueeCSkpKAmDw4MF89913tG7dmpEjR7JgwYJyj3Eq9+7IZ7tv3z62b9/OXXfd5a7Bz8+P559/ntTUVACsViu33XabezhfSkoKf//9NwMHDjzdSz+vqAeSiIiIiIicUyL8y87zeTr7VTaDweAxJxLgMRfRiRz92ZN19ETDBoMBp9NZ7jHLO5fNVv60Fy6X65i9O45eX15dJpOJmTNnsmDBAmbMmMHbb7/NE088waJFi9zz6ByPr6+vx7LRaCz3vp/oek7F0dd9rHtx5HUf2nbouk/Wse5deffzUNh05H04lbZ3PB999BEFBQUeNfXq1YuVK1cyb948fv/9d3r06MGQIUMYO3Zsucc6mXt35LM9dG0ffvghF154ocd+Rwamd999Ny1btmTHjh188skn9OjRw92rTU6OeiCJiIiIiMg55YI6IUQHenO8gSkGSl8cc0GdkDNy/r/++qvMcv369d2/zIaHh5OefngS740bN5Kfn3/Sx2/SpMkxz3E6GjVqRElJCStWrHCv27Rpk8dky0fz9/cnISHhuK+wb9KkCdu2bfOYf2fNmjVkZWXRuHHjk67NYDDQqVMnxowZw4oVK7BYLHz//fcAWCyWk+7ZFR4ezu7duz3CkyMnKj/R9UBpOFLe+QICAoiJieHPP//0WL9gwYJTuuYz5dDQsSPbX3mTtcPJ3ePY2FgSExNJTEz0CGXCwsIYOHAgn3/+OePHj+e///2v+5iAx3Ereu8iIyOJjY1l8+bN7hoOfR0ZMjZr1oy2bdvy4Ycf8sUXX3DnnXeWe01SlnogiYiIiIjIOcVkNPBMnybc9/lyDOAxmfahUOmZPk0wnaG3Dm/fvp0RI0Zw7733snz5ct5++23GjRvn3n7xxRfzzjvv0L59e5xOJ4899tgpvYZ82LBhdOzYkVdffZW+ffsyY8aME85/dCKNGjXikksu4Z577uH999/HbDbz8MMPY7PZyp0jZvTo0QwePJiIiAh69epFTk4O8+fPZ+jQoVxyySU0b96cW2+9lfHjx1NSUsL999/PRRdddNLDyxYtWsRvv/3GZZddRkREBIsWLWLfvn3uQCEhIYHp06ezfv16QkNDCQwMPO6xunXrxr59+3j11Ve5/vrrmTZtGv/73/8ICAg4qes5dL7ffvuNTp06YbVajznE79FHH+WZZ56hXr16tGzZkokTJ5KSksLkyZNP6prPpMTEROLi4hg9ejTPP/88Gzdu9Gibx5KQkEBaWhopKSnUqlULf39/rFbrCc/1zDPP0LhxY9q2bYvdbufnn392P7eIiAhsNhvTpk2jVq1aeHt7ExgYWOF7N3r0aIYNG0ZAQAC9evWiqKiIpUuXkpmZyYgRI9z73X333TzwwAPutxfKqVEPJDmm7AI7+3IKKbRXzjhtEREREZGz6fKm0bx/W2uiAj2HqUUFevP+ba25vGn0GTt3//79KSgo4IILLmDIkCEMHTqUe+65x7193LhxxMXF0bVrV2655RYeeeQRfHx8Tvr47du356OPPuLtt9+mZcuWzJgxgyeffPK06/7000+JjIyka9euXHPNNQwaNAh/f3+8vY8/1G/AgAGMHz+e9957j6SkJK688kr3G7MOveY9ODiYrl27cskll1C3bl2++uqrk64pICCAefPm0bt3bxo0aMCTTz7JuHHj6NWrFwCDBg2iYcOGtG3blvDwcObPn3/cYzVu3Jj33nuPd999lxYtWrB48WIeeeSRk74eKH12M2fOJC4ujlatWh3zPMOGDePhhx/m4YcfplmzZkybNo0ff/zxhBOSH81gMHi8Ja8ymM1mpkyZwrp162jRogWvvPLKCd/gd91113H55ZfTvXt3wsPDmTJlykmdy2Kx8Oyzz9KyZUu6du2KyWTiyy+/BMDLy4u33nqLCRMmEBMTw9VXXw1U/N7dfffdfPTRRyQnJ9OsWTMuuugikpOTywxzvPnmm/Hy8uKWW24pt13LsRlcFR1Ae57Izs4mMDCQrKwsj2T6XHUgr4iVO7J4d/Ym9uUUcUGdEO7pWo/4UBsWU82dYNtut/Prr7/Su3fvU/q/OyJVRW1Wahq1Walp1Garv8LCQtLS0qhTp85p/aLncLpYnHaAvTmFRPiXDls7Uz2PziSn00l2djYBAQEekyafSTt27CAuLo5Zs2ad1sTScuq2bNlC/fr1WbNmzSkHT9VFVbTZE9m+fTsJCQksWbLEY8L4c115P09PJfPQEDZxyy6wM2HuZibM2+xetyUjnx9W7OLrwR1oGRdUdcWJiIiIiFSAyWigQ73Qqi6jRvj999/Jzc2lWbNmpKenM3LkSBISEujatWtVl3bemTZtGvfcc0+NDY+qG7vdTnp6Oo8//jjt27c/r8KjyqQASdz25RZ5hEeHFDucPPH9Kj698wJC/U481lVERERERGoeu93Of/7zHzZv3oy/vz8dO3Zk8uTJ6qVXBQYPHlzVJZxT5s+fT/fu3WnQoAHffvttVZdTYylAErdlWzOPu231rmyyC+wKkEREREREzlE9e/akZ8+eVV2GSKXr1q0bmr3n9FWPgYhSLZhPMBa8vLcviIiIiIiIiMi5SwGSuLWKD+Z4GVGb2sEE2tR1VURERETOLvUaEBE5PZX1c1QBkriF+1sZ1atxmfV+Vi9euKYpwb6WKqhKRERERM5Hpn/fAFxcXFzFlYiI1Gz5+fkApz2fmeZAEjdfqxf92tWiXUIwn/yZRnpWIR0Tw7iudSxxwT5VXZ6IiIiInEe8vLzw8fFh3759mM3mavMa8KridDopLi6msLDwvL8XUjOozVY9l8tFfn4+e/fuJSgoyB3MV5QCJPEQaLPQKt7C2BsCKHY48TGbMJn0zS4iIiIiZ5fBYCA6Opq0tDS2bt1a1eVUOZfLRUFBATabTXOTSo2gNlt9BAUFERUVddrHUYAkx2Q1m7CaTy+dFBERERE5HRaLhfr162sYG2C325k3bx5du3Y97WEoImeD2mz1YDabT7vn0SEKkEREREREpNoyGo14e3tXdRlVzmQyUVJSgre3t34ZlxpBbfbcowBJTkpuYQm5RSVYvAyE+FqruhwREREREREROYsUIEm5CuwONu/L5Y2ZG1ix7SCRAd48cHEiF9YJIdRPQZKIiIiIiIjI+UABkpQrZVsmt360CKerdDkjr5j7Jy/nzk4JPHhJAwJs6oooIiIiIiIicq7T67XkuPbmFDLqu1Xu8OhIn8zfwv7corNflIiIiIiIiIicdQqQ5LiyC+xsycg/7vaVO7POYjUiIiIiIiIiUlUUIMlxmYyGcrd7e6n5iIiIiIiIiJwPlADIcQX5WGhdO+iY28wmA0kxgWe3IBERERERERGpEgqQ5LiCfSy8fG1zAmxl51p/+drmhPnrLWwiIiIiIiIi54MaFSDNmzePPn36EBMTg8Fg4Icffih3/zlz5mAwGMp8rVu37uwUfA6oH+HHL0O78OQVjenWMJwBHWoz7cEuXN40CpvZVNXliYiIiIiIiMhZULZrSTWWl5dHixYtuOOOO7juuutO+nPr168nICDAvRweHn4myjsnGQwG4kJ8uLtLXW5vXxsvk/GEcyOJiIiIiIiIyLmlRgVIvXr1olevXqf8uYiICIKCgiq/oPOMVT2ORERERERERM5LNSpAqqhWrVpRWFhIkyZNePLJJ+nevftx9y0qKqKoqMi9nJ2dDYDdbsdut5/xWmuCnCIHGXl2FqRmYDRAh3qhhPla8LVU3xGRh56dnqHUFGqzUtOozUpNozYrNY3arNQ0arM1w6k8H4PL5XKdwVrOGIPBwPfff0/fvn2Pu8/69euZN28ebdq0oaioiM8++4wPPviAOXPm0LVr12N+ZvTo0YwZM6bM+i+++AIfH5/KKr/Giq/fhB82FDDpr+0e6+/vmsDFcUZ2bt5QRZWJiIiIiIiIyKnIz8/nlltuISsry2Pqn2M5pwOkY+nTpw8Gg4Eff/zxmNuP1QMpLi6O/fv3n/Bmng/mb85k4MQlx9z21T3taR1XPe+R3W5n5syZXHrppZjN5qouR+SE1GalplGblZpGbVZqGrVZqWnUZmuG7OxswsLCTipAOi+GsB2pffv2fP7558fdbrVasVrLvp7ebDaf940+u8DOB3NTj7v9oz/TeLNfS3ys1bdZ6TlKTaM2KzWN2qzUNGqzUtOozUpNozZbvZ3Ks6m+k9acIStWrCA6Orqqy6iRih1O9ucWH3f7vpwiih3Os1iRiIiIiIiIiJwN1beryDHk5uayadMm93JaWhopKSmEhIQQHx/PqFGj2LlzJ59++ikA48ePJyEhgaSkJIqLi/n888+ZOnUqU6dOrapLqNECvL3oVC+UTXtzj7m9a/0w/Kpx7yMRERERERERqZga9dv+0qVLPd6gNmLECAAGDBhAcnIy6enpbNu2zb29uLiYRx55hJ07d2Kz2UhKSuKXX36hd+/eZ732c4HFy8TATnX4eukOCuwOj23+Vi+ubxuHl+m869QmIiIiIiIics6rUQFSt27dKG/O7+TkZI/lkSNHMnLkyDNc1fklLtjG1Ps68vSP/7B0SyYAHeqGMOaqptQKslVxdSIiIiIiIiJyJtSoAEmqnpfJSJOYAD7q35asAjsAQT5mAm2WKq5MRERERERERM4UBUhSIUE+FoJ8SkMjp9PFroMFbM/MJzPPTt1wX8L9rAT7KlQSERERERERORcoQJLT4nS6WJ2ezcBPFpORd/gNbT0aR/DiNc2IDPCuwupEREREREREpDJoxmM5LelZBdz64V8e4RHAb2v38uG8zRQdNdm2iIiIiIiIiNQ8CpDktKxNzyG7sOSY2yYv2sb+3KKzXJGIiIiIiIiIVDYFSHJatmXmH3dbgd1BUYnzLFYjIiIiIiIiImeCAiQ5LUkxAcfdFu5nxWYxncVqRERERERERORMUIAkp6VOqC/1wn2Pue2hSxsQ6a9JtEVERERERERqOgVIcloiArxJvuMCLmoQjsFQui7A24unrmzC5U2jMBoNVVugiIiIiIiIiJw2r6ouQGq+uBAf3r65FQfyiikscRBgNWM1G9mfU8SKbZmE+lmIDrARGajeSCIiIiIiIiI1kQIkqRQBNjMBNjMAu7MKePCrFP7YuN+9vVawjeQ72pEY4V9VJYqIiIiIiIhIBWkIm1Sq/KISXpu+3iM8AtiRWcDtHy8mPaugiioTERERERERkYpSgCSVan9eEf+XsuuY29KzCtmZqQBJREREREREpKZRgCSVqqDYQYnTddztu7IKz2I1IiIiIiIiIlIZFCBJpfK1euFjMR13e51Qn7NYjYiIiIiIiIhUBgVIUqki/K0M6lL3mNuaxgYQHWg7yxWJiIiIiIiIyOnSW9ikUlm8TNzeoTYOp5OP/kyj0O7EYIBBnetwy4W12Z1dyJ6cQkJ9LUQGeGMwGKq6ZBERERERERE5AQVIUunC/KwM7VGffu3iySkswddqYvWubPq+N5+D+XagtKfSG/1a0rZ2MFbz8Ye8iYiIiIiIiEjV0xA2OSOsXibiQnxoEhNAdoGdIV8sd4dHAHtzihjwyWK2661sIiIiIiIiItWeAiQ5o/KKSnhn9iZcx3gxW4nTxWd/bcHucJ79wkRERERERETkpClAkjMqv7iEdbtzjrv9n53ZFNodZ7EiERERERERETlVCpDkjPI2m6gT5nvc7Q0j/bB6aQ4kERERERERkepMAZKcUf7eZoZdXP+Y25rGBHBX57ocyCsit8h+zH1EREREREREpOrpLWxyxiVG+vHq9c155v9WU2B3YDIaePW65hTYS7jns6Vk5BVzYZ1QHrqkPnXDfbGoR5KIiIiIiIhItaIASc64AG8zfVvG0LFeKHtzivCzevHmrI38sirdvc/01bv5be0evr2vAy3jgquwWhERERERERE5moawyVlh8TJRK9iH1vHBlDhcHuHRISVOF0/9sJoDeUVVUKGIiIiIiIiIHI8CJDnr5qfuP+62VTuzyCksOYvViIiIiIiIiMiJKECSs87HfPw5jowGMBoMZ7EaERERERERETkRzYEkZ13HxDAMBnC5Dq8zGKBP8xj6tYsju9DOlv15hPpZ8Pc2V12hIiIiIiIiIgIoQJIqEOFvZXSfJJ75cTVQGh69dG0z1qXncGfyEopKnBgMcFmTSJ7pk0RMkK2KKxYRERERERE5vylAkrPO1+rFta1jaZcQwheLtxIbZGPz3jySF2xx7+NywfTVe9iXU8SH/dsS6metuoJFREREREREznOaA0mqhL+3mSYxATx3dVOuaB7Np39tOeZ+y7cdZE+O3somIiIiIiIiUpUUIEmVMhgM5BU5KLQ7j7vPtoz8s1iRiIiIiIiIiBxNQ9ikyvlYTBgN4HR5rg/1tdCvXRx1wnzYkZlPkI8ZP6sm1RYRERERERE529QDSapcqJ+F3s2iPda1igvitRtasGxrJj3H/0HXV2fzyNcr2bI/r4qqFBERERERETl/KUCSKudnNfPEFY25sG4IAFYvIw9d2oD7Jy9jUdoBoLR30rTVu7n+gwXsyNSQNhEREREREZGzSUPYpFqIDrTx/q2t2ZdTRH6Rgy+WbDvmvEj7c4uZsXoPd3RKwGAwVEGlIiIiIiIiIucf9UCSaiPE10rDqABig20sTM047n6z1+8lv9hxFisTEREREREROb+pB5JUO14mI0E+ZnZkFnisbxDpx+CL6hHkY2bJlgPEh/gQ5mclwKaJtUVERERERETOJAVIUu2E+Fq4p2s9hk1Z4V6XFBPAg5c04D/frWJfbpF7/Q1tajHy8oaE+3tXRakiIiIiIiIi5wUNYZNqqWPdUK5uEeNeHt6jPg99leIRHgF8s2wHXy/djsNRdr4kEREREREREakc6oEk1VKYv5VnrkrinovqsnxrJlkFdnKLSo6573/npXFtq1pEB9nOcpUiIiIiIiIi5wcFSFJthfhaCPG1kBQTyJuzNhxznw71Qrm+TS2yCu04M12E+1uxeJnOcqUiIiIiIiIi5zYFSFIjNKsVWGbdf3o3psDu4IVf1nIgrxib2cRt7eO5u0tdIgM0J5KIiIiIiIhIZdEcSFIjNI4KIOqIUOiyJpFk5hXzxswNHMgrBqDA7uDDP9J45v9WczC/uKpKFRERERERETnnKECSGiE6yMaUey6kVXwQAFe3jGXSwi3H3Hfa6t3sz1WAJCIiIiIiIlJZNIRNaow6YX58PKAdB/KKyC0qIb/YUWafpJgA+ndIIKfQzsY9OQT7Wgjzs1ZBtSIiIiIiIiLnDgVIUqMcmlh7877cMtuubB5Nt4bhjJ2+gd3ZhQDUj/DjjX4tqR/uc7ZLFRERERERETlnaAib1EghvhY61A1xLwf5mLm6ZSyPfrvSHR4BbNyby40TFrI7W0PaRERERERERCpKAZLUSEE+Fl69vgUJoaU9i65pFcvnf23F5Sq7b1GJk6VbD5CYWP8sVykiIiIiIiJybtAQNqmx4kJ8+OreDmzZn4fBAEO+WFFmn2taxdKnRQxLthxgeUEJl5gyaRzj+UY3ERERERERESmfAiSp0SIDvIkM8OZgfjGxQTb25RS5t13dMoaGUf7cmbzEvW7you3Uj/Rj0h0XEBNkq4qSRURERERERGocDWGTc0KQj4VhPQ4PUTMaoG/LWF6Ztq7Mvhv35PLenE0UlZR9i5uIiIiIiIiIlKUASc4ZreKCeOiS+hgNkBQTyPJtmWXmRLKYjNzdpQ4XN4rkn53ZpO7NJTNfE2yLiIiIiIiIlEdD2OScEexr4e4udenbKpaM3CJmrt3rsd1iMvLmzS35YcUu7vpziTtcal83hHE3tCA22KcKqhYRERERERGp/tQDSc4pvlYvaof60rp2CBc3jPDY1q9dHL+sTGf66t0ePZP+2nyAB6asICO3CBEREREREREpSwGSnLMSwnxoEx/kXu7aIJxfV6WX2a9lXBC3XVibHZkFbNiTw34FSSIiIiIiIiIeNIRNzlnh/t68e2sbvli0leSFWyguceI8ak6k61rH0jYhhJf/t459/wZH9SP8GN+vJY2iAzAZDVVQuYiIiIiIiEj1oh5Ick6LCvRmWI/6TBvehcRwH47Mg8L8LFzSJJJR361yh0cAG/fmcuOEhew8WFAFFYuIiIiIiIhUPwqQ5JznZTIS7msme/c2ejeLdq+/rnUtPl24tcz+DSP9ea5vU7YfyGdh6n62ZuSRW2g/myWLiIiIiIiIVCsawibnjd07tvBE7x4UlTiYuWYvtUN9+Hrpdo99WsYFcV+3ejzx/Sr25xYDYDTAwI4JDOmeSKiftSpKFxEREREREalSCpDkvOF0OgnzNTP2hhZk5BZjdziJDbaRmX+4d9HQixMZOmUF+cWOw59zwcQFW+hQL5Su9cOxeBkxGDQ3koiIiIiIiJw/atQQtnnz5tGnTx9iYmIwGAz88MMPJ/zM3LlzadOmDd7e3tStW5cPPvjgzBcq1VqgzULdcD8aRgUwvEd99/oGkX5s2JPjER4BtK0dzMSB7Vi6JZPBny/n1enr2bwvlyK74+hDi4iIiIiIiJyTalSAlJeXR4sWLXjnnXdOav+0tDR69+5Nly5dWLFiBf/5z38YNmwYU6dOPcOVSk3RtnYIw3vUx2Q0EOHvzfYDnhNn1wv3Y1DXugz+fBkT5m1m9vq9vD8nlcvemMeitAOUOJxVVLmIiIiIiIjI2VOjhrD16tWLXr16nfT+H3zwAfHx8YwfPx6Axo0bs3TpUsaOHct11113hqqUmiTY18I9XetybetYdmcVsvNgAV8s3ubeflfnBJ77eQ2Fds+gqFlsIAfyilm3Owdvs5FgH4vmRxIREREREZFzVo0KkE7VwoULueyyyzzW9ezZk48//hi73Y7ZbC7zmaKiIoqKDr/SPTs7GwC73Y7drjdx1VSHnt2xnqHFCDEBFmICLMQGeRPia+FAXukE2mF+VnZkevZKuqFNLVrFB/HCL2vZl1vaVhpH+/P6DS2oF+aDpkeSylBemxWpjtRmpaZRm5WaRm1Wahq12ZrhVJ7POR0g7d69m8jISI91kZGRlJSUsH//fqKjo8t85qWXXmLMmDFl1s+YMQMfH58zVqucHTNnzix3u5+fH8m3t2DkD+tYtzsHh8vlsT3C30q3hhEM+WK5x/q16Tk8/eNqXurbhOzM/RTlHGT/nnScTg1xk9NzojYrUt2ozUpNozYrNY3arNQ0arPVW35+/knve04HSECZt2W5/g0EjvcWrVGjRjFixAj3cnZ2NnFxcVx22WUEBAScuULljLLb7cycOZNLL730mD3Pjvbpne04mG/HaDAQYPMiu6AEgOvb1GLi/DSPfS0mIy9d14x92UUMmbKS3KISujUM5+4u3YkNsKpHklTIqbZZkaqmNis1jdqs1DRqs1LTqM3WDIdGXZ2MczpAioqKYvfu3R7r9u7di5eXF6Ghocf8jNVqxWotO5eN2WxWoz8HnOxzjDCbiQiw4XA4efaqpjz4VQoACWG+fLpwq8e+j/dqxHfLdzB/U4Z73eRF2/jx711MG96VcH8rZpPhuKGlSHn0s0dqGrVZqWnUZqWmUZuVmkZttno7lWdTo97Cdqo6dOhQprvcjBkzaNu2rRqwnBSTycjFjSP4+t4OXFgnhOwCOzFB3u7tgTYz4f5Wj/AI4II6Ibxzcys+/2srgz9fxuszN5C2L5fiEsfZvgQRERERERGR01ajeiDl5uayadMm93JaWhopKSmEhIQQHx/PqFGj2LlzJ59++ikAgwcP5p133mHEiBEMGjSIhQsX8vHHHzNlypSqugSpgQK8zVxQJ4T/3t6GYoeTyABvhk5ZAUCLWoEsSN3vsX+DSD/u6JTAPZ8to6ikdA6k39ft5YO5qUwZ1J5W8cGYjOqNJCIiIiIiIjVHjQqQli5dSvfu3d3Lh+YqGjBgAMnJyaSnp7Nt2+FXsNepU4dff/2Vhx56iHfffZeYmBjeeustrrvuurNeu9R8gT4WADolhnF/t3p8MDcVh8uFl9GzI9/dXery7E9r3OERgJ/Vi6f7NGHL/jy+WrKdQJuZa1rHUivYh0CbesOJiIiIiIhI9VajAqRu3bq5J8E+luTk5DLrLrroIpYvX152Z5EKCvG1cF+3etzYNo4tGbn4e5v57K/D8yIF2sykZxW6lw0GeKNfC8bP2sjqXYcnKPvozzQevawBt3esjbeXFxavc3pEqYiIiIiIiNRgNSpAEqku/L3N+HubSQjz5WB+MXd0TGDigi0AOJyeIWeXxDD+2nzAIzwCGN6jPglhfjzzf2vILrRzdYsY2iWEEB1kO1uXISIiIiIiInJSFCCJnKYgHwtDe9Snd/NoJi3Ygp/VCz+rF7lFJQBc3jSK12du8PjM/d3qsS+niDd/2+he99vavbSMC+K9W1vjZTRgs5jw99bwNhEREREREal6CpBEKkGIr4UQ3xBa1ArCXuLk6T5NGPntSgCsZhN5RYffvmYzm2gRF8S9ny3zOMYtF8TTuX4Yj327ks3786gX4cfwHok0iPRXkCQiIiIiIiJVSgGSSCWyeBmxeBm5PCmKuGAfxs1cz7rd2XRODGXm2r0AXFAnhLnr93l8rnNiGIkRftw/+fB8XTsPFrA3u5CXr22Gn7cXZpORYB8LAZp0W0RERERERM4yBUgiZ0CAzUyHeqF8FN2WIruDgwUl/LFpP4V2J14mA0UlDo/9b7kw3t1j6ZC+LWPpUj+MoV+uYPuBAgwG6FI/nGevSiIhzPdsXo6IiIiIiIic5/TaJ5EzKMjHQmSgjXrhvvz4QGd6JkWxZmc2XeqHe+xnMOCeMwkgKsCbS5tE8vA3f7P9QAEALhf4WExsO5DPN0u38+nCLaxNz+ZAXvFZvSYRERERERE5/6gHkshZ4GUy0iDSn3E3NienoIQSp5MLEkJYvOUAAEaDwWP/fu3i+OiPzR7r+raMpXmtQO5IXuLxpreBHWszqEtdjEYDVi8TIb6WM39BIiIiIiIicl5RgCRyFvlZzfhZS+cwevuWVvy6Kp2J87dgL3ES6msh49/eRIkRfrz9++E3tHkZDVzVMoa7Ji3BdTg7YliPRKIDbdz96VK27M+nXoQvj17WkBZxQQT5KEgSERERERGRyqEASaSKRAZ4M7BjAlc2jwbgjX4tuTN5CSVOF1kFdiL8vdmdXQhA+7qhzN2wzyM86t0sCqcLRn23yr1uXXoOKTuy8LV6kbovl0CbmaSYQCIDrFi8TGf1+kREREREROTcoQBJpAoZDAbC/b0BCPA2M+3BrkxetJUNu7MZ0LE2r0xbX7rN5kVGbpHHZ69pFcsDX6zwWPfaDS346e9dvDFzg3tdsI+ZiQPbEeJnARf4eZs1zE1EREREREROiQIkkWrCajaRGOHHE70bU1TiIK/IwZr0bH76O50Ne3Lp1y6On1emA6WTbheVOCkqcbo/36FuKJv25vL7ur3uddGB3rxyXXPen5vKrLV7cThdtKgVyHNXN6VBlB8OJ3h7GTGZNJ++iIiIiIiIHJ8CJJFqxstkxMtkxNdq5tmrmjK0e31SdhykaWzpULQ92UW4XGA+KvS5ulUMr/3bY+mQp/s04bGpK0nPKnSviwq0kZFXzPO/rCV1bx4t4gK5sW0ctUJsWEwa5iYiIiIiIiJlKUASqcaCfS0E+1poEOUPwNf3duC5n9fw+7q95BaVEOZnYX9u6cTb/lazexJugPoRfuzILPAIj9olBNOjcQR3TVrCoRe5Ld16AH+rF10ahLN+Tw5BNjONogOI9Ne8SSIiIiIiIlJKAZJIDVI71Jc3+rUkM9+OARfv3tKa/p8spqjESdr+PJJiAli9KxuAxtEBLN1ywOPzAzomMGrqKnd4ZDDA2Bta8MOKXbw24/C8SY2i/HijX0vAgNPpItjXQmSANyaj4SxdqYiIiIiIiFQnCpBEahh/bzP+3mYAogJszHioK7+u2s2OzHwevqwBdyYvBSC3qIQIf6v7cyajAaPBQE5RiXtdp3phrNmVzez1h+dNah0fxOCL6nHvZ8vZdiAfKJ2I+91bWhEX4ovD6cJqNhLp741RgZKIiIiIiMh5QQGSSA1m9jJSO9SX+7rVw+l0kW938PGAtjzz42rmb9rPO7e05ssl2wEwAI5DXY/+1bdVDM//sta9bDDA8B71Gfz5cgrsDqA0eHrqyib8tm4fXy9ZTs6/Q+ce69mQrg3DcbrAiIEwP4sm4xYRERERETlHKUASOUcYjQb8rF70aBxJ09hAcgpLsJgMjL6qCaN/XEOJ04W32YjVy+h+e5uPxYuD+Xb3MS6sE8KC1Ax3eARwZ6c6/LZ2L7+sSnevaxobSLCflQe//JvFWw4QZDMzsGMCN18Qh8MFLhcE+5qxag4lERERERGRc4ICJJFzUGSAN5EBpX++vk0cFzUI54+N+yksdjCqVyNG/7QGgO0H8mkQ6ceGPbkAxAX7uP98SMd6odyRvOSIY1u5+YJ47v1smbtHk8PlonFMAB/+kcaPf++iuMRJ72ZRDL6oHjaLieISF75Wk3vonYiIiIiIiNQsCpBEznF+Vi/8rH7UCfMDILugmMbRAbz520Z+W7uHoRfXZ+iUFQDszSkiIczX/Vlfi4n9uUUex7vlgnjen5PqMRzu2auSeOV/69i493D4FOZnZf6mDCYv2srOgwU0jg7g0Z4NqBXsQ1GJEy+jgXB/7zN56SIiIiIiIlJJFCCJnGcCbBYurBvKB9EBFNodGA0GPritDc/+tJo/N+3njk4JTP5rKyVOF0UlTvy8PX9M1I/0541ZG93L9cL9yMgr9giPrmsdS26Rg5FTV7rXOV0uDuTZeef3VfyVlkGwj4V7u9bl0iaRlDhd4IIAmxlfq34siYiIiIiIVDf6TU3kPBVgMxNgKx1SdnnTKFrFBZFdaMfbbOKjAW0ZNmUF2YUl5BaWEBlgZU92aU8kp9PlMY9S24Rg5q7f53HsK5rHMOjTpe7lyAArAzsmMOjTpdgdpT2XfMxe1Ar24dVp6/lp5S4cTheXJ0XxWK9GGIBihwub2UhkgDcGg972JiIiIiIiUpUUIIkIAJGB3kQGlg4piw705n8PdmVPViEGA3zYvy23f7yYrAI7s9bupXezaL5fsRMAu8OJ1Xx4suwAby/25RR5DHG75YJ43pud6g6PAJ7rm8TjU1eyK6sQAIvJSM+mUXw4bzPfLNtBfrGDCH8rr93QnIRQX/KKSrCaTYT6WgjysZyNWyIiIiIiIiL/UoAkImV4mYzEBtmIDbIB4HK5+HV4Z9bsymbL/jy6NYzg7+0H2bw/j7nr9/HEFY2Zvno3ACVOFxYvo8fxjh721rxWIOt257jDI4D7utXj22U7mHNEb6Y7OiWwOC2T+z5fTn5x6Zvh7upch1svjGdXViEOp5M6ob6E+VvxsejHmYiIiIiIyJmi37hE5IQMBgOxQT7EBvm4130x6EL+2ZXNjNW7CfOz0rdlDD+k7CK/2IHNbMJmNlFgd7j3NxkN7l5JzWsFsSA1w2Nb81qBvPnb4ZCpbe1gAN6dvcm97vo2tYgNstHrzT/cQ+i6JIbySM9GrNieydaMfC6sE0rzWoGE+VnIKSzB4mXU299EREREREROkwIkEamQqEAbUYE2LmkcCUBSTAC3XFibyYu28s/Og7x2fXOGfbkCpwvmb9rPJY0jmL56DwBFdgf+R0yWHeJjYUdmgcfxb2wXx2vT1ruXbWYTPZOiPOZWalM7mOvaxHH9Bwvcw+NSth3kkZ4NmTA3lYWbMwj3t/JAt0TqRfhRVOLEBQTavAi0aRiciIiIiIjIyVKAJCKVItTPSqiflba1g3Hiwl7iZPqDXflyyTZ2HChgyMWJ/L09i93Zhfy2bi9PX9mEGWtKA6W84hKCfDx7CflZvdiXW+Reviwpkp/+3uWxz6AudRnxdYo7PIrwtzLk4kTumrSEQntpDyUDBoodTkZ8ncL81AxcLriyWRQPXdaQgmIHOYV2IgO8CfWzEGiz4HS6MBo1abeIiIiIiMiRFCCJSKUyGg0YMeBlMVI/0p8nejeh2OHE6mXku/s7sjA1g+mrd+NjMXHLBfF8sXgb+cUODECwj5nMfDsAxSVO/Kxe5BaVABDmZyVl+0H3eYJ8zOQU2t1zIwHcemE87/6+6XB4ZIAnrmjMA18sJ7uw9Di1gm3c0DaOO5OXsDUjH4D4EB9evb4ZWzMKmLthL7VDfLiudS3C/a3u4wf5mrGZ9SNTRERERETOT/ptSETOKKPRgLex9C1tMUE2rmtTi6tbxWAyGGiXEMItF8bzQ8pOth/I58P+bblj4hJyikr4aeUu+rWL4+M/0wDYmpFH4yh/lm3NBMDby0TOv6HQIQ2jAjwm6+5aP5y5G/a5wyOAEZc24LGpq9idXTqBd6DNzPN9mzL0ixR3j6faoT50qBfGu7NT+fWfdABuax/P7e0TyLc7yC20E+7vTZifBT+rF0UlDsxGIyaT5+ThIiIiIiIi5woFSCJy1nkZS4OWYF8Lwb4WmsYGAuBwuvjfg11YvSubrRl5dG8Ywb6cIn78exez1+/jkwFt+WbZDopKnOzLLaJ2qE95p6FRlD9/bT48WXeAtxdGg8EdHgHc1C6OD+amusMjgwHGXJXEQ1+lkJFXDJT2UOpaP5yBExez5d9eSw0i/XjxmmYs25rJgtQM4oJtDOiYQKCPmYJ/ey0F2swE+WiuJRERERERqfkUIIlItWEyGqgV7EOt4MPB0HN9mzL8kvrsOJBPRICVz++6kJFTV5K2P49lWzPp1TSK//2zG4A16Vm0qR3s7qWUW1RCsO/hACfY18LurEKPc7auHcyEeZvdy53qhTF/U4Y7PILSXkuPfruSvTmlIVO4n5VRvRpzZ/ISd++mVnFBbDuQz7tTN7F820EAbm8fz4COCazbncPurEJaxQdTO9SG2Wgk3+7AbDIS5metxDsoIiIiIiJyZihAEpFqLdBmJtBmpl64n3vdV/e052C+HRcu/KxetIoPZsLcVKYs2s64G1tw3+fLyCt2MO2f3Tx5ZRPmrN8HwL6cImoF2zyO73C6PJZbxAUxZ/1e93KQjxmHy+UOjwBubR/PW79tdIdHZpOBhy5twD2fLXXPv9S2djDtEkK44q0/KSopXXd1yxj6tIjhoz8288/ObCIDvBlzVRNig23sPFiIyQBxIT5E+FvJK3JQK7ExdocLs+f84iIiIiIiImedAiQRqXEiAryJCPB2L9/duQ5XtYjB4XTibTbx6/AufLl4O/NT9+N0uhjUpS4f/rGZ/GIHOUUl1Av3JXVfHgB7c4qoE+ZL2v7S5UK7A3/vwz8aQ32t7Mws8Dh/4+gAxh8x19KlTSL5eWW6OzwCuPeiugydssIdHiXFBNClfhiDPl2K69/Mql/DcJZtzeSO5CXYHS4MBnj6yiaE+1uZOH8LB/KK6VyvmEFd61DidHEw346f1YtQPwshvhYOFtgxAoEaJiciIiIiImeYAiQRqfGMRgNRgYcDpVA/KyMua8C9RXWxepm4pEkE/drVYt6G/TicTv57e1tGfbeSxVsy+WzhVh68pD4PfpWCywXTV+/m/m71+GvzAQD25RQSH+I515LT5dlrqWGkPz+vTHcvxwbZ2HWw0CNQuq19bV6fscEdHoX5WWhRK5BhX6a49xnctR6rd2Xz7bIdAHgZDbS/LJQXfl3L9NV73J97o19L1u/O4YeUnZiNRu7tWpcmsYHkFZVQYHcQ5mslzM+CwQh5RQ68zSb8rPpxLyIiIiIiFaffKETknGQ2Gd0TWNswEWizkBjh794+4fa2HMgvpqDYQZCPme/v78ir09aTsv0gZi8jVzSL5pdV6WQXllDidBIXYmP7gdKeSHuyPXstZReWEOZnZePeXAD8vb3IyCvyqCfQZmbXEfMvXdUihq+X7jiiXgNtE4K5a9JS97prWsfy27o97vAI4JXrmvPkD/+w9d/JvOuF+2E1m7jto0VsO1C67rImEdzdpR5fLNrKqp1ZxIX4MLJnQ3wsXqRnFWI2GYgO9CbS35vMAjsOp4sAby98FDKJiIiIiMhx6LcFETkvHXoD3CG1gn344LY25BWX4GU0cHHDCO7uUocfU3axLSOfjwe049Fv/ubvHVl8tnALD11Sn4e+/huH08UvK9N5+LIGLPz3jW/bD+TTMDLA43xeRoPHcri/ld/XHZ5rqX6EP3/vOOixzyWNI3ngi+Xu5Y71QlmcdsAdHgE80rMBI75OITPfDkDjaH96N4vh5g//cs/v1DMpil//2c2EuamlcyqZDLx2Qwuy8u1MWrCFgwV2LmsSyb0X1eVAbjGb9uUSF+xDvXBfvC1e5BTaMRgMhPiasZn114aIiIiIyPlIvwmIiPwrwGYmwHZ4xupQPyut4oPdyxPvaMeBPDsFxSUE+5r58YFOvDlrIyu2H8TucHJHpwQmzt9CXrGD/blFNK8VyModWQCs3Z1Dy7ggUrYfBGBrRj4No/zZ8m8Y5HS5MBo8QyaH04XdcXi4XJf6YR69lmKDbGTkFrvDI4ABHRN4ddo6d3gUHehNvXA/Hv7mb/c+j/ZsxPfLdzJ3w75/r9uLXk2juHvSUvfcUG1rBzP04kQmzNvMgtQMzCYDz1zZhDYJIUxfvZv9OUVc2iSSxtEBFJY4yS8qwWYxEe5vxdvLRHaBHZPJgL+3ZgAXERERETkXKEASETlJIb5WQnyt7uVawfB6vxbkFjqweBm5wgi3XlibvzZnYDEZePvmVkyYm8rU5Tv5/K+tvH5jC4ZOWcHBfDs//b2Lt25uxcw1e3C6YOPeXB6rFeRxPpPRgMVkpNjh5FgiA7zdw+gOOXqo3DWtYpm8aJt72ddiIi7E5g6PAAZ0SOC9Oanu8MjHYmJYj/oM+nSpexLwq1rEkFVYQq83/3DX1iYhhPGzNjB1+U6KSpzEBdt4o19Llm7N5JeV6dgsJoZdnEhciA+7DhaSW2SnXrgfEf5W8osdFDucmE1GIvytGI4Kz0REREREpHqpUIA0b948OnbsiJeX58dLSkpYsGABXbt2rZTiRESqOz+rGT/r4V42pXMt+bmXn+6TxP3dE7E7XPhZTfz8QGfmbNjHn5v2cyCvmA/7t+WJ7/9hd3Yhv63by92d6/DRn2kAzFi9m6tbxfDNv72O5m3cz+VJUbw/NxWA9KwCrguL9ajHgGcQExHgzY7Mw0PeGkcHsCTtgMc+LeKCePv3Te7lq1rEMGXxNnd4ZDIauLJ5DHckL3Hvc2PbWszftN894bfJaOD5vk0ZOmUF6f8GWB3qhZKZb+e+z/8kp6gEgEd7NiTAZmbC3FR2ZBZQL9yXcTe2YH9uMT//vYtAm5lbL6yNr9VEdmEJdoeTEF8LEf5W8oocFJY48PYyeQw/FBERERGRM69CAVL37t1JT08nIiLCY31WVhbdu3fH4XBUSnEiIjWdt9lErWDPt7jd1r42t1wQj9FowOVy8cOQThzML8ZgMOBv9eLyplF89Eca2w7kM6pXI5xO+H7FDhamZnBX5zrUWV06gXd6ViFBPhZCfS1k5BUDsD+3iPgQH/eE2tsP5NMg0p+9OaWTepc4XVi9TB71FJd49nBqGhvI6zM3uJdb1Apk8VGh08WNIrnv82Xu5UsaRzJ99R53eARwT5e63PvZMncPqt7NosgtLOG16esBMBjg8V6N+c93/7AmPfvfcwfQuX44z/682j1p+X0X1aNFXCDvz0ll8748GkX78+zVTckqsDNn/V4CbRZ6N43CYjaSU1CC3ekk2MdCpL+VnKISCu1ObGYjgT4KnUREREREKqpCAZLL5TrmcIOMjAx8fX1PuygRkXOd8d9JtQ0GA1GB3kQFeru3xQTbaBTpx9r1G2ga7c+Yq5swtEciWfl2/L29+PTOC5izfi/fLtvB//5J55OB7RjxdQqp+/KYOD+NUb0aMfzLFIodTr5bvoOXrm3On5v2A/DPziyG9ajv7sUEpb2HrF5Gd4+jvKISgmxmDvwbSnmbTe4eRIcUlzgpcR6en+miBmGMm3E4dGoWG8jfOw56DL/r2zKWoVNWuJe71g/nr80Z7vAI4KFLGjBsygryikv/R0SPxhH4eXsx+PPl/94vuKtzXZ74fhXLtx0EoEl0AA0i/Xjpf+vY9O+b8IZ0r0fr+GDem53Klow8kmICeOKKJhzIK2behn0E+Zjp1SwKL6OR7EI7JQ4Xwb6loVNWgZ1ih1M9nUREREREjnBKAdK1114LlP7CM3DgQKzWw3OBOBwOVq5cSceOHSu3QhGR85DVy8Curam0TGqIn+XfYXKhh7ff1r42fVrEYDQYCLCZ+fKeDmTkFlFU4iTM18L/hnfh80VbSdl2kD1ZBbxzSyue+b/VZOQV8/u6vdx3UT13iPTLynRuuTCeifO3lC6vSufa1rUYO6O0p9C63Tnc0DaOz//aerg+s7Hc+kP9LOw8WOCxrsTpcodUAD2TIj16OiXFBLAmPdsdHgHc0CaOh75KcS93Tgxj2dZMd3gE8EjPhgyfssIdcl3aJBKb2Yu7Ji0FwGgovV8jvy19ix5Ay7gg6ob78tzPa929tR67vCGxQTbenZ3KtgP5tK4dxNNXNmFrRj7TV+8mzM9Kv3ZxmE1GDuQVY3c4iQzwJszPysGCYkocLixeRiIDvHE6XeQVl2A2GfE2e/b4EhERERGpiU4pQAoMDARKeyD5+/tjs9nc2ywWC+3bt2fQoEGVW6GIiJRhMBgIOmJIVri/lXB/q8c+/+ndiPxiJ95eRswmI23ig8nML8ZkNOBvNdO7WRSfL9rGvpwi7uyUQIivhQ/nbWbljizu6lSHrvXDmLexdK6mgmIHzWIDWbWzNID5e/tBOtQNZeHmDKB0fqbLkiKZsng7UPqWua71wz3qMZs8e65avUzkFR0Oi2KDbGze5zkpuNPlosB+eJ8rmkfz2rT17uWmsQH8szPLo4fU9W1qMfzLwz2dLmoQwcLNGe7wCODBS+pz/+Tl5P8bVl3VIoasAjuv/Htss8nA3Z3rcv/k5e7JxbvWD2PljixG/7Sag/l2jAZ4+brm7M8p4uM/08jIK+bCOiGMviqJuRv28tvavYT4WhjaPRFfqxerdmZTVOKgTXwwAT5m8opKyC924Gf1IiLAit3hJLfQgckI4f6He6Qdr9eviIiIiMjZdEoB0sSJEwFISEjgkUce0XA1EZFqzGwyEWg73PslOshGdNDh4D8m2MaLMYE4nS7MXkaSYgO5tlUs+cUOvM0mOiSGsjOzgFlr95JbZOedm1vx9bLtfLZwK5MWbOHD/m3J/tnO6l3ZzFqzh48HtGX2un3szi4kbX8escE2wvws7M8tHQq382AhdcN82fzvm+NWbMukS/0wZqzZA0B6ViGXNPacW89k9AxOfC1eZBXY3cvxIT5s2JPjXjYYwOF0UWg/3NPpiuZRPPvzGvdy6/hglm7NdIdHAFe1jPGY0+nypCj+989ud3hkNMBdnetw96dLsTtKh+7d3iGBRZszmLp857+1mRjSPZHbPlrknpPq5gvi+HNTBq/NWI/D6cJmNvHWza34YcUOpq3eg8Pp4qIGYTxwcX0++mMzCzdnEOZr4aVrm2MyGvhm2Q6KSpzcekE8UYFWMvKK2Z9bTFywjagAK/l2J3lFJVi8jIT6WvE2mziQV4TLBcG+Fsym8nuKiYiIiIicrArNgfTMM89Udh0iIlIFTEaDO6Qxm4zEHjXhd4S/N63ig93LD17SgNvb18bpAj+riUl3XMCenEJ2ZBYQ7m/lq3vb879Vu/lp5S5+TNnFxDsu4Okf/mHF9oN89Mdmnu/blOFfppBVYOf7FTt5/7Y2/LFxPwV2B6t2ZvHQpQ2wmU3uXkc5hXYi/K3uScBX7czigjohLEgt7fm0N7uIdgkh7vpcrrKhk7fZRE7h4R5KcSE2Nu7JdS97GQ3kF5W4gyEoHQY3cupK93LHemHM2bDPY5/uDcM93kx3TatYPv9rqzs88jYbubhRBIM+PRxMPXBxIh//uZm/NpdOSh4ZYC2dVP3Dv9zHfqB7fT7/ays/rUwHoFawjWtbxXLzh4vYkVk6LPDuLnWID/Hh7d83sS+niDA/C+/d2obFaRl8vXQHTpeLYRcn0io+mOmrd7NpXx5dEkO5sE4ohSVOtmTkEexjIS7Ihslk4GCBHVwQ6GMmzM/K/twiShwufK0m/L1L3zJYXOLEy2hwz98lIiIiIueXCgVIe/bs4ZFHHuG3335j7969uFwuj+16C5uIyLnJbDISFWjzWBfmbyUpJtC9fE/XutzYLg4vY+n8TB8PbEdmfjH2EifBPmZ+GdqZ5dsyWbkji2KHkx+GdOSt3zbx27o9fLogjQ/7t2HE13+zN6eIj/5IY8xVSTz4VQpFJU6+WbqdsTe0YHHaAUqcLpZty+SBixP56M/N7gCmoNhBiK/FPQn4ml3ZtEsIcb9Jbm92EU1jD9frcJX2wDqSl8no0YspKtCbrRn57mUfi4mM3GKO/OuvQ70whh0xdK57wwimr97jXjYaoFGUv/stdAC3XBDPe7NT3bWH+1kJ87O4wyOAYT3q85/vV7nDo6axAcSH+PD0/6127zPmqqaM+m4Vqfty/60lFIPBwOVv/oHD6cJkNHBJowie/nE1v6/bC0Dr+CAe6J7I2BkbWJOejcEAY69vDhj4YG4qe3IK6ZkUxb1d6zJ/UwZzN+yjVpCNAR1rYzAYWPnvkMDW8UHYzCayCu1ENW5HenYxkQHGf9+A58DLaCDcz4rJZORgXjEY8Bh+KSIiIiI1Q4UCpIEDB7Jt2zaeeuopoqOjNTeDiIi4GY0GQo54e1mIr8VjGaBWiA9XtYx1L796fXOyC+0YDAZCfcz8+EDn0knBHU6iAqxMG96Fn1els2pHFgfzi/lmcAde+nUti7dkkrwgjXduac2j3/5NdkEJn8xP45k+TXjkm7+xO1x8s3QHL17bjGVbM3E4XfyVlsG9F9UleUEadocLl6u0d02wj5nM/NLhcf/szOLCOiEs+jd02plZQLNage7wpbjEiY+17OTYziMSpUCbmV1HTCTu721mT3aRx/71I/15Y9ZG93K3huH875/d7mWrlxFfi5c7PAK4uV28x1v0mkQHsD0z3x0eAdzRMYFhX67A8e+b8i5rEslfaQfc9ZuMBh68pAH3fLbUHZTd2akOCzcf4NtlOwAI9jFzZbNobpzwlzuMu79bPb5ZtoMJ8zbjcpUGXuNubMFbv21k6dZMAAZ0qM2FdUN5Y+YGNu7NpXaoD2/2a8mqnVl8s2wHBmD4JfWJC/Fhzrp97DxYQOfEMJrGBnq8jVBEREREqpcKBUh//vknf/zxBy1btqzkckRE5Hzka/XC13r4r6SoQFOZMGHoxfUpcTjx+nden//2b0tuUQlGg4FgHzP/G96V3VkFFNqd1A6xMW14V6Yu38GaXdkczC/m63s78OKva1m2NZNJC7bw7i2tGTl1JQfz7Xz0RxrPXt2Uh7/+m2KHk6+XbueV65qzfFsmdkdp6DT4orpMWrCFohInJU4XBcUOwv2s7MstDYVWbM+kc2IYf2zcD8Cmvbm0rxfKvH+X84tLCPY1l7l2k9HgDnosXkbyiw8PtwvwNrM/1zN0CvKxeARKF9QJYc76vUdsLw3CjuxB1btZNCO/PTwkr3vDcGas3u3ex2gofcPdkUPybr6gNKg6FB6F+FpoFOXPsC9T3Ps8enlDnvlxNWn/zmvVvFYgDSL9uX/ycvc+o3o15tFvV7Jxb2nA1a1BOHuyi7h70lL+vWySF2whLsTGlLvbUyvEcxiliIiIiFQPFQqQ4uLiygxbExEROdO8jpgUOsjH4jEUKtbiRWyQ5/C6R3s2pLjEicXLiMFg4KP+bckrLsFkMBDsa+HXYV3Ym1NEcYmD2CAfpj/YhV9X7eafXVkUFDv4/v5OjJuxnvmbMvh04RY+GtCWUd+VDif7YG4qL13bjOFfriCv2ME3S3fw1k0tWb41k7xiB0u3ZjKkeyKBNjNZBXbsDhcH8+3Eh/iw7UDpcLj5m/ZzSeNIpq8u7XW0YttBrmoRw/xNpXM8HSwoJibIM0hzulwe80SVOJwek2VbjwqhoDSkOvJtdvXC/fjr3zfoAcQE2dh0RA8mgOa1gnhvzuGeTr2bRvHdvxOGA/hbvfD2MrrDI4BbL6zNGzM3uJdbxgWxfk+OOzwCuL1DbQZ/vswdHh2y/UABL/y6lrE3tPAIE0VERESkeqjQv9DGjx/P448/zoQJE0hISKjkkkRERCqHwWDAaj481CzY10LwEcPpYoJsxBwVOg25OBGn0+WeLPqtm1uRW1iCwWgg3NfC1Ps6ciCvmBKnk3A/b6Y92JVl2zLZuDsXs9HA/z3Qmc8WbmHuhn18t3wHn911AS/8soZFaZm8/dtGxt7QgpFTV7Ijs4DvV+zkg9vasHLHQdKzClmTns3QHonUDvVha0Y+doeLLRn5tIoLYsX2gwBM+2c3fVvFMGXxdgDmbNjH/d3quXs+7cspIiHU8y2p+cUlhPpa3BN8Z+bbiQr05u9/5zEqLnFiPWoeKOdR/6MoyNfirgEgIsCbrQfyPfbx9/Zid3ahe7lz/TBmrD48JC8uxMaWjDyPyciPNGPNHg7kFStAEhEREamGKvQvtH79+pGfn0+9evXw8fHBbPbskn/gwIFKKU5ERKQqHPmmMX9vs/tNZACRAd5EBnj2Coo7atjVE1c04YGLizGbjAT5WPjv7W3JzLfjcLkI9jEz9b6O7DpYwJ7sIqICvfnynvYsSTvAjDV7+Hv7QSYObMeXS7bzzdLtfPzHZt67rQ0fzEll5to9TF+9m/dubc3mfXksSjvgHs7WpX7p8DmnC+an7ueaVrF8v6K0x9A3S3dwR6c6jJ1ROoH3tNXpvHRNc/ck33tziogNsmE2Gdzhzu6sQhIj/Nj0b++hTXtzaRYbyOpd2QBk5BURc9SE6iajAYMBjtdJ2XbUG/GO5nC6sDucx90uIiIiIlWnwj2QRERE5NgsXkbC/Q+HTIE+FgKPevPY0SFU7VBf+raK/TeEMfBozwbc2akOLlwE+1gYd2MLMnKLyS92EODtxdu3tGJfdhGrd2UT5m/hhb5NScvI4/O/tpK6N5dHezakXUIw789NZfm2TK5vU4uRPRvy7uxNZBeUsGzrAR6+rAHjZ23E4XTxxeJtPHFFE8b8tBqXCz77aysPX9aA4V+m4HC6mLVmD58MbMcPKTsptDs5mG/HbDJ4zAO1ZMsBuiSGued9+mPDPnomRblDp20H8mkcHXDc+5YQ6oOfeh+JiIiIVEsV+lfagAEDKrsOERGR896RczyZTSaiAg8Pv/M2mzx6QgFE+HuTFBvoXo4P9aVD3TBcLhdWs4kmMYFc0iQSh8OFt9mEn7eJq1rGkFNYgreXkQCbF1e1iGH1rmycLhctYgPpULcLXy/dwbYD+ZhNBn64vyNv/raRZVsz+W75dj6780JG/7Sa1buyeX3mBsbf1JLH/h2S99Xi7bx7a2s2789jR2YBf+/IYnC3ejSM9Gf9nhwK7U7S9uXRKTHUPc/TkcZclUREgN7EJiIiIlIdVShA2rZtW7nb4+PjK1SMiIiInB7LUXMZRfh7BjK1gj2H24X6lfZ+OtKTVzSmxOlyT849vl8rcovsmE1GQv2sfHbXBRzMtwMQ4ls6JG9PdiF7M3OID7Hx5aD2rN+Tw8LNGWQX2JlwexsWbs7gqyXb+X3dHp65KolZa/cycX4aB/PtNI0N4MkrmtAsJhARERERqZ4qFCAlJCRgMBiOu93hcBx3m4iIiFRvBoMBs+nw3/N+3l74eR/+J0OIr5UQX6vHZ0JsJral/Elso56YzWZqhfjQo3Gke3tCmC+9mkZhMBgItJlpFOlPv7ZxOF0uvL2MhPh5Hk9EREREqpcKBUgrVqzwWLbb7axYsYLXX3+dF154oVIKExERkZrlRP8DKeiIeaBMJiNRgRquJiIiIlJTVChAatGiRZl1bdu2JSYmhtdee41rr732tAsTEREREREREZHqwXjiXU5egwYNWLJkSWUeUkREREREREREqliFeiBlZ2d7LLtcLtLT0xk9ejT169evlMJERERERERERKR6qFCAFBQUVGYSbZfLRVxcHF9++WWlFCYiIiIiIiIiItVDhQKk2bNneywbjUbCw8NJTEzEy6tChxQRERERERERkWqqQmnPRRddVNl1iIiIiIiIiIhINVXhSbRTU1MZOnQol1xyCZdeeinDhg0jNTW1Mms7pvfee486derg7e1NmzZt+OOPP46775w5czAYDGW+1q1bd8brFBERERERERE5V1QoQJo+fTpNmjRh8eLFNG/enKZNm7Jo0SKSkpKYOXNmZdfo9tVXX/Hggw/yxBNPsGLFCrp06UKvXr3Ytm1buZ9bv3496enp7i9N9C0iIiIiIiIicvIqNITt8ccf56GHHuLll18us/6xxx7j0ksvrZTijvb6669z1113cffddwMwfvx4pk+fzvvvv89LL7103M9FREQQFBR0RmoSERERERERETnXVShAWrt2LV9//XWZ9XfeeSfjx48/3ZqOqbi4mGXLlvH44497rL/ssstYsGBBuZ9t1aoVhYWFNGnShCeffJLu3bsfd9+ioiKKiorcy9nZ2QDY7XbsdvtpXIFUpUPPTs9Qagq1Walp1GalplGblZpGbVZqGrXZmuFUnk+FAqTw8HBSUlLKDAVLSUkhIiKiIoc8of379+NwOIiMjPRYHxkZye7du4/5mejoaP773//Spk0bioqK+Oyzz+jRowdz5syha9eux/zMSy+9xJgxY8qsnzFjBj4+Pqd/IVKlzuQQS5EzQW1Wahq1Walp1GalplGblZpGbbZ6y8/PP+l9KxQgDRo0iHvuuYfNmzfTsWNHDAYDf/75J6+88goPP/xwRQ550gwGg8eyy+Uqs+6Qhg0b0rBhQ/dyhw4d2L59O2PHjj1ugDRq1ChGjBjhXs7OziYuLo7LLruMgICASrgCqQp2u52ZM2dy6aWXYjabq7ockRNSm5WaRm1Wahq1Walp1GalplGbrRkOjbo6GRUKkJ566in8/f0ZN24co0aNAiAmJobRo0czbNiwihzyhMLCwjCZTGV6G+3du7dMr6TytG/fns8///y4261WK1artcx6s9msRn8O0HOUmkZtVmoatVmpadRmpaZRm5WaRm22ejuVZ1Oht7AZDAYeeughduzYQVZWFllZWezYsYPhw4cftzfQ6bJYLLRp06ZM97eZM2fSsWPHkz7OihUriI6OruzyRERERERERETOWRXqgXQkf3//yqjjpIwYMYLbb7+dtm3b0qFDB/773/+ybds2Bg8eDJQOP9u5cyeffvopUPqWtoSEBJKSkiguLubzzz9n6tSpTJ069azVLCIiIiIiIiJS01UoQMrIyODpp59m9uzZ7N27F6fT6bH9wIEDlVLc0fr160dGRgbPPvss6enpNG3alF9//ZXatWsDkJ6ezrZt29z7FxcX88gjj7Bz505sNhtJSUn88ssv9O7d+4zUJyIiIiIiIiJyLqpQgHTbbbeRmprKXXfdRWRk5BkbtnYs999/P/fff/8xtyUnJ3ssjxw5kpEjR56FqkREREREREREzl0VCpD+/PNP/vzzT1q0aFHZ9YiIiIiIiIiISDVToUm0GzVqREFBQWXXIiIiIiIiIiIi1VCFAqT33nuPJ554grlz55KRkUF2drbHl4iIiIiIiIiInDsqNIQtKCiIrKwsLr74Yo/1LpcLg8GAw+GolOJERERERERERKTqVShAuvXWW7FYLHzxxRdnfRJtERERERERERE5uyoUIP3zzz+sWLGChg0bVnY9IiIiIiIiIiJSzVRoDqS2bduyffv2yq5FRERERERERESqoQr1QBo6dCjDhw/n0UcfpVmzZpjNZo/tzZs3r5TiRERERERERESk6lUoQOrXrx8Ad955Z5ltmkRbREREREREROTcUqEAKS0trbLrEBERERERERGRaqpCAVLt2rUBWLNmDdu2baO4uNi9zWAwuLeLiIiIiIiIiEjNV6EAafPmzVxzzTWsWrUKg8GAy+UCSsMjQEPYRERERERERETOIRV6C9vw4cOpU6cOe/bswcfHh3/++Yd58+bRtm1b5syZU8klioiIiIiIiIhIVapQD6SFCxfy+++/Ex4ejtFoxGQy0blzZ1566SWGDRvGihUrKrtOERERERERERGpIhXqgeRwOPDz8wMgLCyMXbt2AaVzI61fv77yqhMRERERERERkSpXoR5ITZs2ZeXKldStW5cLL7yQV199FYvFwn//+1/q1q1b2TWKiIiIiIiIiEgVqlCA9OSTT5KXlwfA888/z5VXXkmXLl0IDQ3lq6++qtQCRURERERERESkalUoQOrZs6f7z3Xr1mXNmjUcOHCA4OBg95vYRERERERERETk3FChAOlYQkJCKutQIiIiIiIiIiJSjVRoEm0RERERERERETl/KEASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASEREREREREZFyKUASERERkf9n767jparzP46/zvTc7oBLdwgIiIBISNhdgB3You6uunZhu8aa2IVgYYBISXd3wyUu3O6ant8fnztz74D623VVws/z8diH+517zpzvOXNmmPOez/d7lFJKKaV+lQZISimllFJKKaWUUupXaYCklFJKKaWUUkoppX6VBkhKKaWUUkoppZRS6ldpgKSUUkoppZRSSimlfpXlcHdAKaUiBINQlQ8BP1jsEJ1yuHuklFJKKaWUUn95GiAppY4cVYWwZRLM/xdU7If0zjDsSUjrBAEPmCwQk3a4e6mUUkoppZRSfzkaICmljgyucpjzFKx4v/6xqBTwu2HyHbBnoVQjnfQ3aD0YAl5ZxhEP9tjD02ellFJKKaWU+ovQAEkpdWSoKowMj+Kz4ITrYMJI8DcIi2LTYep9sPk7CAag8wUw6AEIBMBTBc4EiE4Hm/PXt9dwqJzVCVFJf9iuKaWUUkoppdTRTgMkpdSRoWhrZLvHNTKULRQeAZz+LHx7swQ/AM5E6DoCJt0B2fPksdhMuPBd8NZA9gJIyILWQyEqGdyVsoxhgq0/wsKXoOIAZHaDs14EZxL43GCxQXSqBEtKKaWUUkoppTRAUkodIQ4ehpbSBg6srm837Q05K+rDI5DKoxmPQP4GaVuj4JxXYdJoKN4pjyU2h+TWMPdZ2DgRet8KFTmw7ov652nWR547NPeSxQ5DHoM2w6AyV6qVEppCTDoYhoRMtmgwmf+QQ6GUUkoppZRSRxoNkJRSR4bEFhIihaqEMKRSKBiQZmY32L2gfnmLQwKdUHgE0OUSWP1JfXgEcMbz8M1NEjyZzNCiP3xyXv3fG/eQgGnSHQ2eZ7iESG/2BZ9LHjv5bpl7afm7EjI1Pxl6XC1zNLnKJbyKSZchdJ5qWccWDT4PVBdIJZWtbhmllFJKKaWUOspogKSUOjLEZsIln8BnF0vYsmcBtBkK26bJ3701MgdSSFQylO+LfI5Wg+Gra+rbzU6CvUvqq5ZiG0n401Cf22D6A/Vte6wEUR+eWf9Yz+skGPrgtPrH+t4OKz+Exa9J35yJcOV30t+1n4HZDqc+JX30uWR+pug08Lpk//xuCcicyfLcrnKpbnLEg9mKEfTTplljjN94OJVSSimllFLq96QBklLqyGC2SOBz6zLYMgXK9sCgB+HAGgmAtk6RQGbbVFm+thRiMw56kiAEfPXNxt0he2592+KQqqCG4rNkHqSQHtfAsrcjl+lxFbw9sEH7WijYBPOeq3/sim9h0p1wYJW0L/lYhr/98Dco2QVmK9w4H/LWwfwXIXcNtDkVTn0S9q+Q4XWGCfr9HUwG5qoiOjpKCZbuBEecVGZ5aySYikqEQBDc5bItZ7Lsu7u8bnhdDMQ1AVdpff+cSRD0QU2JBFXRqVKR5akGvwfscfVD8oJBWebnVBdBTbFsx5kor4HZ+vPL/i8qC6CmSIK2qJT67QQCYDL9/ttTSimllFJK/SoNkJRSRw6LDZJaQt/b6h+7/ifYOQu2/QjWaOh5PayomyTb55K5icr2yrJVBbJ+yS5pe2slGAkJeCG+qQRJoaFpFrsEE6HJurN6RoZO6Z0gb339UDqA4y+DTy+ob7c/S0KgUHhkjYKUtvDxufXVT2e9Crlr4ZsbpW0YEh5Nvqt+e8OeAm8VTLgMozIXHAkY106DTd/D/OclvBn8KLQ7DdaOh43fQEo7OP0ZmPEYbJ0s/TzndWjSCwo2ytxOjY6HJidKCBXwybY91VIVhVmCJbNNwrXyHLkznWGChCYSLpXvk2PviIMf/gHxjSSkwgwnXAv566EyT6rCWg4Gv6uuwsoix8IeC55K8PtkYvLoFFk+NGF5TIa8nq5yMFmgulAqyYq2yXFpPgCGPQ675shxbnQ8HHeJ9NFVJq9fVIrcSc9TI/vT8HVXSimllFJK/c80QFJKHdkSmkgFUNcREi406ws9r4KN30NlPowYD59fIaHRiveg/z/g21tk3a1TZKLtnbOkXZkrAcMZL8DkOyQo8bmhwzmw4WtZxueGtI4S9oBU6vjch/bLVV7//7uOgAX/qm+3HAjFOyIn/M7qDp+cX98e/KjcOS4UHhkmaDsU3hsm1VUgE4Jvnw4zHpJ2TAZ0OBM+Okf2BWDkFzB+RH3Y0nUkZPWAj+uWMZnhxoVS0TX9IQm5Bj0AHc6G6mKpfDKZ4IQbZXm/R0KZtE5QVSgTjltsMsRwyxTofbMESvY4yOwq4V1tGbgrIKsXVOVKhdKBVRLqtB4MpdmyjrsCGveSoC/ol2MYnSphXm2ZhHjOBBk+6CqT/UltB/1Gy/BBb608FtcY9q+EafdJ9Zhhgqt+AF+tzFHlroReN0JGJzmWlXkQlwnOVAi45RwwmWW4YCAg/Qr4pL/BALirwF9bF37FSxhWUyzVX9EpdX2vqAuqEiQUc5fL8ERrVN0d/yrkf2YrRKXWVX+VyrqOBNnPqgLZd2uUHN+aIgn1TFY5LsEA1JZIRZgjTvpSlSd9tdhlPq3aUtkfwwQxaXJO1xTJcXImgdUhwaPfI6GfI06Wd1dIaBiVJM9fUyz/jUqW88FdJee9PVZef79PQkCLXfoLkXN9AUYwQIsmGZHDLn0eed+GqsaCwbrzXQdnKqWUUkodbTRAUkodHSw2+W9Ukvwvo0v93675US7Ga0okcLriW5nXKH+jXCx3uUTuuuZzQ94aWXbE57B7vgQvJ1wv/81bD2s/hwF3w/ov5UI9bz0MeTSyL2abXEiHgiWTWS7cQ2LSoXR35Dre2sj5l1oOlOqjkA5nQ/6m+vAIJDz5vkE11rAxsGZ8fXiU2l7CkVB4BNDvLlkntEz3KyHgkfDK75G+d7oA1n8hd6YDmXsq6Je70G2fDpnHwwVjwVNRNyn5Djj3DUhpLc+xbyn0uV1CHneFvB4mi/x3w0Tpd2p7SO8CRdthyw/QcoBUhxGEhS9JEJPYElqkwf7VUlXWrB/ENaoPjwBOeUgmOA+FRwlNod0ZEpCFjPgc1oyDNZ9KO6snpLaFL6+RoYKGAddMlTBsxkOQsxyOvwp63whl+2DVR/J6DnpA9q9st0zE3npI3V35bBJKOW31gVXABxhg88s5YrFLGBSbKVVfVrsESo74uiqu/dKPIJBokQDMbJVzKK6R9MNbJfvpSJDnCr2uwSAktYLyZXL8/G6ITpcAtXyf9MVWNwF94VY5H4MBiG8s57+rvC64ipcQsnCLLGOyyl0KS3fL3zEkhMKQ5zXbwOyQ91ThZtk2hry+VfkSMBpI30xWzEVb6GILEtznkSq1kp0StJntkN5R+lG8U45feicJlQq3SfVZYguIToLyA/L+tMXKa+itrp8UP72T/Ld0twRcSS0l4KopkfPdEQ8JWRJale0BwywT5Af90l9PtQzttDrkvK0pknWiUuQYVhyQ8ziusaxTUyKvQ0y6vL6eKgk6bTEyjNTnkYDPZJaQkIDsr88t7wWLXfrpqQabU15Xb628TiazLBMISPjo90lAaIuqDyMtdhkm6qmW/hpmCfgIyudE0C/HyR4n/fDW1lf4ucrrtmORdYIB2Z9gQI6ZM1Eq/bw19TcAqC2pe72s9WFqbYl8tjniZJ2q/LrtRMmw0pri+u1EpzTYTt355kiQzyi/GyzO+nU8VfXrBOrWISD7EgpK/V55H8VmSgjqqZbjFp0qfQqHq/HymlTlNwhX0+Q5vXXhanS6fA7WlMg55EwAaxTm2iL6dWmJyVUG1lR5fUPbiUmX925Ncd06dYFsVYFsxxolz6OUUkr9hWiApJQ6+sVmRM6HlNwKrvhOKlIMM3Q6H3rfAuu+lC//3a+ERa/VVcbsh6TWMpm22SZzGzkS4IJ3YMbDciHtqYYTRsHyd+T5C7fKEKrVn0h71xzoeF591dLOWdDx3Mg+HjxPUDAgF8chiS0lqGnIUxVZ6ZTSFuY+Xd/uOhL2Lo5cJxTwhPQcBfNfkMcBWg2S7YbCI4D0zvDTYxIeAfT/u1xITrhMLsB6XicXkJu+gWV1x2DQ/VBZDXOeluqvKydB6R65oJp8l0wYPnycLOutkaF7N86TScY7ngsr3ofYLLk4M5kkQPN764cBhsRmyrC6kMGPwKwx9e2YdLkgDoVHAGf8C767TcIjgM4XyQXh+6fKhafZCn1ugXnPw4avZJlLx0k/P7tUwoimfaDNMNi7EOb9S16LUXNkrq7Fr8Gm7+DUpyWs8tbA0jfl/BlwL5jNULBZXpt+f6sLWswS3GR0qQveKuWC3GKXvxVtkwthw5AAozRbniO1vQRM7gqZWD6ukYQ+FptMEF+0BRKay+tasV9eo6gkyOotIcSWutclvgl0uVTO0dUfyzb7/wOq82U4ZPF2aHOaPM/exRKg2mLg9OegeJvMC1awCc59XS7UN30n/2t7mrzWhVswVn0Mfg/GuW/INteMl6Ds9OfkNdyzCLZMhqZ95XWt2AdrJ0g/z3hOQrRN38OB1TDwn1CWDQVbJIDMPF5CgaoC2PStHPNTHpagaNcc2a8Tb4LiXRIUbp8ulYSOWDnHtk2XY97vb1CyQ5bPWw/dRkqoUFMsFYHJreUOi7WlcrzdVdBrFBRmSyBWsKWuei9f/rZviRz/rF5QWyx991RLVWLRNjlWRduh1SnyWeNzyTLxTaBRN9mfom2yTsdzYf9mOT/K9sg5WL5P3hcFm+WYpXWEygMSdnmrodVQCcr9bjnGjXrIcQx4JGiLTpfgt3yfhCM+FzTpUzcs1y/BTGp7WdfnluAmOk22WbZHlvd5ILOLzEdnGHIuJjaX8y0UbjkS6oK73fJZEwhAWnvYvwow5LM4rpH021UufbfHyTaLd0ggEwzKZ1zOSiAor3FcY6jIravOq6kP4Yp31q3jl3Uq9ss2vTWynco8+Z83tE4NFIW2E5DQs7oAU8BLsrcWymrkNa2oe40cCfL6luys71ticwmtfC7pg8UJyW3k88tXK2FruKIyFFQlSihYVVg3P120fGZVF8hnirku7PLWyutjINu2OmUdv0fWj2uEUkopdSTQAEkpdWyKST203ej4+vZpz8iXeL9bfsVPaApFW2VC6uIdMgH3WS/J331uOPFGaNwDVn0IS9+C896UC7kdP8GysXDzYgmUSnbJhVd0CiQ0k/8PcpHarJ9clAJkL4C2p0sYBbBjJgx+KLLPFkdd1UrdsJ/QXEUhwcChFxahuZ1CTObIQKnNabB9xqHrbP6+vp3aHuY8IxddIIGcu7I+PALp06wx9fNNxTeWi9Kp/5T2wH/KhfD0B+r30WSRioLPL5f2sCflwn32k3KRPfhRSOsQ2beGc0+BhF2hYAig960Sdhy8zznL6tt9R8O0++urxDpdINUXofAIpKpm/PD6yq1THoK8tTDjEWm3HirVB59dIhfmhiFBw85ZMPVeWWb4Z0BQArSSXdC8v1Q/5K2HmY/I325aKOHcktfl8Qvfk9fZUyXLpLWHM1+Sx/Ytk4DuhjkSACQ0hSVvSEgVRIbo5a6BPYulos1VJqHXmvHQ/WqZN6z92TLxfLN+ckFti5JAsGSXXMBv/l7O7QOroeUgWD0OWp4sQVd0qhyPws1wyoNykRuVJJPAd79SAo+YDFj5gfTtjOclQCzdDWu/gBOuk7sVmq1y/LtdDme+CNHJsOpTOb/63y3VOxU5sq8njZYhq5hkvq02Q2XbUckyzHT/SjjhBtleVZ4c676jZb9t0fDjPXIOdbtMQoJtU2Hd59KP1A4S8nx7C/S8FroMl7Bk+kNyXDqcDY26S5C08GUJldudLuHFtzdLSNy0r/Rl9hgZktj5AmjeT863GY9K2NRykGxn0h0y91jzkyUUWPCihHCdLpDPorx1MOUfEja1OVXeCz/eI0FFi/4S4C15E3YvgPanSxVfwUaZrL/d6dLf2hKpqrPFQsv+8v5a+5mEbq1OgT43yzZDfel8iawze4x8rjU/GTKOk/fCmgnQrDcM+KcEk5PulHC9++Vybs17TgKxpn2h902w+VtY8SFkdoYhYySE/OEuqdTpea2E+gteloCsSS84+e+w9QcJIxObSdBbtE32ORiUADAmXd4bOcslnD3lIXkNF78uYcz5b8vn89T7JOTrc5ucg0vfhuw5ct6e9jRsnwYL/y2fOZd+IoHTjAclKOt7h4Q2y9+VQDutg5yXO2bAwlcktBn5pYS4Pz0mfTzpLvlMX/EBbJ4knzH975Zl5j4rIVrm8XKuznhYXltbjGx77eew4Uv5LBv4gLyH5jwln0FZvWDww/I5s3+FnMPDx0sl57rxdRWKjeGsl6WfQb9UDsak180bVwYY9WF0qDrKFi39DQ2TNVlknVDgB/I6mW3y72DAL++BqGSUUkqpX6MBklLqr8nmBFuzyMfiG0kFRkhojhmCEiw5EuSiJnSnszNflF/wi7eDqxIu+0qGym2cCHOehcu+hG9ukqqab26S9ifnyUXYTw/LHefWjJMLifz1Ejg1DJ1clTKMKhT47JonF70z60KN9V/ARe/Lr9WhIV6hoSahoXBBvwQBoeFztaXya3lD3urIoCbgg93zGhyrWAm4GvK5I4MpkHAjJKGZhB6h8AikqqFh9ZAtWoaPFW2XdlJrSGl10P4kyHKh+XbMVgnNQkMEM7vI8Q8xDAm7GrJFw56F9e1OF0jlS4jZKus0rACLSYdJo+vbnS+UkCC0XWs0EISfHq1fJrW9XICGQrUOZ8nFWmgOK2eyXLD98De5qAeZR2rfMgnaADqeL8f/y6skUIhJl0qHPYvq7w6Y0UWe95Pz5Did9oxc9K54D7LnywWnYZEA5aOz5LU97hIJIL++Ti6mT3++/uLz/VNlcvkWA6Dj2TBhpJyTN86XQCh3Hfz0uFQSJbaQ4Oira6Ri6tJxUtn04z3yvxvm1VefjB8uVUKxmVKxNuUeCcou/gg6nQcrP5ShlddNlyqT3jfLxfeJN8uxOvN5mPeCnOcXvCMhmTUKfrgTLh0v1UDnviZhZ+cL5bw5819SUbXkTRj6hAx7O/lvcm6e+TLsXQojJsjfE5tLsDvsCTlu22fI8rHpMv/Y8vckyNn0HVz+tby3LXbI21AXsmyX90CzvlJJMnKCvJ+jkyU0GPmFvG9C4WqfW+XzImeFvC+9Lrhqsjx/QhNY8RFc+qkECYnNIXe9hGndRshrAFBVBNdOhZ0/yfm24l0JIYu2yzxfuevguAtlnYItUmlWuleGcO5bCo27wpKxUklWsV/Cu7z10PZUeR1LsqXKrmCr9K1gI2R2g8VvyNxxrjIJHnLXSPh03EUy7NBql6quy7+R8z+tPSx4BU4dI+eoM1HO88Y9ZMhxdZG8L7dNkyGolQekkmvhSzKUNOiXoWx7F0vV1bVT5Zy3xUgweukn8v6IayxDb0/+uww9tifI0OTElrIdb42EsVsmw4Xvyzxe0WlSfdjnNjk37AlSxRbXGK6aJMMJTSYJV897UyqfolNg7vMy3Lnv7fK+yVsvx+rK76R6KDpFzplz/l03FDUe5r0EPa6AE28ATHLcTCY5Tq664b/L3pHzNlT5NO8F6H4F9Ly6LrRNkXU81VK95UgECmTIq6sSTIYE1aE7anprJAhyVUglmrtSnreqrmrOUzeEEqN+HZ9LKjn9PnmNPVV1QxszJQwND6EMzRNXXtffeHAkQ02hrGOrW6embh2TGZwpyPDOuruEOmLlc60yv24IpVM+06uL6taxgCNJ9qu2RCrb7HHyvizfL/9+WZ3yelUVyP6ZLdIPA1kndGfRuEYSNIcqxmIz5O/uSvmMjEqSfzNqiuuHAkcl169jdUpAWVtS37eoFPnsrymW4M0ed+gPVkopdQzTeyErpdQvCX2xjWss1ScxqZDSBjI6S9iU2FwCpS7DoWkvqdQ5+S4Jkk59Uv4+fJxUnVz8oVwwXTsVzntLhp/tWykXOd2vlC/4Mx6Si84mJ8r2J98hVTqp7aU99xmpPMjsJu2CTYBJLiDrJjKmukQubkM2fScX5iFrx0PrYZH7aYuRL8Yhnmq5MAgp2nZoJdDBE4v7vZFhUcV+qYxpyF0VOceT31M/eTnIxcfuBVJlEF33hTyIXByGmO1SQRNidUpQExKaEyWCETlXSXzT+iF9ob+HAqrwQ0ZkoJTeGbb+2ODvlvr5YBpa1yCYatxTjneIySIXdaHwCOSibO4z9e3MrjKxemjeFbNdLmxCwydBLuxmPla/7bSOEtZlz5e2I04upL67pf51c8TBwlfr5xNKbgMEpaoEpCLDMOrDI5DjuHmyDBkDSG4r4chXV8vrmNBULly/vrZ+KKUzQSr5Zj0hF2kpbSGpBXx8nlRlJLWSff7xHqlc8rkkKCAIX14t/UttLwHEx+fA5u+kOswwpCpoxkNSReKMlWDmwzPkeKW0lkqacRfBolfrJyHf8DV8da2ENrYoqfx5d7C8TglNoFFX2Z/p98u55PfK0MBPL5BqGatDKn/eHQKL/i0XsY27Sbj4zQ1yvnldEiy+fyqs+lhCwg5nycTvMx+RC9Ks7lKFNWGEBLaeGvnvO4Nkv0xW6HqJBH6T7pBjn9UdZj8ld3OsLpT3j9UGb/eHmY/Kcex2ufT162vlM6BxT6m8ef80OU6uSnnN3u4vwSVm6HmNhHvjR0gg1riHDCl9d7AM2aotk9f2nUHw3a2AIZVVX14tgZ/JLOus+xzeHijVSjUlMmfVe0PkuASCMkx04iiZFD8YkMn9N0+CsSdLCFddLAHw+6fCxBtkmT63wfe31g039ck6O2bKOrnrJWTI6inPOXGU3Fmz7+2yb+8OkYrRrB4SIr3dXwK1qgJoepKcTxNvlEDipDulWvKdUySQaNJTAra3B9atky8B2acXyPvI54Z+d8r5984gKN9bP6zvnUESSJbvkx8gxl1cH+6efCfMelyet3yvvL/zN8G7p8iw17K9cqOB8cPl2HpqJNSa87Ss89Pj8rmx4gN4e4Cc7yZD3ksfnyfPU5Yjn18/3AVvnSRVU4Yh76+3B8IHp8t7M289jLtQ9rn8gAQ+U/4h67x/qryXl7wu67xzisxPlrNUjsHbA+Vc9FTJHHtv9pUbPgSDsPgVeGegHIeiHTKs89MLpL+zn5K59L6/Hd7qK/11V8L8l+TvY0+Wark9C+WYvdUPvr0JXCVS9fdGb1nOVSrB2jsDZZktP8q/FZ9eIP3/9haoLZLX6o0T5XlzlklQ+EZfeO0E+czcMVPOnVd7wEdnyvDPiTfAv4+H13rKeTP/Bdm/13rCrCcj1/nwbMjfID8I/ft4eLW7nFd7FtVX7Cql1DFOK5CUUup/1fCOUhaHDM8IiWt06DCzpJZSIRBy+vNw8j/k/8dmwoUfEHSVhn89N4aPr5u3ZZ0EM+ePlS/pWybD2k/h+KvlV/CCLVC4SYZbnRcvQysWvAQ3L5JhMqG5bqxRMuQnNOdRSbZUH6ypm7NoxQfQ6waYcre0142HSz+T5wqxRUVOJF6SXVc1sUbaexZGTnQOdb96N+CrjQxyclfVT2o97AkJtlwlckF73ptSgeOrBXtM/cToVQVygdWivww9Cml7qlQ3gFQYdR0hw2BAfglvd7pUtkDkL9Gh4YKh167iQP1zOJMa7L+TQwQDkcGaPS5y4vSoZBku0lDAKxeR4WVSI6u9YtPkor5hv/xu2LuoQT+zpPIpxJkgQ2sahls+t4QxIYnN6iujQI51RW59eATy2qz6sL6d1AxmP13fF4tTfpkPVZCF1ml4niQ0kwvM0NBKW7RUQDSsXgt45aI3JL6JDAsNhY2WKHnehgGe3y9DB0N9iWsMKz+qf73ssRKihc5pkNfnh7vqJkAHYhvXTRJfF6rZE+RcalhJB3LxG+p/bCNYO04uxkGqEayOyBAQ5OI3VAkXkyGBVc7y+nVs0TD9wQYrBGWesNA+R6fJOrvrQsGYRrJPPzQIUw1DQpTQaxadKpV1ofMnPkuCw0mjI+9+N/H6+uMUkypDHrf8IO2EFlIt9Mm5so7JLOt8fW19ZWRUinyWbJwo7cQWMqn4p+fLMbZGS8jx+bX1xzYqRV6LUMCa3EomTR93gawTkyYBxpdX1gfRUUmyndBcc4kt5T302UVS+ZHQXN67X1xWP+G8M0m2s/IDaSfVrfPuIFkntpFUq3x+ef06jkSZQ235u/XrOGIkUAv4pW22wueX1Z/rGd3kPFg2VtqdzpXjH1ontb0ch89H1gfRGV1g9af151fH86Vq6b0hsk5mVzkvPh9Rf9zOfkX2Z/Fr0u55nYRFn4+sG3YWLVVz4y6qr3w882VY9YkEngAn3iLvuQkj6ipmYiWU/fRC+ZwAuOTTunXqPkfSOsqE9O8NrR/6O+xxCcdCVZjDP5MqwlDfMrpKhc97Q+uD66GPy3ZC584Zz0nwuOTN+mPdtI+EraF1zn5VhgqHPhfPelHO0dCxTmkrgd8HZzRY5xXpW/k+aR9/uQRMKz+UdnQqdD5PjkHovXDqU1KRGfqM7nG1hNGrPpZ2bAa0PwMmDG+wzpNSfRl6/4D8IPDhmTBqVuQweaWUOkYddRVIb7zxBi1atMDhcNCjRw/mz5//q8vPnTuXHj164HA4aNmyJW+99daf1FOllPoPWetCp8RmMjlyQmN8ye34flUuvphGkNwSWg2RX/SbnyzVGR3PlQuFXjdJhUFCU/llPutEudhpOUiqn0bNAgyZN2fUbBnWk79BhiOd/px8gZ92v/zq3fkiuYhb86nMc9LqFOlfdZH88tzuzPo+b/lBhhqFzH5S5gQJ2fSdDL9rGK55ayPDtE3fRz7nqk8k2Ar9wvvFFXKxs7humFK702WIxdK35QJ75Bd1w202y5w3Qx+XSiGfF46/AjqcI/tTWypzAGX1lO3sXSghVNM+0vbXBS2dLqjvi2GW4Soh+Ztk2FWIu1IuTEOVX6F1mvWtb9cW128DJPwKVVaF1zHJBXt4GZdcVDZ8TouDQzQ8rn5PZIWYM1WqVRoKeOuDE5AQqiq/vp3UTOYhasjniqzM8nki7/iX0laOfUPe2sgqs4BHhi6FpHWUeYwa8lRH9sXvkSFaIZmdYffCg9apjJxc3e+JnMcro4vMTxWxTlXk3RH97sh5sDI614eqIe6q+gtzkNdwTYOqsoxOsGXKofvTsHrN56q/KAWplNo86dB1Gh5bb239xS9AegfY+O1B61RGruOpqQ9BQOZ82jAxMnz0VEZWCrpr6odGAqS2kWA2HDiZ5Lg1XMdbLdUzISntZche+Bw01d0RcMtB6zT4/pXUSubbCq9jlWFREdupjdxOUguZAD4UaNgccq5FHLcaWHrQUNqVHzRYJ1qqpRqu46uJ3E58Y1j+fv069lgJ6SKCUjcsHVvfbtRTPpdC66R2kGFQDc8DvzvyGDTuJkFKaJ2MLlC5vz48ClnWYDu9rpewOLRO+7Pk/Gx4jhKIXKfHVTIXVXgOuAtlX0LhEcixbVjleMYLcvOA0DqtTqlbZ3f9MgnNIs+305+Duc/Vv6ZtT5dwJRQegXwerni/vn3Kw/JDR2idJr1lOw1D9awTYOVB68x+un6d5ifLdkLhEUD7MyWsCzn+cjnWofM6uZXM79Yw4G93emTgfPwVUs0YWielrVSRNQyPQoIBqXCqLTv0b0opdYw5qgKkzz//nDvvvJMHHniA1atXc/LJJ3P66aezd+/en10+OzubM844g5NPPpnVq1dz//33M3r0aL7++uufXV4ppY5YJpNUDoXu5uZMlF+I4xtLxUlMukyymtEJEptCXIZcxCS1lMqgpBbyq3OXS2XIRFwj6DocRn4lczNZnDBsjFQrXTMVMMkcT1f/IJPb7lkkfz/3dbkAXvWRBDSnPCzD7/LXy/CswQ/LEJ5gQL7An/O6XISCVFyc+0b9ROCLXpXJeB0J0i7bIxdrKW2kHQxKUNVluPxt9lPw9TUyQffi12TYxw93Q9thMtRm/ZcysbDZInMtxWZIiOb3yLwyXUfIcD9XuVQHnXCd3NUttW7i7vZnylAdW7T8Ep3cRoYXGiaY96w83rduXqTQHZSGPFYf5lTmyXC70Gu05E0J8kIT05btke2GgiyQC7Qe19S3t06WYUkheeukksQeW/+YYYZWg+vb+etlgueQfYslZGwYMplt9ccV5IK4Ydi1d6lcIDUUuo18iKc6cpncdXIRefA6DSd697mlAiekeKeEfw2Z7QcFYl45TiEVByTwa6jhkMvQOg23W1Msx+nX+H2RbU+5PE9DoQvohm1/gyozd/WhQ1cihkci8/l4GgR6PtehF5oHDwkleOhwz4bVYSBD5w5ep6aoQV+9MrdQQ56D+mpwUHjnjQwSDWv9pMsNVTWopPO75O5rIc5YCWkiuhY4qLrNBaUNQg9nfORzgszZVd1gf3yuyHDFkXzo/gW8kdv21siQypDo1MhAA+TYNzzW3lqZOD4kJu2ggAY5B1xlDdqeyHVi0yMDp9DzNjyWPnfkcNbYjJ8PZCPmdDMkYA9J61hfDRfiqT50SG7DZTKOk0nzI9apijyP7XFyE4GQloNkGGhD7orImzbYYyNvcNB68KHz5LkrI8/1+MaRd95s3jeyuhLk35WG78u4zIPWOUluStGQzxMZmKe2r68ADLUPDrK9rsj3e1rHyHXSOh56DBratyTyzqpKKXWMOqoCpBdffJHrrruO66+/ng4dOvDyyy/TpEkT3nzzzZ9d/q233qJp06a8/PLLdOjQgeuvv55rr72WF1544U/uuVJKHQYmk4Qe5rqLbVu0XNjEpMmFviNeJq1OaSNf5OMyJYRq1gcyOkro1LwfnP6s3CEuuaX8kjvyS5m7KbU9nHQH3DBXgqdmveGEUXDLEpmMtvOFMjHzrUvl1+k2Q2VC1RvnSxDT5ETYNhOumyFDM2IzZSjTxZ/IXcQsdhka1G0k9LpR2gWb5ZfmIY9JYFCRI8HSxR/LxeWcp2WYwrmvy/w340fIkIq2p8kdo6b8Qy4+KvNg5xyplOp0vlQkBAIyses5r0kVUHJLCe1Gfi776ayrOBr5ufS/eIf0afh42dflb8t8PsM/q5v8fJpciF34rhyHYEAuXoc8JhNCg8xx0uGc+gBo3vPyWoTmffLWyoXQWS/XB1PrPpcQLRRM/fAPCYMyu0q7ulBCme5X158L+1fJHa1Cvr9DgrnQfFGFW2SYUeMe9ctU5Mld7kKmPySTAYcCwd1z5RyJzaxfxlsDx11c3178uoSEIRu+kH5ao+ofM4L11W4gr1vPa+vby9+FZidFDoE02yKHi+xZJFVoDbfbukHIBjKkKKllfbtgU2TwtvgNGfrYkD1WLuxDyvfJuRSy7M1D13Em1IeiICFIywb7t/wdCT0j1kmMPCauMtnnkNUfQ5shketEJUaGZp7q+vnTQM6T0HkWXie5/vUDqahqeBy3TIrcrq9GhlU2DPh8HrmYDtk1J3K7FQcizwmQ91bDY79vmdzxLqRomwxDbChoSHgakrtOwo+QvLUy3LEhwySfbyElOyC1QV/3LZNAvSGzNTIoLc+BlHb17eyFMkwvYh1bZKhblS9VVSG75kLSQduxOGSerZDqksi+7JwVeYxC6zR8jd1VUm0aXmf2oetYow6a064m8tjumiOfbQev0/C88Lsjq0ULNh163BpWX4JUGzZcp2ibDDM8eDsNeaojz5XyA5GvOUQeM5DPxIavcWWefGY2ZLFFtl3l8iNLw/bB1aAHr+OuiFzGXRFZHXqw6NT/P7RWSqljgBEMNqxtPnJ5PB6ioqL48ssvOf/888OP33HHHaxZs4a5c+cesk7//v05/vjjeeWV+rkhvvnmGy655BJqamqwWq2HrON2u3G7638dqaiooEmTJhQVFREXF3fI8uro4PV6mTFjBkOHDv3Z112pI82xeM4ahkHonxyDIIbPRdBsJ2iYMAJeTK4ygoaJoDMZ/B5MrhKMgJ+ALZqgJQpzTaH8wmuNJuBIxOQqlTmFzDaC0ekQ8GAUb5eLrMyuctGbv0kufjK7yCTQRdtkqJMzWe50VHkAlr+H4akk2PcusEfBotcwircTbHMqdLkYFr+BsWcRxKQRPOslWPcFRt0v+sF+d0HBJoyCTXJxlNGVYHQSRs4KmaTZ7CCY0hZ2z8eIbwyYIK0dwb3LMKKS5EItpS3Bsr0YhkkCitQOclHrKpfKKasT2p0lf9s1R/476H6CVfkY22fKL98n3iITu++YKaFYWicZlpg9V4aMVBfDtVMJ5m/EmP8vqRS4apJsZ9aTMtdO96tlwvU5T8n8Ws4kuHaaDKVa/o5cuN24QI7n1HulamPoExIyfnWtDIlJbS9VX5Prtg1w63K5tfzCl6Wq7KIPZQ6tL6+S52w+EM54FsZfWj9E5vZVUrG2tW542JXfy1xQP/xNnqPLpVIZ98n5ErYYJrhtpcxpEqpOGDVbJgAPzQ/V5zYZIjnuIqkYMTvglkUyEW9ouzctlH6u/1LaQx6XIODLq2S7oWPy4en11TG3LJVJwUP7e+7rUjEx+U5pJzSBEV9IkBmqRLp1uUw2HaoEufhjmZ9s1hPSTu8E574p8+OEKppuWyHhaKiy5fKJEjqE5qBp0lvmqXm/wXwyt62QyYlDw/2u+RHWfFY/r1Db0yXg+/jc+jfqbctlfplQxdD1P0m1YGgy9a7DJXgbPzxynXeH1lfl3DBP9mXHDGmfeLNU3n19nbQNkwTN7wyqr5a5eZG8vnuXSHvAPTJP1eQ7pG22wY3zZFLlUBXLLUtkuGuo8mXYk/Lf0F0NbbFw3TQY27++IuXWZTI8NjRc7ux/Swgx5ylpR6XKXffeGVh/HG9dLvPyhIZ9XfCuVAItfFna8U3hkg9lDqTQ1+pbl8tcUqEhT5d+Btlz6ocMprSTO7a93yCAvG2FTHodOvaXfQMbv5ZhxSA3UBj2BHx0duSxf29YfRXV1T/IPHah4ZnN+8mk4eMuilznnVPqq5uumSKha2gurLanSfXlhJH169y6TI59aG61a2dIwB8abnrcxTIM7KtrI9cZe3L96zXyC3k/hu6K2e50GYb3XYOg+qaFsp3Q63X5NzDnyfrqn+MulsBySt28gYap/rwIVRANfULmuAtVXmX1hDanylBrkDB6xAR5TUOv1+nPymdl6Lxo3k/eU/PrfnQ2W+UuiZ9dys8Jnv48/u7X8EdfVB2L3w3UsU3P2aNDRUUFKSkplJeX/7+Zx1ETIB04cIDGjRuzcOFC+vatL7t/6qmn+Oijj9i6desh67Rt25arr76a+++/P/zYokWLOOmkkzhw4ACZmZmHrPPoo4/y2GOPHfL4Z599RlRU1CGPK6XUkcRkMhEIyEWPxWLB4XDg8XjweDz/z5rHBqvVitlsxuWSoRUOhwOHw4HL5cLlcuFwOEhISMDv91NcXIzFYiEjNQmzyaCorIra2lqyMlKIsRlUugMcKCghMzWJ9DgbHl+A3YVVOGxWWmXEYTYZHCitobzaQ/usBOwWMzUeH9mFNTRPjSbOFiRgWNhX4iLabiYt2oQR9FPus1LlDtA4zoTJV4vPHEWRy0SKM4jVX0PQZKEyGI3d8OIw+SAQwGOOwhcIEmUOgN9N0OLEgxWb4cOoLQFrFF5rHBYjiKk6H4IBAvFNCPp9mOtuax20xxK0xWByV8hFoMlMMCoVfC55DoIEYxthBP0yBMxTJcPPrFFycVpTJBfksZkyl05Vnlx8JbeRoSyVuRi1JQTTOsldxarzMQq3EoxrLHOOuCsw9i4FwyDYZphUK+1dilF5gGD7s2Vi8ty1GDkr5Dma9YXyvRibJ4FhJnjizTJPzrovMKryCPa+TYa2bZmEkbOcYPOT5cI3ZznGhq/AYiM4ZAyU7cVY8S5UFxEcOkbmzln6NkbeOuh0EcH2p8OGiRibvwdnPMGzX5XnWPY21JYQvOBd8HsxFrwooUHvWwm2HgJL38TY+iPENyV4wduw+TuMlR9CbSnBqyZBxQGMuc/I5PbDxhBs2hvmPI2xfTpkdCN4wVgJL1d/Ivt18xKCB1ZjzHtOhkyd9ybBlLYYMx6WC+6WAwie+RLMewFj49cSLN26nOC2HzEW/ltCh4s/JuhMwJh2v/S13ZkEhz4KMx7F2PajVKbcsoTg6nEYy9+RqorLvibod2NMe0ACkm4jCfa5HWPKP2S79ji4cS7BRa9irBknYcBVPxAs34cx8xGpvjnxZoJdh2NMukPCnJh0CSxnPYWxaaJc2F//E8H9KzFmPyVBU/97pKrqu1slFEtoAVd8TXDafXKMgkG4cT7B7dPl2HuqYegYaNRNJikv3yeVUJd+QnDSnRihCcdvXkJw3QSMpW9KX896RSpUvrtFhsllnQDnvSGTlu+vCxtvXU5w2dsYKz+Q4OL8tyW4nTRazv1Wp8CpT8sEygWbpNLk1mUEF/wLY+0ECZou/VTeVz/8TYKZ9mfBoPvg8yvk9TTb4ZbFBGc+hhGa0P6yr6WKcuo/Zd0ul0KfW2HCZbJ/thi4cR7BH+/FCIVxV/0gQ1tnPiLnQM/rpEpzwgjZP0cijPqJ4PejMfbUDe26boYEnHOekf3rcwd0OF0CopoSeZ9fM4XgxFEYoaFdo2bLXF0LX5b9G3CvzCX3+WVy3iQ0l9fry2vkvQRw0wIZurxsrLx+Qx6XYdVfXCmvX3xTuOwLCWRDQc2102Q+rNV184T1u0sqIb++Xj5XklvBJZ/IxOehoYTXz5LJyEMh2aD7Ibm1hIl+j1QonfeW3NEwNDfSeW/KXSW31oVknS6Qatup98kxiWsk1aff3SrzI4FUj64ZXx+SdR0u8+zNeDhi3jl/uzMpPvF+Fq8/aP4qpdT/zGw2k9Y4DUe8g4AvQHluORarhZj0GAzDoLa0lpqKGhIaJWC1W/HUeCjLKyMuNQ5HXIN1bBZi02IxTAY1xTW4qlzEN4rHYrPgrnFTmV9JTEoMjlgHAX+AirwKzDYzsalSbVpdUo23xktcRhwmqwlvrZfqwmqiUqKwOq0EA0EqcisozC/8f/boyFRTU8PIkSOPzQBp0aJF9OlTPynpk08+ySeffMKWLVsOWadt27Zcc8013HfffeHHFi5cSL9+/cjNzSUjI+OQdbQC6dik6bc60hl1Q0RCH8nl7nL2HdhHq6xWOK1OStwleAIeLIaFREciZe4yyj3lmAwTibZEfEEfxa5iqjxVNIpphMVkIa86jx1lO2gc05jm8c1JsaWEt6NUQweff6HHDm43XMZkkiEvocAyGAyyd082WU2aYTabMQwDI+AFk4VA3dOYAjKXScBkrW8HPGCJIoCBKeDD8NUSNNsImO0AmD0VgAm/TeZBMnurIegjaHYSMNsw+V0YnmqwOPBbozEF/RKIGQYBZwpBwFxbhOH3EnDEE7BEYXaVYXiqCFod+J0pmPxuTNUFYJgIxGYSxMBcdQD8foKOOPz2BMzVBRi+WjDb8MVkYvZUYrhKAINATAYYZkyV+yEYJGiLxu9MwVK1X+ZaMpnxx2Zhqi3GqJsnJeCU4WSmmkIgSNBsJxCdgblin8ybZJjwxzXBVJ2P4a0Fk4mgIxEIYtSWygWsxYE/Oh1zRY7M/2OyEohvgqkqVwI6w0LQkQRBH4a7bo4nWzSBqBRMVXky74vVQSA+C1NFbt3cXjaCUUng92C4KuTi2hZD0JGIUVMoz2uLIhDTGFN1noQJZjvB6FQMb420/T5wJBC0x2DUFEvloC2GYEwGRnWBVNdZHBJceColQPP7wZlM0GrHcJVJJaEjjqAzFcNVLEGOxSF3UvNUyDxSAZ9UBhoW2T93JTgTCDqT5RjVFsv8brGN69apO26heblcZbLPzkTZP3e5hKfWunXcFdIOBmRoVcAv67grITqFoD0Ow10hlZC2WIhpDN6KuvmcghKyBDxQUyrrxWUStMViuCul+tERL9vxVkuVmGFAcjsZWlhdKP1NaCbDxdwVMrl0VLL0xVMtlXOGIUFaXYhLbQkktZZ1XGVyh8yYNAlvvDVQtEUC3sxust2yfbJOWie5oUN1sVT7xTaSGzt4qyFvowzxyuwuwxpLsuW4ZB4PVrvsb/F2GVKY2ELWObBG/pZ1ooRjRVvluZv0kqG/FQfkscTmkNgKvFWwb7lUJzbpLdWZ+etlqF/zfrL9sn0y3DaplQRG7gqpWLPHQNOT5FjvXyXHrcXJEn6X75OwKrmNDLl1V8rcTPZY6UvAL9VN7gpofjJBqwOjeJf0LaW9DPdzlcGexTI0tWlvWWffElmn2UkEYjMJ2BN++wfwf0G/z6qjzf9yzvoDfvbX7OetdW+xJHcJjWIa8WifR/lp709M3D4RT8DD430exx1wM3bdWA5UHeC81udxVsuzeGPNG6zIX0GL+BY83vdxvtvxHd/t/A5fwMfzA56nsKaQd9e/S251Lpd1uIxTmp7Cv1f9mzWFa2iX1I7H+jzGuM3jmLp7KgCvDHqF7aXb+WjTR5S4Srim4zWckHkCL696mW2l24i2RjO83XBGtB9Bki3pjziUf6hjsgLpzxrCdrCKigri4+P/o4Opjlxer5cpU6Zwxhln6D+46k/l8/sochXhD/hxWBxYTBZKXCXkVeeRaE8kzhZHbnUuk3ZNwmKyMKLdCHaW7+SDjR9Q6irltuNvw4SJf6/+N/ur9nNOy3MY2HQgzy57lvyafNomtuWuHnfx6KJHya/JJ8Yaw/MDnuf55c+zq7x+4tdEeyLvDnuXtkltf6W3Sv12+jmrjjZ6zqqjjZ6z6mjzv5yzW0u2MvKHkXgCUkX/7MnPMnbd2PD32/Nan0eUJYrPtnwGQFpUGg+c+AB/n/N3fEEZBvviwBd5ccWL5FTJUO6R7UdS46vh2x3fApAVm8Udx9/BPfPuIVg3CPXVU17liSVPUFAjN3e4rvN17K3cy4w9UgnaMr4l1x13HQ8seOCQPvdM78kLA14g2Zn8X+3r4fbfZB6WX/3rEcRms9GjRw9mzJgRESDNmDGDc88992fX6dOnD5MmRd4qd/r06fTs2VM/dJVS/zN/wE9BbQE13hrsZjtWk5X9VfuZtHMSNrON4e2H8/2O75mwdQIuv4t/D/o3n2/5nLn7JfB+vO/j/Jj9I4tzFwNw/XHX8+6Gd5m8azIAvTJ6UVBdwEurXgIgxhrDsObDGD17NIG68vlbut3CvfPupcIjd/e5tN2lfLzx44jwCKDUXcrNP93MZ2d8Rnp0OkoppZRSSh2JKtwVPL/8+XB41DyuOaXu0ojvt0ObDWX0rNHh9kVtLuLd9e+Gw6O2iW3ZV7kvHB4ZGPRr3I9bf6qfd+3ithfzzvp3wuFR19SubCreFA6PTIaJ7undeW/De+F1Lml3CW+ve/tn+70ifwW51blHXYD03ziq7sL2t7/9jXfffZf333+fzZs3c9ddd7F3715uuknu8HLfffdx5ZVXhpe/6aab2LNnD3/729/YvHkz77//Pu+99x7/+Mc/DtcuKKWOEaWuUr7Y+gUXT7qY8747j2W5y3h8yeNcNfUqvtr+FZkxmTy++HHe3fAuVd4qzmp5Fj9m/xgOj1oltKLKWxUOjywmC91Su4XDI4AL2lzA+xvfD7fPaHkGX23/KhweNYpuRGFNYTg8AvmHL/ScByuoKSCvJu93PxZKKaWUUkr9Xqq8VSzNWxpud03tyqIDi8LtKEsUpa5S/EF/+LFWCa1YX7Q+Yp0luUvC7Th7HHnVeeGwCCArJottpdvC7Y7JHVmetzzcTnYkk1OZE9G3VGcqeyr2/GLfV+Wv+k9386h01FQgAVx66aUUFxfz+OOPk5ubS+fOnZkyZQrNmjUDIDc3l71794aXb9GiBVOmTOGuu+7i9ddfp1GjRvz73//mwgsvPFy7oJQ6BvgDfqZmT+WpZXLXnuZxzXEH3MzLmQeAw+wgKyaLFfkrwusMyBrA3fPuDrcHNx3MD7t+CLdbxrdkQ9GGiO1YTVbK3eXhdpPYJizIWRBup0alhn9VCfHWzTHzS8pCd0lSSimllFLqCGQYBlaTNfy91hvw4jQ7w3/3BXzYzLaIdYIEsZgs+Oru4ujyuYi2RIf/7vF7iLIeelOshuvU+mqJtcWG/+byuYipm4MxYh3DEq50OliS4+ibA+m/cVRVIAHccsst7N69G7fbzcqVK+nfv3/4bx9++CFz5syJWH7AgAGsWrUKt9tNdnZ2uFpJKaV+q4LaAl5f+3q4fUrTUyLCoCaxTSJ+zQAIBAPhf5wA7GY7Nd6aiL9bTJGZvtUUOdS2uLaYRjGNwu0DVQdoHtf8kP45Lc5DHgvJis36xb8ppZRSSil1uCXaEzmjxRnh9qIDizil6SnhtifgwWSYiLHWhzsL9i9gaLOh4fb8/fMj2rW+Wqwma8Q68/fPZ0jTIeH23H1zObX5qeF2pbcSh9lBtLU+iFp4YCGDmw7+2X5bDAvd0rr9l3t7dDnqAiSllDrcarw1EZVBNrMtIgyq9lYTb48/ZL2Gwc66wnX0btQ73N5VvouOyR0jll9XtI6e6T3D7SnZU7iwTX0FZWFtIdHWaFKdqRHLjGg/4mf7PSBrwDE9JlsppZRSSh39HBYHN3e7mUbR8sNpmbuM3OrciFDpk02f8MCJD2Ax5AfYH7N/5JxW54R/LC1zl5FTlcPZLc8Or/Pxpo95qPdD4R9pf8z+kXNbnUvT2KaAzBm6v2o/57U+L7zORxs/4pE+j2AzScXTlF1TOK/1ebSIaxHRZ7Nh5sWBL5Ialcqx7KgawqaUUkcCu9keUbq6vnA9vRv1ZnvZdgAOVB8gKyYrovR26u6pXNjmQj7d/Ckgv3i8MfgNfsz+kTJ3GYFggFl7Z3Ft52t5f4PMe/TF1i94tv+z7K/aT251LgU1Bewo28ENXW7g/fXv4wv6eGXVK4zpN4aXV77M5pLN/LT3J+7rdR+jjx/Nhxs/pMJTgd1s54LWF3B9l+tJ+JNuNayUUkoppdRv1TimMR+d/hHL85Yzfc90cipzuKHLDVza7lK+3v41Lp+LxjGN+eqcr5ixZwbbSrdRUF3A2CFj2VqylZl7Z1LlqeKGLjcwov0IJu+ajMvnollsM74+52vm58xnZ9lOqn3VvDnkTbLLs5mfMx8Dg1HHjWJk+5HM2DMDT8BDq/hWTDxnIkvzlrKnYg+BYIA3hrzBvsp9LM1dSkZ0Bn0b9SUtKg272X64D90fyggGg8H/f7G/rv/mlnbqyKW3PVW/pxpvDWOWjGHSLrnLo4HBG0Pe4IEFD1DiKgGgd2Zvzmx5Jo8tegxf0IeBwSN9HmFLyRa+3v413oCX5nHNebTvo0zcPpEZe2ZgMkw80vsR0qPT+Xzr5xTUFHBqs1Pp27gveyv2srZwLU3jmtI9rTsBAuyt2IvVZKVpXFMsJgvl7nLcfjfx9niSHcmUukqp9dVit9hJcaRgtxzb/6Cpw0s/Z9XRRs9ZdbTRc1YdbX6vc9YX8GEyTJgMGUAVDAYJBoOYTPUDqgLBQPjv6r/z32QeWoGklFL/pShrFKO7j2ZvpYQ6QYI8vfRpnj35WaZkT2Hq7qmsK1xH/8b9mXjuRJblLSO3KpfM6Ez6Z/Xnqk5XUempxGlxkuhI5KHeDzH6eLkNaaIjEZvZRofEDmzcvJEurbtgs9poGteUfln9IvrRJLZJRDvFmRLRzozJ/GMPhFJKKaWUUr/AMAwyMjIiHgsEAhHBjy/gIxAMhCfF9vq9ePweHBYHZpMZ4JB5Qg3DwDCMiMc0PPpzaICklFK/QUZ0Bq8MeoW86jy2l24nPTqdZnHNuO/E+7i1260AJNgTsFvstIhv8f88m4z1bshiWNi/ez9dO3b9Q/p/pHH73JR7yjEZJpIdyYd8KVBKKaWUUv+7ktoSimqLKKgtINWZSoI9gVpfLTvKdhBtjaZ5XHP8QT9bSrZQ7a2mW1o3zIaZPRV72FW+izbxbWgS14QiVxFLDiwh3h7PSY1Pwu1zM2vvLCq9lZze/HSirFEsPLCQzZ7N5O/Jp1taN7aUbGHa7mkkO5IZ3n44xbXFfLHtC2p8NVzV8Sri7fF8sfULdpXvonNKZy5qcxGNYhphNWvF3ZFCAySllPqNkp3JJDuT6ZTSKeLxX7sL2l+Bx++hzF2GCRNJziSKa4spdZXiDXhJcabgDXhZkb+C9YXr6ZXei7bJbfl006fM3jebKGsUI9qPYGizoaRFpR3uXVFKKaWUOmYcqDrA3+f8nQ3FGwB44MQH2Fi8kW93fAvA4KaD6de4H08tfQpvwEtGdAaP9HmEhxY+RFFtEQYGLwx4gQcWPsDK/JUAjGw/kvyafN5d/y4AbRLa0DW1K/fNvw+X34XFZOG0Fqdx88yb2Vu5F4A7ut/Bm2vfZOruqQD0TO/J3sq9PDHjCQLBAAAr8lcwbvM43hn2Dj3Se/yZh0n9Cg2QlFJK/ccCwQDFtcUEggFirDHU+GrYX7Wf3eW7aZnQkjhbHOM2j+OnvT/RLrEdo7qM4uFFD7OnYg9ZMVncf+L93Dvv3vBtUQc3G8zlUy6nwlMhG6iFZ5Y9w/Ts6bww8IVj/k4WSimllFJ/hjJ3GfcvuD8cHnVM6kitrzYcHpkMExe2uZDbZt0WDnGu6XQNzy17jqLaIkDm+FxftD4cHtnNdnpn9mb07NHh7Vzd+WrGLBmDy+8CYEjTIUzbMy0cHsXZ4mgc05hXVr0SXmdE+xE8vOjh8HZDvAEv982/j3FnjNPvhEcIDZCUUkr9LLfPTVFtEYW1hVhNVhLsCczcO1PuJBeE5/o/x8OLHmZ3xW5sJhuvDn6Vm2feHA6DHurzELf9dBuV3koArup0Fc8seybcPq3FaXyz/Zv68KiBVYWr2FG2Q78sKKWUUkr9DkpqS8LBD8BZrc7isy2fhdvd07qzNG9pRIiTGZNJdkV2uH1ai9N4eeXL4XavjF7My5kXbhsYxFhjKHYVhx8b1GQQjyx6JNzuk9mHOfvmhNsWw0KQINXe6p/td251LqWuUv1OeITQAEkppf7CfAEfvoAPh8XBgaoDrC5YzdrCtZzS9BR2lO7g5VUv4/a7ua/XfUzbPY1VBasAuKXrLby48kV2V+wGYFjzYUzaOSkcBrVKaMXu8t3hsAggPSo9/OsTQI/0Hjyz7Jlf7Nt3O76jd2ZvnQ9JKaWUUup/dHBAk+RIIq86L9yOt8dTWFMYsYzX741oR1miKHOX1betUVR66r/rmQwTHr8nYh2LyYLb7/7FtmEY+IP+X+37wZVJ6vDRqcqVUuovqNxdzrrCdTy48EEeXvQw6wrXcenkS/nn/H8ye99sCmoKeHb5s7j9buJscSQ6EsPhEUD75PasKVwTbvdI78GC/QvC7czoTLLLsxtuEm8g8kuIL+DDZrL9Yh8dFoeGR0oppZRSv4M4exwG9d+r9lTsoX1S+3B7V/kuOiVHzutpN9sxG+Zwe1vpNrqndw+3NxdvpkdG/fxE/qAfh8URcde09UXrOTHzxHB7dcFqTmp8UrjtDXhxmp2/+J0wyZFEoiPxv9lV9QfSAEkppf4CCmsKWXxgMffPv5/vd3zPJ5s+4bIpl/HDrh9on9Sexxc/Hv5F6ZxW5/DF1i/C67ZLasfqgtURz3fwL1K+gC98+1WAgpoCmsY1jVjGbDJHTDA+N2cup7U47Rf7fGGbC//r/VRKKaWUUodKdiRzavNTw+1vdnzDlR2vDLezy7NpHNuYFGdK+LG5OXM5u9XZ4fbE7RO5suOVmAyJEfZW7iXBnkDT2PrvfNN2T2Nk+5GHbCcUEB2oPoDVZKVjUsfwMt/u+JYbu954SJ8NDB7p84gOXzuCaICklFLHuIKaAu6eezc3zLiBH7N/JMGRwNh1Y8N/bxHXgq2lW8PttKg09lbUDzXz+r04zI6I57SarFhN9bdUnbNvTsSXkm2l22iT0CYiMPp+5/dc1fGqcHtezjxObnwyzeOaH9Lni9teTFZs1m/aX6WUUkopFSnGFsPdJ9zNOa3OwWyYyavOY2nuUp446QlSnRLQvLD8BZ7r/xy9M3sD8NW2r+iT2Yebu95MrDWWYlcxU7On8uaQN8MB0L9W/Iun+j3FxW0vxm62M3nXZNoltuOpfk/RLK4ZlZ5KpmRP4ePTP2Zo06FEW6N5f8P7PNznYf7e4+9kxWaxvmg9jaMb8+6wd+md2ZtG0Y0Y2GQg488cT+/M3uHASh1+OgeSUkodw4LBILP2zmJlgUya2D65PavyV0Usc/DQstyqXFrEt6C0oBSADUUbGNVlFB9s/CC8zMy9Mzm/zfnhSqVFBxYxvP1wFh1YxM6ynQC8ufZNnj35WcYsHUNBTQGz9s6iQ1IHxpw0hnfWv8Oeij28tvo1nuv/HDvLdjIlewrR1mhGtB9B87jmWq6slFJKKfU7SotK4/4T7+emLjdR5a0ixhpDsjOZPpl9qPBUYDFZSLQn8uLAFyl1leIL+Ii1xTKs+TDOb30+br8bu8VOmjONt4a+RbW3GpNhIsmRxL1J93JDlxvCd+qNs8fRO6M3hSWFpCalkhqdyhP9nqDKU4XJMJHsTKZDcgfOanUWgWCABHsCNrONjskdcflcRFmjiLZGH+5Dpg6iAZJSSh3DSlwlEXfYsBiWQwKj0D/0Vd4qQCqF7jnhnvCcR76gj7k5c7n+uOt5d/27AEzaOYmH+zzM1Z2u5sttX1LtreaJxU/wbP9nKagpYPKuyURbo0l1pvLRaR9R6anE7XeT4kwhxZnCSY1PwhvwYjEspEal0iG5A0ObDcVsMkeMm1dKKaWUUr+faGv0IcFMlDWK9Oj0iMdibbER7cyYzIh2oiPxkB/7MiwZEe0EWwKLVi2izRltfnHbDYfMhbZ78LbVkUO/pSul1DEsEAxQ460Jt7eWbuWqTlfx8aaPw49N3DGR6467jldWvQJAYW0hy/OXc88J9/Dmmjep9FbyxdYvuKHLDXx2xmdM3jWZotoiYm2xXNnxSka0H0GtrxaHxUGKIwW7xc7gpoN/NQxyWByHPGa32H/nvVdKKaWUUkr9XjRAUkqpY1i8PZ5BTQYxYesEAGp9teyu2M2ArAHMzZkLwOIDi+mQ1IFH+jzCxxs/Jrsim7n75tKvVz8+P/tzKj2V4fLktKg0jks9jkAw8Kvj0TUMUkoppZRS6tiiAZJSSh3DbGYbV3a8kinZU6jwVADw+urXeajPQ5yYeSLf7viWMncZxbXFXNz2YgZkDcAX8GE2mUl1pmIYxs8+r05mqJRSSiml1F+LBkhKKXWMy4rNYvyZ4xm7biwz98zEaraSXZ7NlR2v5MwWZ+IP+omxxUTcMU0ppZRSSimlGtIASSmljnGGYdA0rikP9n6Q0cePBiDJkYTVbD3MPVNKKaWUUkodLTRAUkqpvwinxalVRr+TGm8N/oCfWLveJUQppZRSv59AIIDJVD9VQJWnCrNhxmmV73Dl7nJ8AR9xtjisZivl7nJcPhd2s50ERwKVnkqqvFUYGCQ5kvAFfJS6S/EH/ERbo0l2Jh+uXVPHAA2QlFJKqQb8AT8evweb2YYv6KOotogyVxk2s41oazTbSrcxbvM4XD4XZ7U6iwFZA8iIzvj/n1gppZRSx6TCmkJKXCV4/B6SHEnYzDZKXaUcqD5AijOFZEcyNb4aVhesxm62c3zq8XiDXubnzKe4tpghzYYQZ4tjbs5cVhespltaNwY2GcjyvOX8sOsHoixRjO4+muzybD7e9DFVnipu7nozCY4E3ljzBrvKdzG46WAubncxr61+jcUHFtMophHP9X+OTzZ9wsw9M/EFfbROaM19J97HccnHhQMppf4bGiAppZT6y6ryVFHmLiMQDBBliaLcU85X275iR9kOruh4BdtKt/HW2rdw+938s9c/Wbh/IfP3zw+vv6ZwDR/Gfsj7w94nMybzMO6JUkoppQ6H7aXbuWvOXeyp2IPT4uSFAS/w9rq3WVu4FoD7et3H+qL1TN41GYBTm59KmbuM55c/T5AgWbFZdEvvxvXTr6fGV4PJMHFBmwu4ZeYt7K3cC8Cd3e/k9TWvM3vfbAB6Z/amoLaAe+bfA0C0NZphzYdx9Y9X4wl4ABjdfTT3zruXnKqccF93lO3g+mnX88npn9A1reufdozUsUNvo6OUUuovodpbzb7KfSw5sIRNxZvYXb6b+xfcz5nfnMkDCx5gSe4SLvz+Qj7d/CmlrlL2VuzllVWv4Pa7SXYkE2uLjQiPQnIqc/hy25f4Ar7DsFdKKaWUOlxyq3K5dtq17KnYA8DFbS9mwpYJ4fCoZXxLggTD4ZGBwXmtzguHRwBXdrySf634FzW+GgBOanQSC/YvCIdH0dZomsQ2CYdHABe1vYi31r4Vbp/V8iw+3/p5ODxqHNOYSk9lRHgUEiTICyteoNxV/nsfDvUXoAGSUkqpY1JudS5z9s3h3fXvsqVkC6+vfp2zvjmLUTNGkVudy3XTr2P2vtkEggEu63AZTy97Gn/QD8CFbSVICumV2Yu5++b+4ra+2/kdJa6SP3qXlFJKKXUE2Vi8kTJ3WbjdM6MnC/YvCLfPaHEGE7dPDLc7JndkdeHqcHgEkB6VHg6gAPpn9WfGnhnhdufkzizPWx6xXQODKm9VuN0puRPLcpeF260SWrG+cP0v9ntt4Vpq/bX/4V4qVU+HsCmllDrq1XhrKKotYnHuYghCl9Qu3DjjRkrdpXRK7oTJMPHJ5k8AaJPQhr0VeymoKQDAZJgwm8xUeCrCz5fsSGZ/1f5w24QJb9D7i9v3B/x/0J4ppZRS6ki1pWRLRNvr90aEQ3H2OIpri8PtKGsUlZ7KiHUOrmA2DINAMBBuBwhgMiLrPswmc0Tb5XcRa4sNVzFVeapoGd/yF/ud6Eg85DmV+k/oWaOUUuqoU+OtYV/lPpbnLmdbyTamZE/hrG/OYsySMWDA3+f+nVJ3KQDntj6Xz7d8Hl63dWJr1hWuC7cNjEMCoDJ3GelR6eH2ivwVnJx18i/258yWZ5JoT/y9dk8ppZRSR4H2Se0j2maTGavJGm7vLNvJcanHhds7SndwXMpxEev4g37ibHHh9rLcZQxoMiDcXl+4nl6ZvSLWKXWV0ii6Ubg9ffd0zm51dri9pnANvTJ6YWD8bL+v6HgFyQ69G5v672mApJRS6qhQUltCXnUeedV5vLv+Xc7+5mxumHkDeTV5PLb4sfAvfmnONPZV7guvl+RI4kD1gXC7ylNFkjMp3PYH/djNduxme/ixb3Z8w8gOI8Pt/Jp8AsEA3dO6H9KvVGcqIzuMxGq2HvI3pZRSSh27OiV3It4eH27P2juLc1udG27/sOsHLml7CRZDBv6Uuktx+90RwdNX277ipq43RTzHqc1PDQc8Lr+LzcWbObtlfUD08aaPuafXPTjMDkB+6OqQ1IFuqd0ACAQDfLfzO/7Z65+YjchqpZMancS5rc49pIpJqf+EBkhKKaWOaOXucubum8uoGaO4c/adzN43m3fWv4M/6OeE9BNYuH9heFkDIzyBZMiBqgO0SmgVbi/JXUL/xv0jlvl2x7fc0OWGcHtD0QasJisj248Mf+l7dtmzXNbhMh7r+xgdkzrSMr4lt3a7lU/P+JTGMY3/iF1XSiml1BEsIzqDD079gCaxTQCYvGsy3dO7M7zdcGwmG1XeKsZvGc/Lg16mTUIbAP614l/cc8I9XN7hcpwWJ8vyluH2u3lryFscl3IcNrONTzd9yjvD3mHUcaNoFteMufvmcnHbixk7ZCz9s/oTZ4uj1lvLF2d/wejjRzOoySCyy7J5st+TvH/q+1ze4XJaxrekb6O+fHfedzzR9wnu7nk3E86cwFP9niI1KvVwHjZ1FNM5kJRSSh1ximqKKHWXYjbMLDywkOeWPwfAPSfcw7jN48LLRVujIyavDhLEYXZgNszhCbEnbp/I1Z2u5tHFjwLgDXiZuXcmd/W4i1dWvUIgGGDWvllkxWbx8sCX+XTzp+yr3MfC/Qv5R89/cFmHyyhxlWA320lyJJEWlcYpTU7BH/STYE/QX/CUUkqpvyjDMGiT2IaPT/uYElcJLr+LJEcSA5sM5KpOV1HtrcZpcZLiSOHdYe9S4anAZJhIsCfQLbUbV3W6ikAwgNPiJNGRSKfkTrj8LmwmG0nOJFrEt+CyDpdhMkwkOmSo/PHpx+Pz+4i2RWMyTIzqMgpfwIfFJJf2TeOackLGCRH9bBbX7E8/NurYpAGSUkqpI0YgGGB76Xbunns32RXZvDzoZf696t/hv6c4U8iprL8l7fay7YxsP5Kpu6eGH5uzbw7ntj43fNeT3RW72VOxh7u638W769+l0lvJtzu+5aqOVzHxnImsK1xHtbeaEzJOID0qnV6ZvXD5XDgtTmJsMYB8GWsowZHwxx0EpZRSSh1VUqJSSIlKiXgs1hYb0Y4iKmIIPUgFU0MHf7+wmCwkOyPnKnJanIdcxYfCI6X+aHqmKaWUOmLkVudyzdRrqPTKHUr8AT8uvyv89/1V+2mV0IptpdsA2FOxhxRnCo2iG4XnOfp6+9c83Odhkh3JfLHtC8rd5Xy741se7P0gn5/9OdXeaqwmK4n2RJKcSRHD20IO/tKnlFJKKaXUX50GSEoppY4YS3OXhsMjOPQ2tRO3T+SGLjfw0MKHwo89s+wZHj/pcSZun8jsvbPxBX18ufVLnjjpCS5qexG+gA+b2UaqM1WHmymllFJKKfUbaYCklFLqiLGmYE1Eu9xdTnpUOvk1+QDsq9zH9tLt3NXjLt5dJ8PRCmsLeWXVKzzf/3n+3vPvBAIBYmwx4bkClFJKKaWUUv87DZCUUkodMdoltYtof7TxI/7Z65/cN/++8FC2jzd9TP/G/fn49I/xBrwyHM2ReMgcAUoppZRSSqnfjwZISimljhgDsgbw0sqXcPvdAOwq38WHGz/kpYEvsbV0K5uLN3Nc6nGc0vQUMqMzddJIpZRSSiml/iT6zVsppdQRIyM6g3eHvcsds++gxFUCwMaijawuWM1Vna4izh53mHuolFJKKaXUX5MGSEoppY4YFpOFLqld+PyszymqLcLtc5MWnUayI5koa9Th7p5SSimllFJ/WRogKaWUOqKYDBMZ0RlkRGcc7q4opZRSSiml6pgOdweUUkoppZRSSiml1JFNK5CUUkqpY0ggGACkkquguoD8mnxKXCU0imlEijOFREfiYe6hUkoppZQ6GmmApJRSSh2lXD4XlZ5KrCYr/qCf3eW7+Wr7V8TZ4jiv9XncOftODlQfCC9/YsaJPNnvSdKj0w9jr5VSSqmjiz/gx+V3YTPZsJqteP1eytxlGIZBkiMJk6EDe9RfgwZISiml1FGiqLYIf8CPzWSjzFPG+xveZ2nuUm4//nZm753NjL0zABhz0hhun3U7+TX5EesvzVvKK6te4cHeD+qk5EoppY56Hr+Ham81drOdKGsULp+Lcnc5AAn2BPxBPyWuErwBL1GWKKKt0ZS4SqjwVBBliSLWFkutr5YtJVswm8y0T2yPN+Blbs5c8qrzGNZsGAmOBH7Y9QOrClbRNaUr57Q+h2+3f8vU3VOxmCxc3PZiTm9xuv44o/4SNEBSSimljkD+gHzpDRLEhInFuYsZu24sXr+Xh/s8zB2z78Dtd5MelY434A2HR06LE5vZdkh4FPJj9o/c3O1mDZCUUkodsSo9lZS4SlhXuA4Dg66pXXEH3EzNnsr+qv2c2eJMMmMymbBlggQ7qV0Z2X4kH278kOl7phNni+PFgS8ybvM4pu+eTpAgzw94nrk5c5m0cxKBYIBbut5Cja+GjzZ+RJAgpzQ5hcJGhTy97GkCwQBZsVmckHECN8y4AZffhckwcW3na7l22rUU1RaF+/qvlf9i0q5JvDH4DQ2R1DFPAySllFLqCFHrq8VqslJUW8TE7ROZuH0iZ7Y4k2pfNZ9v/RyAm7rexJtr38TtdwPQP6s/M/bMCD9HnC0u4ovtwXxBHy6f64/dEaWUUuo3KneVM37LeN5Y+wZBggxsMpBKbyVPL32aIEGyYrIY2mwol0y6BE/Ag8kw8bcef+PaaddS6i4F4J4T7uGxxY+xrXQbAGe1PItF+xfx3Y7vAEiPSqdRTCMeXPhgeLsXtb2I22fdHp5L8LL2l/Hyqpdx+eXfzP5Z/Zm7b+7P/hu7rXQbqwtWc1qL0/7QY6PU4aaDNZVSSqnD7EDVASZsmcCds+9kVf4qbph+A2+ufZOCmgJ6ZvTki61fhJdtm9iWtYVrw22ryRoRCIUmzP4lTouTaGv0H7MjSiml1P9oW9k2Xl/7OkGCAFzc9mKeW/ZcuD2i/QheXf0qnoAHgJMancS8nHnh8CjWGku0NTocHgEMbjqY73d+H26f0eIMJm6fGG63jG/J1tKt+IP+8GOZMZlkl2eH2z3TezJ///xf7Pc3O76h1lf7v+y6Ukc8rUBSSiml/mQlrhJKXCXUemuJtkZz7bRrKXYV0zqhNZtLNpNdIV9YE+wJ5Fbnhr80hxgY4cfWFKxhSLMhrMhfAYA34CWvOo+OSR3ZVLLpkG1f1fEqUp2pf/AeKqWUUv+9ak81761/L9xuHNOYPRV78AV94ccyYzLZUbYj3O6a2pUp2VPC7UYxjdheuj3ieQPBQDhwAkhwJFBQUxBuOy1OKj2VEev4A/5D2laT9Rf7bjfbMWl9hjrG6RmulFJK/QmCwSCBYID9lfu59adbOf+78/lu53e8vOplil3FAByfdjwL9y8Mr+MJeHBYHBHPs7pgNX0a9Qm3N5VsomVCS7Jis8KPvb76dW47/jZObnwyBgYADrODUceNYnj74VjNv/wFWCmllDpc3AF3RLBjN9up8db8+jp+d8S8fhWeClKcKRHLmE3miPBnd/luOiR3qG9X7KZTcqeIdSo9lWREZ4Tbc3PmMqz5sF/sx/B2w7Fb7L/aV6WOdhogKaWUUn+gUlcpawrW8PDCh5m9dzajZ49mQ9EGAHpl9GJezrzwst6AN+LLZ7W3GqfFSZSl/ovxdzu+44qOV5BgTwg/9sTiJ7i/1/1c2fFKkh3JmE1mFucu5oETH2DS+ZP46uyv+Pa8b7mp600kO5P/+J1WSimlfoMYaww90nuE2/sq99E2qW3EMgeqDtAmoU24/dPenzizxZnhdm51LpnRmTgtzvBjs/fO5owWZ4TbU3dP5YLWF2AxZEBOtbeawtpCuqV2Cy8zfst4Rh8/GpMhl8yrClbRMbkj7RLbHdLvU5qcckg/lToWaYCklFJK/QHcPjfFtcW8vPJlrvjxCibtmoTJMEXMyQBEzLewYP8ChjQdEvH3cZvHcf+J94e/5FZ4Knh22bM8e/Kz3NXjLk7IOIETM08k3h7PjV1u5Iuzv+Crc77izu530ji2Mc3imtEuqR2NYxpjM9v++B1XSimlfiOb2cZlHS/DbpYfU7wBL1tLtjKwycDwMhO2TOC242/DZpJ/03aV7yLKGhVRnfvehvcYc9KYcIj0w64fODnrZIY0HYKBQa2vlnFbxvH8gOdpFtcMgJdXvsxNXW/i+uOuJ9Yay9bSrWwp2cInp3/C4KaDyYzO5OttX/P0yU/zfP/nOanRSQxqMoixQ8byUJ+HDql6UupYpHMgKaWUUr+j3KpcFucuZvGBxZze4nQm7pBJOqOt0eGhaiFbS7fSPa07qwpWAVBUW0SFp4LBTQfz096fAFiZv5IoSxRjh45lVcEqdpXvoldGL5rHN6d3Zm+GtxuOxWQJh0NxxP2Je6uUUkr9vrJisvjotI94bPFjbC7ZzNi1Y3lh4Av0Su/Fx5s/Jr8mn8UHFjP+rPF8tfUrVheuZt6+edzT8x7K3GVM3jUZi8lC09imfHX2V+wq30VhbSFZMVnc1+s+7ux+J6XuUqKt0aQ4U/jwtA+pcFdgYBDviOfEjBMZ3m44/qAfp8VJoiORJ/s9SY23BrvZTpw9jjaJbRjYZCAmw6Q/zqi/FA2QlFJKqd/Jvsp9XDP1GvJr8jmr5VlM3jU5/LdqbzXJjsjhY19v+5rH+j7GxrkbcfvdAPxrxb+4s8ednN3ybKbtmYbH7+GCNhfQPL45vTJ7HbLNKFPUIY8ppZRSRyuLyUKnlE6MHTKWck85hmEQZ4vjlCancFqL0wgEAzgsDuLt8fzjhH9Q7a3GYXbgtEq1Uc+MnhHP1zSu6SHbaEaziPbB1UPp0ekR7Whr9CF3MD14jkKl/go0QFJKKaX+B8W1xRTXFhMIBvhw44fk1+QD8gW43F0eXs4f9JNTlUOHpA5sLtks67qKeW/De7wy6BW+2/kdK/NXkmBPIMWRwvFpxzOoySACBLCY9J9rpZRSfy2JzkQSnYkRj6VGRd5F1Ga2aQWQUn8i/UaqlFJK/UY5lTncMfsOtpVu4/n+zzNtz7Tw39YWruXithczf//88GNvrX2LZ/s/yzvr3gkPW1tTsIYfs3/k7p53EySIxbCQ5EwKr6O3BFZKKaWUUkcCDZCUUkqp36C4tjgcHgGYDBO+gC/89+zybFKcKbSIa0F2RTYgE2DfO+9erul8DQ+c+ABuv5t4ezxJjiRibDGHZT+UUkoppZT6T2iApJRSSv0GRbVFEXdU21S8iRMyTmB53vLwY08tfYoxJ41hce5ipmZPxRvwMrjpYIY2G0rT2KYYhnE4uq6UUkoppdR/TQMkpZRS6jcocZVEtCdun8iYfmNYV7guPCF2mbuM0bNHc+NxNzLujHFYTBYS7AnYLfbD0WWllFJKKaV+Mw2QlFJKqd/g4Ik8S92lvL3ubV4Z9Arf7PiGFXkriLfHc1Wnq+if1f+QO7wopZRSSil1NNEASSmllPoNkh3J9EzvyYr8FeHH1hau5c7Zd3LPCffw9x5/x2a2kexMPoy9VEoppZRS6veht3ZRSimlfoNERyJPn/w0AxoPCD9mNsyc1uI0BjYZSGZMpoZHSimllFLqmKEVSEoppdRvlBGdwVP9n6K0tpQqXxVx1jiSnclEWaMOd9eUUkqpw8rtc2MxWTCbzHj9XkrdpRCEBEcC/oCfYlcxbr+bKGsUTrOTMncZudW5xNvjSXWmHjJUXCl1+GmApJRSSv0P4mxxxNniDnc3lFJKqd+F2+eWYMcShcVsodRVisvnwmQykeJIodhVTKmrlCBBkh3JeANedpbtJLc6ly6pXYiyRDEvZx4LDyykTWIbLmh9AV9u+5LJuyYTZYniuf7P8emmT5m+ZzpBgrww4AUm75zMT/t+CvehcUxjXh/8Oq0SWh3GI6GUOthREyCVlpYyevRovv/+ewDOOeccXn31VRISEn5xnauvvpqPPvoo4rETTzyRJUuW/JFdVUoppZRSSqkjisvnoqi2iHJ3OXaznThbHNW+apbkLsEX8NGvcT+qPFV8uulTcqpyuLjtxWTGZPLiyhfZVLyJIU2HcF7r83hiyRPk1+TTNrEttx9/Ow8seIAKTwUJ9gSePvlp7pt/H2XuMgAubXcpo2aMIq86D4Abe93Ik0ufZGPxRgBOb3E6C/cvjAiPAPZX7WfU9FF8duZnZERn/KnHSSn1y46aAGnkyJHk5OQwdepUAG644QauuOIKJk2a9KvrnXbaaXzwwQfhts1m+0P7qZRSSqnfprS2FHfAjckwkeJMwWToVI1KKfV7KHGV8Nnmz/hgwwd4Ah6u63wdgWCADzbKddKQpkPw+D28vOplAFrEtcBisnD99OsBsJgsXNj2Qm6fdTu+gA+AUceN4sGFD1LhqQDgwjYX8v6G98Ph0fFpx7OhaEM4PHJanKRGpYbDo9B2719w/8/2ubC2kL0VezVAUuoIclQESJs3b2bq1KksWbKEE088EYB33nmHPn36sHXrVtq1a/eL69rtdjIy9ENHKaWUOpL4Aj6Ka4vxB/2YDTPZ5dm8sOIFtpZuJcWZwnWdr+O0FqeR4kw53F1VSqmjWiAYYGr2VMauGwvI0OsOyR34x9x/hJc5r/V53DnnznD7knaXhJcHGJg1kOm7p4fDozhbHJ6Ah3J3eXiZzimdeW/De+H28WnHs/DAwnA7LSqN3eW7D+mf2+/+xb7nVObQK7PXf76zSqk/1FERIC1evJj4+PhweATQu3dv4uPjWbRo0a8GSHPmzCEtLY2EhAQGDBjAk08+SVpa2i8u73a7cbvrP8QqKiRR93q9eL3e32Fv1OEQeu30NVRHCz1n1dHm/ztnvUFv+FdqDPhq21d8tvkzmsU346I2F/Ho4kfDyxbVFvHs8mfZWLyRe3reQ4wl5o/uvvoL0s9ZdbT5redskbuIt9e9HW4PbDKQqdlTw+1EeyIFNQXhcAjqwp6K3eF249jGrM5fHW7HWGMocZVEbCcQDET2N+DFYXaE2xXuikN+FPAFfcRYY6jyVv1s31vEt9D36FFMP2ePDv/N63NUBEh5eXk/G/qkpaWRl5f3i+udfvrpXHzxxTRr1ozs7GweeughTjnlFFauXIndbv/ZdZ5++mkee+yxQx6fPn06UVF6V52j3YwZMw53F5T6r+g5q442oXM2KTkJZ6wTi2HBmeZkwo4JTN83nZu73szcnLksyZX5CC9pewmvrXntZ59r8q7JjGw1kuwV2QSDwT9tH9Rfi37OqqPNf3vOtuzekmJXcbgdY41hf9X+cNtkmAgQGf4YhoHFsOALSqhUVFNE49jGrCtaB8jwsqaxTSPWya3OpU1CG7aXbQdg9r7ZXNXxKlbkrwCg1F1KtDWaOFtc+AeFH3b9wCXtLuH9De8f0u/mcc2x1FiYsmTKf7W/6sijn7NHtpqamv942cMaID366KM/G9Y0tHz5ckA+xA4WDAZ/9vGQSy+9NPz/O3fuTM+ePWnWrBk//PADF1xwwc+uc9999/G3v/0t3K6oqKBJkyYMGzaMuDi9y87Ryuv1MmPGDIYOHYrVaj3c3VHq/6XnrDraeL1eZs2axSmDT6HYW8yP2T+yNG8ptx9/OzfNuYmi2iIcZgeZMZnh8Agg2hpNQU3BLz7vPtc+Tj/99D9jF9RfjH7OqqPNbz1ni1xFxNvjw8PNtpVuo1tqN1bmrwSg2FVMo+hGmA0z/qAfgMUHFjOwyUBm7p0JwKx9s3iu/3NMzZ5KkCDegJe9lXs5Pu14VhdIZdKErRO4q/td3DvvXnxBHzmVOVhMFvo26suiA4sAGLtuLGP6jeHBBTJ30rycefTP6s/lHS7ni61f4Al4AOiR1oMnTnqCDGcG7bPa/z4HUP3p9HP26BAadfWfOKwB0m233cbw4cN/dZnmzZuzbt068vPzD/lbYWEh6enp//H2MjMzadasGdu3b//FZex2+89WJ1mtVj3pjwH6OqqjjZ6z6mhQWFNIYU0hScclsbtmN9dNu44qbxV9Mvswc+9MimqLAMiKzWJbybaIda2mXz+/Y22x+h5Qfyj9nFVHm//2nE0zp3FNp2vCE2SvyF/BtZ2v5avtX4VDpSnZU7i609XhOYwm75rMiwNfZGvpVvZV7qPWV8u03dO4/8T7eXHli9T6anljzRs81/85Zu2dxeRdk8mpzGH67ul8eNqHfLjxQ1YXrObLrV/yUJ+HuKbzNXyz/RuCBEmyJzHhzAnsq9pHQXUBbZPaMqTJEC7rcBmVnkocFgdJ9iTiHfG/+7FTh4d+zh7Z/pvX5rAGSCkpKaSk/P+TY/bp04fy8nKWLVtGr14yidrSpUspLy+nb9++//H2iouL2bdvH5mZmb+5z0oppZSCSk8lRtAgrzaP23+6nZyqHG7tdivzNswLz2XRNbUrs/bNCq9T460h1hYb8TzritbRM71neIhDQ06Lk1YJrf7YHVFKqWOc2WTmvNbnkVedxxfbviAQDPD8iud5vv/zfLzxYxYeWMjkXZO5v9f9jB06lg83fkhuVS7zcubxxuA32FOxhyUHlpARk0G/xv04ufHJ5NfkEwgGyIzJpGd6T27seiMevwenxUlaVBpj+o2h2luN1WQl0ZEIQK+MXhAEk0nusNkkrsnhPCxKqd/gqJgDqUOHDpx22mmMGjWKsWPlbgA33HADZ511VsQE2u3bt+fpp5/m/PPPp6qqikcffZQLL7yQzMxMdu/ezf33309KSgrnn3/+4doVpZRS6qhWUFPAstxlfLntS67tfC2PLn40XGHUJrENr695PbysJyAXEyEHqg+QFZuF1WTFG5AJG7/c9iXPnPwMeyr2UFhbGF7WYlh4aeBLpDpT/6Q9U0qpY1eyM5k7e9zJFR2voKi2iChrFMmOZJ4b8Bzl7nKCBImzxhHviKdLShfcfjfR1mgcFgfN45szoMmAiOdrHNs4oh1ji7zZQbQ1mmhrdMRjJsMEvzz7iFLqKHBUBEgA48aNY/To0QwbNgyAc845h9dei5x0c+vWrZSXSxmm2Wxm/fr1fPzxx5SVlZGZmcmgQYP4/PPPiY2NPeT5lVJKKfXzKj2V1Hhr8AV8/H3u39lYvFHm0/CUh8MjOPQOPLP2zmJ4++GsLVwbfuyzzZ/xUO+HeGzxY/iDfsrd5Tyx+Ake6fMINb4aVuStkIuVrAFkRGdgNWvJu1JK/R5CoU7TuMjJrw+uDI2xxRCD3v1SKXWooyZASkpK4tNPP/3VZRreocXpdDJt2rQ/ultKKaXUMavWW8vO8p28vPJlanw1nNb8NDYWbwQgyZ5EXnXknVDzqvNoGd+SXeW7ANhdsRuH2UGfzD4szl0MwOLcxVhMFt479T22lGwhvzqfXhm9aJPYhvTodE5voRNmK6WUUkodiY6aAEkppZRSf45aby3egJfNJZsZNX0UQYJc3elqpu+ZHl6msLaQrNisiPUmbJnAHd3vCN+BB+DJpU/y955/Z0T7EczYMwOTYeL8NufTPK45PdJ7/Kn7pZRSSimlfjsNkJRSSikFQLm7nJ1lO/lgwwcMbT6Ud9a9QxCp7jUwIip9q7xVuHwumsU1Y0/FHgD2Vu5l4vaJvHrKq3yz4xvWF60n1ZlKVkwWXVO7MrDJQAxDJ8BQSimllDoaaYCklFJKKao91UzcPpEXV74IwNmtzmZ3xe7w35fmLmVIsyGsK1oXfuzfq/7Nk/2eZOy6sawuWA3A8rzldEnpwn297iNIEJvZRrxdb8WslFJKKXW00wBJKaWU+osKBoMU1hRS4i7BYlh4edXL4b+ZTWapOqqrQNpUsonrjruO1gmt2VG2A4BiVzH3zr+Xm7rcxEO9H6K8spyMhAxSo1KxW+yHY5eUUuqYlpKSEv7/Lp+LSk8lFpOFREciJa4Syt3lBIIBEmwJeINessuzOVB1gNYJrWkU04jUKL2zpVLqt9MASSmllPoLcvvdrClYw/0L7sfA4JrO10TcRW11wWp6Z/YOT34N8Njix3i076PsKtvFT3t/IkiQC9pcwKAmg0i2JTNl3hS6ntEVq0XvnKaUUv+Nak81Vd4qTIaJZGcyRbVFlLpKCQQDJDuS8QQ8rMxfyTbLNsyFZlKjUvlw44csyV1C99TujOgwgieXPsmWki00i2vGfb3u4/4F91PiKglvo01CG14b/BqNYhodxj1VSh3NNEBSSiml/oL2V+7nphk34Qv6SI9Kj5jfCOCb7d/wXP/n2F62naLaIgAqPBX8fc7feX3w61zQ5gIsJgsJ9gQMw8Dr9R6O3VBKqSNOKAwyDIMkexLF7mJKXaX4Aj5Snam4/W4W7F/AttJtDMgaQGZMJm+ueZMluUvok9mHS9tfyqOLHuVA9QHaJrbl1m638s/5/6TWV0uSI4kTG5/I8MnDcfldGBic3edsbpxxIzW+GgBu6HIDDy18KCI8Athetp0xS8bwbP9nibXFHo5Do5Q6ymmApJRSSv1FePweimqL8Pq9jNs8LnyntPyafJrFNcNkmMJVSBWeCsYsGcNDvR8ipzKHtYVraRLbhLNbnU1mdCZR1qjDuStKKXXY+QI+8qrzWHxgMVtLtnJy1smkR6fzxpo3WJK7hL6Zfbmk/SU8vPBh8mvyaZ/UnlHHjeL+Bffj9rtJdiQzqMkgRv4wEm/Ai4HBRe0u4vZZt+P2uwG4rvN1PLroUWp9tQCc3/p8PtjwAS6/C4ATMk5gSe6ScHhkN9uxm+0U1hb+bJ8X7F9AiatEAySl1G+iAZJSSin1F1DqKuXrbV/z9vq3Gd5uOJtLNkf8feruqVzT6Rre2/Be+LGcqhzunns3488cz+UdL8dkmP7sbiul1BEpGAyyuXgz102/jlpfLQn2BPo36X9IGDR61uhwGHR1p6sZs2RMuH1Bmwv4YOMHeANSwdkroxeLDywO/91qsmI2mSl1l4a32ymlU8TndPP45mwp3hJuR1ujKXOX/XK/CeLyuX6346CU+mvRb4JKKaXUMS4QDDA1eyqvrH6FWl8thbWFZMVmRSzz/c7vAXi2/7P0a9yPtoltGd5uOF+f8zUt41tqeKSUUg0U1BRwx+w7IiqDPt74cTgM6pHeg6W5S8NhkNkwYzPbIsKg9kntWZm/MtxuHNuYXeW7wm272U61tzpiu8FgELNhDrdLXaWkR6eH2+XuctKj0vklTotTq4+UUr+ZfhtUSimljnEFNQW8te6tcPunvT9xRoszMDAilntvw3s8s/QZ/tHzH7w77F3uPuFumsc3x2LWgmWllGqo2FUcMUysc0pnluUtC7czozPJLs8Oty0mC26fO+I5AsEAVlP9TQcKawrJiqkP96u8VaQ6UyM+q5flLaN/Vv9we37OfIY2Gxpu+4N+tpZspU9mn5/t96jjRpHq1DuxKaV+Gw2QlFJKqWOcy+eKmEy11lfL1Oyp3H/i/URZ6ucycpgd3NXjLtKj0kl0JGIz2w5Hd5VS6oh38DAwX8CH3WwPt0Nzy4W4/W7i7HER1UPzcuZxavNTw+1FBxYxIGsAFsMS8diZLc8MtyftnMSl7S4l2ZEs/fC7mLlnJnf3vDscRr297m0ubncxF7a5EJtJPsfjbHH8o+c/uLDthVjNeqdMpdRvoz8pKqWUUsc4u9mO0+IMD7UA+CH7B4pqi3jipCdIsCdgNVlJj04nxZmiwZFSSv0/UqNSsRiW8M0IZu2bxWktTuPbHd8CsCJ/Bdd0vobxW8aHh7XN3DOTi9tezIStEwCYtnsa/z7l36wpXENOZQ7+oJ/xW8fz2EmP8eyyZ6nwVPDZls94rM9jtEpoxaebPqXYVcx7699j7NCxLM9bzpx9c/AEPPTO7M03537D7vLdePwe2iW2o1d6L0YdNwq3343T6iTNmYbZZP653VFKqf+IBkhKKaXUMS7FmcLI9iMjJl4FWJq3lM0lm/nq7K/IjMk8TL1TSqmjT7IjmWs6X8M7698BZGjwq4NeZU3BGnZX7CYQDPDBhg94qt9TPLPsGYpdxXyz4xvuPeFeHur9EB9s+ID9Vft5Z/07vDLwFXaW72TmnpmkOFM4Lvk4Pj/rc0pdpXgDXtKj0kl2JnNWi7MoKi0iLSmNtOg02ia25cI2F2IxW8LVRw2rngDiHfF/+rFRSh27NEBSSimljnFWs5XLOlzG/qr9TN09Nfx4qjOVNwa/QUZ0xmHsnVJKHX2irFFc3vFymsU14821b7K/aj9vrH2D5/s/z77KfczYO4MkRxJtE9sy7oxxlHvK8QV8pDhTSHGmMKjJIPxBP1aTlWRnMm2T2nJq81Mjblhw8M0Oku3JLF21lHZntAPAMAycVuefut9Kqb82DZCUUkqpv4DUqFQe7P0gt3S7hf1V+4mzxZEelU5aVBqGYfz/T6CUUipCkiOJc1ufS99GffEFfdhMNpKdybRPbs+QZkMiPlsb0zhi3dSoQyey1rtdKqWOdBogKaWUUn8R8fZ44u3xtIhvcbi7opRSx4yfC4M0mFdKHYs0QFJKKaWUUkqpX+D2uTGbzFhMFqo91ZS6SwkEA8RYY0hyJh3u7iml1J9GAySllFJKqd+gylOFyTARZY063F1RSv0GgWCA4tpiAsEAcfY43D43Ja4SKjwVJDoSMRtmVuavZOruqTSNbcrFbS/m1dWvMidnDoFggLaJbXmw94N0TOqI3WI/3LujlFJ/OA2QlFJKKaX+C3nVeSzYv4DJuyZjM9kY2WEknVM6k+JMOdxdU+ovLRgMEgwGMZlM+AN+CmoLcPvc2M12bGYb+TX5rMxfSbwtnuPTj2fmnplM2DIBgGf7P8srq15hRf4KLCYLr57yKk8ueZKcqhwAXhr4EjfOvJGCmoLw9raVbuOaqdcw/szxdEjucFj2WSml/kwaICmllFJK/Yq86jx2lu1kc8lmBmQN4M7Zd7K3cm/474tzFzMwayCP9H1EQySl/iBun5taXy1OixOLyUJBTQHlnnIshoUYawzFrmK+3vY1Ze4yRnUZxaIDi3h/w/tUeCp4rv9zfL/zexbsXwDAI30e4d5597K+aD0At3S9JRweAQxpOoRpu6eFw6NWCa3YX7U/IjwK8Qf9vLLqFZ7v/zyx9tg/6WgopdThoQGSUkoppVQDlZ5Kylxl+II+AG6YcQN51Xn0bdSXUldpRHgUMidnDpeVXqYBklL/o2AwSEFNAcWuYlw+F+nOdKp91Xyy+RO2lmzl4rYXYzPbeH7F85S7y7my45UEggE+3fwpAOe1Po8vt33Jl9u+BKB7Wnd2le0Kh0epzlQsJks4PALomNyRN9a+EW4PyBrA40seD7fbJLRhbeHaX+zzqoJV1PhqNEBSSh3zNEBSSimllKqTU5nDU0ufYsH+BdzS7RYW7F9AXnUeACc3PpmPNn30i+t+se0Lemb0xGLSr1dK/Ra+gI/NxZu5Y/YdFNYW0im5EyPaj+DhRQ8TCAbIiM4g2hrNvfPvBcButtMzvSejZ48OP8fgpoO5a/Zd4fYZLc/gnXXvhNvHpRzH0tylEdt1+90RbbPJjNfvDbcrPZVkxWb9Yr+THcmYDNNv22mllDqK6CedUkoppf6yimqLWJ63nMcXPc7y3OWMmj6K+fvnEyRIu8R2EVUHJsNEMBj8xefyBXwE+eW/K6V+XX51PtdNv47C2kIARnYYyUsrXyIQDABSXRSqNAKpLlqcuzjiOTx+T7h6ECDWGkuxqzjc9ga82M2RE147LI6I9qr8VfTL6hduL81bSr/G/fglV3e6WqsPlVJ/CRogKaWUUuovpcpTRUF1AblVudw3/z6unXYts3Nmk1OVE57zBORCs6GluUsZ0GTALz7vhW0vxGqy/mH9VupYtyR3CbW+2nA7yhIVEf5kxWSxo2xHuG0xWSKWB7CaI9+D20q30S21W7i9In/FIWHQ+sL19M7sHW5P2jWJ4e2GE2WROyz6Aj5m7pnJ33r87ZBKo6HNhjK42WAMw/gv91YppY4+GiAppZRS6i+hxlvDhqIN3D33bh5a9BA/7v6RJblLAGgW14ytpVsjljcMA6fFGW7PzZnLoCaDSItKO+S5u6d2p2NSxz92B5Q6xh38HjxYUW0RjWMah9ubijdxQsYJEcvkVObQOqF1uP3tjm+5ouMV4eCn1lfLpuJNXNz24vAyH236iMs6XEbfRn0BqPZW88qqV3hzyJtc2OZCUp2prCtcR6v4Vnx77rc83vdx7j3hXr48+0se6v2QVh8ppf4ydJC+UkoppY5pRbVFEIT1Reu5Y/YdBAky+vjRfLfju/Aypa7SQ4KhyTsnc3mHy3lnvcyf4g/6eXzx4zza51FW5q9k1r5Z2M12RrQfQb/G/UiNSv1T90upY81xKccxnvHhdq2vliRHEiWuEgC+2/kdI9uP5MmlTwJQ7CrG7XPTJaUL64rWAfDhxg95vO/jPLzo4fBk3N/t+I7n+z/PW2vfYnvZdt7f8D6P932cs1udzcRtE6nwVOAP+Hm0z6O4/W4qvZXEWmNJdibzz17/5JZut2A2zCQ7kwFoEd/iTz4ySil1ZNAASSmllFLHpKKaIubkzOGjjR9xQ5cbeGnlS+E5ihwWB9Xe6vCyu8p30Sq+FTaTDU/AA8CsfbPoktqFu7rfxSebP6GotogqTxXri9ZzVcerwlUNiY7Ew7J/Sh1reqT3IM4WR4WnAoDxW8ZzV4+7eGTRIwSCAbLLs6nyVnFFxysYv3k8vqCP51c8z9MnP82usl18se0Lqj3VzM+Zz3vD3uNA1QF2lO2gVUIr2ia25Z1h71DtrcZsmElwJBBtjaZralcCwcCvTn5/8BxJSin1V6UBklJKKaWOOaWuUp5a9hQz9swA5AIwNDEvSDVS78zefLezvgrpw40fMqbfGB5Z9Eh4XpWXV73MNR2v4ZPTPyEQDGA1W8O3AVdK/T5Kakuo9FZiM9l4/9T3uXve3WSXZ7O+aD1NYpvw4Wkf8vmWz9letp3NxZu5pestDG83nNzqXOxmO+nR6fRv3J/zWp9HIBgg1hZLlDWK5vHN6du4b8S2QlVEISbDpHdQU0qp/5B++1FKKaXUMaGotojd5buZtnsag5sNDodHwCEXiDP3zOS1wa/x096fqPJWATK5rjfg5bn+z2FgUOmppF1SO1KcKVplpNRvVOOtocRVgi/gI9YaiyvgYnnectYWruWkzJNIcCTw9LKn2Va6DQODc1qdw2unvIbb78bj95DoSCTVmUqHvh2o8dXgtDjDc5M1jWsasS0dRqqUUn8sDZCUUkopddQrrCnkwYUPsujAIjoldyLaGh3x9wNVB2gZ35Jd5bsAucPav1b8i38N/Bdfbv2SeTnzsJqtdEruRNvEtjSKaXQ4dkOpo0owGKSgpgC3343VbMViWMipymHGnhkk2hMZ2mwor615jZl7ZpIWlcajfR/l7rl3U+GpIM4Wx8CsgVw//Xr8Qb88H0G+2/kdC/Yv4LMzP6NNYpvwtqxYdSiZUkodZhogKaWUUuqoVeYqwxf0MX//fBYdWATILbdtZlvEcuM2j+PeXvdy77x7w8PTtpVu467ZdzF26FjuOeEeTIaJBEcCdrP9T98PpY5ENd4aKjwVGBhEW6IpdZeyLH8ZxbXFDGoyiLWFa3ljzRsU1hbyfP/n+WrbVyzNWwrA0/2e5tafbmVv5V4Aruh4Bc8tfy48v9FZLc9iwtYJ4fCooWJXMYsOLOKithf9eTurlFLq/6UBklJKKaWOOpWeSjaXbObFFS8yKGsQM/bWD1fbXradO7vfGbH8/qr9jF07lhcHvsiq/FVsKt5Ei/gWXNT2IhrFNAoPiVHqr6TcXY434CXWGkuVt4r8mnz2VuylaVxT7GY7b6x5g1l7ZzGoySBOaXoKDy58EH/Qz8AmA3H73by97m0AOiV3Ym/l3nB4lOpMxRPwhMMjgKyYLHaW7Qy32yS2YfKuyb/Yt3k58ziv9Xk635hSSh1B9BNZKaWUUkeVQDDAkgNL+NvcvwEwrPkwqn3VEX+ftmcaN3e9mTfXvhl+fGPxRh5d9CjjzhhHvD0eq8mK2WT+0/uv1J/NH/BTWFtIqasUk2Ei1hrLltItvL/hfWq8NTzS5xGeXfYs64vXYzVZeW3wa/xtzt/Cdyo8v8353D7r9nC10Nktz+bBhQ+Gn39Y82F8s/2bcLtFfAs2FW+K6IM34I1oV3oqSXYkhyuSDpYZnYnZ0PenUkodSTRAUkoppdRRo9JdSbmnnKeWPRV+bF3hOvpk9uHLyi/Dj32741uGtxvOvwf9m3k58yh2yZCb3pm9SY9OPxxdV+qwqPHWsDh3MY8teoxSdymjjhvFgaoD/JD9AyBDy95e/zbri9cDMKTZEKbsmhIOj9omtmVzyeZDhpqFhoICOC1OKj2V4XYoHDpYtDU6/Lw/Zv/IeW3O46WVL/1svy9scyGGYfwPe66UUur3pvesVEoppdQRr9RVyvyc+YyePZodZTsoqi0K/23OvjkMbjqYOFtcxDoTtk7gxZUvcvvxt/PiwBc5v835ZMZk/sk9P/z8AT8FNQXkV+dT46053N1Rf7Ls8mzumn0Xpe5SrCYrx6UeFw6PAE5IP4H5OfPD7eNSjgsPRQMJfUpdpRHPaTVbI9obizZyQsYJ4fbmks10TukcUUH0zY5vuK7zdRHLxNniGNJ0SMRzmQwTj/R5RCeyV0qpI5AGSEoppZQ6olW4K3h73dvc8tMtrMhfQSAYiPi7P+jnueXP8fyA5zm1+ak4zA5irDGMaD+CsUPHkuRM+svNo1Lrq8Xj95Bfnc97699j+OThnPvduTyy6BGyy7PxBXyHu4vqT1DtreatdW8RJAhAm4Q2rCtcF7GMN+AN/x3k3ImxxoTb2eXZdEruFLHO1pKtdE3tGm5P3T2V89ucHzGX2GdbPuORPo9gNUnYtGD/Aqq91Yw5aQwt41sC8P6G97mi4xV8dfZX3H/i/Txx0hNMOm8SZ7Q4gxhbDEoppY4sf61vU0oppZQ66hTWFvLp5k/D7e2l2zku5TjWF60PP7arfBd3zLqDc1qdw9fnfI3dbCfRkXjI3diOdXnVeSw6sIip2VO5vOPlvL76dTaV1M9FM3X3VObmzGXCWRPCF/Hq2FPjraHYVYzb72Z76fbw4wECWIzIr/+GYeAwO3D5XQDM3DOTs1qexcurXgagzF2G2++mbWJbtpVuA+CzzZ/x9MlP8+jiR8mrzsPtd/Pq6ld5eeDLjNs8jgUHFrA8bzm9M3oz8ZyJbCnZQqm7lK6pXWkU3Yh+jfvhCXiwGBZSo1IBaJfU7k84Mkoppf4XGiAppZRS6ohU5irD5XexJHdJxOPjt4xnTL8x3D//fkrd9UNrfAEfg5oMIjM685AhNseqotqi8PC0FvEtuHnmzeRU5ZAWlUZRbVFEeBRS66vl9dWv8/hJjxNtjT4MvVb/q1pfLeXucgwMnGYnxe5ipuyaQm51Lld0vIIvtn7BxO0TGdFhBFkxWeyv2g9I+Hr78bdHPNe07Glc1PaicEi7uWQzV3S8gl4ZvViWtwyAf634F8/0f4aZe2byw64fKHWX8sGGD3hj8BsU1BSE72rYIr4Fz/R/keCbOwAAJxJJREFUhipPFYZhkGhPxG6x0zy++Z96fJRSSv0xNEBSSiml1BHFF/Cxo2wHY5aMocZbw7DmwyL+Xuwq5tllz/JY38fYXbGbbaXbaJXQiqHNhpIRnXFMh0f+gJ8SVwnBYBB3wM0ds+5ge9l2hjYbSpwtjpyqHAA6p3Rmed7yX3yeeTnzqPRUaoB0FKjyVFHsKqbMXUa8NZ6gEeSdde8wbfc0BjcdTM+MnoxZMoYgQc5ocQafb/2cL7fJhPJTdk3hn73+GZ7TyB/0s2D/Ai7vcHk4MJq2ZxoP9X6IqzpexRfbvqDWV8uYxWN4pv8z3NT1JqbtnobD7CDNmcZd3e/i5q434wv6iLJEkexMpk1iG05qfFJEn2NtsX/uQVJKKfWn0ABJKaWUUkeUnMocrphyBS6/C7NhPmT+FYDdFbsZPXs057c+n4d6P0SUNeow9PTPVVBTwPc7v2fClglc1uEyZu6ZyfYyGZ40IGsAzyx7Jrys1+/FYXf84nM5LU4M9A5XRwKv3xuupIs2R1PoKmT6nunkVuYyosMIPtz4IZN3TcYwDN4Y/Ab3zr+Xcnc5AGe3OpvbZ90ensNoSLMh3Df/vvBzF7uKWV2wmju638Fba9/C7Xczfst4bu12K28PfZsvtn5BiauECk8Fl3e8nBHtR1Djq8FhcZDiSMFpdUZMjq2UUuqvTQMkpZRSSh0x3D43n2z6JDwfiz/oZ17OPC7rcBnjNo+LWDbGGsNVna46ZsMjt89NUW0RRa4iYm2xPLzwYdYWrgWgZXxL1hXVT4ZsMkx4A95we0X+Cp4++Wm+2v7Vzz73RW0v+tnbrKs/li/go7CmkP9r786jo67u/48/J8lkspAMWUgmMUEQLSIEBJFdQKxI1YLVWhdKtWoPiIBKa91QYkVRikgVqvWnoLZfCtgColgEZBHZtwiIhC0kQDYkIRMyyWSWz+8PDh8dwYAwMRl4Pc7JOXw+nzt37iSvQ2beufd+qjxVxFhj8Bt+Ptj1AQv2LeBqx9V0T+vOM6ufwW/4ubHljczMnclH+z4CoPdFvVl+YLlZPGoR34Ld5bvxGT6zf8MwcPvcAc85Y+cM+mb2ZULvCURHRBMTEUNKTArNopvRKaUTHr+H6IhowsPCERERqYvuwiYiIiKNxjHPMXPflRNm5s6kibUJL1/zMn0y+pCVnMXQ9kP54Jcf0NLesoFGWr8qair4985/M3DeQB5e+jDbv9luFo+Ak4oEm0o20Sejj3lc7a1m2+Ft3NH6jpP6vqzpZdzR+g4iwvV3xPpWUlVCTmkOSwuWkl+Rz4yvZ/Drj37Nr+b/it3lu/n9p79n2vZplLhKGNBiAGNXjzXvMnhd8+uYv3e+2Vf7Zu3NpWgAtnAbVd6qgOcLDws/5R0Hlx9YzsPLHibWGkuHlA6kNUkjIjwCW4SNJpFNVDwSEZEzoncOIiIi0mhEhkeSEJXAfuf+gPP/2PoPEmwJPNjhQW5ocQN2m/28+9BbUlXCfud+SqtKsUXYeGXTKwBckXTFSfsZ2cJtWLCYS5c+yfuEyddOZk3hGio9lQC8s/0d7m93P1P7TWX5weU43U5uuuQm2ia1JSU25ad9cT/C0Zqj1PpriQqPIt4W39DDqZPP76PKU4Ut3IbL6+LQsUN8uv9TEmwJdE3rysilIzlcfZhuad24KvUqpuZMBaBzame2lG6huKoYgIuaXERBZQFewxvQ/3cLhdXe6oA9q/Kd+bRJbBPQfsWBFQxoMYCP93180lgz4zJxxDqC9tpFROTCowKSiIiINBpxkXHc3+5+RiwdcdK1cnc5lyddTmJ0YgOMrH7lO/P5w6I/UFRVxKiOo1i4f6F5zev3EhUeuJ/R2qK1XH/x9SzKXwQcLy5M3DCRiX0nsjh/MV8c+oJYaywZcRm0SWpD78ze+A0/YZbGN/m8wl1hzrrZengrb259k8Jjhfws4WeMuHIElza9lNjIxrHZ94niVqw1lrKaMj7c8yFri9ZyT9t7WHZgGR/tPb7cbELvCQz/bDhlNWUADGo1iJc2fLtH1VWpV7H8wHLz2BZuo8oTOJsIICo8ylzO+Vn+Z/ym9W/Y/s12AGp8NeQ78+mR3oPVhasB+GjfR0zoPYHK2kpWHFxh9tOqaSteu/Y1UmIab+FQREQaPxWQREREpFHJapbF3ZffzYydMwLOD+8w/LxZsub1eyl1lVLgLKCJtQl/WfsXiqqKAEiNTaXAWWC23Vy6mbva3MXM3JnmuZm5MxnfazxREVF8kvcJXr+XvIo8Fu9fzENXPsTwDsMJs4SRFP3tPkeNpXhkGAYWi4VSVynritYxY+cMujq6EhEWwT+2/sNst7ZoLWuL1vJq31fp17zfTz7+Wl8t5TXHN7cOs4Sx7ZttvLX1LTx+D493eZxRS0dR5anCEeugsrbSLB41tTWl1ldrFo/g+My6E3sXwfGfvy3cZh4frDxI64TWAc+/OH8xgy4dxKzcWQDkOfOIjoim10W9+OLQFwBMyZnCCz1foGNKRz7Y9QFl1WXM3jmbJ7o+weirRlNWU0Z8ZDyJUYkkxyTXzzdKREQuGCogiYiISKOSGJXI8CuH85vWv2Ft0VoiLBF0SetCcnTyeXF78FpfLZtLNvPwsodxeV281u81vi772rxeXFVMS3tL85zb52Zj8caAW697/V6eXPkk97S7hzkD51DrqyXGGkNydDLREdEN8rpOp6SqhC8Pf8mSgiXcdultvLH1DTaVbALgwQ4PMmrpqFM+btzacWQlZ5Eam1qv46twV1DtrSYiLAK31817O97j470fc8tlt+Dz+8yC5rAOw3ht82vmjKF+mf34ZN8nZj9NbU0pcZUE9G2xWIgIi8DrP75EbfnB5dx22W3mRui1/lp2H93NNRddw8pDKwFYlL+IF3q+QJWnik/yPsFv+Bm3bhxju4/l/nb3s3D/QiIsEWTGZ9Lzop7cetmtGIZBVEQUdpsdgEu4pF6/ZyIicmFRAUlEREQaHbvNjt1mp1XTVg09lKCpcFdwzHOMWl8twz8bbt41zePzBLSbu3suQzsM5ZlVz5jn3t/xPve2vZe/Xfs3Vh1axVH3UW685EbaJbWr98LK2TrsOkypq5Qj1UdoHt+c4Z8N50DlAdJi0+ji6GIWj2KtsZTXlAfcTey7jtQc4aj7aNBfp9PjpGVWS5y1TgqPFvLKplf4svRLXr/udbJXZ1PiKsGChe5p3Xnos4fMx7VOaM2bX75pHkdHRFNZW2kel7pKaR7XPOC5Pj/4Of0v7s8neccLTXuP7iU+Mp7OqZ3ZWLIRgDe+fINxPceR1SyL2bmzOVJ9hNm7ZvNMt2cY1mEYzlonMRExJEQlkBiVSGdH56B+P0RERE5HBSQRERGReuTxedhzdA8vb3iZak81fTL7mMUjAGuYNWB2ysFjB9l3dB8jO47k7W1vU+2tBmDh/oX0v7g/T3V9CovF0miWpJ3g9ropd5djsVio8dYw8rOR5DnzuPmSmwE4UHkAgKsdVwfsz+Pz+7CGWevsO9xy7humH6s9hmEYeA0vG4o38I+t/yAyPJIHwh/g0eWPYmDQoVkHviz90pxBlBqbyn7nfnOzciDg3wBfHfmKLmld2FG2AwCX10VlbSWXNr2UPUf3ALBg3wJe6fsKRVVFbCndAsDza59nTNcx3NP2Hj7c8yEWLCRGJdIjrQe3XXYbfsNPVHgUTaOanvNrFxERCQYVkERERETq0X7nfgZ/MhiP30PP9J4nLW9aUrCE2y67zdzrBmD6V9PpndGbv1/3d2zhNvPudI11E+TCY4W8s+0dPtz7IX/s/Edm5c4iz5kHQJ+MPjz9xdNmW8MwCOPb4leNrwZruJWYiBhcXtdJfbe0tzynIsph12E2l25m5s6ZXHPRNRyuPmwuBXys82O8nvO6WRTq0KwDa4rWmI/1+r0nFbdO3P3sxBLDdUXruKftPczfO9/c9+hvW/7GS9e8xD93/JM1hWvw+D1kr8pmQp8JxFnj2O/cT7PoZmTGZ5Iak0qvi3oBEBGmt+YiItJ46beUiIiISJBVuispc5fh9XuZmjPVnHFUUFlA74zeAW3n753PmG5jeCDrAWbnzsZZ6yTWGkubxDa0sLcgObrxbX5cXlNOiauErYe30r5Zex5d9igHjx3EggVHrIO9R/eabcMsYdT6a83j9cXrGX7lcJYeWGqem/H1DB7v8jjPrXnOvCMbHF8eNr7X+B/1PfjG9Q35lflsLNlIz/SeTNw4kU0lm7Bg4b529zF582Sz7ffHWuurJSYi5tu+qr8hLTYtYIbYrNxZPNXlKf604k/U+msxMBi/bjzjrxnPvN3zWFywmKraKhbtX8Qz3Z7BZ/io8dYQFxlHs+hmWMOtXJF8RcCYIyx6Sy4iIo2ffluJiIiIBFGpq5SX17/M4vzFPNv9WTYUbzCvHag8QHJ0MsnRyXxT/Y15ftzacfRM78m0G6ZhC7dhC7fRLLoZEeGN562a2+umxleD2+fmL6v/wopDK2hpb8ntvts5eOwgAFERUTjdzoDH5Zbn0imlE5tLNwNQ4irB6/fSxdGF9cXrAdhYshG7zc4bP3+D1YdWs69iHx1TOjKg5QDSY9PrHJfL4+JIzRHcXje2CBt/XP5Hvi77msy4TOyRdnOvpaToJA4eOxiwBO3EUsATRavlB5czrP2wgFlIc3bP4dFOj/LXjX8Fjm9y/t6O95hy3RQW7l/I5pLNJEcnY8HC410eZ3Tn0QDER8YTY/22GCUiIhLqGs+7EhEREZEQd6z2GK9sfIVF+YuA48WNeFs8ztpviyqTNk1iXM9xvLX1LbOokhSVxMBWA0lvkt7o7jTn8rgoqCzgva/eI9Yai91mZ8Wh43sYtU1qG1Agq/ZWkxCVEPD4/+76L9k9stm6fKs5i+fl9S/zdLenubHljXy872NqfbV0S+vGJfZL6JbWDY/PQ2R4JBaL5ZRjMgwDA4PDrsNM3jyZ/+X9j1+0/AVhljBzaVn39O4sLfh2lpPX7yUyLDKgnw3FG+id0ZvlB5YDx4tDbp+bfs37mY9demAp8bZ43rr+LRbtX8ShqkN0c3QjMy6TJ7s8SZWnCmuYlXhb/Nl/k0VEREKACkgiIiIi58jtdVPmLsPlcbFw/0Lz/Kf7P+WWVrcwJWeKee7QsUM8ufJJbm99O093fRqLxUJ8ZDzNYpo1qo2xy6rL8Bk+tpRu4U8r/oSBwfM9n2fixolmmxNLs75rx5EddHV0ZV3xOuD4XdT+teNfvHbta/x757/ZULwBu82O0+1kYKuB3NDiBvyGn7jIOLNgZIuwnXpMNWXkO/P5z67/0DujN7NyZ5kFrL6ZfXlq5VNmWwuWgOVwR91HSYxOxBZuw+1zA/Dhng95pe8r5JblUlRVBMCEDRMY1WkUd7a+k0/3f4rP72NQq0G0tLfkasfVePweosKjzLFGRUSd0/dZREQkVKiAJCIiInIOiquKeXvb28zbM48Xe70YULTY+s1W7m5zN93Tugcsiyp3l9PE2gRHrKPRzVwpdZWy/MByZuycwSOdHuHZ1c+ay75iImKocFeYbVcXruaFXi8wf+9889w7295hQu8JNIlswrIDy/AbfjaXbuaKxCvI7p6NgYHFYiE5OvmMCmZOtxOX14Xf8DM1Zyrz984n3BLO9RdfHzD7yYIlcK+lovXccfkdZiELYNbOWTx29WO8sPYFDAxcXhfZq7N5ossT1PpqWVW4iouaXETfjL44Yh10T+9+0ni00bWIiFyo9BtQRERE5CyVukp5aMlD7Dq6C+D4sissAfvsPLPqGUZ1GsWvf/ZrcstyiYuMo3dmb5pFN2tUy9W8fi/lNeX8ecWf2VS66fjm175aqjxVZpuCygIuT7ycnWU7geO3rN/2zTZ+2+a35p3Nanw1PPb5Y4zqOIqHOz1Mra+WWGssydHJP2q2To23hn1H9zFp0yTyKvIY3Xm0Waiy2+wUVxUHtD9cfZgW8S3Y79wPQJ4zD3uknSsSr2BH2Q4AVhWuoklkE974+RusOrSKgsoCuji60CaxDelN0rnxkhvP+vsnIiJyvlMBSUREROQs7Tu6zywewfE7jPXN7MuyA8vMcx6/h1c2vsLVqVcz+drJjW7GUXFVMVtKt7D60Gp6XtSTTaWbfrDtf3f9l5GdRvL454+b56Ztn8Zv2/yWN37+BjmlObi8Ln7e/Oc0j29+TneQyy3P5Z7/3YPP8HHLpbewaP8i81qVp4rEqMSA9rNzZ/NA1gOMWTXGPDdu3Tiyu2dTVFXE//L+h8/wkZWcxSVNL6FLShdytubQsXVHIiL0llhEROR09NtSRERE5CytLlwdcDw7dzZ/7f1XcznUCR2adWBcr3GNrnhUdKyIBxY9QEFlAf0v7s9nBZ+Z1/yGnzBLGNER0VR7qwE4eOwgqw+tZlzPcby59U0OVh4kzBJGUVURLeJb0OuiXkEZV3lNOS+uexGf4QPAGmal2ldtXnf73FR7q3HEOsyZSPsq9rGpZBPjeo7jnW3vkOfMw+f3salkE8M6DONXl/4KAwO7zU6YJQyPx0PhwUKubH9lUMYsIiJyvlMBSUREROQsfX+Gjdvn5s+f/5nftf0dg9sMNu9alhiVeNLdyRqK2+vmcPVh/H4///r6XxRUFgDgM3xEhgfepeyDXR8wquMoXt7wsnnuw70fsrNsJ5P6TCIqIgprmJUEWwKxkbFBG2OVp4odR3aYx18e/pJftvolawq/3Ufqza1vMrb7WLJXZ1PiKgFg7p65uLwu/v7zv2MYBhFhESRFJ530ukREROTHUwFJRERE5Cz1yezDxI0TA/Y8qvHV8NbWt/h9298zsuNIrOHWBhxhoMOuw/y/rf+P/+z+D3/p8Rfm7Z1nXttQvIEx3cbw8b6PzXOrC1eTGpPK3679Gx/u/ZB8Zz6tE1pzX7v7aB7XnGhrdL2MM8wShjXMisfvAWBX+S7SY9O5OP5i8p35ABysPMiL615k9FWjaRbTjG+qv+Hi+ItJjUklKTqpXsYlIiJyIVMBSUREROQspUSn8FLvl3hy5ZMBd19rn9yewW0GN6riUWVtJa9sfIUFeQuA43cTq/V9e9cyZ62TwmOF9L+4P4vyv91vaO6euXxd9jWv93udyPBIoiOiiY6on8LRCQlRCdx0yU3M2zPPPPfCuhd4vufzrDq0ik/3f4rH76GLowvtktuRGZeJxWKp1zGJiIhc6FRAEhERETlL0dZors24lo9u+YhVhasoqy6je3r3c95Auj6U1ZTxSd4n5vGW0i30SO/BykMrzXOvbXmN0VeNpk9mH5bkL6HaW81Nl9xEt7RuOGIdP9lYoyOiebDDg2wq2cSBygPm+EcuHcnr177OvW3vJcwSRlNbU2wRtp9sXCIiIhcyFZBEREREzkG0NZrm1uY0j2/e0EOp09GaowFL7T7a+xET+kxgY8lGc5Nsv+Fn4saJ9MvsR3b37OOzjeppmdrppDdJZ/oN0/nqyFcsK1hGSmwKN7a8EUesg1hr8PZbEhERkTMTMgWkF154gQULFpCTk0NkZCRHjx497WMMw+C5557jrbfeory8nK5duzJ16lTatm1b/wMWERERaURirDEBx5WeSqbmTGXytZOZs3sO64rW0cTahMFtBnNDixtIjE5soJF+KzU2ldTYVPo179fQQxEREbnghTX0AM5UbW0tt99+Ow8++OAZP2bChAlMmjSJKVOmsGHDBhwOB9dffz2VlZX1OFIRERGRxicxKpGfJfws4Nz2b7bz8NKHaWVvxb9v+jf//MU/GdxmMM1imjXQKEVERKSxCpkC0nPPPcejjz5KVlbWGbU3DIPJkyfz9NNPc+utt9KuXTvee+89XC4XM2bMqOfRioiIiDQuSdFJvNr3VZrHBS61S4tN45etfklGXAbJMcnajFpEREROKWSWsP1YeXl5FBcX079/f/OczWajT58+rF69mqFDh57ycW63G7fbbR47nU4APB4PHo+nfgct9ebEz04/QwkVyqyEGmU2NKRFpzGt/zSKXcUcOnaIjLgMHDEOEiITLrifnTIroUaZlVCjzIaGH/PzOW8LSMXFxQCkpqYGnE9NTSU/P/8HHzd+/Hiee+65k84vWrSImJiYUzxCQsnixYsbeggiP4oyK6FGmQ0N4eHhWK1WCjwF5PnyGno4DUqZlVCjzEqoUWYbN5fLdcZtG7SAlJ2dfcpizXdt2LCBzp07n/VzfH8atmEYdU7NfvLJJxk9erR57HQ6yczMpH///sTHx5/1OKRheTweFi9ezPXXX4/Vam3o4YicljIroUaZlVCjzEqoUWYl1CizoeHEqqsz0aAFpBEjRnDnnXfW2aZFixZn1bfD4QCOz0RKS0szz5eWlp40K+m7bDYbNpvtpPNWq1WhPw/o5yihRpmVUKPMSqhRZiXUKLMSapTZxu3H/GwatICUnJxMcnJyvfTdsmVLHA4HixcvpmPHjsDxO7mtWLGCl19+uV6eU0RERERERETkfBQyd2ErKCggJyeHgoICfD4fOTk55OTkcOzYMbPN5Zdfzty5c4HjS9ceeeQRXnzxRebOncv27du59957iYmJ4e67726olyEiIiIiIiIiEnJCZhPtZ599lvfee888PjGraNmyZfTt2xeA3NxcKioqzDZ//vOfqa6uZvjw4ZSXl9O1a1cWLVpEXFzcTzp2EREREREREZFQFjIFpHfffZd33323zjaGYQQcWywWsrOzyc7Orr+BiYiIiIiIiIic50JmCZuIiIiIiIiIiDQMFZBERERERERERKROIbOEraGcWBbndDobeCRyLjweDy6XC6fTqVtISkhQZiXUKLMSapRZCTXKrIQaZTY0nKh1fH9LoFNRAek0KisrAcjMzGzgkYiIiIiIiIiIBF9lZSV2u73ONhbjTMpMFzC/309hYSFxcXFYLJaGHo6cJafTSWZmJgcOHCA+Pr6hhyNyWsqshBplVkKNMiuhRpmVUKPMhgbDMKisrCQ9PZ2wsLp3OdIMpNMICwsjIyOjoYchQRIfH6//vCSkKLMSapRZCTXKrIQaZVZCjTLb+J1u5tEJ2kRbRERERERERETqpAKSiIiIiIiIiIjUSQUkuSDYbDbGjh2LzWZr6KGInBFlVkKNMiuhRpmVUKPMSqhRZs8/2kRbRERERERERETqpBlIIiIiIiIiIiJSJxWQRERERERERESkTiogiYiIiIiIiIhInVRAEhERERERERGROqmAJCFh/PjxXH311cTFxZGSksItt9xCbm5uQBvDMMjOziY9PZ3o6Gj69u3LV199FdDG7XYzcuRIkpOTiY2NZeDAgRw8eDCgTXl5OUOGDMFut2O32xkyZAhHjx6t75co56Fg5fa7bX/xi19gsViYN29ewDXlVoIhWJktLi5myJAhOBwOYmNj6dSpE//5z38C2iizEgxnktk5c+Zwww03kJycjMViIScnJ+B6WVkZI0eOpHXr1sTExNC8eXNGjRpFRUVFQDtlVoIhGJk9Yc2aNfTr14/Y2FiaNm1K3759qa6uNq8rsxIMp8usx+Ph8ccfJysri9jYWNLT0/nd735HYWFhQD/6HHZ+UAFJQsKKFSt46KGHWLt2LYsXL8br9dK/f3+qqqrMNhMmTGDSpElMmTKFDRs24HA4uP7666msrDTbPPLII8ydO5eZM2fyxRdfcOzYMW6++WZ8Pp/Z5u677yYnJ4eFCxeycOFCcnJyGDJkyE/6euX8EKzcnjB58mQsFsspn0u5lWAIVmaHDBlCbm4u8+fPZ9u2bdx6663ccccdbNmyxWyjzEownElmq6qq6NmzJy+99NIp+ygsLKSwsJCJEyeybds23n33XRYuXMj9998f0E6ZlWAIRmbhePFowIAB9O/fn/Xr17NhwwZGjBhBWNi3H++UWQmG02XW5XKxefNmnnnmGTZv3sycOXPYtWsXAwcODOhHn8POE4ZICCotLTUAY8WKFYZhGIbf7zccDofx0ksvmW1qamoMu91uvPnmm4ZhGMbRo0cNq9VqzJw502xz6NAhIywszFi4cKFhGIaxY8cOAzDWrl1rtlmzZo0BGDt37vwpXpqcx84mtyfk5OQYGRkZRlFRkQEYc+fONa8pt1JfzjazsbGxxvvvvx/QV2JiovH2228bhqHMSv35fma/Ky8vzwCMLVu2nLaf2bNnG5GRkYbH4zEMQ5mV+nO2me3atasxZsyYH+xXmZX6UldmT1i/fr0BGPn5+YZh6HPY+UQzkCQknZhWnpiYCEBeXh7FxcX079/fbGOz2ejTpw+rV68GYNOmTXg8noA26enptGvXzmyzZs0a7HY7Xbt2Ndt069YNu91uthE5W2eTWzj+l5277rqLKVOm4HA4TupXuZX6craZ7dWrF7NmzaKsrAy/38/MmTNxu9307dsXUGal/nw/s+fST3x8PBEREYAyK/XnbDJbWlrKunXrSElJoUePHqSmptKnTx+++OILs40yK/XlTDJbUVGBxWKhadOmgD6HnU9UQJKQYxgGo0ePplevXrRr1w44vt8GQGpqakDb1NRU81pxcTGRkZEkJCTU2SYlJeWk50xJSTHbiJyNs80twKOPPkqPHj0YNGjQKftWbqU+nEtmZ82ahdfrJSkpCZvNxtChQ5k7dy6tWrUy+1FmJdhOldmzceTIEZ5//nmGDh1qnlNmpT6cbWb37dsHQHZ2Nn/4wx9YuHAhnTp14rrrrmP37t2AMiv140wyW1NTwxNPPMHdd99NfHw8oM9h55OIhh6AyI81YsQItm7dGvBXlhO+vz+MYRg/uGfMD7U5Vfsz6UekLmeb2/nz57N06dKAvWNORbmVYDuX/2vHjBlDeXk5S5YsITk5mXnz5nH77bezcuVKsrKyTtnHqfoR+THqyuyZcjqd3HTTTVxxxRWMHTs24JoyK8F2tpn1+/0ADB06lN///vcAdOzYkc8++4xp06Yxfvx4QJmV4DtdZj0eD3feeSd+v5+///3vp+1Pn8NCj2YgSUgZOXIk8+fPZ9myZWRkZJjnTyzr+X51urS01PxLucPhoLa2lvLy8jrblJSUnPS8hw8fPukv7iJn6lxyu3TpUvbu3UvTpk2JiIgwl1Pcdttt5nIg5VaC7Vwyu3fvXqZMmcK0adO47rrr6NChA2PHjqVz585MnTrV7EeZlWD6ocz+GJWVlQwYMIAmTZowd+5crFareU2ZlWA7l8ympaUBcMUVVwScb9OmDQUFBYAyK8F3usx6PB5+85vfkJeXx+LFi83ZR6DPYecTFZAkJBiGwYgRI5gzZw5Lly6lZcuWAddbtmyJw+Fg8eLF5rna2lpWrFhBjx49ALjqqquwWq0BbYqKiti+fbvZpnv37lRUVLB+/Xqzzbp166ioqDDbiJypYOT2iSeeYOvWreTk5JhfAK+++irTp08HlFsJnmBk1uVyAQTcCQggPDzc/Ku5MivBcrrMnimn00n//v2JjIxk/vz5REVFBVxXZiVYgpHZFi1akJ6eHnArdYBdu3Zx8cUXA8qsBM+ZZPZE8Wj37t0sWbKEpKSkgOv6HHYe+Qk37BY5aw8++KBht9uN5cuXG0VFReaXy+Uy27z00kuG3W435syZY2zbts246667jLS0NMPpdJpthg0bZmRkZBhLliwxNm/ebPTr18/o0KGD4fV6zTYDBgww2rdvb6xZs8ZYs2aNkZWVZdx8880/6euV80Owcvt9fO8ubIah3EpwBCOztbW1xqWXXmpcc801xrp164w9e/YYEydONCwWi7FgwQKzH2VWguFMMnvkyBFjy5YtxoIFCwzAmDlzprFlyxajqKjIMAzDcDqdRteuXY2srCxjz549Af3o/YEEWzAyaxiG8eqrrxrx8fHGBx98YOzevdsYM2aMERUVZezZs8dso8xKMJwusx6Pxxg4cKCRkZFh5OTkBLRxu91mP/ocdn5QAUlCAnDKr+nTp5tt/H6/MXbsWMPhcBg2m83o3bu3sW3btoB+qqurjREjRhiJiYlGdHS0cfPNNxsFBQUBbY4cOWIMHjzYiIuLM+Li4ozBgwcb5eXlP8GrlPNNsHJ7qn6/X0BSbiUYgpXZXbt2GbfeequRkpJixMTEGO3btzfef//9gDbKrATDmWR2+vTpp2wzduxYwzAMY9myZT/YT15entmPMivBEIzMnjB+/HgjIyPDiImJMbp3726sXLky4LoyK8Fwuszm5eX9YJtly5aZ/ehz2PnBYhiGEYyZTCIiIiIiIiIicn7SHkgiIiIiIiIiIlInFZBERERERERERKROKiCJiIiIiIiIiEidVEASEREREREREZE6qYAkIiIiIiIiIiJ1UgFJRERERERERETqpAKSiIiIiIiIiIjUSQUkERERkZ9QdnY2V155ZUMPQ0RERORHsRiGYTT0IERERETOBxaLpc7r99xzD1OmTMHtdpOUlPQTjUpERETk3KmAJCIiIhIkxcXF5r9nzZrFs88+S25urnkuOjoau93eEEMTEREROSdawiYiIiISJA6Hw/yy2+1YLJaTzn1/Cdu9997LLbfcwosvvkhqaipNmzblueeew+v18thjj5GYmEhGRgbTpk0LeK5Dhw5xxx13kJCQQFJSEoMGDWL//v0/7QsWERGRC4YKSCIiIiINbOnSpRQWFvL5558zadIksrOzufnmm0lISGDdunUMGzaMYcOGceDAAQBcLhfXXnstTZo04fPPP+eLL76gSZMmDBgwgNra2gZ+NSIiInI+UgFJREREpIElJiby2muv0bp1a+677z5at26Ny+Xiqaee4rLLLuPJJ58kMjKSVatWATBz5kzCwsJ4++23ycrKok2bNkyfPp2CggKWL1/esC9GREREzksRDT0AERERkQtd27ZtCQv79u96qamptGvXzjwODw8nKSmJ0tJSADZt2sSePXuIi4sL6Kempoa9e/f+NIMWERGRC4oKSCIiIiINzGq1BhxbLJZTnvP7/QD4/X6uuuoq/u///u+kvpo1a1Z/AxUREZELlgpIIiIiIiGmU6dOzJo1i5SUFOLj4xt6OCIiInIB0B5IIiIiIiFm8ODBJCcnM2jQIFauXEleXh4rVqzg4Ycf5uDBgw09PBERETkPqYAkIiIiEmJiYmL4/PPPad68Obfeeitt2rThvvvuo7q6WjOSREREpF5YDMMwGnoQIiIiIiIiIiLSeGkGkoiIiIiIiIiI1EkFJBERERERERERqZMKSCIiIiIiIiIiUicVkEREREREREREpE4qIImIiIiIiIiISJ1UQBIRERERERERkTqpgCQiIiIiIiIiInVSAUlEREREREREROqkApKIiIiIiIiIiNRJBSQREREREREREamTCkgiIiIiIiIiIlInFZBERERERERERKRO/x/xRrhFxTlHuwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# notice how we don't specify a characterization_function_dict here?\n", + "# this triggers the use of some default ones that work with biosphere3! \n", + "# Check the docstrings for more info :) \n", + "\n", + "tlca.dynamic_lcia(\n", + " metric=\"radiative_forcing\",\n", + " time_horizon=100,\n", + ")\n", + "tlca.plot_dynamic_characterized_inventory(sum_emissions_within_activity=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "GWP:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/timodiepers/anaconda3/envs/timex/lib/python3.10/site-packages/dynamic_characterization/dynamic_characterization.py:80: UserWarning: No custom dynamic characterization functions provided. Using default dynamic characterization functions from `dynamic_characterization` meant to work with biosphere3 flows. The flows that are characterized are based on the selection of the initially chosen impact category. You can look up the mapping in the bw_timex.dynamic_characterizer.characterization_function_dict.\n", + " warnings.warn(\n", + "/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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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tlca.dynamic_lcia(\n", + " metric=\"GWP\",\n", + " time_horizon=100,\n", + ")\n", + "tlca.plot_dynamic_characterized_inventory(sum_emissions_within_activity=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Prefer waterfall charts?" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from bw_timex.utils import plot_characterized_inventory_as_waterfall\n", + "plot_characterized_inventory_as_waterfall(tlca)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "timex", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/_static/custom.css b/docs/_static/custom.css index 17c3ce3..29a67cb 100644 --- a/docs/_static/custom.css +++ b/docs/_static/custom.css @@ -47,3 +47,29 @@ body { margin-left: 1rem; } } + +div.admonition.admonition-launch > .admonition-title { + background-color: var(--pst-color-secondary-bg); +} + +div.admonition.admonition-launch { + border-color: var(--pst-color-secondary-highlight); +} + +div.admonition.admonition-launch > .admonition-title::after { + content: "\f135"; + color: var(--pst-color-text-base); +} + +div.admonition.admonition-example > .admonition-title { + background-color: var(--pst-color-secondary-bg); +} + +div.admonition.admonition-example { + border-color: var(--pst-color-secondary-highlight); +} + +div.admonition.admonition-example > .admonition-title::after { + content: "\f518"; + color: var(--pst-color-text-base); +} \ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py index 1ea8394..ab8226f 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -81,6 +81,55 @@ graphviz_output_format = 'svg' # https://pydata-sphinx-theme.readthedocs.io/en/stable/examples/graphviz.html#inheritance-diagram +# Inject custom JavaScript to handle theme switching +mermaid_init_js = """ + function initializeMermaidBasedOnTheme() { + const theme = document.documentElement.dataset.theme; + + if (theme === 'dark') { + mermaid.initialize({ + startOnLoad: true, + theme: 'base', + themeVariables: { + edgeLabelBackground: 'transparent', + defaultLinkColor: '#ced6dd', + titleColor: '#ced6dd', + nodeTextColor: '#ced6dd', + lineColor: '#ced6dd', + } + }); + } else { + mermaid.initialize({ + startOnLoad: true, + theme: 'base', + themeVariables: { + edgeLabelBackground: 'transparent', + defaultLinkColor: '#222832', + titleColor: '#222832', + nodeTextColor: '#222832', + lineColor: '#222832', + } + }); + } + + // Re-render all Mermaid diagrams + mermaid.contentLoaded(); + } + + // Observer to detect changes to the data-theme attribute + const themeObserver = new MutationObserver((mutations) => { + mutations.forEach((mutation) => { + if (mutation.type === 'attributes' && mutation.attributeName === 'data-theme') { + initializeMermaidBasedOnTheme(); + } + }); + }); + + themeObserver.observe(document.documentElement, { attributes: true }); + + initializeMermaidBasedOnTheme(); +""" + master_doc = "index" root_doc = 'index' @@ -116,7 +165,7 @@ "content/contributing": [], "content/codeofconduct": [], "content/license": [], - "content/chagnelog": [], + "content/changelog": [], } html_theme_options = { @@ -124,7 +173,7 @@ "announcement": "⚠️ This package is under active development and some functionalities may change in the future.", "navbar_start": ["navbar-logo"], "navbar_end": ["theme-switcher", "navbar-icon-links.html"], - "navbar_align": "left", + "navbar_align": "content", # "navbar_persistent": ["theme-switcher"], # this is where the search button is usually placed "footer_start": ["copyright"], "footer_end": ["footer"], @@ -134,7 +183,7 @@ "icon_links": [ { "name": "Launch interactive Demo on Binder", - "url": "https://mybinder.org/v2/gh/brightway-lca/bw_timex/HEAD?labpath=notebooks%2Fexample_electric_vehicle_standalone.ipynb", + "url": "https://mybinder.org/v2/gh/brightway-lca/bw_timex/HEAD?labpath=notebooks%2Fgetting_started.ipynb", "icon": "fa-solid fa-rocket", }, { diff --git a/docs/content/data/dynamic_characterized_inventory_gwp.svg b/docs/content/data/dynamic_characterized_inventory_gwp.svg new file mode 100644 index 0000000..65f517c --- /dev/null +++ b/docs/content/data/dynamic_characterized_inventory_gwp.svg @@ -0,0 +1,960 @@ + + + + + + + + 2024-09-03T13:14:58.495950 + image/svg+xml + + + Matplotlib v3.5.2, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/content/data/dynamic_characterized_inventory_radiative_forcing.svg b/docs/content/data/dynamic_characterized_inventory_radiative_forcing.svg new file mode 100644 index 0000000..2be7b9b --- /dev/null +++ b/docs/content/data/dynamic_characterized_inventory_radiative_forcing.svg @@ -0,0 +1,2344 @@ + + + + + + + + 2024-09-03T13:16:08.869064 + image/svg+xml + + + Matplotlib v3.5.2, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/content/data/dynamic_prospective_timeexplicit_dark.svg b/docs/content/data/dynamic_prospective_timeexplicit_dark.svg new file mode 100644 index 0000000..d85cc8e --- /dev/null +++ b/docs/content/data/dynamic_prospective_timeexplicit_dark.svg @@ -0,0 +1 @@ +time-explicitdynamicprospectiveUseUseUseEoLConstr.environmental impacts2025203020352040204520252030203520402045databases:Constr.ConstrUseEoLenvironmental impacts2025203020352040204520252030203520402045databases:UseEoLstaticprospectiveevolving production systemdatabases:UseUseUseConstr.environmental impacts2025203020352040204520252030203520402045EoL+ \ No newline at end of file diff --git a/docs/content/data/dynamic_prospective_timeexplicit_light.svg b/docs/content/data/dynamic_prospective_timeexplicit_light.svg new file mode 100644 index 0000000..e45a20b --- /dev/null +++ b/docs/content/data/dynamic_prospective_timeexplicit_light.svg @@ -0,0 +1 @@ +time-explicitdynamicprospectiveUseUseUseEoLConstr.environmental impacts2025203020352040204520252030203520402045databases:Constr.ConstrUseEoLenvironmental impacts2025203020352040204520252030203520402045databases:UseEoLstaticprospectiveevolving production systemdatabases:UseUseUseConstr.environmental impacts2025203020352040204520252030203520402045EoL+ \ No newline at end of file diff --git a/docs/content/data/matrix_stuff_dark.svg b/docs/content/data/matrix_stuff_dark.svg new file mode 100644 index 0000000..dcf75cb --- /dev/null +++ b/docs/content/data/matrix_stuff_dark.svg @@ -0,0 +1 @@ +process Aprocess Bproduct Aproduct B10-31511CO2temporalizetechnospheretemporalizebiosphereforbothtechnosphere&biosphereexchanges*sourcenewvaluesfromtime-explicitdatabases*CO2process B @ 2020process B @ 2030product A @ 2024product B @ 2020product B @ 2030process A @ 20240010011000-0.8-0.60-0.20-0.8-0.2-0.40-1.500-0.90001010-0.600010product B @ 2022product B @ 2024product B @ 2028temp. market B @ 2022temp. market B @ 2024temp. market B @ 20285711000CO2 @2022process B @ 2020process B @ 2030product A @ 2024product B @ 2020product B @ 2030process A @ 20240010011000-0.8-0.60-0.20-0.8-0.2-0.40-1.500-0.90001010-0.600010product B @ 2022product B @ 2024product B @ 2028temp. market B @ 2022temp. market B @ 2024temp. market B @ 202800010.20030009.40200000000007.8CO2 @ 2024CO2 @ 2025CO2 @ 2028 \ No newline at end of file diff --git a/docs/content/data/matrix_stuff_light.svg b/docs/content/data/matrix_stuff_light.svg new file mode 100644 index 0000000..9f3e1c3 --- /dev/null +++ b/docs/content/data/matrix_stuff_light.svg @@ -0,0 +1 @@ +process Aprocess Bproduct Aproduct B10-31511CO2temporalizetechnospheretemporalizebiosphereforbothtechnosphere&biosphereexchanges*sourcenewvaluesfromtime-explicitdatabases*CO2process B @ 2020process B @ 2030product A @ 2024product B @ 2020product B @ 2030process A @ 20240010011000-0.8-0.60-0.20-0.8-0.2-0.40-1.500-0.90001010-0.600010product B @ 2022product B @ 2024product B @ 2028temp. market B @ 2022temp. market B @ 2024temp. market B @ 20285711000CO2 @2022process B @ 2020process B @ 2030product A @ 2024product B @ 2020product B @ 2030process A @ 20240010011000-0.8-0.60-0.20-0.8-0.2-0.40-1.500-0.90001010-0.600010product B @ 2022product B @ 2024product B @ 2028temp. market B @ 2022temp. market B @ 2024temp. market B @ 202800010.20030009.40200000000007.8CO2@ 2024CO2@ 2025CO2@ 2028 \ No newline at end of file diff --git a/docs/content/data/method_small_steps_dark.svg b/docs/content/data/method_small_steps_dark.svg new file mode 100644 index 0000000..726f06b --- /dev/null +++ b/docs/content/data/method_small_steps_dark.svg @@ -0,0 +1 @@ +temporalinformationtemporalized system modelenvironmental impactsprocess timelinetime-explicitinventorystatic system modeltime-explicit databasesbuild_timeline()lci()dynamic_lcia()Step 1Step 2Step 3Step 4 \ No newline at end of file diff --git a/docs/content/data/method_small_steps_light.svg b/docs/content/data/method_small_steps_light.svg new file mode 100644 index 0000000..cf507f4 --- /dev/null +++ b/docs/content/data/method_small_steps_light.svg @@ -0,0 +1 @@ +temporalinformationtemporalized system modelenvironmental impactsprocess timelinetime-explicitinventorystatic system modeltime-explicit databasesbuild_timeline()lci()dynamic_lcia()Step 1Step 2Step 3Step 4 \ No newline at end of file diff --git a/docs/content/data/td_convoluted.svg b/docs/content/data/td_convoluted.svg new file mode 100644 index 0000000..a849cc0 --- /dev/null +++ b/docs/content/data/td_convoluted.svg @@ -0,0 +1,736 @@ + + + + + + + + 2024-09-11T11:28:46.438974 + image/svg+xml + + + Matplotlib v3.5.2, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/content/data/td_spread_over_four_months.svg b/docs/content/data/td_spread_over_four_months.svg new file mode 100644 index 0000000..31faece --- /dev/null +++ b/docs/content/data/td_spread_over_four_months.svg @@ -0,0 +1,786 @@ + + + + + + + + 2024-09-11T11:28:20.951542 + image/svg+xml + + + Matplotlib v3.5.2, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/content/data/td_two_and_four_years_ahead.svg b/docs/content/data/td_two_and_four_years_ahead.svg new file mode 100644 index 0000000..8d0ad22 --- /dev/null +++ b/docs/content/data/td_two_and_four_years_ahead.svg @@ -0,0 +1,836 @@ + + + + + + + + 2024-09-11T11:26:17.507002 + image/svg+xml + + + Matplotlib v3.5.2, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/content/examples/example_electric_vehicle_premise.ipynb b/docs/content/examples/example_electric_vehicle_premise.ipynb index d3b9931..58703e6 100644 --- a/docs/content/examples/example_electric_vehicle_premise.ipynb +++ b/docs/content/examples/example_electric_vehicle_premise.ipynb @@ -11,9 +11,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This notebook shows how to use `bw_timex` with a cradle-to-grave case study of an electric vehicle (ev). The case study is simplified, not meant to reflect the complexity of electric mobility but to demonstrate how to use `bw_timex`. \n", + "This notebook shows how to use `bw_timex` with a cradle-to-grave case study of an electric vehicle. The case study is simplified, not meant to reflect the complexity of electric mobility but to demonstrate hot to use `bw_timex`. \n", "\n", - "> **Note:** This is the \"premise\" version of this notebook that works with ecoinvent and premise data. If you don't have access to that, please check out the [\"standalone\" version](https://github.com/brightway-lca/bw_timex/blob/main/notebooks/example_electric_vehicle_standalone.ipynb) of this notebook.\n" + "More information on the inner workings of `bw_timex` can be found [here](https://timex.readthedocs.io/en/latest/content/theory.html).\n", + "\n", + "\n", + "> **Note:** This is the \"premise\" version of this notebook that works with ecoinvent and premise data. If you don't have access to that, please check out the [\"standalone\" version](https://github.com/brightway-lca/bw_timex/blob/main/notebooks/example_electric_vehicle_standalone.ipynb) of this notebook." ] }, { diff --git a/docs/content/examples/index.md b/docs/content/examples/index.md index c6cbe88..60c9b31 100644 --- a/docs/content/examples/index.md +++ b/docs/content/examples/index.md @@ -1,4 +1,4 @@ -# TimexLCA Examples +# TimexLCA Examples Here are some examples on how you can use `bw_timex`. @@ -64,6 +64,6 @@ hidden: maxdepth: 1 --- self -example_ev +example_electric_vehicle_premise example_simple_dynamic_characterization ``` diff --git a/docs/content/getting_started/adding_temporal_information.md b/docs/content/getting_started/adding_temporal_information.md new file mode 100644 index 0000000..1fdd79d --- /dev/null +++ b/docs/content/getting_started/adding_temporal_information.md @@ -0,0 +1,257 @@ +# Step 1 - Adding temporal information + +To get you started with time-explicit LCA, we'll investigate this very simple production system with two "technosphere" nodes A and B and a "biosphere" node representing some CO2 emissions. For the sake of this example, we'll assume that we demand Process A to run exactly once. +```{mermaid} +:caption: Example production system +flowchart LR +subgraph background[background] + B(Process B):::bg +end + +subgraph foreground[foreground] + A(Process A):::fg +end + +subgraph biosphere[biosphere] + CO2(CO2):::bio +end + +B-->|"3 kg \n  "|A +A-.->|"5 kg \n  "|CO2 +B-.->|"11 kg \n  "|CO2 + +classDef fg color:#222832, fill:#3fb1c5, stroke:none; +classDef bg color:#222832, fill:#3fb1c5, stroke:none; +classDef bio color:#222832, fill:#9c5ffd, stroke:none; +style background fill:none, stroke:none; +style foreground fill:none, stroke:none; +style biosphere fill:none, stroke:none; +``` + +:::{dropdown} Here's the code to set this up with brightway - but this is not essential here +:icon: codescan + +```python +import bw2data as bd + +bd.projects.set_current("getting_started_with_timex") + +bd.Database("biosphere").write( + { + ("biosphere", "CO2"): { + "type": "emission", + "name": "CO2", + }, + } +) + +bd.Database("background").write( + { + ("background", "B"): { + "name": "B", + "location": "somewhere", + "reference product": "B", + "exchanges": [ + { + "amount": 1, + "type": "production", + "input": ("background", "B"), + }, + { + "amount": 11, + "type": "biosphere", + "input": ("biosphere", "CO2"), + }, + ], + }, + } +) + +bd.Database("foreground").write( + { + ("foreground", "A"): { + "name": "A", + "location": "somewhere", + "reference product": "A", + "exchanges": [ + { + "amount": 1, + "type": "production", + "input": ("foreground", "A"), + }, + { + "amount": 3, + "type": "technosphere", + "input": ("background", "B"), + }, + { + "amount": 5, + "type": "biosphere", + "input": ("biosphere", "CO2"), + } + ], + }, + } +) + +bd.Method(("our", "method")).write( + [ + (("biosphere", "CO2"), 1), + ] +) +``` +::: + +Now, if you want to consider time in your LCA, you need to somehow add temporal information. For time-explicit LCA, we consider two kinds of temporal information, that will be discussed in the following. + +## Temporal distributions +To determine the timing of the exchanges within the production system, we add the `temporal_distribution` attribute to the respective exchanges. To carry the temporal information, we use the [`TemporalDistribution`](https://docs.brightway.dev/projects/bw-temporalis/en/stable/content/api/bw_temporalis/temporal_distribution/index.html#bw_temporalis.temporal_distribution.TemporalDistribution) class from [`bw_temporalis`](https://github.com/brightway-lca/bw_temporalis). This class is a *container for a series of amount spread over time*, so it tells you what share of an exchange happens at what point in time. So, let's include this information in out production system - visually at first: +```{mermaid} +:caption: Temporalized example production system +flowchart LR +subgraph background[" "] + B_2020(Process B):::bg +end + +subgraph foreground[" "] + A(Process A):::fg +end + +subgraph biosphere[" "] + CO2:::b +end + + B_2020-->|"amounts: [30%,50%,20%] * 3 kg\n dates:[-2,0,+4]" years|A + A-.->|"amounts: [60%, 40%] * 5 kg\n dates: [0,+1]" years|CO2 + B_2020-.->|"amounts: [100%] * 11 kg\n dates:[0]" years|CO2 + + classDef bg color:#222832, fill:#3fb1c5, stroke:none; + classDef fg color:#222832, fill:#3fb1c5, stroke:none; + classDef b color:#222832, fill:#9c5ffd, stroke:none; + style foreground fill:none, stroke:none; + style background fill:none, stroke:none; + style biosphere fill:none, stroke:none; + +``` + +Now it's time to add this information to our modeled production system in brightway: +```python +import numpy as np +from bw_temporalis import TemporalDistribution +from bw_timex.utils import add_temporal_distribution_to_exchange + +# Starting with the exchange between A and B +# First, create a TemporalDistribution with the time information from above +td_b_to_a = TemporalDistribution( + date=np.array([-2, 0, 4], dtype="timedelta64[Y]"), + amount=np.array([0.3, 0.5, 0.2]), +) + +# Now add the temporal distribution to the corresponding exchange. In +# principle, you just have to do the following: +# exchange_object["temporal_distribution"] = TemporalDistribution +# We currently don't have the exchange-object at hand here, but we can +# use the utility function add_temporal_distribution_to_exchange to help. +add_temporal_distribution_to_exchange( + temporal_distribution=td_b_to_a, + input_code="B", + input_database="background", + output_code="A", + output_database="foreground" +) + +# Now we do the same for our other temporalized exchange between A and CO2 +td_a_to_co2 = TemporalDistribution( + date=np.array([0, 1], dtype="timedelta64[Y]"), + amount=np.array([0.6, 0.4]), +) + +# We actually only have to define enough fields to uniquely identify the +# exchange here +add_temporal_distribution_to_exchange( + temporal_distribution=td_a_to_co2, + input_code="CO2", + output_code="A" +) +``` + +## Prospective data + +The other kind of temporal data we can add is some prospective information on how our processes change over time. So, for our simple example, let's say our background process B somehow evolves, so that it emitts less CO2 in the future. To make it precise, we assume that the original process we modeled above represents the process state in the year 2020, emitting 11 kg CO2, which reduces to 7 kg CO2 by 2030: + + +```{mermaid} +:caption: Temporalized example production system +flowchart LR +subgraph background[" "] + B_2020(Process B \n 2020):::bg + B_2030(Process B \n 2030):::bg +end + +subgraph foreground[" "] + A(Process A):::fg +end + +subgraph biosphere[" "] + CO2:::b +end + B_2020-->|"amounts: [30%,50%,20%] * 3 kg\n dates:[-2,0,+4]" years|A + A-.->|"amounts: [60%, 40%] * 5 kg\n dates: [0,+1]" years|CO2 + B_2020-.->|"amounts: [100%] * 11 kg\n dates:[0]" years|CO2 + B_2030-.->|"amounts: [100%] * 7 kg\n dates:[0]" years|CO2 + + classDef bg color:#222832, fill:#3fb1c5, stroke:none; + classDef fg color:#222832, fill:#3fb1c5, stroke:none; + classDef b color:#222832, fill:#9c5ffd, stroke:none; + style foreground fill:none, stroke:none; + style background fill:none, stroke:none; + style biosphere fill:none, stroke:none; + +``` + +:::{dropdown} Again, here's the code in case you're interested +:icon: codescan + +```python +bd.Database("background_2030").write( + { + ("background_2030", "B"): { + "name": "B", + "location": "somewhere", + "reference product": "B", + "exchanges": [ + { + "amount": 1, + "type": "production", + "input": ("background_2030", "B"), + }, + { + "amount": 7, + "type": "biosphere", + "input": ("biosphere", "CO2"), + }, + ], + }, + } +) +``` +::: + +So, as you can see, the prospective processes can reside within your normal brightway databases. To hand them to `bw_timex`, we just need to define a dictionary that maps the prospective database names to the point in time that they represent: + +```python +from datetime import datetime + +# Note: The foreground does not represent a specific point in time, but should +# later be dynamically distributed over time +database_date_dict = { + "background": datetime.strptime("2020", "%Y"), + "background_2030": datetime.strptime("2030", "%Y"), + "foreground": "dynamic", +} +``` + +:::{note} +You can use whatever data source you want for this prospective data. A nice package from the Brightway cosmos that can help you is [premise](https://premise.readthedocs.io/en/latest/introduction.html). +::: + diff --git a/docs/content/getting_started/build_process_timeline.md b/docs/content/getting_started/build_process_timeline.md new file mode 100644 index 0000000..650c5e0 --- /dev/null +++ b/docs/content/getting_started/build_process_timeline.md @@ -0,0 +1,29 @@ +# Step 2 - Building the process timeline + +With all the temporal information prepared, we can now instantiate our TimexLCA object. This is very similar to a normal Brightway LCA object, but with the additional argument of our `database_date_dict`: + +```python +from bw_timex import TimexLCA + +tlca = TimexLCA( + demand={("foreground", "A"): 1}, + method=("our", "method"), + database_date_dict=database_date_dict, +) +``` + +Using our new `tlca` object, we can now build the timeline of processes that leads to our functional unit, "A". If not specified otherwise, it's assumed that the demand occurs in the current year, which is 2024 at the time of writing this. Actually building the timeline is now very simple on the user-side: +```python +tlca.build_timeline() +``` + +The timeline that is returned looks like this: + +| date_producer | producer_name | date_consumer | consumer_name | amount | interpolation_weights | +|---------------|---------------|---------------|---------------|--------|------------------------------------------------| +| 2022-01-01 | B | 2024-01-01 | A | 0.9 | {'background': 0.8, 'background_2030': 0.2} | +| 2024-01-01 | B | 2024-01-01 | A | 1.5 | {'background': 0.6, 'background_2030': 0.4} | +| 2024-01-01 | A | 2024-01-01 | -1 | 1.0 | None | +| 2028-01-01 | B | 2024-01-01 | A | 0.6 | {'background': 0.2, 'background_2030': 0.8} | + +Here we can see which share of which exchange happens at what point in time. Additionally, the "interpolation_weights" already tell us what share of an exchange should come from which database. With this info, we can calculate our time-explicit LCI in the next step. \ No newline at end of file diff --git a/docs/content/getting_started/index.md b/docs/content/getting_started/index.md new file mode 100644 index 0000000..d45437c --- /dev/null +++ b/docs/content/getting_started/index.md @@ -0,0 +1,35 @@ +# Getting Started + +This section will help you quickly getting started with your time-explicit LCA project. We're keeping it simple here - no deep dives into how things work in the background, no exploring of all the features and options `bw_timex` has. Just a quick walkthrough of the different steps of a `TimexLCA`. Here's a rundown: + +```{image} ../data/method_small_steps_light.svg +:class: only-light +:height: 450px +:align: center +``` + +```{image} ../data/method_small_steps_dark.svg +:class: only-dark +:height: 450px +:align: center +``` +
+ +In the following sections, we'll walk through the steps 1-4, considering a very simple dummy system. If you directly want to look at a more complex example, take a look at our [example collection](../examples/index.md). If you're interested in the full details on how `bw_timex` works, you can also skip to our [Theory Section](../theory.md). + +```{admonition} You want more interaction? +:class: admonition-launch + +[Launch this tutorial on Binder!](https://mybinder.org/v2/gh/brightway-lca/bw_timex/HEAD?labpath=notebooks%2Fgetting_started.ipynb) In this interactive environment, you can directly run the bw_timex code yourself whilst following along. +``` + +```{toctree} +--- +hidden: +maxdepth: 1 +--- +Step 1 - Adding temporal information +Step 2 - Building the process timeline +Step 3 - Calculating the time-explicit LCI +Step 4 - Impact assessment +``` \ No newline at end of file diff --git a/docs/content/getting_started/lcia.md b/docs/content/getting_started/lcia.md new file mode 100644 index 0000000..1066f3b --- /dev/null +++ b/docs/content/getting_started/lcia.md @@ -0,0 +1,99 @@ +# Step 4 - Impact assessment +To characterize the calculated inventory, we have two options: Static and dynamic life cycle impact assessment (LCIA). + +## Static LCIA +If we don't care about the timing of the emissions, we can do static LCIA using the standard characterization factors. To characterize the inventory with the impact assessment method that we initially chose when creating our `TimexLCA` object, we can simply call: + +```python +tlca.static_lcia() +``` + +and investigate the resulting score like this: + +```python +print(tlca.static_score) +``` + +## Dynamic LCIA +The inventory calculated by a `TimexLCA` retains temporal information. That means that in addition to knowing which process emitts what substance, we also know the timing of each emission. This allows for more advanced, dynamic characterization using characterization functions instead of just factors. In `bw_timex`, users can either use their own curstom functions or use some existing ones, e.g., from the package [`dynamic_characterization`](https://dynamic-characterization.readthedocs.io/en/latest/). We'll do the latter here. + +First, we need to define which characterization function we want to apply to which biosphere flow: + +```python +from dynamic_characterization.timex import characterize_co2 +emission_id = bd.get_activity(("biosphere", "CO2")).id + +characterization_function_dict = { + emission_id: characterize_co2, +} +``` + +So, let's characterize our inventory. As a metric we choose radiative forcing, and a time horizon of 100 years: + +```python +tlca.dynamic_lcia( + metric="radiative_forcing", + time_horizon=100, + characterization_function_dict=characterization_function_dict, +) +``` + +This returns the (dynamic) characterized inventory: + +| date | amount | flow | activity | +|------------|----------------|------|----------| +| 2023-01-01 | 1.512067e-14 | 1 | 5 | +| 2024-01-01 | 1.419411e-14 | 1 | 5 | +| 2024-12-31 | 2.322610e-14 | 1 | 6 | +| 2024-12-31 | 4.941608e-15 | 1 | 7 | +| 2024-12-31 | 1.343660e-14 | 1 | 5 | +| ... | ... | ... | ... | +| 2124-01-01 | 1.400972e-15 | 1 | 7 | +| 2124-01-01 | 3.302104e-15 | 1 | 8 | +| 2124-12-31 | 3.294094e-15 | 1 | 8 | +| 2125-12-31 | 3.286213e-15 | 1 | 8 | +| 2127-01-01 | 3.278458e-15 | 1 | 8 | + +To visualize what's going on, we can conveniently plot it with: +```python +tlca.plot_dynamic_characterized_inventory() +``` +```{image} ../data/dynamic_characterized_inventory_radiative_forcing.svg +:align: center +:alt: Plot showing the radiative forcing over time +``` +
+ +Of course we can also assess the "standard" climate change metric Global Warming Potential (GWP): +```python +tlca.dynamic_lcia( + metric="GWP", + time_horizon=100, + characterization_function_dict=characterization_function_dict, +) +``` + +| date | amount | flow | activity | +|------------|-----------|------|----------| +| 2022-01-01 | 9.179606 | 1 | 5 | +| 2024-01-01 | 14.100328 | 1 | 6 | +| 2024-01-01 | 3.000000 | 1 | 7 | +| 2025-01-01 | 2.000000 | 1 | 7 | +| 2028-01-01 | 4.680263 | 1 | 8 | + +... and plot it: +```python +tlca.plot_dynamic_characterized_inventory() +``` +```{image} ../data/dynamic_characterized_inventory_gwp.svg +:align: center +:alt: Plot showing the radiative forcing over time +``` +
+ +For most of the functions we used here, there are numerous optional arguments and settings you can tweak. We explore some of them in our other [Examples](../examples/index.md), but when in doubt: Our code is pretty well documented and there are [docstrings](../api/index) everywhere - so please use them ☀️ + + + + + diff --git a/docs/content/getting_started/time_explicit_lci.md b/docs/content/getting_started/time_explicit_lci.md new file mode 100644 index 0000000..b992813 --- /dev/null +++ b/docs/content/getting_started/time_explicit_lci.md @@ -0,0 +1,11 @@ +# Step 3 - Calculating the time-explicit LCI + +Calculating the time-explicit LCI from the timeline is very simple, at least from the user perspective: + +```python +tlca.lci() +``` + +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](../theory.md#time-mapping). + +Now that the inventory is calculated, we can characterize it in the next step. \ No newline at end of file diff --git a/docs/content/installation.md b/docs/content/installation.md index 46b0597..8346245 100644 --- a/docs/content/installation.md +++ b/docs/content/installation.md @@ -3,8 +3,8 @@ `bw_timex` is a Python software package. It's available via [`pip`](https://pypi.org/project/pip/) or [`conda`](https://docs.conda.io/en/latest/) / [`mamba`](https://mamba.readthedocs.io/en/latest/). ```{note} -1) We currently recommend the installation via `conda` or `mamba`. That's what we're providing detailed instructions for below. -2) bw_timex depends on Brightway25, and will install bw25-compatible versions of the bw packages. This means that it cannot be added to existing virtual environments that are based on Brightway2, e.g. virtual environments containing activity browser. Please install bw_timex in a separate virtual environment following the instructions below. +1) We recommend installation via `conda` or `mamba`. +2) bw_timex depends on Brightway25, and will install bw25-compatible versions of the bw packages. This means that it cannot be added to existing virtual environments that are based on Brightway2, e.g., environments containing [Activity Browser](https://github.com/LCA-ActivityBrowser/activity-browser). Please install bw_timex in a separate environment following the instructions below. ``` ## Installing `bw_timex` using `conda` or `mamba` diff --git a/docs/content/theory.md b/docs/content/theory.md index a9db6f9..fcee16b 100644 --- a/docs/content/theory.md +++ b/docs/content/theory.md @@ -1,33 +1,28 @@ # Theory -This section explains some of the theory behind `bw_timex`. Check out -the flow chart below for a quick overview of how it all comes together, -and you\'ll find more detailed explanations of each step in the -following subsections. +This section explains some of the theory behind time-explicit LCAs with `bw_timex`. In contrast to the [Getting Started section](getting_started/index.md), we explain a bit more of what`s going on in the background here. If this is still to vague for you, you can always check out our [API reference](api/index). -```{image} data/method_light.svg -:class: only-light -:height: 450px -:align: center -``` +## Terminology +LCA terminology can be confusing sometimes. Here's an attempt of visualizing what we mean with "time-explicit LCA". Essentially, it combines dynamic LCA, where processes are spread out over time, with prospective LCA, where processes change over time: -```{image} data/method_dark.svg +```{image} data/dynamic_prospective_timeexplicit_dark.svg :class: only-dark -:height: 450px -:align: center +``` +```{image} data/dynamic_prospective_timeexplicit_light.svg +:class: only-light ``` -## User input +## Data requirements -`bw_timex` requires 3 inputs: +For a time-explicit LCA, 3 inputs are required: 1. a static foreground system model with 2. temporal information using the attribute `temporal_distribution` on - technosphere or biosphere exchanges in the foreground system modeel, + technosphere or biosphere exchanges in the foreground system model, and 3. a set of background databases, which must have a reference in time. -```{dropdown} ℹ️ More info on inputs +```{note} - The foreground system must have exchanges linked to one of the background databases. These exchanges at the intersection between foreground and background databases will be relinked by `bw_timex`. @@ -42,15 +37,69 @@ following subsections. the consuming process is adopted also for the producing process. ``` -## Graph traversal +## Temporal distributions and graph traversal +To determine the timing of the exchanges within the production system, we add the `temporal_distribution` attribute to the respective exchanges. To carry the temporal information, we use the [`TemporalDistribution`](https://docs.brightway.dev/projects/bw-temporalis/en/stable/content/api/bw_temporalis/temporal_distribution/index.html#bw_temporalis.temporal_distribution.TemporalDistribution) class from [`bw_temporalis`](https://github.com/brightway-lca/bw_temporalis). This class is a *container for a series of amount spread over time*, so it tells you what share of an exchange happens at what point in time. If two consecutive edges in the supply chain graph carry a `TemporalDistribution`, they are [convoluted](https://en.wikipedia.org/wiki/Convolution). + +````{admonition} Example: Convolution +:class: admonition-example + +Let's say we have two temporal distributions. The first dates 30% of some amount two years into the future, and 70% of that amount four years into the future: + +```python +import numpy as np +from bw_temporalis import TemporalDistribution + +two_and_four_years_ahead = TemporalDistribution( + date=np.array([2, 4], dtype="timedelta64[Y]"), + amount=np.array([0.3, 0.7]) +) + +two_and_four_years_ahead.graph(resolution="Y") +``` +~~~{image} data/td_two_and_four_years_ahead.svg +:align: center +~~~ + +
+ +The other distribution spreads an amount over the following 4 months, with decreasing shares: +```python +spread_over_four_months = TemporalDistribution( + date=np.array([0, 1, 2, 3], dtype="timedelta64[M]"), + amount=np.array([0.4, 0.3, 0.2, 0.1]) +) + +spread_over_four_months.graph(resolution="M") +``` +~~~{image} data/td_spread_over_four_months.svg +:align: center +~~~ + +
+ +Now let's see what happens when we convolute these temporal distributions: +```python +convoluted_distribution = two_and_four_years_ahead * spread_over_four_months -`bw_timex` uses the graph traversal from -[bw_temporalis](https://github.com/brightway-lca/bw_temporalis/tree/main) -to propagate the temporal information along the supply chain. The graph -traversal is priority-first, following the most impactful node in the -graph based on the static pre-calculated LCIA score for a chosen impact -category. All input arguments for the graph traversal, such as maximum -calculation count or cut-off, can be passed to the `TimexLCA` instance. +convoluted_distribution.graph(resolution="M") +``` +~~~{image} data/td_convoluted.svg +:align: center +~~~ + +
+ +Note how both the dates and the amounts get scaled. +```` + +To convolute all the temporal information from the supply chain graph, `bw_timex` uses the graph traversal from +[bw_temporalis](https://github.com/brightway-lca/bw_temporalis/tree/main). An in-depth +description of how this works is available in the [brightway-docs](https://docs.brightway.dev/en/latest/content/theory/graph_traversal.html). In short, +it is a priority-first supply chain graph traversal, following the most +impactful node in the graph based on the static pre-calculated LCIA score +for a chosen impact category. Several input arguments for the graph traversal, +such as maximum calculation count or cut-off, can be passed to the `TimexLCA` +instance. By default, only the foreground system is traversed, but nodes to be skipped during traversal can be specified by a `edge_filter_function`. @@ -59,7 +108,7 @@ temporal distributions of the process and the exchange it consumes into the resoluting combined temporal distribution of the upstream producer of the exchange. -## Process timeline +## Building the process timeline The graph traversal returns a timeline that lists the time of each technosphere exchange in the temporalized foreground system. Exchanges @@ -71,31 +120,49 @@ resolutions down to seconds while one may not have a similar temporal resolution for the databases. We recommend aligning `temporal_grouping` to the temporal resolution of the available databases. -> Let\'s consider the following system: a process A that consumes an -> exchange b from a process B, which emits an emission X and both the -> exchange b and the emission X occur at a certain point in time. -> -> ```{image} data/example_ab_light.svg -> :class: only-light -> :height: 300px -> :align: center -> ``` -> -> ```{image} data/example_ab_dark.svg -> :class: only-dark -> :height: 300px -> :align: center -> ``` -> | -> -> The resulting timeline looks like this: -> -> | time | producer | consumer | amount | -> |------|----------|----------|-----------------| -> | 0 | A | n/a | 1 | -> | 0 | B | A | 2 \* 0.2 = 0.4 | -> | 1 | B | A | 2 \* 0.8 = 1.6 | +````{admonition} Example: Timeline +:class: admonition-example + +Let's consider the following system: a process A that consumes an +exchange b from a process B, which emits an emission X and both the +exchange b and the emission X occur at a certain point in time. +```{mermaid} +flowchart LR +subgraph background[" "] + B_2020(Process B \n 2020):::bg + B_2030(Process B \n 2030):::bg +end + +subgraph foreground[" "] + A(Process A):::fg +end + +subgraph biosphere[" "] + CO2:::b +end + +B_2020-->|"amounts: [30%,50%,20%] * 3 kg\n dates:[-2,0,+4]" years|A +A-.->|"amounts: [60%, 40%] * 5 kg\n dates: [0,+1]" years|CO2 +B_2020-.->|"amounts: [100%] * 11 kg\n dates:[0]" years|CO2 +B_2030-.->|"amounts: [100%] * 7 kg\n dates:[0]" years|CO2 + +classDef bg color:#222832, fill:#3fb1c5, stroke:none; +classDef fg color:#222832, fill:#3fb1c5, stroke:none; +classDef b color:#222832, fill:#9c5ffd, stroke:none; +style foreground fill:none, stroke:none; +style background fill:none, stroke:none; +style biosphere fill:none, stroke:none; + +``` +The resulting timeline looks like this: +| date_producer | producer_name | date_consumer | consumer_name | amount | interpolation_weights | +|---------------|---------------|---------------|---------------|--------|------------------------------------------------| +| 2022-01-01 | B | 2024-01-01 | A | 0.9 | {'background': 0.8, 'background_2030': 0.2} | +| 2024-01-01 | B | 2024-01-01 | A | 1.5 | {'background': 0.6, 'background_2030': 0.4} | +| 2024-01-01 | A | 2024-01-01 | -1 | 1.0 | None | +| 2028-01-01 | B | 2024-01-01 | A | 0.6 | {'background': 0.2, 'background_2030': 0.8} | +```` ## Time mapping @@ -107,13 +174,13 @@ databases based on temporal proximity. The new best-fitting background producer(s) are mapped on the same name, reference product and location as the old background producer. -## Modified matrices +## Modifying the matrices `bw_timex` now modifies the technopshere and biosphere matrices using `datapackages` from [bw_processing](https://github.com/brightway-lca/bw_processing?tab=readme-ov-file). -### Technosphere matrix modifications: +### Technosphere matrix modifications 1. For each temporalized process in the timeline, a new process copy is created, which links to its new temporalized producers and @@ -124,7 +191,7 @@ as the old background producer. relinks the exchanges to the new producing processes from the best-fitting background database(s). -### Biosphere matrix modifications: +### Biosphere matrix modifications Depending on the user\'s choice, two different biosphere matrices are created: @@ -143,20 +210,19 @@ created: `TimexLCA.dynamic_inventory_df` contain the emissions of the system per biosphere flow including its timestamp and its emitting process. -> For the simple system above, a schematic representation of the matrix -> modifications looks like this: -> -> ```{image} data/matrix_light.svg -> :class: only-light -> :height: 300px -> :align: center -> ``` -> -> ```{image} data/matrix_dark.svg -> :class: only-dark -> :height: 300px -> :align: center -> ``` +```{admonition} Example: Matrix modifications +:class: admonition-example +For the simple system above, a schematic representation of the matrix +modifications looks like this: +~~~{image} data/matrix_stuff_light.svg +:class: only-light +:align: center +~~~ +~~~{image} data/matrix_stuff_dark.svg +:class: only-dark +:align: center +~~~ +``` ## Static or dynamic impact assessment @@ -181,9 +247,3 @@ horizon means that each emission is evaluated starting from its own timing until the end of the time horizon. The former is the approach of [Levasseur et al. 2010](https://pubs.acs.org/doi/10.1021/es9030003). This behaviour is set with the boolean `fixed_time_horizon`. - -```{note} -*Work in progress*. `bw_timex` *is under active development and the -theory section might not reflect the latest code development. When in -doubt, the source code is the most reliable source of information.* -``` diff --git a/docs/index.md b/docs/index.md index c1df594..dbd1320 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,6 +1,6 @@ # Time-explicit LCA with `bw_timex` -[bw_timex](https://github.com/brightway-lca/bw_timex) is a python package for time-explicit Life Cycle Assessment that helps you assess the environmental impacts of products and processes over time. `bw_timex` builds on top of the [Brightway LCA framework](https://docs.brightway.dev/en/latest). +`bw_timex` is a python package for [time-explicit Life Cycle Assessment](content/theory.md#terminology) that helps you assess the environmental impacts of products and processes over time. `bw_timex` builds on top of the [Brightway LCA framework](https://docs.brightway.dev/en/latest). ## Features This package enables you to account for: @@ -16,15 +16,6 @@ You can define temporal distributions for process and emission exchanges, which - **Long-lived** products - **Biogenic** carbon -Here's a visualization of what `bw_timex` can do for you: - -```{image} content/data/timex_dark.svg -:class: only-dark -``` -```{image} content/data/timex_light.svg -:class: only-light -``` - ## Support If you have any questions or need help, do not hesitate to contact us: - Timo Diepers ([timo.diepers@ltt.rwth-aachen.de](mailto:timo.diepers@ltt.rwth-aachen.de)) @@ -37,8 +28,9 @@ hidden: maxdepth: 1 --- Installation -Examples +Getting Started Theory +Examples API Contributing Code of Conduct diff --git a/notebooks/data/method.svg b/notebooks/data/method.svg new file mode 100644 index 0000000..cf507f4 --- /dev/null +++ b/notebooks/data/method.svg @@ -0,0 +1 @@ +temporalinformationtemporalized system modelenvironmental impactsprocess timelinetime-explicitinventorystatic system modeltime-explicit databasesbuild_timeline()lci()dynamic_lcia()Step 1Step 2Step 3Step 4 \ No newline at end of file diff --git a/notebooks/getting_started.ipynb b/notebooks/getting_started.ipynb new file mode 100644 index 0000000..52cd41f --- /dev/null +++ b/notebooks/getting_started.ipynb @@ -0,0 +1,1072 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Getting Started with `bw_timex`\n", + "\n", + "This notebook will help you quickly getting started with your time-explicit LCA project. We're keeping it simple here - no deep dives into how things work in the background, no exploring of all the features and options `bw_timex` has. Just a quick walkthrough of the different steps of a `TimexLCA`. Here's a rundown:\n", + "\n", + "
\n", + " \n", + "
\n", + "\n", + "In the following sections, we'll walk through the steps 1-4, considering a very simple dummy system.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1 - Adding temporal information\n", + "\n", + "To get you started with time-explicit LCA, we'll investigate this very simple production system with two \"technosphere\" nodes A and B and a \"biosphere\" node representing some CO2 emissions. For the sake of this example, we'll assume that we demand Process A to run exactly once.\n", + "\n", + "```mermaid\n", + "flowchart LR\n", + "subgraph background[background]\n", + " B(Process B):::bg\n", + "end\n", + "\n", + "subgraph foreground[foreground]\n", + " A(Process A):::fg\n", + "end\n", + "\n", + "subgraph biosphere[biosphere]\n", + " CO2(CO2):::bio\n", + "end\n", + "\n", + "B-->|\"3 kg \\n  \"|A\n", + "A-.->|\"5 kg \\n  \"|CO2\n", + "B-.->|\"11 kg \\n  \"|CO2\n", + "\n", + "classDef fg color:#222832, fill:#3fb1c5, stroke:none;\n", + "classDef bg color:#222832, fill:#3fb1c5, stroke:none;\n", + "classDef bio color:#222832, fill:#9c5ffd, stroke:none;\n", + "style background fill:none, stroke:none;\n", + "style foreground fill:none, stroke:none;\n", + "style biosphere fill:none, stroke:none;\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "First, we need to model this production system - so far only \"normal\" brightway stuff:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1/1 [00:00<00:00, 5652.70it/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, 22795.13it/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, 20460.02it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vacuuming database \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import bw2data as bd\n", + "\n", + "bd.projects.set_current(\"getting_started_with_timex\")\n", + "\n", + "bd.Database(\"biosphere\").write(\n", + " {\n", + " (\"biosphere\", \"CO2\"): {\n", + " \"type\": \"emission\",\n", + " \"name\": \"CO2\",\n", + " },\n", + " }\n", + ")\n", + "\n", + "bd.Database(\"background\").write(\n", + " {\n", + " (\"background\", \"B\"): {\n", + " \"name\": \"B\",\n", + " \"location\": \"somewhere\",\n", + " \"reference product\": \"B\",\n", + " \"exchanges\": [\n", + " {\n", + " \"amount\": 1,\n", + " \"type\": \"production\",\n", + " \"input\": (\"background\", \"B\"),\n", + " },\n", + " {\n", + " \"amount\": 11,\n", + " \"type\": \"biosphere\",\n", + " \"input\": (\"biosphere\", \"CO2\"),\n", + " },\n", + " ],\n", + " },\n", + " }\n", + ")\n", + "\n", + "bd.Database(\"foreground\").write(\n", + " {\n", + " (\"foreground\", \"A\"): {\n", + " \"name\": \"A\",\n", + " \"location\": \"somewhere\",\n", + " \"reference product\": \"A\",\n", + " \"exchanges\": [\n", + " {\n", + " \"amount\": 1,\n", + " \"type\": \"production\",\n", + " \"input\": (\"foreground\", \"A\"),\n", + " },\n", + " {\n", + " \"amount\": 3,\n", + " \"type\": \"technosphere\",\n", + " \"input\": (\"background\", \"B\"),\n", + " },\n", + " {\n", + " \"amount\": 5,\n", + " \"type\": \"biosphere\",\n", + " \"input\": (\"biosphere\", \"CO2\"),\n", + " }\n", + " ],\n", + " },\n", + " }\n", + ")\n", + "\n", + "bd.Method((\"our\", \"method\")).write(\n", + " [\n", + " ((\"biosphere\", \"CO2\"), 1),\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, if you want to consider time in your LCA, you need to somehow add temporal information. For time-explicit LCA, we consider two kinds of temporal information, that will be discussed in the following." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Temporal distributions\n", + "\n", + "To determine the timing of the exchanges within the production system, we add the `temporal_distribution` attribute to the respective exchanges. To carry the temporal information, we use the [`TemporalDistribution`](https://docs.brightway.dev/projects/bw-temporalis/en/stable/content/api/bw_temporalis/temporal_distribution/index.html#bw_temporalis.temporal_distribution.TemporalDistribution) class from [`bw_temporalis`](https://github.com/brightway-lca/bw_temporalis). This class is a *container for a series of amount spread over time*, so it tells you what share of an exchange happens at what point in time. So, let's include this information in out production system - visually at first:\n", + "\n", + "```mermaid\n", + "flowchart LR\n", + "subgraph background[\" \"]\n", + " B_2020(Process B):::bg\n", + "end\n", + "\n", + "subgraph foreground[\" \"]\n", + " A(Process A):::fg\n", + "end\n", + "\n", + "subgraph biosphere[\" \"]\n", + " 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", + "\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", + "Now it's time to add this information to our modeled production system in brightway:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from bw_temporalis import TemporalDistribution\n", + "from bw_timex.utils import add_temporal_distribution_to_exchange\n", + "\n", + "# Starting with the exchange between A and B\n", + "# First, create a TemporalDistribution with the time information from above\n", + "td_b_to_a = TemporalDistribution(\n", + " date=np.array([-2, 0, 4], dtype=\"timedelta64[Y]\"),\n", + " amount=np.array([0.3, 0.5, 0.2]),\n", + ")\n", + "\n", + "# Now add the temporal distribution to the corresponding exchange. In \n", + "# principle, you just have to do the following:\n", + "# exchange_object[\"temporal_distribution\"] = TemporalDistribution \n", + "# We currently don't have the exchange-object at hand here, but we can \n", + "# use the utility function add_temporal_distribution_to_exchange to help.\n", + "add_temporal_distribution_to_exchange(\n", + " temporal_distribution=td_b_to_a, \n", + " input_code=\"B\", \n", + " input_database=\"background\",\n", + " output_code=\"A\",\n", + " output_database=\"foreground\"\n", + ")\n", + "\n", + "# Now we do the same for our other temporalized exchange between A and CO2\n", + "td_a_to_co2 = TemporalDistribution(\n", + " date=np.array([0, 1], dtype=\"timedelta64[Y]\"),\n", + " amount=np.array([0.6, 0.4]),\n", + ")\n", + "\n", + "# We actually only have to define enough fields to uniquely identify the \n", + "# exchange here\n", + "add_temporal_distribution_to_exchange(\n", + " temporal_distribution=td_a_to_co2, \n", + " input_code=\"CO2\", \n", + " output_code=\"A\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prospective data\n", + "\n", + "The other kind of temporal data we can add is some prospective information on how our processes change over time. So, for our simple example, let's say our background process B somehow evolves, so that it emitts less CO2 in the future. To make it precise, we assume that the original process we modeled above represents the process state in the year 2020, emitting 11 kg CO2, which reduces to 7 kg CO2 by 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:::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" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "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, 14513.16it/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": "code", + "execution_count": 6, + "metadata": {}, + "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, 17476.27it/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": [ + "So, as you can see, the prospective processes can reside within your normal brightway databases. To hand them to `bw_timex`, we just need to define a dictionary that maps the prospective database names to the point in time that they represent:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime\n", + "\n", + "# Note: The foreground does not represent a specific point in time, but should \n", + "# later be dynamically distributed over time\n", + "database_date_dict = {\n", + " \"background\": datetime.strptime(\"2020\", \"%Y\"),\n", + " \"background_2030\": datetime.strptime(\"2030\", \"%Y\"),\n", + " \"foreground\": \"dynamic\",\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> **Note:** You can use whatever data source you want for this prospective data. A nice package from the Brightway cosmos that can help you is [premise](https://premise.readthedocs.io/en/latest/introduction.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2 - Building the process timeline \n", + "\n", + "With all the temporal information prepared, we can now instantiate our TimexLCA object. This is very similar to a normal Brightway LCA object, but with the additional argument of our `database_date_dict`:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from bw_timex import TimexLCA\n", + "\n", + "tlca = TimexLCA(\n", + " demand={(\"foreground\", \"A\"): 1},\n", + " method=(\"our\", \"method\"),\n", + " database_date_dict=database_date_dict,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using our new `tlca` object, we can now build the timeline of processes that leads to our functional unit, \"A\". If not specified otherwise, it's assumed that the demand occurs in the current year, which is 2024 at the time of writing this. Actually building the timeline is now very simple on the user-side:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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:195: UserWarning: No edge filter function provided. Skipping all edges within background databases.\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", + " \n", + " \n", + " \n", + "
date_producerproducer_namedate_consumerconsumer_nameamountinterpolation_weights
02022-01-01B2024-01-01A0.9{'background': 0.7998905009581166, 'background...
12024-01-01B2024-01-01A1.5{'background': 0.6000547495209416, 'background...
22024-01-01A2024-01-01-11.0None
32028-01-01B2024-01-01A0.6{'background': 0.20010949904188335, 'backgroun...
\n", + "
" + ], + "text/plain": [ + " date_producer producer_name date_consumer consumer_name amount \\\n", + "0 2022-01-01 B 2024-01-01 A 0.9 \n", + "1 2024-01-01 B 2024-01-01 A 1.5 \n", + "2 2024-01-01 A 2024-01-01 -1 1.0 \n", + "3 2028-01-01 B 2024-01-01 A 0.6 \n", + "\n", + " interpolation_weights \n", + "0 {'background': 0.7998905009581166, 'background... \n", + "1 {'background': 0.6000547495209416, 'background... \n", + "2 None \n", + "3 {'background': 0.20010949904188335, 'backgroun... " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tlca.build_timeline()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calling this directly returned the `tlca.timeline` dataframe. Here we can see which share of which exchange happens at what point in time. Additionally, the \"interpolation_weights\" already tell us what share of an exchange should come from which database. With this info, we can calculate our time-explicit LCI in the next step." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3 - Calculating the time-explicit LCI\n", + "\n", + "Calculating the time-explicit LCI from the timeline is very simple, at least from the user perspective:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/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" + ] + } + ], + "source": [ + "tlca.lci()" + ] + }, + { + "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.\n", + "\n", + "Now that the inventory is calculated, we can characterize it in the next step." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "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 the standard characterization factors. To characterize the inventory with the impact assessment method that we initially chose when creating our `TimexLCA` object, we can simply call:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "tlca.static_lcia()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "and investigate the resulting score like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "32.96019709827539" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tlca.static_score" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dynamic LCIA\n", + "\n", + "The inventory calculated by a `TimexLCA` retains temporal information. That means that in addition to knowing which process emitts what substance, we also know the timing of each emission. This allows for more advanced, dynamic characterization using characterization functions instead of just factors. In `bw_timex`, users can either use their own curstom functions or use some existing ones, e.g., from the package [`dynamic_characterization`](https://dynamic-characterization.readthedocs.io/en/latest/). We'll do the latter here. \n", + "\n", + "First, we need to define which characterization function we want to apply to which biosphere flow:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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", + " co2: characterize_co2,\n", + " ch4: characterize_ch4,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So, let's characterize our inventory. As a metric we choose radiative forcing, and a time horizon of 100 years:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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-1415
12024-01-01 11:38:241.419411e-1415
22024-12-31 05:49:122.322610e-1416
32024-12-31 05:49:124.941608e-1517
42024-12-31 17:27:361.343660e-1415
...............
4902124-01-01 06:00:001.400972e-1517
4912124-01-01 06:43:123.302104e-1518
4922124-12-31 12:32:243.294094e-1518
4932125-12-31 18:21:363.286213e-1518
4942127-01-01 00:10:483.278458e-1518
\n", + "

495 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " date amount flow activity\n", + "0 2023-01-01 05:49:12 1.512067e-14 1 5\n", + "1 2024-01-01 11:38:24 1.419411e-14 1 5\n", + "2 2024-12-31 05:49:12 2.322610e-14 1 6\n", + "3 2024-12-31 05:49:12 4.941608e-15 1 7\n", + "4 2024-12-31 17:27:36 1.343660e-14 1 5\n", + ".. ... ... ... ...\n", + "490 2124-01-01 06:00:00 1.400972e-15 1 7\n", + "491 2124-01-01 06:43:12 3.302104e-15 1 8\n", + "492 2124-12-31 12:32:24 3.294094e-15 1 8\n", + "493 2125-12-31 18:21:36 3.286213e-15 1 8\n", + "494 2127-01-01 00:10:48 3.278458e-15 1 8\n", + "\n", + "[495 rows x 4 columns]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tlca.dynamic_lcia(\n", + " metric=\"radiative_forcing\",\n", + " time_horizon=100,\n", + " characterization_function_dict=characterization_function_dict,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize what's going on, we can conveniently plot it with:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIQAAAIcCAYAAACHN3UiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hc1Z3/8feZomkadbnLFfeGK9U2Nth0QiBZ0khIsmTTCaSSTd30tsvukk02uwR+6SRL6L0bYwOuGPeCe7d612jm/P44kkZjzchgZFnl83oeP9bce+feI3ksjT73e77HWGstIiIiIiIiIiLSb3jO9ABERERERERERKR7KRASEREREREREelnFAiJiIiIiIiIiPQzCoRERERERERERPoZBUIiIiIiIiIiIv2MAiERERERERERkX5GgZCIiIiIiIiISD+jQEhEREREREREpJ9RICQiIiIiIiIi0s8oEBIRERERERER6Wf6dSC0dOlSrr76aoYMGYIxhgceeKBHXe+f/umfMMZwxx13nNZxiYiIiIiIiEj/0q8DodraWqZPn86dd97Z4673wAMP8OqrrzJkyJBuGJmIiIiIiIiI9Ce+Mz2AM+nyyy/n8ssvz7i/qamJb3zjG/zxj3+koqKCKVOm8JOf/ISLLrrotFyv1YEDB/jsZz/Lk08+yZVXXnlK1xIRERERERERyaRfB0In89GPfpTdu3fzl7/8hSFDhnD//fdz2WWX8cYbbzB27NjTcs1EIsGNN97Il7/8ZSZPnnxariEiIiIiIiIi/Vu/njLWmZ07d/LnP/+Zv/3tb8ybN48xY8bwpS99iQsvvJC77777tF33Jz/5CT6fj89//vOn7RoiIiIiIiIi0r+pQiiDNWvWYK1l3LhxKdsbGxspLCwEYPfu3YwaNarT83zmM595yz2KVq9ezb//+7+zZs0ajDGnNnARERERERERkZNQIJRBIpHA6/WyevVqvF5vyr7s7GwAhg4dyubNmzs9T35+/lu+5ksvvcTRo0cZPnx427Z4PM4Xv/hF7rjjDnbv3v3WPwERERERERERkQwUCGUwY8YM4vE4R48eZd68eWmP8fv9TJgwocuueeONN3LJJZekbLv00ku58cYb+ehHP9pl1xERERERERGR/q1fB0I1NTXs2LGj7fGuXbtYt24dBQUFjBs3jg9+8IN8+MMf5he/+AUzZszg+PHjPPfcc0ydOpUrrriiS683fPhwCgsL26ajtfL7/QwaNIjx48ef+icqIiIiIiIiItJOvw6EVq1axcKFC9se33bbbQB85CMf4Z577uHuu+/m+9//Pl/84hc5cOAAhYWFnHfeeacUBr2V64mIiIiIiIiIdAdjrbVnehAiIiIiIiIiItJ9tOy8iIiIiIiIiEg/o0BIRERERERERKSf6Xc9hBKJBAcPHiQajWKMOdPDERERERERERHpEtZaqqurGTJkCB5P5zVA/S4QOnjwICUlJWd6GCIiIiIiIiIip8W+ffsYNmxYp8f0u0AoGo0C7ouTk5PTJeeMxWI89dRTLFmyBL/f3yXnFOnp9LqX/kive+lv9JqX/kive+mP9LrvO6qqqigpKWnLPjrT7wKh1mliOTk5XRoIhcNhcnJy9J9H+g297qU/0ute+hu95qU/0ute+iO97vuet9IiR02lRURERERERET6GQVCIiIiIiIiIiL9jAIhEREREREREZF+pt/1EBIRERERERGRvslaS3NzM/F4/EwP5bTx+/14vd53fB4FQiIiIiIiIiLS6zU1NXHo0CHq6urO9FBOK2MMw4YNIzs7+x2dR4GQiIiIiIiIiPRqiUSCXbt24fV6GTJkCFlZWW9ppa3exlrLsWPH2L9/P2PHjn1HlUIKhERERERERESkV2tqaiKRSFBSUkI4HD7TwzmtiouL2b17N7FY7B0FQmoqLSIiIiIiIiJ9gsfT92OOrqp86vtfKRERERERERERSaFASERERERERESkn1EgJCIiIiIiIiLSzygQEhERERERERE5g5YvX47X6+Wyyy7rtmsqEBIRERERERERAeLWsvZ4Jc/uP8ba45XEre2W6/72t7/lc5/7HMuWLWPv3r3dck0tO9+PNdZZGqqgrgKyQhDMgUh+13QrFxEREREREelNlh4s5T837OJYQ1PbtuJgFp+bMor5QwpP23Vra2v561//ysqVKzl8+DD33HMP3/rWt07b9VqpQqifqquwrPi95f9utzz2Y8sD37Y8+kNL+YHuST9FREREREREeoqlB0v51qqtKWEQwLGGJr61aitLD5aetmvfe++9jB8/nvHjx/OhD32Iu+++G9sNlUkKhPqheMyy4UnLzhVAu9dY9TF4/KeWmjKFQiIiIiIiItI/xK3lPzfs6vSYOzfsOm3Tx+666y4+9KEPAXDZZZdRU1PDs88+e1qu1Z4CoX6orhI2Z3ht1VdC5aHuHY+IiIiIiIjImbK+tKpDZdCJjjY0sb60qsuvvXXrVl577TXe9773AeDz+bjhhhv47W9/2+XXOpF6CPVD8SZo7uS1Xn0UmNxtwxERERERERE5Y8pOEga93ePejrvuuovm5maGDh3ats1ai9/vp7y8nPz8/C6/ZitVCPVDvgBkhTPvzxvSfWMREREREREROZMKglldetxb1dzczO9+9zt+8YtfsG7durY/r7/+OiNGjOCPf/xjl17vRAqE+qFwHky9PP2+aDFEB3TrcERERERERETOmGmFORSfJOwZEMxiWmFOl173kUceoby8nI9//ONMmTIl5c973vMe7rrrri693okUCPVDHq9h/ALD1CvA027SYPEYuOzLRkvPi4iIiIiISL/hNYbPTRnV6TGfnTIKr+na35XvuusuLrnkEnJzczvsu/7661m3bh1r1qzp0mu2px5C/VQoxzDzWpiwEJpqwZcFwSgEowqDREREREREpH+ZP6SQf5k9nv/csCulwfSAYBafnTKK+UMKu/yaDz/8cMZ9M2fOPO1LzysQ6sd8WYacYqD4TI9ERERERERE5MyaP6SQCwYXsL60irKGJgpapol1dWVQT6FASEREREREREQEN31sRlHHKVx9kXoIiYiIiIiIiIj0MwqERERERERERET6GQVCIiIiIiIiIiL9jAIhEREREREREZF+RoGQiIiIiIiIiEg/o0BIRERERERERKSfUSAkIiIiIiIiItLPKBASEREREREREelnFAiJiIiIiIiIiJwhN910E8aYtj+FhYVcdtllrF+//rReV4GQiIiIiIiIiAiQSFgObbbsfMX9nUjYbrnuZZddxqFDhzh06BDPPvssPp+Pq6666rRe03dazy4iIiIiIiIi0gvsXmV55Y+W2vLktkg+nPtBGDnbnNZrBwIBBg0aBMCgQYP46le/yvz58zl27BjFxcWn5ZqqEBIRERERERGRfm33Ksuzd6aGQQC15fDsnZbdq7qnUgigpqaGP/7xj5x11lkUFhaetuuoQkhERERERERE+q1EwlUGdeaVP1mGzwSP5/RUCj3yyCNkZ2cDUFtby+DBg3nkkUfweE5fHY8qhERERERERESk3zqylQ6VQSeqLXPHnS4LFy5k3bp1rFu3jldffZUlS5Zw+eWXs2fPntN2TVUIiYiIiIiIiEi/VVfZtcedikgkwllnndX2eNasWeTm5vI///M/fP/73z8t11SFkIiIiIiIiIj0W+Hcrj2uKxhj8Hg81NfXn7ZrqEJIOmWtpa4C6qvANkMwB0K54Ms6vR3WRURERERERLrDwPFuNbHOpo1FCtxxp0tjYyOHDx8GoLy8nDvvvJOamhquvvrq03ZNBUKSUSJuOb7bdVSva/mP4fXDzHfDuPkQzFYoJCIiIiIiIr2bx2M494Pud99Mzv2AOW0NpQGeeOIJBg8eDEA0GmXChAn87W9/46KLLjpt11QgJBnVlMJjP7HEm5Lb4jFY+VfIGQgjZ525sYmIiIiIiIh0lZGzDRd/Fl75Y+rS85ECFwaNnH36wqB77rmHe+6557SdPxMFQpLR3nWpYVB7a/5uGTgWQjmqEhIREREREZHeb+Rsw/CZbjWxukrXM2jg+NO31PyZpkBIMjr2ZuZ9lUcg0dx9YxERERERERE53Twew+CJZ3oU3UOrjElGA8Zk3pc7CDyKE0VERERERER6JQVCktHw6QZfVvp9s643mi4mIiIiIiIi0kspEJKMIoVwxdcMkYLkNm8WnPN+w8CxZ25cIiIiIiIiIulYm3mlsL6iqz5HTfqRjDxeQ/FouPqb0FDtegYFc1xjLa9f1UEiIiIiIiLSM/j9fgDq6uoIhUJneDSnV1OTW/3J6/W+o/MoEJKTiuQbIvlnehQiIiIiIiIi6Xm9XvLy8jh69CgA4XAYY/peIUMikeDYsWOEw2F8vncW6SgQEhEREREREZFeb9CgQQBtoVBf5fF4GD58+DsOvBQIiYiIiIiIiEivZ4xh8ODBDBgwgFgsdqaHc9pkZWXh8bzzltAKhERERERERESkz/B6ve+4v05/oFXGRERERERERET6GQVCIiIiIiIiIiL9jAIhEREREREREZF+RoGQiIiIiIiIiEg/o0BIRERERERERKSfUSAkIiIiIiIiItLPKBASEREREREREelnFAiJiIiIiIiIiPQzCoRERERERERERPoZ35kegPQN8ZilrhJi9eDNgmAUAmFzpoclIiIiIiIiImkoEJJ3rL7KsuV5y/pHobkJMFAyHc6/EbILFQqJiIiIiIiI9DSaMibvSDxu2bbUsub+ljAIwMK+dfD0v1vqKu2ZHJ6IiIiIiIiIpKFASN6R+gp4/dH0+8r2Qm1ptw5HRERERERERN4CBULyjsQaXN+gTCoOd99YREREREREROStUSAk74gvCzzezPuzC7pvLCIiIiIiIiLy1igQknckmANjzku/L5QL0QHdOx4REREREREROTkFQvKO+AOGWdcbhkxK3R7Oh8u+bMgu0CpjIiIiIiIiIj2Nlp2XdyySb1j4KairhOqjrmoouwAiCoNEREREREREeiQFQtIlglFDMAoFw870SERERERERETkZDRlTERERERERESkn1EgJCIiIiIiIiLSzygQEhERERERERHpZ85oIPSjH/2IOXPmEI1GGTBgANdeey1bt2496fNefPFFZs2aRTAYZPTo0fz617/uhtGKiIiIiIiIiPQNZzQQevHFF/nMZz7DK6+8wtNPP01zczNLliyhtrY243N27drFFVdcwbx581i7di1f//rX+fznP899993XjSMXEREREREREem9zugqY0888UTK47vvvpsBAwawevVq5s+fn/Y5v/71rxk+fDh33HEHABMnTmTVqlX8/Oc/5/rrrz/dQxYRERERERER6fV61LLzlZWVABQUFGQ8ZsWKFSxZsiRl26WXXspdd91FLBbD7/en7GtsbKSxsbHtcVVVFQCxWIxYLNYl4249T1edT6Q30Ote+iO97qW/0Wte+iO97qU/0uu+73g7/4bGWmtP41jeMmst73rXuygvL+ell17KeNy4ceO46aab+PrXv962bfny5VxwwQUcPHiQwYMHpxz/ne98h+9+97sdzvOnP/2JcDjcdZ+AiIiIiIiIiMgZVFdXxwc+8AEqKyvJycnp9NgeUyH02c9+lvXr17Ns2bKTHmuMSXncmmmduB3g9ttv57bbbmt7XFVVRUlJCUuWLDnpF+etisViPP300yxevLhDhZKkSjQbmmo9YMEbtPiDiTM9JDlFet1Lf6TXvfQ3es1Lf6TXvfRHet33Ha2zot6KHhEIfe5zn+Ohhx5i6dKlDBs2rNNjBw0axOHDh1O2HT16FJ/PR2FhYYfjA4EAgUCgw3a/39/lL/TTcc6+pPq45fWHLTuWQzwGgycZznmfj7wh4PV1DPOkd9DrXvojve6lv9FrXvojve6lP9Lrvvd7O/9+Z3SVMWstn/3sZ/n73//Oc889x6hRo076nPPOO4+nn346ZdtTTz3F7Nmz9cLtwWpKLY//xLL1RRcGARzaBA9/z1J15MyOTURERERERKS/OaOB0Gc+8xn+8Ic/8Kc//YloNMrhw4c5fPgw9fX1bcfcfvvtfPjDH257/MlPfpI9e/Zw2223sXnzZn77299y11138aUvfelMfAryFh3ZAdXHOm6Px2DN/ZZYQ49oZSUiIiIiIiLSL5zRQOhXv/oVlZWVXHTRRQwePLjtz7333tt2zKFDh9i7d2/b41GjRvHYY4/xwgsvcPbZZ/O9732P//iP/9CS8z1YImHZ9VrmwOfgJmiq68YBiYiIiIiIiPRzZ7SH0FtZ4Oyee+7psG3BggWsWbPmNIxITgePxxDKzfxvnRUGc0ajSREREREREZH+Rb+GS7cYvyBz0+jJSyCU242DEREREREREennFAhJt4gWwez3dNw+ZDKMnmswRquMiYiIiIiIiHSXHrHsvPR9gYhhwiIYPgP2rLHE6mH4DEN0AIRzFQaJiIiIiIiIdCcFQtJtAmFDIAz5QxUAiYiIiIiIiJxJmjImIiIiIiIiItLPKBASEREREREREelnFAiJiIiIiIiIiPQzCoRERERERERERPoZBUIiIiIiIiIiIv2MVhmTHqmh2hKPgfFAOE+rkomIiIiIiIh0JQVC0qM01VmO74aVf7WU7oVIAZx9NQyfAaEcBUMiIiIiIiIiXUFTxqTHsAnL/g3w+E9dKGQTUHMclt1tWXO/pbHOnukhioiIiIiIiPQJCoSkx6irgFf+mD702fI8NFR173hERERERERE+ioFQtJjNNZBfWXm/eUHum8sIiIiIiIiIn2ZAiHpMTzezvf7g90zDhEREREREZG+ToGQ9BjBKBSPSb/PF4Ccgd07HhEREREREZG+SoGQ9BjBbMP8jxuC0dTtxgsXf9YQzjsjwxIRERERERHpc7TsvPQoeUMM7/o2HNoKBzdZ8obAyNmG7ALw+rTsvIiIiIiIiEhXUCAkPU52kWFsEYy9QAGQiIiIiIiIyOmgKWMiIiIiIiIiIv2MAiERERERERERkX5GgZCIiIiIiIiISD+jHkLSK8VjlroKqDgE8RgUDINgDmSF1HdIRERERERE5GQUCEmvE2uw7Hsdlv6vJR5r2Whg2hUw9TIIRhUKiYiIiIiIiHRGU8ak16kphed/3S4MArCw/lE4sv2MDUtERERERESk11AgJL1KImHZ8rwFm37/2gctDTUZdoqIiIiIiIgIoEBIeplEHKqOZN5fW05q5ZCIiIiIiIiIdKBASHoVrw8GT8y8v2gk+IPdNhwRERERERGRXkmBkPQqxhhGzTH4Q+l2wqzrjFYaExERERERETkJBULS62QXwlVfNxSOSN126W2G3EFnblwiIiIiIiIivYWWnZdex3gMBSVw6Rehsdb1FQpGIJyvyiARERERERGRt0KBkPRaoRxDKOdMj0JERERERESk91EgJH1erMESawCvHwIRVRGJiIiIiIiIKBCSPivWaKk8DOsetJTuhewiOPtqKBoBgWwFQyIiIiIiItJ/KRCSPslay+Et8NQdFqzbVnMcnthimXsDTFwEvoBCIREREREREemftMqY9El1FbDs7mQY1N6q/4O6ym4fkoiIiIiIiEiPoUBI+qTGGhcKpZOIQ/XRbh2OiIiIiIiISI+iQEj6JHOS2WDG2z3jEBEREREREemJFAhJnxTIhpyB6ff5siBa3L3jEREREREREelJFAhJnxTOMyz4hMHrP2GHgXkfN4Rzz8iwRERERERERHoErTImfVbRCHj39w3bX7Ic2QF5g2HiIkO0GLx+rTAmIiIiIiIi/ZcCIemzPD5D7kCY+W5obgKvH7y+9EFQImFpqAJrIZitwEhERERERET6NgVC0ud5vIasUOb9NWWW7S9Ztr0EiWYYNRcmL4ZosUIhERERERER6ZsUCEm/VltmefLnloqDyW0bn4I3X7Vc/Q2FQiIiIiIiItI3qam09GuHtpASBrWqr4QtL1jicdv9gxIRERERERE5zRQISb8Va7Rsfzlz4LPrNWis7sYBiYiIiIiIiHQTBULSbxlDx2Xp2/H6weh/iIiIiIiIiPRB+nVX+i1flmHSJZl7BE282BCMduOARERERERERLqJAiHp1wpLYNScjtuLR8OImWCMmkqLiIiIiIhI36NVxqRfC+UazrsRJiyCLc9Z4s0wbr6haCRE8lPDoFijpb4SYvXgD0IwB7JCCoxERERERESk91EgJP1eKMcQyoFB48Ba8Po6hjx1FZa1D1q2LYVE3PUfGjEbzn0/RAoUComIiIiIiEjvoiljIi08XpM2DIo1WNbcb9nyvAuDwAVHu1fCS7+1NNRoaXoRERERERHpXRQIiZxEfRVseyn9vgMboKGqe8cjIiIiIiIi8k4pEBI5iaY6sInM++squ28sIiIiIiIiIl1BgZDISfiDne8PZnfPOERERERERES6igIhkZMIRmHY1PT78oe51cZEREREREREehMFQiInEYgYLrjJMGBM6va8IXDJ5w3h3GQj6sYaS9k+y9oHE6y5P8Hx3ZaGajWdFhERERERkZ5Fy86LvAXZhYZLboH6Sqgtg1AehHMhnJcMgxqqLesesmx8Ovm8tQ9axpwP59wAoVwtTy8iIiIiIiI9gwIhkbcolGMI5UBBSfr9ZftJCYNa7VwOI2fCyNmnd3wiIiIiIiIib5WmjIl0gVijZeOTmaeGvfG4pbFGU8dERERERESkZ1AgJNIFEnFoqMm8v7HOHSMiIiIiIiLSEygQEukCWUEYPiPz/mFTISucui0etzTVWeLNqhwSERERERGR7qUeQiJdwHgMo8+BDU9YGqpT9/mDMOlig9fvmkrHY5bqY7D5eUvpHsgfCpMugewi8AfUeFpEREREREROPwVCIl0kWmS46huw+v8su1eDtVAyDebeYIgWu2NswnJkOzzxC4ttmUJ2ZBtsfcFyyRcMw6ZYPF6FQiIiIiIiInJ6KRAS6UK5Aw3zPg5z3+cCoUAEskLJgKeuAl7472QY1MpaePE3lnf/iyG7sHvHLCIiIiIiIv2PAiGRLuYPGvzB9Pvqq6G+Mv2+plqor0KBkIiIiIiIiJx2aiot0p1O0j/aJrpnGCIiIiIiItK/qUJIpBsFo261saa6jvt8AQjlJh83VFtqjsOulRYLjJpjyC6CUFQ9hkREREREROSdUSAk0o3CuXDBTYbn/6tjqdB5HzKEWwKh+irLyr9ati9L7n/jMctZ58PcGyCUq1BIRERERERETp2mjIl0I4/PMGwqXPMtQ8nZEC2GYVPhqn82jJxF29L0x3eREga12rEcjr3ZvWMWERERERGRvkcVQiLdLCtkKB4NF/0TNDeBLyt1JbKmessbT2RuNvTGk5ZBE1KfIyIiIiIiIvJ2KBASOUOyQoasUMftiXj6HkOtmuog0Zy6ra7SkmgGjw/Cmk4mIiIiIiIiJ6FASKSHyQrBiBlQuif9/hEzXGNqcI2nD2yE1X+3VB+FnIEw63oYMgmC2QqGREREREREJD31EBLpYTxew1kXGILRjvsC2TD2QoPHa2husmx53vLCr10YBFB1BJ7/L8u2pZbm2EnWuBcREREREZF+S4GQSA8ULTZc/Q3D6PPAeN2f0efA1d90S88D1FfC2ofSP3/NA26/iIiIiIiISDqaMibSQ+UMNFx4E8x5L2AhEAF/MDkNrL6qYy+hVvEmaKiCaFFym7WWhmrAQCiq6WQiIiIiIiL9mQIhkR7MHzD4A+n3eU7yv7f9/poyy+6Vlm0vgfHAhAUwfAZEChQMiYiIiIiI9EcKhER6qVAORAqgtqzjvmgxBHPcxzVllsd/Yqk6kty//PeWzS/ApbcqFBIREREREemP1ENIpJcK58HFnzP4Tqgg8gdh0WcMkTyDta4yqH0Y1Kp8Hxzc1C1DFRERERERkR5GFUIivZQxhsIRluu+bziwAY7vthSPNgyZBNmF7piGati+LPM5tr5oGT4TAmFXJWQTlrpK15vI64dwnqqHRERERERE+iIFQiK9mMdjiBbDhIUAHcMbY9yfTNrvr6+07FoJ6x621Fe6UGnmdVAyDYJqQi0iIiIiItKnaMpYL9NYZ6k8bDm42XJ8t6W23J7pIUkPFowaxl+UOcyZcLEhK2Roqre8/qhlxR9s23L1NaWw9H8s216yxGN6nYmIiIiIiPQlqhDqReoqLavvcytF0fL7eaQAFn8BCkrcFCKREw0/G7a8AGV7U7cPOAsGjXMfN1TBpqfTP3/tAzBqbuoS9uBeb7m5uV08WhEREREREekOCoR6iUTcsvUFy7alqdtry+Dxn1iu/RfT1jdGpL1IgWHJF+DgZtczyBiYuMgwcBxE8l2IWFcBNkMRUHMTNFYnA6GGakttOex/w0NO4jxqjnoJ59u2PkQiIiIiIiLS853RKWNLly7l6quvZsiQIRhjeOCBBzo9/oUXXsAY0+HPli1bumfAZ1BdBWx4Mv2+xloo3dOtw5FeJlJgGHuBYfEX3J/R55i2MAjosFLZibx+93d9leXVv1ge+JZl1d9g7X1+/v7PsPFJS0ONppWJiIiIiIj0Fmc0EKqtrWX69Onceeedb+t5W7du5dChQ21/xo4de5pG2HPEm6GpLvP+ykP6ZVxOLhB2PYNOFMp1y9inkz8Mgjnu48NbYcfLHY9Z+yBUHuq6cYqIiIiIiMjpdUanjF1++eVcfvnlb/t5AwYMIC8vr+sH1IP5/O6X8oaq9PsLhmu6jpy6cB5ccovh8Z9YYg3J7cEoLPyUIZRjaKixrH8sc/C48WlL4Ujw+d1rsaHa0lANsQbICrvXr6aViYiIiIiI9Ay9sofQjBkzaGhoYNKkSXzjG99g4cKFGY9tbGyksbGx7XFVlUtUYrEYsVisS8bTep6uOl86WdmGGe/ysOL3HfdFCiB3iCUWaz5t15e+L28oXPs9L0e3Q/l+KBrl/gRzm4nFoLnJQ0N15kCnvhJiTQksCRoqvLzwG8vR7S3HGxg5y3LOBwyBaLybPiORrtcd3+9FehK95qU/0ute+iO97vuOt/NvaKzN1Eq2exljuP/++7n22mszHrN161aWLl3KrFmzaGxs5Pe//z2//vWveeGFF5g/f37a53znO9/hu9/9boftf/rTnwiHw101/G4x8awZVG4ZxMYnfcSb3LaikTD3w/W8seNl6uvrz+j4pG/Izs4mEAhQX19PXV1ynuLQwcOpe2MK21/ypn3e2dfFqMt/jUGFI9l47xBK93QMj0aflyB/9lb27N9x2sYvIiIiIiLSX9XV1fGBD3yAyspKcnJyOj22VwVC6Vx99dUYY3jooYfS7k9XIVRSUsLx48dP+sV5q2KxGE8//TSLFy/G7/d3yTkzSTQbGqs9NNaCLwsC2RZ/OHFarynSqva4lwe+TVsg2SoYhau/BaG8OFWHvDzwrfTPNx64/kcQLnBVQtYaGqs8NFSDxwuBbFRBJD1ad36/F+kJ9JqX/kive+mP9LrvO6qqqigqKnpLgVCvnDLW3rnnnssf/vCHjPsDgQCBQMcllPx+f5e/0E/HOTteBAKhEzemr9gQ6Wo5xZZrvgmv/NFyaAsYAyVnW+be4CGn2AAe6ioskD5ntglobjD4/X6a6i37Xoflv7c01br9kQJY+CkfRaPB61W/Iem5uuX7vUgPote89Ed63Ut/pNd97/d2/v16fSC0du1aBg8efKaHIdIveHyGghK4+HPQWGuprKqkaHAOoUgyvInkZX6+8YA/6D4u3w8v/Do1OKotg8d/ann39w25A0/DJyAiIiIiIiLAGQ6Eampq2LEj2Utk165drFu3joKCAoYPH87tt9/OgQMH+N3vfgfAHXfcwciRI5k8eTJNTU384Q9/4L777uO+++47U5+CSL8UiBg8Wc08v2IpV4y4gvZVaqE8KBwJpbs7Pm/0OW6J+8Y6y5r701cRxWOw/WXLrGvBeFzQVFtuqSl1jaujxW5VtFCOKohERERERERO1RkNhFatWpWyQthtt90GwEc+8hHuueceDh06xN69e9v2NzU18aUvfYkDBw4QCoWYPHkyjz76KFdccUW3j11E0gvlGC7+rKv+Odqud/TI2TDnHwz+oKG23FJ+IPM5ju90wZAvABUHLU/83FJbltw/YCws/BRkFygUEhERERERORVnNBC66KKL6Kyn9T333JPy+Ctf+Qpf+cpXTvOoROSdihYZFt8CDVXQ1ACBCIRyICvsAhxfFuQMdBU/6eSXgMfvKoOe/EVqGARwdDu8+ifLvI9DVig1FGqOWTzGTW8TERERERGR9DxnegAi0jcFo4a8oYYBYwy5g0xbGARuytnMa9MHNsYD4+cbPB5DbRnUlKY//57VUF+VfFxbbnnzVctzd1pe+G/LoS2W+qoesYiiiIiIiIhIj9Prm0qLSO9UOALO+5DhtXst8ZjblhWBhZ80ZBe7x3UVmZ9vLcQb3cc1Za6SqKLdNLRdKy1jL4Q5/6B+QyIiIiIiIidSICQiZ0QgYhi3wFIy3VBXAcYL4VzXMNrTsuR8zoDMz/dmgT8Mibhl+9LUMKjV9mUwfr6brtaqudFSX5XsURTOB49HgZGIiIiIiPQvCoT6sOYmSyLulvk2Rr/wSs/j8xuixW7lsHRCuTBwHBzZ1nHflEtdgNRQDVtezHyNzc9bis+iZQqaZfX9lp3LIRGHQDbMvNYw6hxLKKr/IyIiIiIi0n8oEOqD6qstFfthw1OWploYMRtGzoTsIv3CK71LKMew8JPwyp8te1a5aWK+LJhyGUy62OD1G6y1JJozn6O5CbBQX2V54TeWw1uS+xprYMUfLNYaJi6ybZVJrRJxizFgVEEkIiIiIiJ9jAKhPqahxrL2AcvmZ5PbDm+DNx6zXPl1yBmgX2yld4kUGOZ9DOa8x4U7/pCrDPL63Ws5EHGh59bn0z9/3DyDx2uoq0gNg9pbc79lxExDdqF7XFtuOboTdi63ZIVhwkI3fS2oKiIREREREekjFAj1MTWlpIRBreoqYN1DlvM/DL4s/VIrvUtWyJAVSr/Pl2WYdjnsfs3SWJu6r2ika14NpO0x1KqpDmL17uPaMssTJzSo3r7MMnkJnH0NBLP1/0dERERERHo/LTvfx+x6LfMy2ztfcf1WRPqaaDFc823DpEtcU+roADjn/XDJLYZIvgtwQnmZn2+Ma1Idj1s2P5e+QfXGp6D6WOq2ukpL2T7Lke2WyiOWpjotcy8iIiIiIr2DKoT6mEQ88z6b6L5xiHQnYww5A2DuDTDtSjAeCEVTe/+4KV/pQ9ERs1r2VcHWThpUb1tqKR7lzllxyPLMf1gqD7UOAsZeALPfA+E8VRGJiIiIiEjPpgqhPmbUnMy/iA6fAVnhbhyMSDfz+l1FUDjXdGgEHcmHS79oCERSn1M4As55vyErZMC2NKHOINbg/q4tszzxs3ZhEIB1y9xveMoSj6VWCtVXW6qOWWqOW5qbVEUkIiIiIiJnniqE+phosat22LM6dbs/BLPf0/JLr0g/ZDyGwuGWa//FUHEQassgfxhkFyYrerLCLjh985X05zjrfHdc1VH3/HQ2PwMTF0G0CGKNlrJ9sOL3ltI94PHBmHNh5rVa9U9ERERERM4sBUJ9TCjHcP6HYdQc2PCEpbEOSqbD5EsM0eIzPTqRM8t43EpirauJncgfNMy8Fvats23VQK2KRkPBMPdx1ZHM12hugnhLlVHFQXj0BxbbUhSUaHZVREe2W674qltBrb2GGkuiGbJC4AsoMBIRERERkdNHgVAfFM41jDkXhk6GRAIC4eQS3SLSuegAeNd3DK8/Ytm7FvxBmLDIVQeFWxpU5w7K/Hx/0DWobqy1vPaXZBjUXtUROL4HIgXucX2V5fA2WP+opb4SBo2H6Ve5vkf6vysiIiIiIqeDAqE+LBjVL5Iib5fHY8gdBOffCLOudyuQhXJSG1RHB7jpmSeuOgYw+VK30ll9FRzZlvk6e9dZRswwNNZY1txv2fJ8ct/OFbBrpeWqfzYUj0p9nk1YYo3g8aiKSERERERETp2aSouIpOELtDSozkvXoNpw2ZcMhSOS24wXJi2GSYsMXp/BGAhkZz5/JN/9XVdJShjUKtEMy/+fpaE6WWJUfdyy4SnLU/9qef5XloObLfXValItIiIiIiJvnyqEREROQc5Aw6VfdMvYNze68CeUC/6Wqp1QDkxeAqvvS//80XPdcYe3Zr7G8d3QWAvBKFQdtTzyAzelrNXedZaJF8PMd0MwOzW0SsRdPyJVEYmIiIiISDoKhERETlEoxxDKSb/P4zWMuxAObrQc2tJuh4F5HzWEW/oHeU7yXdh43Gpla+5PDYNabX4Wxi+AYEs1UmOtpeoobH7WUlfhVk0bPl2rmomIiIiISCoFQiIip0k433DRp6DmOBzYYAlkG4ZOdj2G/EEX0AwaBxggzcyvIZMgEIHGGnjztczX2b3SUjjc0FRn2fqiZeVfk/sObLCsfRCu+mfIHZgaCllraW50oZTXp8BIRERERKQ/USDUjzXWWhqqobYMssJuukskX78UinSlcK4hnAsDxqT/vxXKhbk3wGt/Sd0eiMB5HzIEIoZYg4VE5mskWvbVV5ISBrVqqILX7rUsuBmyQm4cNccte9bCnjWWUI7rf5Q7qOPUMxERERER6ZsUCPVTdRVuSeydryS3ZRfB4i9AwTD9QijSXbJChnHz3FLzm5621JbDsKkwao4hu6jlmDCUzIC9a9KfY+Rs93/2wMbM19m31lUaZYWg6ojlkR+mTkF781XLjHe5vkeBSOr3gKZ6148oK+ymwomIiIiISO+nQKgfiscsG59ODYPATWt5/CeWd30Hsgv1S59IdwlE3PLyF37MrS7my0pd5j4rZJjzXji02RKrT33uqDmQXeg+bm7KvOKYte5PrMGy6v/S9yNa+yCMmuuqkwDqqyylu2H9E5amGhg2DcbPh+xiMEbfI0REREREejMFQv1QXSVseib9voZqqDiY/AVTRLqP12fwZviunDsQrv2OYdOzln2vu2qdqZcbBo13za0Bhk4xrPxr+lBowFkQCLsqod2rM49h3+uW/KGGhhrL6r9btr6Q3Fe6FzY/Z7n6m4a8wanPa6q3xBpcE+xwrsIiEREREZGeznMqT1q6dCnNzc0dtjc3N7N06dJ3PCg5veIxt0x2JlVHMlcZiMiZYTyGnIGGOe81XPl1w6VfNIyea1LCl0g+jDm343M9vpZ+RNkGC9hO+hHFY+7v2jJSwqBWTXWw8q+Wpnr3fSLeZCnda3nxvy33fd3yyA8sm5+31FXq+4iIiIiISE92ShVCCxcu5NChQwwYMCBle2VlJQsXLiQej3fJ4OT08GW1rFxUm35/vnoIifRYXr9rUp1OMGqY+34YNh3WP2pprIFBE+Hsqww5A90xWSEYPBEObU5/jpLp7v//3nWZA51969z3j6wQlO6DR35osS3f9mP1sPz/WQ5sgAtuglA0+f2kqd6NKdEM/hCE8/S9RkRERETkTDmlQMham7Z/RGlpKZFI5B0PSk6vcB5Mv7rjqkYA0WLafnEUkd4nnGs46zwYOhkScTe1zB9Ifr8ORAznfgAe+p4l3pT63FFzIfI2povWV1uW/y4ZBrW3ZzWcfQ2Eou5x9THLynstu9e4CqWcgXDeh9xUttaVz0REREREpPu8rUDouuuuA1wz0ZtuuolAINC2Lx6Ps379es4///yuHaF0OY/XcNb57m79G48lp4gMGAsLbjZael6kD2jtK5RO3mC49ruGNx53lTzBbJhyuWHIpGRFz/CzDWv+nr5KqORsV2XYUA2lezKP4eBGS9EIQ2255fGfWqqPJfdVHYEnf2G54muGwROS25vqLPXVUF8J/iCEclRJJCIiIiJyOrytQCg3181TsNYSjUYJhUJt+7Kysjj33HO5+eabu3aEclqEcgzTr4JxF7qpH74sCOZAMFu/eIn0dR6fawp93odcTyCP1003ay9SAOMXwtbnU5+bFYY5/2DIChkaayzGk7knkb+l8qd0DylhUHuv/tly6ZdcEFVXYVl9n2XbMqAli4oWw+IvQP5QfW8SEREREelKbysQuvvuuwEYOXIkX/rSlzQ9rJfz+Q3RYvcLl4j0P74sgy8r/b5gtmHWu2HkTHjjCUtjNZRMh3HzDNkt3zMC2TBiRoZVywwMmeg+PLAhcz+i0j0Qb4J4s2Xzc5ZtL6Xurz4Gj//Ucs23ILvQhUJNdZbacnjzVdeTaMQsQ/5QVRKJiIiIiLwdp9RD6Nvf/nZXj0NERHqYUI5h2FTX5yfR7KqDPN5k6JIVMsy5AY6+aakrT33u+TcaQnnu4+yizNcIRNxS9fWVsPGp9MfUV0LFQcgudGHQ1hctr92b3L/5OUvRSLjk8xApSA2FGusszQ2uCiqUq8BIRERERKTVKQVCR44c4Utf+hLPPvssR48exdrUu79aZUxEpO/orOlzzgDD1d9wq5btWWuJ5MP4BYbsQsgKtvQjmmFY+VebdmrZ5CWuT1D1UYg1ZB5D5WHLsKmG2jJSwqBWx3fDlhcsM97lQqtYo6XiIKy+z3LsTQjlwtlXwdApCoZEREREROAUA6GbbrqJvXv38s1vfpPBgwenXXFM+oZYg6W+Eg5tgcZay5CJhkhh5w1rRaR/yS40jL0QxpyXWkHUKpIPiz5reP6XlkS7+wXDprrwyOM1eLMsWRFoqk1/jdYeQjtWZJ5+tvlZmLDQXe/YTnjiZ5bW+xVNdfDi/1jGL4A5/+BWW2tVW25pqHarsgWjEM4Fr1/f40RERESkbzulQGjZsmW89NJLnH322V08HOlJYg2W3avgpbuSv1SBZdgUmPeP6tchIqnShUHgehUNm2q5/keGY29CY41lwFhDJD8ZLofzYPqVsPKvHZ+fXQi5g9zHDdWZr99UD9ZCXYXl5f/X/vtW0tYXYcqlbqpaIm4p3QPP/dJSU9oy1oBrmj3mXJsSGrWyCcOAAQM6+zKIiIiIiPQKpxQIlZSUdJgmJn1PbRks/d+O/877N8CO5Zapl4HxKBQSkZPz+Q05AyBnAEDH7xser2HsBdBQY9n4lOtZBFA4AhZ+2rT1Bho527BtafqfP0OmuKXq6yvcsvaZHH0T8oZATSk89mNLc1NyX3MjrPi9JVpsKJnmtllrqTkOe9dZDm70ECmaTc1wL9mFFn9Q3wNFREREpHc6pUDojjvu4Gtf+xr//d//zciRI7t4SNJT7Hw1c+i34Uk3PSSS340DEpE+LZRrmHktTFwIjTXgzXL9hYLRZOhSUAL5JVC+L/W5Hh/Mfa8hEDY0VHd+w8IfcH/vWZMaBrW3+j5L8Sh37fID8OgPLU11rXu9bH4WFn4KRsywKdPLGmvdymfWuibcml4rIiIiIj3VKQVCN9xwA3V1dYwZM4ZwOIzf70/ZX1ZW1iWDkzOrdQpFOg3VpJ2OISLyTviyDNFiiBan3x/JN1x6K2x8xrLlOYg1wtDJbppX67SyYDYMGg+Ht3Z8vsfrqo6stRzdkXkcFYegOQYN1ZaX7mofBrWwsPR/LNf/0LSNtfKQ5eXfWw5tco/zhsAFH4GiUe7zEhERERHpSU65Qkj6vuFnG3YsS5/6DBybvMsuItKdIgWGWdfB5EtaKnFCkBVOBi6BiOGCm1xVT0rPIQPz/tEQygVjDMWjXZ+0dHIHgtcPDTVwfFf6Y+IxKD/owqvq45ZHTrhexUF47CeWd33bUDgiub2m1IVRh7dZ8oYYhk2FSAF4fQqNRERERKT7nFIg9JGPfKSrxyE90IDRLb/oHEvdbgzMvcGkbbgqItIdvD5DpCDz/rzBhmu+DfvXw4ENlmgxjJtvyC4Ef6ClH9Esw5r7LfFYx+fPvM4QihoaqjovhWxudH/vX5++4bVNwOq/Wy76JxdaVRyyPPojS0NV2xF4/XDpFw0Dx9qUxtyNtZbGWneOrAiEovqeKyIiIiJd55QCob1793a6f/jw4ac0GOlZIgWGy78Cq+6z7FoJNu76d5z3IUPe0DM9OhGRzkWLDBMXwfgF6VdAixTCZV82PPdLS32l2+b1w6zrXBUkQCAM2UVQczzNBQwUDod4s2Xf+szB0dEdbmpbIm5Z+r/twyAnHoNn/sPy7u+5wMpaS+VhWN5u+lnBcDf9rHA4KT2LWtmEVZN/EREREXlbTikQGjlyJMZkfuMZj8dPeUDSs0SLDRfeBLPf4wIhf0hNUkWkd0kXBoGrMho41k3pqq9yK5uFct2f1p4/4XzDBR+BJ//VwgmZz+Qlrum1xwvRoszXD+W6Yxpq4NjO9Mc01blqzOxC17/tke+76qBWZXvdFLhr/8WQ3xLI24SlphT2roPDWy0FJZbR57hQKV1oJCIiIiLS3ikFQmvXrk15HIvFWLt2Lf/6r//KD37wgy4ZmPQc/qDBHzz5cTbhVuzx+jP/AiYi0pMY46aedTb9bOBYuOabhlX3WY7vdqsrnn01DJlk2noXjb8INj2Tvkpo+lWGUI6hvqLz6WexelcdtGd1ahjUKhGHtQ9a5n3MfV8u2+9ColiD2797Fax7yLLkNsPg8RZPu55EdeWWhpbVz4LZEM5DFUUiIiIi/dwpBULTp0/vsG327NkMGTKEn/3sZ1x33XXveGDSe9iEpfo4vPma5eBGd6d84iWQU5za6FVEpDfyBw3Fo2HRZ6Cp3nLg4F5KJgxNWWEzWgjzPmZYdo/FJpLPHTcPhk5xH2dFIJANjTXpr5M7GJqbYN/6zGM5ss0FR7FGy/O/SoZBrRJxeO6Xyeln8WbLsTfhxd/YtmlvoVy48KOGwRMs/mDq9+imehfs+7IgK6Tv3yIiIiJ92SkFQpmMGzeOlStXduUppRcoPwiP/MASq3ePDwHbXrJccJNhzLkdf+EQEemNAmGDx9/M1mWvM2ZCaiM1f8gw6hzLoAmGoztds+mBYyGcC4Hs1ulncM77DEv/t2Ol0PgFEMwBr6/zaqVQLnh8UFcJlYfSH9NUB7VlLdPPjsPjP7UkmpP76yvh6X+3vOs7hqKW1c9iDZaKQ67CqHw/5AyEs6+B/GHu8xYRERGRvueUAqGqqtSOmNZaDh06xHe+8x3Gjh3bJQOT3qGhxrLs7mQY1N7y31mGTHpr081ERHo7f8DgHwA5A9Lv93gMw2dYFt9qWHmvpeKgm7o1/SrDqDnJ4GXSxbD9pQzTz640BKOG2rKTrH7W5JpYb3k+NQxqY134s+Bm8GbBgY3w7J3JPknVx9zqbBd+1HDW+batJ1FTnWvAfWirm342eLwLqbTqpIiIiEjvc0qBUF5eXoem0tZaSkpK+Mtf/tIlA5PeobGTJqk2Acd3Z/7lSESkvwlEDMOnQ9FI18Ta44FQHik/U3MGwLkfNLz6J4ttl/uMvwgGTWg5TzYEIqTtNWQ8EC12VUrHdmUeS9let/pZYx0su7tj02yAFX+0DJlsiBa5GwCbnrGsfSD1mKmXwbQrIRhNfg7NTS44ijWAP5jaqFtEREREeoZTCoSef/75lMcej4fi4mLOOussfL4unYUmPVz7XhnppL0zLSLSz4VzM4cjWWHDuHmWYdMMR7dDcwwGjTth+lmeC41e/E3HFGf6VS2rn/lcX6Ij29JfJ1rsegVVHcnc1yjeBHXlrjdcxQE6hEEAbzwBQ6bAsJZeSXUVltcfsWx9EeIxN47xC1wj7nBe6uediFsaqt3HwagWJBARERHpTqeU3ixYsKCrxyG9VFbE/cKRqZdF8ejuHY+ISF/gDxpyg5A7MP1+j9cw/GzL5V81rPqb6/sTLYYZ1xoGT6Ctd9vkS2Db0vTVPzPeZcgKGYzpfPqZ8bgm1m88kfm49Y9aBoxxH6/6P8v2Zcl9iWbY/CzE6i3n3ZhsVl1Tatm21LL9ZXfcuAth7DzILlQoJCIiItIdTrmcZ+fOndxxxx1s3rwZYwwTJ07klltuYcyYMV05PunhwrmGCz8Kj/3EYuOp+6Zc5pqkiohI18sKG4ZMhCW3JitxQjmpYUq0GBZ92vDSXckVybx+mPs+Q/4w9ziY4xpe15Wnu4arRkrEoK4i81jqK90YYvWw4+X0x+xY4RpVZ4VcGPToj5IrnwGseQC2v2y54mvJUCgRt9SWupXXju+2DBhjGDrFNcw2HgVHIiIiIu/EKQVCTz75JNdccw1nn302F1xwAdZali9fzuTJk3n44YdZvHhxV49TerDiUXDtdwzrHrIc3el6RZx9jWHgWVqdRkTkdGvfu+dE/qBrZH3d9w01ZW6ab3Zhak+fcB4s+IThyZ9bEu2CfWNg/s2GcC5gYOhkOJ6hJ9GQSS7oqT5GSt+jFNb1PLIJy66VqWFQq+pjsHcdTFzkTnJ8l1slrbnJ7d++zOIPwRVfS66QBtDcaKmrdNPfjMf1YQrn0dYMW0REREQ6OqVA6Gtf+xq33norP/7xjzts/+pXv6pAqJ/x+g0FJTDv49DU4JZNDmZ3fBPeVG+pq4B9r7s71cOmGqLFHe9oi4hI1/H6DNlFkF2Ufr8xhoFnudBo8wuW47sgfyhMutiQXQwen/sePW4+bHomWWnUypcFky4xeP0Gf7Dz6Wf+oAuFdi7PfMz2ZZYx5xiam+CZ/0yGQa1i9fDcnZar/tn1JGqstex4GV67Nxloef1w4UcNI2ZY/KHkz5hYo2t23dzY0uw6D3wKjURERKSfOqVAaPPmzfz1r3/tsP1jH/sYd9xxxzsdk/RS/mDmJeab6lyfiFf+mPxlYe0DlqFTYP4/dmw0KiIi3cfrN+QOhrn/4MISb5YLktqLFsFV3zCs+J3lcEuj6gFj4fwPuXAfXGPoolHpK4kKR7j9xoDH39lYAA/UV7mpaOlUH4OGalcFVLYPXvlTahAVj8GLv7Fc+11DYUslUW25ZfV9lh0rwMbddSZd4qY3n9jku6nB0lTrxhrI1gppIiIi0jedUiBUXFzMunXrGDt2bMr2devWMWCA1hiXjmpKU8OgVgc2wJuvWSYvTl12WUREup/Ha8gKp99nPIaCYXDJLclVybIiqRWhoRzDwk/BU/9mUxYbyB0Eiz5j2ipCJ10ML+5MX0006RJDIGyoiHVebRRvdpWnrz+c+bgNT1kuvAlijfDyPZZ9r7d7fgzeeBzizZY57wFfwJBIWKoOw8r/s+xb6/oyjTnPrZAWLe74M6qxzhKPgT+QbOQtIiIi0lucUiB0880384lPfII333yT888/H2MMy5Yt4yc/+Qlf/OIXu3qM0gdsXZr5DfvGJ2H0XHenV0REerZAxBCIZN6fM8BwxVehtsxV8kSLIVKQWgk6eBIMGg+Ht6Y+d/BEGDTOfRzOA4+XlL5GrXwBV20Ub4LqNL2IWlUdgeYYNFSREga1t+U5mLzY9R2qOQYP/UtyWlw8BtuWwoENbopaa7PrxlpL6V5Y97Cl5hgUjYTpV0POQPAHOgZDzY0WPJqeJiIiIj3LKQVC3/zmN4lGo/ziF7/g9ttvB2DIkCF85zvf4fOf/3yXDlB6P5uwna5O01DjGp2KiEjfEM4zhPOgeHT6/ZE8V0l0fBdsecGCgYkL3fSu1uAolONWJVtzf8fnz7reNbtOJFwYU3Uk/XUGjHHhUWc/gxJxaKqD5phl/RMdeySBC7f2r4cJC124s22Z5bU/J/dXH4PdqyxLvmgYNqX98yyHt7q+SN4sN0WtoES980RERKRnOKVAyBjDrbfeyq233kp1dTUA0Wi0SwcmfYfxGEbOht0r01cJDZlIxt5DIiLSN4XzDMNnwJCWAOXE6hlfwDBxkZtutvrvluqjkDsYZr/HMHCc63vkBaZfBbtesx1WN/P6YcJCg9drCERO0uw6AE21sD9DFRHArpWWMee53kYrO7ZRxFpY9lvL1d+ESL6htszyxM8tFQeTx+xdaxk1F877IIRa+hbFmyw15bBntTt2yCTDoHGQXaTQSERERE6vUwqE2lMQJG/FoLFuhZsTlxn2eN2d3qw0y9Mnmm3b6jYiItI3dTaNKhg1jD4HBk1wlTxebzJIaRUdAJd+0fDSby21ZW5bzkCYf7NpW1ktlOuCpcrDHa8xZBIEc9z5s8K0neNEWdmup1DVEdeUOp3aMtdfKZTjqojah0Gtdr0GExe6McWbLYe2wlN32LZzbl9mCebAlbdD3uDk51pfZak5Dvs3WLJCMGyKIZQHWSH9nBQREZFTc0qBUGlpKd/61rd4/vnnOXr0KIlE6nyfsrIM76ak34oUGK74Gqy53/LmK+6N94CxcN4HDbmDksdZ697w7llrObQJcgZZxs03RAvd3WIREel/TlwFrD1/wDB0Clz9TRfGtK4M1r5nUTjPsPgL8OQvLNXHks8tGA7zPmYIRNyxUy+Dpf+bvppo8iUGr89gvJ1XGxnjVkDb9mLmYzY/Zxk4zk1le/ZO2yFgaqiCl35rWXyLa9pdV2lZ9lt7Qh8ky7kfNIy9wLbdVEkkLHVlULoXasvdym7R4s6/fiIiItJ/nVIg9KEPfYidO3fy8Y9/nIEDB2p1KHlLokWGCz4Ms97tSuuzQhDITn3tVByAR35oaapLbtvwpGXRpw3Dp1u8WvpXRETSiOQbIvmZ9+cOMlz5dVfFU1vW0uw6P7XiaOgUKJnesQH15Eshb7D7OGeAm44Wj3W8Rs5AF0ZZ61ZByyQec8dUHYbmxvTHHN3uAq5AxLJ7Zfqm2K/80TJ4gqEg7MKg47vgiZ+l9kEqGA6Lb0k2xAZoqLHUV8Lx3eAPQWEJhHPJ+DM2HM6w9JyIiIj0aqcUCC1btoxly5Yxffr0rh6P9HG+gCE7kH5fQ7Vl6V2pYRAAFl78jeX6Hxqixad9iCIi0ke1hUZj0u8P5xnmfRyqjrq+d14/jJpryC5I3sAI58KFHzO8+N+plUJePyy42RDOM8RjrlfQpqfTX2fcAldt1NTQebVRvBnqK+GNJzIft3Wp5bwPGurKXAXUiU2xy/bCa/da5n0M/EFDfaXltXstO5Ynj/H4YOGnDEOn2LZV0hIJS105VBzyMthzIZUHvUTyrRpii4iI9CGnFAhNmDCB+vr6rh6L9HMNNW7FmXTiMag4hAIhERE5rUI5hlAODDwrffDh9RuGz7Bc+y+GTU9bKo/AwLNg3PxkzyKv3zBlCbz5qqWhKvX5RaPcymgABUM7GUcuBMJuFc7GmszH1ZW78KbiMB1vqLTYvQpmvwd8Acvu1aSEQQCJZnjuTnfjJXewO1/pbnji5603adydnEHjLRd90gVrrRpq3Eqix3dBIOJWUQvnua+BiIiI9GynFAj913/9F1/72tf41re+xZQpU/D7/Sn7c3JyumRw0r9katLZKlNZvYiISHfKChoKh8P5H4F4k1va3uM9odl1seGab8Lm5y27XnMVRBMXuVU3WwOVYA6MXwBb0/QbOveDhnA+xBpg8ATYuy79WEbMMng8hvqKzFVENuFurNRXwvpH0x9nLbz5mmXGu1y1UTIMSjq8FdY+aDn3A+DLcr2NXvmDZdfK5DFePyz6rGHIJNvWMDze7KqNju+GugrLgDGG7MKODcJFRESke51SIJSXl0dlZSWLFi1K2W6txRhDPH6S3+xF0siKQHYh1JSm2WncXccTNVRbEgkIZnd8My4iInI6eX0GbyfvpKLFhlnXwZQlrtl0MIeUvouBiNtfNBJef8StklYwHObeYCgc6Y7NCsGs62HfGx2bT2cXwqBx7uP8ND8jWwWjrldQIgG1FZmPqzzi/i7bn7naaMfLMP1KyC607FyeGgaBC56e+XfL9T8y5A50YdCR7fDUv1niTa1HWQacBYs+7RadaFVXaak6Agc3ualpQydDKI+2aWwiIiLStU4pEPrgBz9IVlYWf/rTn9RUWrpMJN9w/kfcm0ZOuIE5ZQmE2hWe1ZZb9q2Hzc+6N5ij5sK4+a5xtYiISE/h9RnCeZn3h3IN4y+yDJ9hSCTA54dgNPVnWe4guPqfDSv+aDm2E4zX/dybfZ1paxYdyYdB410Vz4lmXe/G0FQHxaPg6I70Yxk2xZ2rppPFYuMx19uorhLWP57+GJuAvWstUy8z1JXDU/9qOzThProD1j1iOef94PMbasssz95pOfZm21kwBi76pKHk7GRvo6Z6V2208xX39/AZhqJRqdPY2os1Wrw+3TQSERFJ55QCoQ0bNrB27VrGjx/f1eORfm7QOLjmm4ZV97nVUiIFcPY1hiETaVtWt67C8tyvLEe3JZ+37iHY+qLl6m+4O7IiIiK9hTGdh0Zev6F4NCy5FWL1YDxuNbP2lTOhHMNFn4R1D1m2L3PBTSgXZl9vGD4TPB5DMBvm/AM8+sOO08ZCuS5QAigannksoVzwB1zoc2J/pPaqj7q/j+5MvyIbwPaXYNoVEM61bHiqfRjkWAsv/Npy/Y9dtVGswU2/W3Z3cvzbXrLkDITLvpx6U6jmuGXv67BnjSWcC5MugehACEY6vkdorLUk4pAVdgGeiIhIf3FKgdDs2bPZt2+fAiHpcv6ge9O76DPQ3OBWPjlxRZPSPaSEQa3qK2HTM5bZ71EzSxER6XuC2S7UySSSbzjn/TDtShfC+AMQzk+dplYwHJbcalj+e0vNcbdtyCQ4/8PJaqPsYndc2d6O15h1nQuvGmqhcIT7mZzOkMnuXLXlmXsbxWOQiEN9FWx5Pv0x1sK+1y25Swx1FbDsno7nqzoCax+wnP9h19uo8ojl0R9a6iuTx+xYbpl1PUy6OHmDqb7ScmQHvPG465c0bBpMXATRIjCe1PcRjbXW9TL0uJXmVB0vIiJ9wSkFQp/73Oe45ZZb+PKXv8zUqVM7NJWeNm1alwxO+q9A2BAId9yeiFu2vpj5zeXOV2DKZa50XkREpL/xZRmiRZn3ZwUNJdPhqhFuCpnH6/rwBdpVzoRzDYtvgdf+4lYlswlXkTTresOIWS4sCUVh7vvg8Z90/JkcKXBT0wAGjDF0mAfeIrvIhVbxWOcLR9RXuL8PbMx4Kna+AjOvhayIZeVfU8OgVqvvg5GzXSVQQ7Xl1XstO9utuFZxELYttVz9TUPeYLct1mipOAgr73XhUSjHvc8YPRfCeamhUFO9paHafb38wY77RUREeppTCoRuuOEGAD72sY912Kem0nK6ebyZ9xmPa9zZXqzREmsAXxZkhfTmTEREJJJniORl3p9daJj3cZj1HktleQ35RdlECtzUs1ZFI+GSWwyv/MG6BSEMDJ0K53/ItDWLzhkAhcOhNE210TnvM4TzDPXVttNqo6EtvY0aazLfEEo0u6bZjbWwd03mz2v/G5a8wYaaUlLCoFZNdbDyb5YFN7v3DKW74bEfW2zLpWvL4NU/waEtlgs/CqGWfk/Vxyyv/sWyd42rasoZCOfdCAPPctXPrWKNLqxqrHGr0wVzkucQERHpbqcUCO3ataurxyHylni8hgkLYdfK9G8Kx893q6mAe9NVfRTWPWw5vtuVgE+/2r0xDaTpISAiIiJJ/qAh7G3mhVee54oxV+DxpFaEZ4UMI2a4YChW727YBKKuyrdVOM+w+Auw+u+WnSvcFLHsQpj7PsPgie6YUNRw7gfh0R91XFQiv4S2ap2hUwxr7k//879oJGSFoKmBtvAmndaVzvasznzQvrUuGIrHLMt/Z9Oeb+8aqH0XhKJQW2Z57CfJKXjgprE9+XPLlV83bSvB1VVa1j9q2fQsbSvGFY6AhZ+G3IHJr1k8ZqmrcCFaU72rtgrluimD6diE7TDFTURE5K04pUBoxIgRAGzatIm9e/fS1NS2jijGmLb9IqdD/jAYMQv2rE7dnjMQxs03bSuJHN0OT/4i+Uau+qhbynbuDTBhYeodOxERETk1kXwDnUzVjhQYzr8RZrzLVfL4gxA+YVWwwuFwxddctVHZPvD6Yew8OPsq03ZstBgGT4RDm1PPbzxw7oeMW53NWAaOgyNpeg0CDJ1q2p6TUcvQmuqh/EDmww5vtRSNMBzbTUoY1N6rf7Zcehv4w7D1BcvGp1L3l+6BJ35mueqf3dcx1mjZ/4Zrpp1oTh435nw45wa3Kl2r6uOWAxvgwAZL7iDLmPMN2YWpzcYBrLU0VLmgLBBRn0UREUk6pUDozTff5N3vfjdvvPEGxhhsy2/crQ32NGVMTqdQjuH8D8P4BbDxabfs/FkXGIZNoa1Evbbc8tJv09/VW/l/LlDyB7t54CIiIv2UL2CIFmfe7w8aBo93q4XFGlp6G+W4JelbhXIMF30Ctr1s2fikm3Y1aDzMucGQP9QdE8w2nPdBePj7HZe6H30uZBe4j0fMMqx9MH2V0MjZLjhpqHbT0DNVHLVOQz/wRuZqo+O7oLnJ/XnjifTH1Bx3FUWRfDcl7flfdnz/snO5m342YaHFGEPFIdc4u6E6ecz6Ry0LP20oOdu2fd1qyy17VsOmZ937pRGzWlZcK05tjG0TltoK18vJ63cVST4FRyIifd4pBUK33HILo0aN4plnnmH06NG8+uqrlJWV8cUvfpGf//znXT1GkQ7CuYbwNPdG0CY69gZqrHVvqtKxcag87PoaiIiISM8RyjGEcjLvD+cbpl0BYy8ArOvDc+I08LyhcO13Da8/Yjm4yU0ln3qFYcgkXBURrvH1xIth87Op5w9GXfNsf9Dd8Bw+s2NFMrigqHUqWHYnTbyDUVeNFKt3fzKpOASDJ8Cbr6a/mQWw/jHLiJkGj8+y7O7UMAhccPXibyzX/9CFb3UVlud+aTm6I3nMxqdgx8uWa75t2t4HNVRbdq2CNX935/RmuSn4065sqf5qkWi21FW691eJOEQKIZzjwj4REemdTikQWrFiBc899xzFxcV4PB68Xi8XXnghP/rRj/j85z/P2rVru3qcImmdWBbd6mSrwXralYo31bsGjwc3QbzZMmSiIZyfea6+iIiInDkej+l0NVGvz5A3BM7/SHIltVBO6s/0YLZh5rWuYmbjE5aGWhgxE0bPNUSL3bFZIcM5N8DxXTb1JpOBef9oCOW5hyNnGVb/X/ogZ8plrtrGJlx4lWk1tdyB7u+qI5k/r7pyd57GmsxT4uIxKNvnKoBK95ISBrVqrHXh0rkfAOOFHcvd1La2czTBpmeg6qhrrh2MGpqbLIc2w/O/tm3BlscLs66HcfOT75msdQ3GD212U+ryh8GIGYZIoft3aS+RSE5lC2ZrKpuIyJlwSoFQPB4nOzsbgKKiIg4ePMj48eMZMWIEW7du7dIBipyKQMT1FEr3xsrrd/sAGmvdMvYr/9r+CMvYC2HOe1Pn6ouIiEjv4Q8Y/IHM+4NRw9BJMGBMS2+jUOoqagDRAYarvuH6Eu5dZ8kuxPXqKUjelArnw6LPGJ77lW1rFg1QcjaMvcDg8RhCOZbJi+H1RzqOI5wHuYPcx8OmGnauyNA4e7Sr3mlq6Pzzbm50Ycu2lzJPZdu1EmZc48KYTFPn9q+HukpX5VRzHJ7+d4tNJPcn4rDyr1BQAsOmum0VB+HRH1oaa5PHrfo/y6VfNAwaZ9v6PNaUWXa8bNn6ovvajz6ndSpb6te/ucndtIs1uEAtlKMekCIiXemUAqEpU6awfv16Ro8ezTnnnMNPf/pTsrKy+M1vfsPo0aO7eowib1s4z7DgE26p2BN7CFz40eRdvaqjnBAGOduXuTc3o8857UMVERGRM8gfMNBJcJRdYMg+B0afkz6I8AcMw6Zb3vMjw7E3XQXOwLEuKGpdUt7rN0xaDPWVlm3LaFtNLXcQXHKLaeuBOGi8qyiqrzzhIgbm3mAIZhvizZbsosyNrAtHukppnz/9fgCvz52zqdZVUWVSeRjyh1i2LU0Ng9pbc7+laJSrXnrxv1PDIHCBz7P/aXn391zT69oyy5M/t1QcTB6z4UnY+Yrl6m8kQ6G6Csv6xy1bnnOVT8YLY86F2e9JncrWVGepr4LDWyGRgMEtX8N0K8o2N1pijS5cylRlLiLSn5xSIPSNb3yD2lr33f773/8+V111FfPmzaOwsJB77723SwcocqoKR8C7v2fYutRydDtEB8KUxW7OvM9vSDRbNj2d+e7Z+kdtSr8BcHfc4k2uyqj1LpeIiIj0bz6/e3/RWX/CcK7hnPfDtKugocotbhGMuptYrbILDVfeDst/5/ofgZv+dd6NhoJh7nEkz3DBR+DJf7VtwVKr8Re5KhpjDBMugh3L07/PGT/fHRdvwq2qluHtUCgK8Xjnq61VH3OBTazeTVNLp6kOakohuxAObSElDGpVXwlbXrDMvM6FSOsetik9nmwcdrwMjTWW+Te7aWqNNZbNz1tW35d6rsmXwvSrkoFcrMFSdRTWP2IpPwC5g2H6lS6Q85/Qh7K+ytJY42XmxIU01Xrw52X+3EVEertTCoQuvfTSto9Hjx7Npk2bKCsrIz8/P2XFApEzyesz5A6C2dfj7gZlpc5fj8ehriLz8+ur3THgegvVlML2lyxHd0LeEJi4yDWS1B0mEREReSuywoascLJnUDq5gwyLPuN6BSXikBVODY3AVSBd/Q3Dqr9Zju92086mXWUomZqsjMkZDGdd4EKU1PPD+IsMHq8hELUMmwb7X+84jmAUsotdNdGAs2D/G+nHW1DiKm5ObHJ9olgDxBot21/uZCrbazB5sVuVbcsL6Y/Z97q7VjDbNeM+MQwC2PgkDJ0MJdPczbyDm+CZ/0wGaOUHYPcqy0WfNIycbfH63I3C0n2w7G5L2V6AbPKHwbyPWQqGp76HrCmzVB6EikOWvCGGvMHJlW7bSyQsjTXu42AU/Z4kIj3OKQVC6RQUFHTVqUS6lMdrCIQ7bvdlufn9rXfgTjR4AmSF3MfHd8PjP0lOPzu0GbY8Z1n0OUPJNNuhUaKIiIjIqQpEDIFI5v3+oGHAGLj4c65nkPG6CqT2QlHD3Btg7IWw+Rk3Veqs8w2DJrhpcACBsOH8G+GpY6lTuLLCcOkXDZE8F2KMORdef9RVSZ9o1nWGQNgQi1gCETpMGQM3hS1noPvb29lUNr9bla2pjpR+TCeqK4fsQssbT3ZS6f2IZeBZ0FQPL/22YzUVwMv3WAaOdVPZqo+7/kftWw2U74dHf+Smu7X2eao4aHn8p7bdTUVLpAAu/zLkDm4XGpVadqyw7HjZfd7jF8DIOcmvfaumetdcO9bg+liFcnWzUUS6T5cFQiK9jTGGETPh9Yc7Lt3q8cH0qw3+gKGuwvLif3fsRWQtLP2N5d3fN0Q7WXJWRERE5HQ4WXAUyjGEcmDgWa6/TrqgIVpkuPwrrq9i2V5LdrGbnhbJB9PSZDu7EK74quGF/7ZUH3XPC0bdVLa8oe5xOA/Oeb9h6f92TF4mLXZT1HxZhkmXwL516YOciRcbgtH0oVLK550N8WaoL898TH2VO6ahmrYqnRPFGly1eCjHsunZju/1wE2H2/iU5Zz3Q2OdqzQ6scK8tgye/aXl8q+4r3lNqeWxH1uqjyWPefXPsPVFy2VfSlYT1ZZbXvuzZddK977SeGHcPJh5bWpVWH2Vm/K2a6XF43X9rLIL06+IW1dhScRdZZcWRxGRk1EgJP1atMhw1dfhlb9Y9q8HLBSPgfM+ZNr6ADRUk/IDvb1Yg3sT0BoIxWOWukrX6NFatz2Yozs9IiIicuZ4/QZvJ/vDeYZwHgwal/79isfnKpKu+jo01LjqnUC2a5zdujKbx2sYPsOtKLbyb5byfW5q/dlXG0rOhqyWXj2FJTBqjlvprL2iUTBiprthF8pxfRzTVXHnDm5ZbSwAQ6fA0Z3pP6dBE13FzckY41oLHOlkoeQj293qbg1VUHko/THl+10IFcy27HrNpn3vWHEQ9m9wPZwaaizL7m55/9nCxmHrC2ATlnM/4CrB6iotL99j2bs2edwbj1kmXgwzrk32SaqvsuxZA+sestSWufYGs98LA8dBsF2D7ViDa8JdcciFRjkDIZzrXiMnijW4kMwXcGGeiPQ9CoSk38sdbFj4SXf3yFpXJt3+jkumVTVaJVpKmmMNln2vw0t3WZpbSqo9PjjnfYYx59m0q12IiIiI9BatwVEmgYhh2FS3sEe8GTyejv2PQrmG826ECQth83OWRDOMm28oHgXhltXDAhHDvI+5apzSPcnnRgfA4ltM2znHXgAbnrLE6lPH4fXD1EsNPr8hmGMJRtP3OMoKuylaXh+ECzI3xY4UuFXbmhs7//rEm1xgtv3lzMdsW2oZOduNp30Y1N72Za7ptT8IBzeSEga12vysC9ZCE9y0s9cftmx8Orm/4iA88++WCz9qGHuhxeM1NNRYNj9jWftQ8v2tNwsW3GwYNtXiD7qva2Otm0L4+iOWmuPuZumUS13T9PbBUSLuqqUaa1x1UzC74793e4m41aIsIj2MAiER3F2rrAx3kYJRV+XTUNVxn8eXrA6qPgbP/zp1jnqiGVb8wZJfYhg8vuvHLSIiItLThHI6/6U/lGMITYJB493NuHS9GLOLDEtuc1O6ao65KWyRgmRo5I6Bq/7ZsOL3lsMtFT7FY+D8G5PT+SN5MP9mw9P/ZrHtZ6oZmPcxQzjXVUBNuyLzVLZpVxj8QUMwajGG1PO0ns7rqqaMAU8n5Vger1vYrb4y8zE24aan1VdbNnTSJ2njU5biMe496qZn0h/z2r2WoVPcFLNjO2HNA6n7403w3H9ZrvueIX8YNDdadiyHV/6YvG75AdjxsuXyrxgGtbyfbaqz7FsPK35v26b45QyEiz4JhcOTq/HGGiw1ZbDtJUv1ERgyCUqmu3+7E5ts11VYmurd1yiQ7XpcicjppUBI5CTCeXDBTYZn/7NjQ8I573V3luLNlo1PpW9YCPD6Q5bCzybLpeurLPWVLfPWc92fE5tBioiIiPRlJ6sWCee6wKZoRPr9xuP6HV3yedd3yFoIhCEYNSnHDBpvufZ7ho1PuRXE8obClEtdewBPSxiVPxTm/AOs+lsy8DEGZl3v9oG7QegqmzqOZdLFyYbQExa6htXpTLzYkBU2BCKZgx6ArKALhprqMh/TWOduPlYfSx9SgXt+Yw34Apa1D2Y4yMKWF1yfpPoqePUvHY9LxGHp/1qu+mdXBVS2D174depxVUfgsR+7Jtw5A1wrhf1vuMCp9T3ynjWW1ffDVV83bV/XWKPl2E5Y/jtL5WHAwNCpcN4HIXdguxWCY5bacrfiXfUxy+CJhsKS9Cu8NVRbYg2uSXkwqilvIpkoEBI5CeMxDJ1kueabhjUPJufEz7zWUDjC/YBpqm/5AZZB1VG3hGpWyK068dx/uR98rfKHweJbIFqsH1YiIiIib8dJV2ULuODovBvdtC9fVseAIBAxTFgEI2fBsd2WxoZGho4PEM41+Ftu6GWFDGe/C4I5lg1PQqzeTTubejmMn2/aekaWTIeikW6V2vYGjYdB49zHoVwoKIGyfR3HO3SKC59aV8Td9HTHYwBGzTH4g67HT2c8Ptccu6Y08zGVh1y4VHEo8wpv1cdcuOT1W1bdlz5cam6E3ass064w1FXAi7/peMO0qdat/LbkVtemoeIAPP6zdsdZOLAeHttrufqbkF1oiMcsh7bAU3fYtvFteMKSXQRXfDX5Hro55kK/FX+wHN/lpg+edT6cfY07T6t4s6Wu3PWgqi2zDDjLhVjpprw11raES8b9u2h1YelLFAiJvAX+oKF4NCz8pGs86POT0hPIlwXFo13TwXSKRrjmh421lpfuSg2DwDUifPZOy6Vf7Fhmba37Adm60oeIiIiIvH0+v8HXybL3WUFDVhBCBc08//xLjC1ciN+f+oRwrmH61W41sHiT68ETzkutdorkGy65BY5sc5U3xgMTF7nG3K2BQyjHcPHnXJ+f8gPJ8w8YAxd+1LS9z5x8CWxf1rFPUjgPhk93064iBZZAJP3qbAXDXYWM1weFI2H/6+k/94Hj3edyUsbd5Czfn/mQI9sgscR9XulWbgM3fa2xBoyxrPxr+ir7ugo4tMX1iqqrgGf+w3YIq2qOwyt/siz4hAvsyvfDIz+wbT2S4jHY+iIc3upWgYsUGOLNliPb4Kl/a7+ynKVwOCz+QrLiqDlmKd8Pr/3Zcnib6+k0cRFMuiS1Kqk1XDq+2017GzDGEClMX/3fUGNpbnThUij35FVyIqebAiGRtyFTryGP17Q1RzzxB58xMP0aN/e84pBNu2IGQOkeNwc8lOMe11e5hn5bl7ofkmPnuZJlTS0TEREROb3q6+sz7vN6XU+ezkTyDaPPcdVCQFvD5vZyBhgu+4oLO+orXI+kUG7qzcFoMVzzLcPq+9wqYh4vjDnPrd6WXeSOC+fDJbcYnvhZ6vvQQDZc9E+m7Xwzr4X96zuGL74AjDnXYIwhb7Bb2j6RpkooZyAEIm4M0WJSGn63lz/MTcVrbux8Wlwi7iqKMq0UB7BvvWXsBW6KWqZwad8616TbJiwr77VpF4SpPOyahkcKoK78xDDIKd0Lq/9uOf9G8AVcuPTw95LnizXA+sfg4CbL4i+4cC8ec2HR03ekhksDxsGiT7nXAbhpcRUH4JU/W45ud5Vlky5xUxAj7fpixZsstRXua9JQbRl4liG7KH1frvrqlnDJ435/UOWSnIozGggtXbqUn/3sZ6xevZpDhw5x//33c+2113b6nBdffJHbbruNjRs3MmTIEL7yla/wyU9+snsGLNKJ7CK4/CuGF3+TXGo0nOfu8uQMdI9jDZ2fo7FlnnhdpeXl/2fZuya5b+cKy7CpMO/jna/gICIiIiI9Q7ogqL3WPkl00icpb7B7/3fO+92NxkB26pQ3j8dQPNpy3Q8M+9+A8v2WgWMNg8bRFhoB5A2GxV8wvHyPq2gBtzz9gk+40AHclKjzPmR4+f+lhjkeH8z/x+QKbzOvhaf/vWPgY7ww9kJ3TOHwzJ93dhFt0/xCua7SJ52cYvd3Q03mc1nrprvFGmlrLp7OnrWW4Wcbju/OHC7tXAEz3gX+kOWVP6UPl47vdlPrwnlQW3FiGOQc3QbrH7PM/Qe3MlvZPnj0B8nG5k11sO4hOLjFcvFn3OugOeZuHD/7n7ZdIGcZNN41624Llxosx3fDq3+ylO5tqVy6uKVyqV24FGuw1FXCgTdcuDRkcuZpcXUVlqYGLzMmzSMRN9BJJZ30LWc0EKqtrWX69Ol89KMf5frrrz/p8bt27eKKK67g5ptv5g9/+AMvv/wyn/70pykuLn5Lzxc5nbw+w8CxcNU/t9ylsK5EN5yXXEUhK0zG1SnAHQ+ujLZ9GNRq/xvuB93oc5Lbmhst9VVuHrs/5O4Q+AIKjERERET6is5WxAX3PjRngGtu7dYx68gfNJRMs1zzLUNjbUtPnGhq9Yk/YBh9jqVwhGH945bqozDwLJh4iSFanDzXgLGu4faaB5I9h7LCsPBTyeqpYK4LKTqsgGbg/A+7cMla129o+e/SLd0GZ53vxlY0KvPnnl3o3gMDZEXcVLR0Innu77ryzJVLiXhL5VIDHM3QCgJg7zrLkImGo9szh0tbX4Spl4Evy/LKH2za9/9Ht0H1UQjnusqlZ/6z47S4w1th0zOWme92/85Hd8ITP0ueLNYA6x+FIzssiz7twqVYg2X3atcIvLUibO2DlgFjYdGnk8FRY63rzfTqny01x8Hrz2PcPJh+lU2ZFtdYZ6kthR0rLI01MHK2oaAkNYACiMct9RXQVO9aagRz3FTMdJpj7nM9WWgqp9cZDYQuv/xyLr/88rd8/K9//WuGDx/OHXfcAcDEiRNZtWoVP//5zxUISY8RzjOE89LvC+XAmPNhx8sd9w2b5n4oN9W3rFiWwcanLEOnuB5GdRVuxYhtS90PL48Xxs13dzZURSQiIiIi7RljiORDJD/zMVlh1ztzwT9Cc8z1wfT6U99XBrMNkxe7m5Q1pa5HUaTABRutK7cFwoazr4EBZ8HrD7sVwopGwuz3GPKGJMczYpbr6bPzlXbj9MKCmw2RAvc4kgfDz4a96zqO95wPGCL5hkTcMnkxrLk//ec16hw3ruIxhkxLA2cXtTTptu7v5sb052q9iVtTmvk9e7yppXIp0bHBeHsHNriKrgMbMzf03vys61/k9Vle+WP6ax7Z6iqtwrluGmL7MKjV0e2w+VnLjHe7qY8HN8Fzv0weFI+5VfRK91ou+RyEcg2NdZYtz1lW/V/yPNuWduy5VF9t2fGyZe2D7ka1MTB8Jpz7gdSG3vVVrr/Upqdds+7R58LQyanHSPfpVT2EVqxYwZIlS1K2XXrppdx1113EYrEOTd8AGhsbaWxM/k+uqqoCIBaLEYtliHPfptbzdNX5pO8yPpj1Hi8eL2x/2X3TNwZGzrHMfZ/BG2gmVu+huSnzN8RYIzTHEiRq4LV7DTtXJPcl4rDleWhqSHDuB8EXSNa52oShqcaAgayIxXg6n9d9MnrdS3+k1730N3rNS3+k130LD3gDkAAS6b4UXgjluz+t4ja1YsYXguGzYNAED4m4wZdl8QVd6tH65fWHYe4HPEy70lW/+INQPAoC0Th4LbEYeINw/ke8FI6CjU+5lcryh8Lc90PhyDixmHtfO3aelwObLEe2pr6XvuAmCOa44yKFHgacBUd3dHy/Pfd9kJXdjE0Yxl/kYeOT6b80I2a618fAsd6MX77oAPBmJUjEDV5/5kqiQDY0NzdTU+rJeK5YAyTibmpaxcGMh3Foi6VgRJzdqz2ZMi82PQvjF1qMsbz65/THHN0B1cctvnAztaXelDCoVele1z912tVxMLBzhYfX/pLcby3sWQ01xxMs/gJkZSeI1XpYdZ9h+0vJ4w5uskQHwOVfsQRzMyRi8ra8ne9dvSoQOnz4MAMHDkzZNnDgQJqbmzl+/DiDBw/u8Jwf/ehHfPe73+2w/amnniIcDnfp+J5+OsOakCLtGGMomTaKJfOHk2jy4slKUFq1n+df3kkikSA/v4BhM+dy7M30k3dLZjazbuMqRg6ays5X0q+x+uYrhnEX17Jq43OEQiGmjj2PN18Osmel+0Ezcm6cURc0sH7rChoaTtLY6CT0upf+SK976W/0mpf+SK/77mWMIRKJEK+Ks+GV9E29i4sGMO/zY/B6/dQ3VLPl8DZqdyaXV/N6vUy4dgZTYvkc2eLDH04waGIzB47t4KlnXRdsn8/HzA9ewJsvRNi53Es85ppkn31dE5VmF+sf24YxhtnnzufQpihl+1KDoznvj/Hmvq3sX7mLaRPOIX9YMeX7O4ZLZ1/XxKtrl5OTnc/oc6ew/aU04ZGB/NF1PPPMMsaOmg8E037e+UPh8LH9hLKieLy5aZt+A3gCTbzxxmbqSqcA6cOqWD1UlFdg415qy6LpTwQc2NrEgarNNGzJfK7Nz0Ph1DI8xsO6BwvSHlO6x3D8YAOb9y1lwtD5bH+p4+dYfRTeeLIZz+h1HDl6KOOY5K2pq6t7y8f2qkAIkr1YWtmWyZgnbm91++23c9ttt7U9rqqqoqSkhCVLlpCTk9MlY4rFYjz99NMsXrw4bZWSyMkMZCyTpo5te9xQ6WXbc1BblnpcOA8mzPMRzJtD+R5vxuQfCz4iXHHFFTRUennkB7Q1DwTY/LSPfWuzueJrizsk8YmYoTnm7uB4fJmriPS6l/5Ir3vpb/Sal/5Ir/veIptR4zsWBLQaNslgrQG8FA+fzNlMTtlf9H7D9Ktchb0vyxKIeoGzmDztrLZjFt9qqDjopqqFcmDkbAjmePEFJjKNie48XzCsuR/efMWdK7vIVRoNGu9nVHAeAA2jvRzdaak8mPo767yPQcGgIBcPv5jGai+5g6EyTR4y9/0wcNxgEjHDmPNg+7KOxxgPDJ+aRbhgCoe9XrY8l/7rUjzGUjggl+YGk3FFOYC84ixKpk5lxdrOK5eKCotoboTG2oyH0XA8yCWXXMKK32U+15srfFx72WxmzVaV0DvVOivqrehVgdCgQYM4fPhwyrajR4/i8/koLEy/9mMgECAQCHTY7vf7u/wb/Ok4p/RP/iK48uuWTU9bdiwHm3BLjE651BAtNoAHf8iSORFyzQe9Xh87X7EpYVCrmuOwdy1MusSHMYamekvVYXj9MUvlISgoMUy93K2Q5u+kSbVe99If6XUv/Y1e89If6XXfx/khkFKs0rEKxl8A2QUwbEr7ramhhr8Izv+wZea1rmeQL9i+2bK37ZjLv2wp2wf71lnC+TByluuR5A/62q512Zcsq+6zvPmqay2RMxDO/YBhwBj3esQPM99tOfqmpbLd1DFjXEPvSD74/H4KSix5Q91S9+0ZA+e+30M4xxALWMaca9meprepNwuKRhp8Ph+j5li2LU3/O8ewlr6mWPB4bcZwKbvQ4PV6icc6b+htjNH/uS7wdr6GvSoQOu+883j44YdTtj311FPMnj1bLxzpc6JFhtnvgSmXucfB7NSGfqEct+LC8V0dn1s0yu1vrIVdr2a+xo7lcNZ54Ata9r0OL/w6+U26fD+8+Yrlki8YSqZajCd5bZuwNNV6GDtySsbqPBERERGR/sAfMPiLOz8mku8Cm5Jpmd87ZxcaLvgIzLrOhUv+YMeFYrILDZd/GSoOwIFNlkg+DJvmFrXxZZm2a116G6x7xLJjmetfVDgCzv2gIb8kOeaZ10HpPkvZ3uT5vX5Y8gVDuKU3VEGJe27pntSxev0w+72GrJDB47GcdQFsW9rxcwpkQ+5gF/aMvQB2rkgfCo2a446V7nVGA6Gamhp27NjR9njXrl2sW7eOgoIChg8fzu23386BAwf43e9+B8AnP/lJ7rzzTm677TZuvvlmVqxYwV133cWf/5yhG5ZIL+f1m4yrQASjhkWfhqf+zaY0l8sbAos+ZQhGDY21Fm9W5vP7Am4Vh/oKePmejt+crYWX/tfyru8aslumBdeUWt581bLjZYPxjsKUwvAZtsOykyIiIiIi8vb4AwZ/xwkuKVrDpaFTOg+Xzn0/nH0VJBIuXApFO4ZLl94GVUfh6A6LL9LIsEkBIvluiXtwgdTiW1wDabd4jasMmv0eQ+4gdx5fwDDz3VB1zHJ4c/L8wShc9qXkanH5w2DQeDi8NXWsgQhMv9K0BVrSfc5oILRq1SoWLlzY9ri1189HPvIR7rnnHg4dOsTevcm4ctSoUTz22GPceuut/PKXv2TIkCH8x3/8h5acl34rWmy4/KtQVwY1ZW65z0h+8k5CIOKWBH1hZ/okfvJil+pXHHTLPqbTUA0NVa5ctqbU8tiPLdXHkvuX/w62vmjdspMnhEJ1lRYbB48PQjn6Bi8iIiIi0l18WYbs9J1V2oTzXHVR4ahmXnhhGWPzLsLrS519Eylwgc/Ei90N46yQa0+Rcky+YdGn3JL3lYcglOuadUcKkv1+w3mGiz4J+15vWXa+EUbOgokXG6InqbCS0+OMBkIXXXRRW1PodO65554O2xYsWMCaNWtO46hEepdwriGc66aJpTN4AgyZDAc3pm4vmQ4Dzkr/nBMZ46aJ7XwlNQxqVbrHJf1jznWPG6ot+9+ANQ9Yao5B3lCY8153vUBEwZCIiIiISE/T2epUHm/mmQutQjmGUA4UDs98TCTfMOEiGDHT9UkNRFLbYkj36lU9hETk7QvnGRbc7HoCbXnR4jEw/iJD/lAI5bam9a6MNF2VUDDHlXs2VMOONE3nWm19wVIy3YVHbzxhWf9ocl/5fje17cKPGsZeaPF43XWtdQ2vG2vd8wLZHedJi4iIiIhI36LZAz2DAiGRfqC1FHTwJPfY40n9BhzKhQs/Znj+VzZl4TJjYP4/uuc21LjHmRiP+1NfCW88nv6Y1+61DJ3iSldjDZZDW1zvoroKtz93ECz4hLur4PHph4SIiIiIiMjp4jn5ISLSV3g8pkMYBK5pXMk0uPY7htHnupUExl4I137PMGg8GI8hGIXxF2U+98RFBn/AUHPclX+m01TngiWAysPw9L8nw6DWbY/+2FJTmtyWSFiqj7npamsfTLBvvaW2LPNUUxERERERETk5VQiJCAD+oKFwBMz7GDQ3uhXI2nf6N8YwchZsXWop35f63EHjk/2IfJ2sagbg9UFTvWXNA6nVSK3iTbB9uWXGu8AAx3fDEz9t3/TaEimAK74KOQNTw63mRktjLWAglEPb1DQRERERERFJpUBIRFL4skzGUCdSYLj0Vji4CbYttRiPW21g4FjT1vsnnO96ATXWdHx+3hAIZkOs0TWizuTINhcMNdbC0//WcQW02jJYepflks9DMNtgE5aqo7DuYcueNeD1w/j5MGGhW05TREREREREUmnKmIi8LZECw9gLDYs+bxm6ZAvDzo6nNIIO58PFnzN4U1erJCsMCz9lCOUafH46XQIzb7ALdWpLXTPrdI5sS+6rPgYP/Ytlx8sQq4eGKnj9EXjyF5ba8tQypNoyy5Edlt2rLaX7LPVVmn4mIiIiIiL9jyqEROSU+AIJdu/bzqSpY1O2ezyGAWdZrvuBYe86S9leGDjOMGQiZBe5YwIRw8xr4YmfpwljjOtH5PEaGms7D2viMWhusqx/zNKUZpXMioNwdDuMmuselx+wPPFzt7JZq0Hj4aJ/ckFXe7FGS1PL6mdBTT8TEREREZE+RoGQiHQ5r9eQMwCmLMkcohSOhDnvhVV/Bxt323xZMP9m0xYc5QzKfI2sMAQiblrZnrWZj9ux3DJ8pqsaOjEMAji8FV77q+XCm1wfpUTCUn0U1j1k2bvOjWnCQhg3HyL5CoVERERERKRvUCAkImdEMNsw8WIYOQeqjoDHBznFEMoFr98FL6EcGHMe7FzR8fmzrjOE89y0sc4aWftDYDxQfZwOYVCrXa/BrOvAH4Tqo/Dgd5J9i5rqYM39sGe1ZfGtyVAoEbfUlsPxXVBTaikeZcgZSMr0ORERERERkZ5KgZCInDH+oMEfhJwB6fcHIoa574PcQZYNT7pwJlIAs99jGDbNTeMK5VgmXgwr701/jomLDB6Poa488/Qzm4DmJjdNbO2DHZtYA5TudY2wI/kuDDr2pqs4am5sOwt5Q+HS2zo2sq6rsDTVg8cDwShkhRUaiYiIiIjImaVASER6tHCuYfpVMHYeJJpds+n2U7eMxzDmXNi90oU07U1YBLkt0846m37mD7o/TbWwd13m43Yst5RMc5VGT/5r+zDIqTgAr/3ZcuHHIStkiDVYjmyH5b+zVB9zxwydAufdCLkDO4ZCTfWWRLMbS2uVlIiIiIiIyOmgQEhEejyP15BdkHl/JN9wyeegbD9sX2bxB2HcfNfHKBg1LcdA8Wg6hEYAUy+DcC401LjpZ7H69NfJCrkAqvygzXjM7tUw+x/csWX73Epn7R3YAI/9yHL1N5OVRA3VlrL98MZjlroKGDwRJl4M0SI1sxYRERERkdNDgZCI9AnhfEM431XgGNMxRAnlGBZ9Bl79s2XParAWfAGYejlMWGTw+t30swkLYe0D6a8xfoE7b31l5nFY61Y/a6ixvHZv+mlqdRVwZDtkF0JTnWXj05Z1DyX3l+2DrS9YrvqGoXB4cnt9laW2DA5tsQSjhoFjXc8lf0ChkYiIiIiIvD0KhESkT0kXBrXKLjTM+zjMfi/Em1zD6XC7JtYer2H8fNi92lK+L/W5kxdDtNh93D6kOVEwx523uSl9NVKr/RssY8411FeREga1am6Cl/+fZcmtrgF3bbll6f9aDm5sPcJiPLDwU4Zh02xKKFRfZWmodsFUIOJCI1+WQiMREREREUlSICQi/UpWyJAVyrw/UmC49DYo3Q3bl1sCIRh/kSFanJx+Fs5307oObe74/DnvNUTyoL4KwnlQW5b+Oq2NtA9vyzyWYzuhsRayQpZtS9uHQY5NwPP/Zbn+R6atV1LlYcvzv7KU7nGPvX6YdoWbghbKSQ2F6qtdHyRjWlZ38yk0EhERERHpLxQIiYicIJJviOTDsOkuLDmx6iiUY1jwCVj/qGXrUldtFCmA2e81lEx1fYZCuZZpVxhW/KHjtDFjYPSctx6+1FfBxqfS77MW9qxx16opszz2E0tdeXJ/PAZrH3Srm01cZDEeQ6zRUrobXvmTC458WTBuAUy73AViJ2qosSTikBUGn5pdi4iIiIj0CQqEREQy8Hgyhx+RfMPcG1xD6niz60eUsvqZMYycYzmyA958pd05fW6aV7ilSfagcZmvXzzGTflqbnSVQpnUtFQhVRwgJQxqb+2DlhEzDZECKN0Dj/7YQktW1dwEm56GI1stS26DcF5rryTL4a2w/nFLYw0MmQJTL3VT59I1u26OWTzezr9uIiIiIiLSMygQEhE5RV6/Ibso8/5wruG8D8HZV7t+QlkhKBwBobxkpU0oB2a8y1XxtOfLggs+YghmGxqspWgUHN+V/jrDprhzle1L38QaoKEammNumtgrf0yGQe2V7oXKQ26qW0O1a4q9Y3ly/9bnYefLlqu/ZSgYltxec9yyf4OrVArnwcRFLjQKRBQMiYiIiIj0VAqEREROo2C2IZgN+UPT788KGyYthsETYP1jlvrKlmXnFyXDpmDUcO4H4JEfdgxyogOSTa5zBxvSJj246V5eHzQ30NZfKJ39GyyDJxpqy0gJg1o1N8Grf7Is+owLfKqOWB79kaWuInnMtqWWOTfAhAXu8wOINbhj9q6zNFTBsKmG3MHJaiQREREREeleCoRERM6wYLZh8EQoGuWmn/mDHRs8F5TA5V92PYkqDoLxwqg5MPs9pq3vT+FwCGRDY03Ha0y9zFX+1FW46qPmpvRjCee5v/etz1xtdHATNNWB8VhW/i01DGq18l4YcbYLomINlt2rYOldyUBr/WOWwhGw+JbUvkX1VZaaUji+260AVzAcInngUcNrEREREZEupUBIRKSH8AcN/k72DZkEl38VYg3g8bhG0f5gMiiJFMAVXzU8fYcLVQAwMG4+jF9g8HgNoRzL+IsyNKk2rnIHwOPNPE5j3LGNtbBndebj9m+w5A421FWkhkGtSvfAhqcss6930+9qyyzP/cpydHvyGF8ALr3NMGCMbQuFEs2W2gqoOuoqnvIGQzAXAmGFRiIiIiIib5UCIRGRXiScayA3/T5jDAUlcNU33MpksXoI50Mompy65fUbpl4GR7ZZju9u/1xY8AlDON89LpluWPnX9FVCw2e6ZtcNNW6Vs0xaq5D2rk3fswhgy/MwZQkEsi3rHk4Ng8A11H7yF5brfmCIFkM8Zjm8DZ79T0usIXnc+AUw63q3AlyrxhpLfTXUlkJWxFU/tW/8LSIiIiLSnykQEhHpYyL5hkh+J/sLDIu/AJWH4cAGSygXhk0zhPPAH3CBSTgPpl8Frz+S+txgFOa815AVMiTilgFnwdEd6a8ztKXZdV1l5rE0N0Ii4QKs7csyHNPkppBFi6G2HJ76V0sinnrM1hddw+4JCy3GGOoqLCv+4KaqtcouhMW3QsGwZCiUSLgpb3XlEI+5KqtQbvLrICIiIiLSVykQEhHph8J5LgAaPCF98BGIGKZcBiXT3LSuhiooORtGzTVEi9xzgtluFbWHv29JNKc+f9QcyC5wH5dMM2x4In2JUPEY1zOpscYFMpnUllvAsHdtxzCo1euPWEbMNAQilvWPpYZBADWl8MTPLO/6tgvF4s2Wozvg2TttW98l43VB2KRLIBRtV21Ua6mvgtoyLzPHLaax2oO/IPN4RURERER6OgVCIiKSVjDbEBwHhaMg0Qz+ABhPaoCUPwyu/a5h7YOWQ1sgmA1TLzcMm+ZWRwPIG+IaXpfuTT2/MXDu+w3BbEM8ZokUQG1Z+rEUj3LnqjiYeby1ZZCIu4qkLS+kP6a+EioOuUqg2lJ44uepYZaNw7oH3apwo+e2nLfcsuJ3lj1r274yRAfAki9Y8oYkvx7xZkt9BVQfg+YY5A6EYA5khVRtJCIiIiI9jwIhERHplM9vyNTt2usz5A+FeR+DpnrX7DqUmxqAhPPcFLU3nrBsfdFNEyse48Kg/BJ3TCTfMOcf4IVfd6wkKhgO0QHu48ETDVtfTF9tVFACXn9LtVGGVdQAqo8Ck2H36o6VTa3W3G8ZNB6yQrDuofZhUPIcT/zccvU3XLVRc5Pl4GZ44VfJ3kbGwLQrYcqlyXAMoL7SUlPWEkzlQ85AyC5QaCQiIiIi3UuBkIiIvGP+oMEfzLw/UmCY816YchnYhKs2ah+SAAydCgv+ybDyXtfXx3hh9Dkw+3rjmmkDA8e6qpuGqo7XmHuDIZTjqo2ywtBUl34seUPd36V7Mo+3+pirNqqvhG0vpT+mtswdFylw09Ge+XeLTST3W+t6MBWOcFPoAGpKLc/8p6V0d/K4UC5c9iUoKEl+PZrqLfWVcHATNDdZhkwyRApc1ZaIiIiISFdQICQiIt3C6zdtfYXSCUYMY861DJ5giDWA1+fCn/YNnrMLDVfeDkv/13JsZ8vzcly1UdFo97i1IfbKv3a8Ru4gyGmpNho4zvDmq+mrjfKHgs8P9fVkrCICqC6FQcCOl1PDoPbWPuiqjbx+eOWPqWEQuNDpyV9YrvmWC84a6yzbllpe+0v7oyxjzoO576MtHLPWUlMKh7fA4W2W/KEwfIYLjry+jsFRc6PFWhfeiYiIiIgoEBIRkR7DmM5XSAPIG2xYcis0VLuwJtCypHxrfyOP1zD2Qog1WN54PNmsetB4mP+PhnCeO65kGqwKQay+4zVmv9cQjBpijRZfwE1zSyd3ICTittPeRjWlbpyxejpMPWtVVwE1x121UfVRTgiDnJ0rYNhUOOt897jiIDz6Q0tjbfKYlX+zXPYlw8CxFo+3dZU3y/HdsPkZ15B73Hz3tYjkdwyGmuotzY0uvApEFByJiIiI9GUKhEREpNcJZhuC2Zn3h3IM06+GcfPc1DFvFgSjqVOusgvhyq8Znv+VpfKw25YVdlPPike5x+FcN81t3YMdr5E3BLKLXAA1aLxlz5r0YyksAV8AF9ykL0gCoL7KhUubnst80PrHLEOnuI9f+O/UMAhc8PTMf1je/T1DdqELg166y7J/ffKYg5ss+SVw6a2uIglcEFRxENY8YCnf76qoZrzLTXc7MRhqqrc01bpPJRBR02wRERGR3kqBkIiI9Ek+vyFanHm/8RgKR8AVX2tpRN3sQqNwHm3VNV6/YeIiiDdaNj6TnD42eIJl3j962qZvjZhpWPOAzVhtFIgYmuot/iBtTadPlDOwZZW08sxjbqh2xzTVQ9ne9Mc01bkV1LIL4fhuUsKgVuX7YNcqy+TFrtfRgQ3w3C+TQVRdOTz+U8u5HzSMX2DxZbnPs/KwZeXfLHvXuEBo2FQ4531uKl77Fehija4HUqwB/EEI5WiqmoiIiEhPo0BIRET6tXCeIZzXyf5cw8zrYMLF0FRraWyuJX9AmHDOCdVGtxte/I2rsOH/s/fW4XFeZ/r/5wyTZsQs2TLIzBA7sePEiQMOp2m75Xa7hW2/bdJuIe222y1ky7RbSmHLlDaFMIMTUxzHzAyyZFkMwzPn98ejIc2MnP21TWLnfK7Ll+R5z7w074zm3O/93A8SFr30LYqyxtR6pOvY5rvzt1E3TYQom0Mxbi607SjsEkp1PgsPjn1MsYiEUe95vLjbaO+TMHGJCGFrf1543Ka7NM1zRVgbPKO57w6ds+2T2+H0fs2Nn1X4a+SxYJ9m8580B9aCToCywMSlsPCW3DK1eEQT7CddbldaL+fI5jTCkcFgMBgMBsNLgRGEDK84hns0PSfhzCGNv0ZRM1lyNVJ37A0Gg+GlxuZQ+KsgVhrngQeeYPW41YA1vVxZFBXNcPVHITwsQsjobCOrXTFlBVismm33iZPHYhWxZMHNKt11rWkOuO+RsOlsLDaYd4PC7lI4vRqnl7ySMZB29/5qcf4kE8WPKZmQMeFBcUgVIhGTbmreCs2hjbqgEBULw54nNAtvkfHP/V5zaH1muU7CwbWS6bT8n6UELTKsObQBNvxGo0f2UVklHHziUp0uU0smNMPdcGI7nDmsqZ6kaJwF3gqwWHL/JiSTmsggoMDly3UsGQwGg8FgMBjyMYKQ4RXFQKfmwa9ohrpSj2hsDrjqo4qqiTpvAmAwGAyvJNwBhTswxnK/YsaVMOECEVKsdnES5XRSq1Rc80l47neaE1tFtKmaCEvfrNId0jylsPgNimd+nO/smX5Fpjtb68Vwaldh98+kpSKchAfGPiaLVfb1RJFAbBDBZvZqiIbh8IbCY45thkWvFaGsvx3W/zJ3v3QC1v9KUzFeUTNJuqh1HYMHv6SJR2XMwXVSdnf1xzM5TwBD3ZqD6zQH1wIKplws5ziVkZQiEdeE+sQVZbXnlgcaDAaDwWAwvNowgpDhFUNkWPPsT7PFICEehUe+mQlJNRgMhnMZq/Xsn2WBGsWKd4tzR2spE0s5iEBEjHHzNO4PK57/g7gqfRUw73pF09xM0HNtK5Q35+cNecuhdbnCYlU4fRpfJXmfvSAh254yEYWcY4R4O73iYIoOy/4WIzwEnohm2wNjB2df8m7JSXr8vzNiUIpYWPKOrv0UeEsVQ92aB76kGTyTGfPc72H/M5qrPpIRhYJ9mt2PaXY/JutweGHONTB5mQh1KeJRyT8aOCPHXVIhop3VXlg40klt3EgGg8FgMBjOSYwgZHjFEB6E9j2Fl0WD0orZCEIGg+HVgsOtcLiLL3d6FU2zoXK8OF4sFslDysZbprjiNji6WbP3SSkTm7gEJi9X+CpVeswl75EQ6UQs81xlgRXvVngCYLEpZl4FJ7YVFnJmr5bgbLtrDDUIEbYS0cLiU4qhM1J6FhqAYF+RMV3ibPL4NYc35opBKfpOQdsu6TQXCUoY9sG1meXRYdh0F0SDmrnXS1lgZFhz4FnNprsy5XY2B1z8LkXjLJ0Oxk7ENEPdcHijpucE1E6F5jnyN2q0OBSLSFc2lISWW21GPDIYDAaDwfDKwAhChlcM2RORQoQLZGUYDAbDq51sd0shvOWK6ZdLCZXWUiY2ukyqsgVu+rziwLOaM4cl4HnqpQpfpYhBAOWNMOMK2PVI7vonXQTVk+R3lx9qWuH0/vz9qBwvgojdBdUTi3dJq5okY5Jn+ZuQjEuG0sF1xcfsX6MZt0DEo2Ljdj4MU1ZASRV0H4eNv81dHo/CE9/T3PQ5RXkTJOOajn3w8Dcz+UdHn9dsvluCxSua5TGd1Ax0wpa/ao69AFYbtK6A6ZeBryL3/EeGNKFBcS45vaYrm8FgMBgMhpcGIwgZXjE4PBQNSQWZoBgMBoPh/45SCre/+HKrTRGohfk3i4PHas8XjVwlinnXQ+vFcHyLJpmA5nkKX3mmnM3lk1K3x7+j6T6aeW5ZI6x8v0qLVzOukJKuZDx3Pyw2mHmFwmpXuAMai428MSCuHdfI8Vis+cvT67NKyHawDyhiXkrE5O+Ow6vZ8tcig7QEZy95k4R9P/7djBiUIhaCp+/UXP0xyZIaPAP3fE4TDcryeAR2PADHNmtWfzxTyjbYpXn6hzotoimLuJrm35Tr+Ar2awY6xO1ld0HLIoW3nHQAdzbBftk/m7PwcoPBYDAYDAYwgpDhFYSnFBa9TvHsT/O/kLcsYszJjMFgMBj+diwWhcVVfLnTp3D6oLyxuMhQUqm48sMiwgz3yme7t1REkswYWP1xxZofawZOy2P+Grj4XxQllfJ/dwDm3Qib/5i/jQWvkRb1Vrti6qWw9meFhZxpl6mR0ruxS9lsjrOXsvWdEvFoqFvEn0L0tklOkt2j2fFQRgzKZuA0tO+TUO9Qv+axb0vZWQqdhH1Pg9WuWfQ6KWUL9mme+oGmfW9m3NZ7NPNuhOmrwDUi+oQGNCd3wLZ7NcO94spa9FoR5LIdR4mYJtgnpdoWq4hr3rLCr6lSiob6xuInxmAwGAwGwzmLEYQMrxgsVsX4BZLRsOkPEi7t8Mid5KmXKFw+c5fTYDAYzgXcfnEkpcqnRmO1K2omwzWfyLhCnd5cR4zNoZi6AgI1sPlP4o4J1MGC1yhqp2RCnpvmiPDRdTR3G3XToGZyan+kJKxQ1lBly0i2jx3Km4qLQtWTMsLRWCQTkk90fIyubIfWacYvFMEsWwzKZt/TMPNK8FVKTlK2GJRiy1+geS64vNKY4YU/S1ZUio59cO8dmis+JHlTAOEhzcF18PwfdfpYvOWw8v1yHlPOsFhYcpL2P2Nh8Mw8Dg1Dw0xNSWX+3+LwoCYalhwrV4m8dgaDwWAwGF75GEHI8IrC6VNMuABqp0hug8Umd4FNW2CDwWA4//CUKjylxZe7ShQti6RbWjIhbpZspxGIs+XyW+H0Adj3tEYpmLZSUTUhIzB5yhSrboUHvqIJD2Se66uES9+r0iVv826E41t1XnmZ1Q6tF0tXtpJq2UahbmpOnwhbKCnXKobdAxYlbqNiJGKSKRTqh12PFh+390nNRW+XEO5sMSiNhnW/0Fz3KTkfpw/Axt/k7vxwDzz4Zc1NX1D4qyUI+9gL8PSPMufi2GZw+TXXfAJK6+R8xaOa7uOw4VearqPyN3vShTDvhtycpGRSE+yFvnY5nvJG6V5XKP8qEdNEhkFZwV1i/vYbDAaDwfCPxAhChlckozvljCYSlC+Xx17QxCOSY1FSmT9RMBgMBsO5z9k+271ligmLEReMArszf3xZo+KGz0jpV/9pTVm9IlCXWyoVqIFVtyme/V9pPQ/iLFrxHpXucun2w+xrYNt9+fux9E0KT5nkFk1fpdjwq8KlatMvU1hsCm9Z8VI2ZRVRSScpWHqWIjwoY7qPFR8z1CVOLGXRbL678DbjURHDZl6hCPXDmp/kC2PhAVj/S83K90s2UW8b3H+HTotjyTjsXwOn90uWkrdckUxozhyBR76RW0JXNw1WvDtz/pNJ6Ra362Epe3N4YNZVUDcdPKNe/9CAJjQgbi1XiZQXFnMlxSMaizUTjm4wGAwGgyGDEYQM5xyRIc2uxzRb/pJ5bNt9mqa5sOztZxeTDAaDwXB+crbOXL4KEXYaZxUeZ3cpmmZrbviMIjwkAc8uX+7fFbtLMfNKKG+GLX+R8uayJlh0i6JinOQwAYxfoDnyXH7HtakrpfQNwFMOgVro78jfl8kXitCBhoaZcOS5wsc04QJxLtldY+ckWayQiBfeVoozh+Rn1xHyQrNTnNoNkSEAzXO/1QWdUv0d0rHNWy5lcQ9/TRML545p3wPb79csej3Y7IqBDgnhzh731J2a8Qvgwrdl3ER9pzSPf0fTd2rkuGwiHM24ItdxNNilOblNbhy5/DDjcsmpco4qP48GpcNbMg4Ot2ReKYv5HmEwGAyGVwdGEDKccwx0kiMGpTixFU5sk/bBBoPBYDD8/0Ep6d7lLS8+xlUijqS6qSKy2OyZTmspvGWKle+ToOkDazV2J7QuV5RUZcZ6SxVXfAge+x9N78nMc8ctgPk3q7TTaf6N0tktEcvdj5JqqB7JSSprkNK20WNAxjh94iQK1JKzrWyqJsjPWKT4sQMkk1LO1nGg+JjjWzTNcxXdx8gTg1LsexpmXgVOr2bTXfmiEcDRzeLIcvthqFvzwJcz7i0QIWfbfSLkTFupURbFwGnNff+VO+7Qes38mySE2+mR8zrQqVn3C03bThnjDsDifxJRMLs723CP5sxROLFV4yuHlgsU3rJ8ATIW1oSHpLzR4S5cEmcwGAwGwysJIwgZzimSCc2eJ4rfBd3xkKZ5rikdMxgMBsM/nrNN+FMZSQ0zio/z1yiu/qhkAEVDIny4SnLbxfur4frPKDbdJeVUVpu0pp+9WuEbaV/vCUhp25PfzXXtuEpg+TsyjRkWvAYe+3b+31GrQ8qvAaonFj+mQK2Uc+mk5CWJWygfb5n8HOou/jc7ERNBJxqE49uKb/PoZk3VBEXPCXJEnmy23KMZN1/h8Gie/6MuOO6FP8P4ReD0iMjz4Fd0Toh4qB+evlNz+a2KcfPkscEzMi47kPyFv2pWvEsxboFOi3aDXbLdI5vEXRWog6VvlnOZLRwN94r4175H46tUNMyUc5UKSU8Rj+h0OaDNbfKUDAaDwfCPwQhChnOKZFK+NBcjMixjDAaDwWA4V3AHlJSHFcFiU5Q3wiXvHWl5r0a6eWWJCFaHonGW5uY7FAfXafo7oGGmonEm+LI6g9VMhsX/BJvvzriJPGWw8v2ZnCRPKUxeDgeeyd0PpeDCtyo8AckGmrFKRJZCtCyWbVaOV+SFEZHZTionyWIRZ03h45ef3ceLi0vhATme8JC4iopxcpvkR3WfKN5R7rnfaaomgN0p3djyutNpWPMjzS0TFfYaEXke+qpm4HRmSH87PPQ1zTWfUNS2ymODXaPHaZQVVn1QUT9dp0WhwS7pGHd4g5yTyvGw5M3StS87K2m4R9PbBh37NCVVirpp4myz2go7l3RSnEuj3WwGg8FgePViBCHDOYXNrhi/EE5uL/ylsHGm3Lk0GAwGg+F8w+lROMf4G2d3KkrrYeEtCp3UBbNwXD7FtMtg/EII94vY4vKPZOcoGe/0KhbdIt3dtt+vCfZB1UTNwlsslNbLeixWRevFcGq3pmNf1gaUOJI8IyV3/mooayxcprbwteKgikehZTEcWl/4uFoWyn6VNRYXl1wlUjKXTIjwUYx4VH6e3l9cXBo4LYHViRgceb7wGK2hfZ/kEnUfJ0cMygyCjb/VXPlh2bdNd+m8cTohJYO3fFHKCVPOpcHOzJiuo3D/f2mu+7SiqkUey3cuaSw2uPLDippWnRaFBjs1m/6oOfq8nJfK8bD0LVDelCsuDXVL+PfpfRp/raJxVmHnUmRYExmSm29Oz9iO7GLXoMFgMBheORhByHDO0TBjJKiyJ/dxqx3mXKcKdpcxGAwGg+HVxFgTcZtdOnOWVBZ/vjugaF0ODTOTdHZ2UVtfmVe25C1TXPo+GDoDbbskd6dhpohLqTIpz0hO0sbfao5tFiHFVSKiVdMcEaHsTph/k4hLo0u9ZlyZKT+rHCdZSIXK1GZfA+5ScVDVTYX2vYWPq2mO7Je/uri45PBKl7dkrHi4Nog4AoqTO4qLS11HRISKheFoEXEpGYczR6Sj3Zmj5IhBKXQSNv1ec9kHJOx8w2/ynUvJODz6Lc3N/yWv71C35v4v6ZzvS11H4b47NDf8p6KiWR7rP6154Isi/I1sraC41N+uWfdLzandMqq0Hi56u4hMKXFJaynDO7kdTu3RlDVoJi5VeCtyHW0AwX4Rl3RSXtdsUTKbRFwTj0pW12iBymAwGAx/G0YQMpxz+CoUq2+HLX/N2KnrZ8AF/6TwV+WOjUXky2UsJLZ0tx8cHvNlwmAwGAyGF4PDl2T7mg00TlgNWPOWewIKTwCqJxX/2+qrUCx/Jyx6nbhuCnXz8lcrrv80HNsKR5/XuHwwY5U4nlKdwbzlsPrjisf+OyOGKAtMuwwmXaiwWBROL1zwRrj38/kh3C2LwDtSFlc3rXgI98wrJJMpMlzc3QRQP1X2yzdGALnDK/uYiI7tXAoPys9jLxQXlzr2S+B3Mg7HtxYeE4/K/pZUSoe70TfPQPbj+T9qLv1X+X3tT7PFICEZh8f+W3PzFxS+Silju++/dHo/AfpOwQNfyhWXetvEzRQNyv+PPg9b79OsunWkLM4m5Ybdx+HpH2r622WcpwyWvV1RO0WnxcRETDPYBXue0HQdBn+dvDb+6txcpmRcE+yHYD+gJRzcEygsHkWGRVyy2knnahXD5/ONudxgMBjOB4wgZDgn8VcrLnorLLhZ7jY6PflCT7BPs/Uezb6nR3IJFDTNhgvfKl9ODQaDwWAwvDQ43AqHe+wxvkrF9Ms0ky9SWGz5jhKlFOVNcO2/S55gPCo3etz+XIGgrB5u/Jxi232aU7vEfTLranEvpVxO3nK44sOKx76d291s3EKYskJhsSrcfrjwLSJ66FE6TePMjLg0br7i+T/kjwERMNx+CCtxAOXlEY2QCvIeu7ud5Dgl4hQzNwGMhFFrjo4lLu2Tm2XxaHE3VSwM/R3gq4ST28gRg1LoJLzwJ82K94i49vQPM2JQekwCnvxeRlwa6oYHvqjT5XsAwV545FuaGz6jqBwvj3Uehoe+otPZUp2H4OBazaXvVYybL5lLsYg4ltb8KLNdmwOWvkUxfoFOfzeMBjU9J+CFP0vukr8a5t8s7qbsAPdoUBMagNMHrFQlL2T4jBVPqc77jplMakJ9csxWu7jTLEVceTopr4MpnzMYDK9EjCBkOGexORU+Z+Fl8Yhm232aPU9kPailLf1TPxDLtWkHazAYDAbDKwulzi4cpbq3FcNiU5TWwUVvlQ5mypr/N99qU9ROFpGir13K0MqbxV2S7RypGA/Xfkrx3O81nQfAWQIzr4TJF6n0Oj1lcOn7FE9+X+e4gOpnZMQlTykseZOUdI2mfkZGCJp4gWLbPYWFnBmrSIePe0rJc/WkqBwv4oOvvLgg5CoZcS7Fiw4BxCWViGtOjFEWd/qgiEexEPQcLzwmFoaBM+At1xxclysGpdGw5S8iLsXCsOaHOj9oXMMz/6upmjhSFncGHv/vXDEuHoVnfqIprVNUT5IOtce3iliVIjwID31Vs+RNiikrNDaHIjKs2f24lqB0DeBkEzDnWs3MqzLXRWhAjmH7/bIeV4mULE5ampupFOzT9J6C/U9rUDB1BQTqxVWXe47FeRUNSg6myy95YaNJJDSREVHO5S8uQBkMBsP/BSMIGc5Lgv2w96nCy04fkNaybv9LuksGg8FgMBheQmxOha3IjSMQ4chXKQ6YYtidiuqJcPkHRWhQSkSZ7Mm43alonK255UuK0wcgPKipnSJd27KFqNopcNVHFBt/Ky4VhwemXQ7TVmbEJW85LHuH4tmf6RwXUN10mLxMyuI8pZoL3iAC1GiaZpMWyyYvV+x8uLCQM/Mq6Wynk3I8o7ObUpQ3SQe4sfKmPAGwWIt3iUsRj0I8JqVsxeg6KmJQZEicRAXXE4HhbvCUioBTyJkFEi1w6ftEaFn/q8KDNt2laZ4rgd69bfDCn/LHbLtPSgwbZkgUwY4HNTsezCwPD8JzvxMBaP5Ncj0E+zRrfqJp25EZd3iDpnme5C6lRKGhbs3an2lOpsYpGL9AxENvWebaGezS7H1SohKUBVovhkkXga88M0ZryYvqOQH9HZqKZkWgLnc9KUL9mkhQrmenr3j5XDymSUTB5gKr1QhQBsP5iBGEDOclsZDUvxdjqEe+5BgMBoPBYDCcjbPlzdidCnu1lCJB4bEOt5StXf0xEUcsVnAFcifaDrdiwgUiKLXtEvdI4wyFryojLimlaJilWXWb4rnfafo7RFyaPiIupdrK+yrgwrcq1v0yV1xqmit5SkplxKWnfpAvmEy8UMQiZVFMWQG7Hyssqsy+VgStZFzj8kN4IH+MUhCoBatNfqaCqUfjq5SSr/AYJXEgQlYqL6kY/R0yJuW+KUQiJk4rl1+EnmJsu19TNUHWtfORwmN2PQrTVoK9WjrQZYtBKY5vgcnLYfx8CA+JaNSefS50Knxcs+yfxSk02KW57w5NsDczbPPdcHCd5uqPgndEFOo9CQ98WWeFrmt8lXD1R8FfM5LLFNV0HYNnf6rpOyWjqifDsrdBaUMm1Dsako54ux6Rn1WTYNql8vqkQsZT48IDkidltYO/tnB+UzIhOU/JhISDe0qLv5/iMY3FIp0MDQbDPx4jCBnOS+wu+fJR7K6RJ/DS7o/BYDAYDAYDjN2qHSQPKVArwkkxccnpUTTPhcoWCaxW1pRTJ1dcmnihpn664tRumbw3zFB4y7PEJYu4m674sGLT78W55PLD7Kth4oUqna/jqxTn0tqf55bFtV4szhkQZ9KFb1E88d38L18zrxZntsWqmLYS9jypC+YgzbtBthmP6KLOJat9RDhyQsU4cX4XoqwR7E5x1IyFZaSjXLESPIBwv9xoDA8W7zynE7Lc6dXsfqS4uLTrEU39NBHO2osIY0c3w8JbwO7UHHw2VwxK0d8ObbugdTkM92oe+abO68A31AVP/VBzxW3gKlH0d8L9X9I5x9B5AO77L82NnxWnVDwmHQHX/DhzDJ2HYO8Tmqs/pqiZLI+FBjW7HpbSudT3basDLnmPomGmTnf9DfZp9j6l2fWICHMlVbDwtdAwPRMYDzDco+k4AIfWaewuCYsP1JHX3TDYJyHokWFGruXcHKgU4SHJB1NKrunRmWQpdFJKE00HO8OrFSMIGc5LXH4Yt6Bwi9dAndT7ZxMakPptrcHpLWyvNRgMBoPBYHglMTqPZjQOl8LxIsSlptlQOU4yhZRFxKXsEOSUc6lumqLzkJRt1UyWcalJvbKIEHDNJxSb/qjpOSbCzdzrFQ0zZB0gj136r4o1P5ZyJHkuzL9JBC6Q72nL36l49Jv5JWEXvFHK3axWxbTLRFwqJNLMvV5hdylcJRpveeGOa06fuKBsbqifBl1HCp/H2ilys9HmKHamBZsDkiPupWLEIyPi0VDxMWiIhkT0OLSx+LADz2rGLxQxq9DxAZw5JEKV1a7Z+tfC5yoahMPPaWavhlAfrP15vqCViIlIdM0nxOHTeUDK6XLGROGJ72hu+oKirEFEmfW/1hzdlBkzeEZCxpf9s2LyMo3Fohjq1jz0tUzXOYDDGzVTLoGFryHteutr0zzyLZ0Tzj5ugYS/p1xHiahkN234jeb0fhEQJy+HOdfkNpWJhmQ9+57SDHVD42xomgMllbnvk5QLavCMXAOechE/R2c4JWISSJ5Mgt1RXPjVWhOPiIhbTKQyGF5KjCBkOC9xuBVL3giRYK4VN1AHV9ym0l+gCrU+9ZbDsn+WLzqpuxsGg8FgMBgM5zMvxrlkd6XK4grjcCtqp8CqW0UcsFjz12t3KcbN07zmvxQDneK8CdTmdotTSlrQ3/BZ6RbXfUy2O/d6RWkD2BwyrqQSrvo3xdM/1GmHj9MLF71dgsVBbvJd+q/w4Fc0iVhmP5QVLn2vwlMmk/spK2D34zJZz8bqgBlXKKx2EZcCdeQIFyn8NRIw7fRCy2LJ8inExCXg8Mq4sXC4xd1iHWO2ZrXJmGIlcSniUYiGxelTjFO7pOxw4DQ55ymbgdOS72Sxarb8tbALSmvYv0az+J/E4ZUtBmXz/B80DTMV7oDkIxU6p/uegtZlcl6HezQPflXnObmObZY8qcWvl+uirwPu+XxG+ErEYO8T0L4nU2IXC2sOb4S1P8scw4ltmi1/gWs+CaV1mQDxbfdqdj+WcUE5fbDqVkVVi8YyUj433KvZ+ZBm71Mi+JXWw5I3QtXEjBAKkgV1fIs4sJx+mHm5zE1cWS6oZEKOsb9DznVZY37YvZxnGRcLj7zPRnVbzCYyLC4ohye35G80Sil8Pl/R5YbzEyMIGc5bvOWKlf8qrWmDvfLHxB3IrVse6oL7v5i5QwVyh+WRr8uXkIrml2HHDQaDwWAwGM5hzpa5ZLVLl7CxwqrtTvketvydMum1OXIn16n11E3TXP8fKu30dpWMODiyyucqW+CmLygOrdOcOSI5kpOXyT6knB6+KrjuU1IW13kw87yL3qbS++kpVVz2/ySrJzsryVUCl39Qpb9jTlwKex7PFy+85TB+oUIphcuvqZ5EelvZNM5JiUuKqSthXQHHDsD0y8UF5asoXqJmdYj4ZLXJ9+BiTiJvhYwpFreQQmtxkhUL/QYRM5JxCeouRirbSSnYt6b4uH1rNNWTRDwsVta3fw3MuhocHs2muwq7oPrboeuYvAah/sLnNDwI63+pWfl+EU+ObZZsqGwiQyIu3nyHwl8tAd1PfFfnvI59p+Chr0kpZtNseWzgtOa+/9I5ZZBHn9PMWi3uJadXcrg6D8Mj39TEQplxo11QkaCmbSc89zsJElcWGL8QFr8OfFkOp1C/5vRB2PGgJhoUB9TUS6VsL5UXBVKG198BHfst1HgvItRrxVKm88roQv1SUZGIj8yrSk3Y+PmAEYQM5zWuEoWrBMoa8pclk5oDa3PFoBRaS3eKFe8qrrYbDAaDwWAwGP6x2J0K+xjd4pSSXCRvefExVpsiUAPzbpTJrNWaWxIHIgyVN8Gq26TUaXBgkIoaH55AbghRWYPihs+IA6j3pKasQVHenFuOVFKpuPbfYecj0hkMpCvY9MtVepy7RHHpe+HJOzWdWTlI9TNg2dsy+U3Nc+HAM3DmcO4xNc2Gygnyu8svIeCH1uUf+5xrRCCz2hVzroXH/6e4uGSxKvw1umjXOF+FOGRS+U2ndhVcFbVTZHtO39jqUsr9NFYjmHhEcn6yy8RGk4jJOGWB9j3Fxx3drBk3T8oeiwlfp3aL6JOIwZZ7Cg9KxCS/yV8Ng12FRT2ADb/WVDRLqdnmP+mCmVg7HoBJF4poN9wrQtLoucmxzVDeqJl7vQidHXul7C6FTsKR56DnhGb1x0U4Cg9qNv5e51wTfadg39Oa6z6dcdANdUsZXm/a0eZgk01cfnVTRRTSWvLFnvq+Tot8djcseq1iwmKdkwVlOPcwgpDhVUsiepbWp0fkjpTd9dLtk8FgMBgMBoPhH4NSCpt97DEun8LqjPP0xqdY3bIasOaN8VUofBXQPLf4RLikSrH4dTB7dWq9+cHFvkrFqg+Kmz0aFFHA7c8NW/aWKS77gHwv3fe0Rlmlm1x5UyZDyumRbZVUSnhzLCwOjnk3KFoWZ7Zb0wozVuW6XpQFlr5Z4a+S/3sCsPj1ig2/yRVDlAWW/bNK52wuuBlO7c4PB7e7oGWhjAlUi9OmUElb/XTZR6sdxs2HA88WPo+TlymURRGoKy4u2V0iUikl2wsPFh6XaiozVsYTiFiUTFAwzDtF7wkNKE7vL75fA6chFpF1HSmQa5ri+BZNeaOiYz8Fb1SDvGatK8Bi0Wz8beFt9rdDX7sIgEPdhQXCaBA2/UFuelss8MKfs8UgIRmHR7+tueWLEjQ+1C0VFdHhzJhYCNb9QuMpVYybX/zYDK98jCBkeNVisUu9d/vewst9lfJHKkU8Ksp+NCR/eMaq1TUYDAaDwWAwvLqx2hXesrHHpNzsY+Etk/U0zJJo8EIdsTylirk3wJQV4mCxOvLDj90link3wtSVkidktUHVhNzvtDanYtJFmopxiq33aoa6oKIF5lyjcvKjyhokS2ftzzNd0Mqb4OJ3KXypErsyWHWbynO9+Col5ynlgppzHRx7QecJR1UToaxJfi+ppGh+06yrZVsKmL4KXvhT4fM4cemIMDa58HKQzB6HB9DFtyfrkHW5/IqCLfMAi03yfbQmpzvfaFIOqcHO4uJSNCjjkjCmW+r0QU39NMXR54uv68QWWZ/WcGh98X3qPCTlZR17yRGDsnn+j5rqiWfPIDO8cjGCkOFVi9WqmH651CYX+hyfe33mD1WwT7PtPgmLS4504GhZDItfbzqSGQwGg8FgMBj+8ZytK5XVKs6lsXB6FU4v6ZKhYmNqp8DKJojHwOESoSgbu0vRNEfymyRoeqRrmz8zzmJVVE/QvOYOxekDkqNTNVFR3ihZnyn81XDDZxQ7HtIce0HcPtMvh5ZFCu9Ibo6nVHHlh6XTWce+keO1iwA09RKVzrJpXQ4nd2o6R1UBLHmTwjdSVugJQOvFkj2UjbLAhW9V6WNYeEvhEjunLyMq1UymaIndpKUitiXi0DAT2nYUPt8pp1nVxOLiUknVSBe7hJyf0eHnKXzlqa5/hZfLQvmRjBfe7xShgREX1IHi4lLfKTk+w7mLEYQMr2pKquCS9yie+Umm84SywPyboXK8/D8Wlk4Ke5/MPE8n4fAGiAY1K9599vBEg8FgMBgMBoPhXMLhUTjGWK6UOJfGckFZbFJ2VFIFaSWiwHr8NXDBG2Hu9fJd3O3PDT4GKcO77ANSEhaPjJTYBTJd52CkxO79Uq51YqvG4YVx8xWe0kwoudOnWPgaqJ8G2+6XCoDqSTD/ZkWgNrO9uikSKr7pDxn3UnkTXPJelQ5v9pbCZR9QPPY/uWHWZY0w70aFzaGwOeCC18M9+/O72LUsAu+Io6q8UdxTQ13552jR6yS0PBHTTL0Udj6UP8Zql7JAgPELFFuLZCCNXyjnLhaW16WY46h6oho55uJCla9SBDHDuYsRhAyvauwuxfgFI90LOkQlD9TlWmdDA8W7H5zcDuEBqQs3GAwGg8FgMBgM//+w2RW2s5XY+dRZv3d7AgpPAGpbi9+wdQcUE5dKiHcyIXEQo7vYOX2K1os1jbNHXFC2ke5aWS4oq0NRP0Pydtr3wHCPpm6qIlCX29k4UAc3flax42FN2w4RZGZdraibJqV8IK6p1R+HtT+XLmIg21v0OkX99JHt2RUzr4TuYzonQNvqgCtuy5QoeiukNHDvE6POXwkseI10p7O74II3wGP/nS/2VE/KdAFsnC1iU+rmeTbzblA5x2k49zCCkOFVz9lan0aDFGxfmSLYB6X1WeNDOl2X6/BI0J/BYDAYDAaDwWB4ZZEt7hTCMlKGN1Ypns0u+UqSsVR4fRaruI+WvAGiN4irxlWSP7akSnHpv0J4pNOZw5OfBeUtkzHDPdB1VLrMVTSPdJOzjWQb+RTzb4LxC2Dnw5rIMDTPg4lLFCVZrenrpsKqDyk2/kYzcFqEpSkrYPbVKp0L5CuHqz+meOy/dTqwW1lg5lXSyt5wbmMEIYPhLJyty5gz6y5Ff4fm+T9ojm0RQahhllhEA3W5H+QGg8FgMBgMBoPh1UWqhGwsUjlPY+H2K9z+TMRFwTElioYZUD1xxAXlzp+PODyK5jlQOQ5iEU3/QC+1TQEcroxMYLEpqidqbvisItgn5Xq+CtNg53xhrLgpg8GAWCsbZhZeVlovtcsAg12a++7QHN080klAQ9t2uPfzmqExugEYDAaDwWAwGAwGwz8Cu0sa5Yx1c9pTqvCUJ9iy+1mUNb+ETFkUvnJF9QRF/TSFv1oZMeg8wQhCBsNZcHoVy96hqJyQ+3igVtptegIKndQc2pCxUWYTC8OuxzSJWPGEfoPBYDAYDAaDwWAwGF5KTMmYwfAi8FUorrhN8oKGuqVG11uWCYuLhuHE1uLPb9sB0WszbqKhbk3Pceg+oSlrVFSOA295fjcFg8FgMBgMBoPBYDAY/hEYQchgeJGkanUrmvOXWa1jdxpz+qQzAUDfKc39X9KEB1JLNU4vrL5dUd70995rg8FgMBgMBoPBYDAY8jElYwbD3wGbUzHjyuLunllXS+1uaEDz+HeyxSAhMiwtH4N9pqzMYDAYDAaDwWAwGAz/eIwgZDD8nShvhBlX5j8+6UKomSy/hwag71Th5w+ekeUpwkOanhOarfcm2XJPku7jmvCQEYwMBoPBYDAYDAaDwfC3Y0rGDIa/E64SxbzroHU5HN+iSSageZ7CVy7LABLRsdcRj8jP0IDmhb9o9j6RWfbCnzRTLoEFN0v5msFgMBgMBoPBYDAYDP9/MYKQwfB3xOlTOH1Q3lhYsHGVSJZQMp6/TFkyodPdx8gRg1LsewrGzYem2bmPB/s0ybisOxV0bTAYDAaDwWAwGAwGQzGMIGQwvIS4AzDrath2b/6yaZeB2w/RkGbHQ8VLw3Y8pKmZDA63IjSoObkNXviLZqgLfJXiIGqclXElGQwGg8FgMBgMBoPBMBqTIWQwvITYHIoZqxRL36xw+eUxpw8Wvx7mXquwuxTJBESGiq8jMigOo3hEs+dxzZofixgEMNQFT/9Qs/cpTTyaLypFhjQRk0NkMBgMBoPBYDAYDK96jEPIYHiJcfsV01Zqxs1XJOJgtYG7FCwWcfQ43NA0R8rGCtE4B+weCPbAtvsKj9l6D0xcAiVV8v/hHs3xrbD/GY1SMPVSaJgJ3jLjIjIYDAaDwWAwGAyGVyNGEDIYXgaUReEtL7zMYlW0Lofdj2uiw7nLHB6YskJhtUoL+0JZRACJGIQHRRAa7tE89DWd093szGFN5Xi4/NZ8USgS1CSiYHNKWZrBYDAYDAaDwWAwGM4/jCBkMLwC8VXCdZ9SbLpLc2KrPNY0Bxa9XlFSKf+3nuXda7GB1pqjLxRudd91FNr3wqSl8v/IsKbnBGz5q2bgNJQ1wvwbIVBnhCGDwWAwGAwGg8FgON8wgpDB8ApEKUVpHax4N0RGXEJOb64w4/KDrwKGuvOfX1IlAdXhIdi/pnhm0N4nNU1zwGqHwxth3S8yY4d74OR2zcr3K8Yt0OmSNpCuZpFhK/OnXUosaMEe+NuP2WAwGAwGg8FgMBgMLx1GEDIYXsE43AqHu/Ayb5nisg/AA1/SxMJZz/HAZR9QeEqlC9mLIdQHG39beOzan2uqJip85ZCIac4chmd/qunvAPBRMQ6W/7OmrIkc0chgMBgMBoPBYDAYDK9cjCBkMJzDVDTDTV9QdOyFrqOayhZF7RTwjeQTuXzQerFiw68Kiz1TL1U4PYq+Nk0iVngbkSEID8g6+0/DA1/R6ERmefcxuP+Lmhs/p/BXy2OJuGa4G46+oOk9ATVTFA0zxNGklBGNDAaDwWAwGAwGg+HlxghCBsM5jLJIplDJMpi8LF9oUUoxfr5m7xP5OUKVLVA3NbWesbdjsUAsotl2b64YlCIWhgNrNfNuADScPgAPfz0Ten1wncbhgWs+qShvzDwvmdQEe6W0zWIBp890PjMYDAaDwWAwGAyGlwIjCBkM5znecsVVH4ET22Hf0xplgWmXKupnZMQXT6mUmkWDhZ4PzhKIhaDzUPHtdOyF+FWyjse/k98BLRqEp36gufpj4PYroiHNyR2SWxQZkjG+SrjkvVA5Hqy2jDCktSbUD8mkhGm7/UY0MhgMBoPBYDAYDIa/BSMIGQyvArzliqmXQMtCQIHTmyuoeAKw4t2Kx76t0VnVZRYbXPIehbdMERnWeMtgqKvwNnyVEk493APR4cJjek9CeFACr/va4Mnv5ZayDXXBg1/W3PwFhb9GHgv1a45uhm33aYZ7pPvZ4tdD1URwenKPI5nQRIbF8eTyGdHIYDAYDAaDwWAwGIpxlkKRfzzf+973aGlpweVysWDBAp555pmiY5966imUUnn/9u7d+xLu8fnFYDRGZyhCdziK1i8ugNhw7uL0qTwxCMBiU9RNg5vuUEy/XErJZq+Gm7+gqJo48lyvYu71xUWWGasUVpsiHhl7H5JxiAQ1m/9c+HpLxODAOo1OaiJBzQt/1qz7hYhBIKLSw1/XnNgmJWcpBrukpO2BL2ke/prmwFpNsK/YNmTdyYS55g0Gg8FgMBgMBsOrk5fVIfT73/+e2267je9973tcdNFF3HnnnVx99dXs3r2b5ubmos/bt28ffr8//f+qqqqXYnfPK0LxBIcHgvxg91H29A5R7rLzhkkNrKiroNzleLl3z/AyYHcqyurhgjeIKGO1g8WaKwBVjoe518PWe4ERLUVZ4cK3ZBw9JVWgFBTSF51eyQmKR0TYKcaZg7IP4QHY+1ThMRt/o6mdIt3PBs9o7rtDE+zLLF/zI03dNLjkPeApleOIBjUDp2HnI5qhLqidAq3Lxd00+lgBoiGNxQI2p3EbGQwGg8FgMBgMhvOLl1UQ+sY3vsE73/lO/uVf/gWAb33rWzz88MN8//vf54tf/GLR51VXV1NaWvoS7eX5ya6eQT66YXdqTk9nKMq3dxxhR/cAt86aQMBpf1n3z/DyYbEqLNbCy1wlillXw+SLpKtZNB6hfrITd0AEJQCXH2ZeDTseyH/+BW9QeEolhLqkGkL9hbdT2ggWe34QdjbhQSlNS5Rodj2aKwalaN8DPSclIykW0RzaCOt+nlGqTh+AXY9orvmkonJ85nlD3ZqT2+HQRo3dCTNWQXlz4eyiWFg6tNldYLUb4chgMBgMBoPBYDCcG7xsglA0GmXz5s3cfvvtOY9fccUVrFu3bsznzps3j3A4zPTp0/nUpz7FpZdeWnRsJBIhEsnUsAwMDAAQi8WIxYr02f4/klrP32t9/2j6Ywm+ueMwhYplnjjVzZsnN+J52YsJDa9UlA3c5VDnj7NmzRqafcvBYid1+SsbzLjSQlmDYus9MHgGyhth4WuhfFySRDKJxQHzb7Dy0NcKrN8CU1ZAIhHH7iqiTKXGWjWhAc2hDcWFmH1PJ6lp1QT7LKz/Vf7yeBSe+V/NFR9O4vAmCfdbeeBLuVlJJ7ZpJl2oWfh6cHiSAMRCFvpPKXY8qBnuVdROgWkrNZ7yJMqS++5KxhXRoMJiAYdPQ8F3n+Fc4Fz7vDcY/lbMNW94NWKue8OrEXPdnz/8X17Dl00Q6urqIpFIUFNTk/N4TU0NHR0dBZ9TV1fHD3/4QxYsWEAkEuGXv/wll112GU899RQXX3xxwed88Ytf5LOf/Wze44888ggej+dvP5AsHn300b/r+v5RTFy0hLbhcNHlW053c+TEAYaGhl7CvTKcqxS77v1+P3PfNhmn3UUwPMSejgMED2famE1snsb8145n219sJEY+sxweWPr2KPuO7uD0plPMn7Ecu7uUWCh//VUTNKe7j2GzulCqtuj+KaXYtXsnruFWdMJZcEzPceg5PUx7735iB+Yw1JUvRB1cpxi3NMyu409SV91M4sQUtt9jA1R6Hfuehss/FGX3iWcJhUL4/QGmjlvE3secnNqpcLhh0oo4Fa2DbN+7gUQikd7Hmuo6astbsGAlHBvieMd+8x58BXOufN4bDH8vzDVveDVirnvDqxFz3Z/7BIMFWkcXQemXKUn41KlTNDQ0sG7dOpYuXZp+/I477uCXv/zliw6Kvu6661BKcc899xRcXsgh1NTURFdXV04O0d9CLBbj0UcfZdWqVdjtr/xSq9OROG95YktRj8J/LJjM8urSl3KXDOcgf4/rPhlXRAYtDPeCxSqlXc6SjMNGJxVnDlp45JvktLF3+WH17eCrSqCTim33WNh+f+FtXP1xqJqU4MQWK09+r/i+3HyHlH39+T+Kd0lrvRiWvjXJUJeFuz9BQaNPxTi44sMauyfJ0Bkr935OSuSyqZuqWfEecPjEbRQZtLL7Udj7pIwN1EmWU+WEJDZnZiM6qQgPWIgOS8aTw6txeJPFD8rwd+dc+7w3GP5WzDVveDVirnvDqxFz3Z8/DAwMUFlZSX9//1k1j5fNIVRZWYnVas1zA3V2dua5hsZiyZIl/OpXBepARnA6nTid+a4Au93+d7/Q/xHr/EdQimJRdSnPdfblLbMpxdTSkpzj6ItE6Y/GiWtNid1GhcuBVZmsFIPwN133dnC6wV+d/WBuvWJtq+Y1/wXHt2r62qBumqJmMvgqVHrstJWaI89pBs/krr55PpTWK+x2OxXjNErpgmHXgVrpoqaToMfoPJaMg81mo+uwLpyaDXQfk3Iym8PC5rt1nhgE0L5XMXBaUVdmJTSgefpOTce+zPL+dnjkG3D5rVbGzZP3WnhIc3gDPH+3TjumypsVl7zHRllD5v2YjEueUu8pCeUubwZvmeQ/FSIek+DsQqHahuKcK5/3BsPfC3PNG16NmOve8GrEXPfnPv+X1+9lE4QcDgcLFizg0Ucf5aabbko//uijj3LDDTe86PVs2bKFurq6f8Qunrf47DZundnCret20RWOph9XwL/Pn0y5Sy4grTVHB4Pc8cIBDg6I7SzgsPGBmS0sqSnDZ39ZM8kNrxKsdoW/GmZeUVyw8FUoVt8OJ7bCwfUamwNmrFJUTgBPQJ7n9sO8G+CFv+Q+V1lh2TsUnlJFPKppWQz71xTezuTlL140iYbg+Nbiyw9v1NRNVQx1kyMGZbPxN5qqFumS1r4H1v8qV4TqOQ4PfElzw3/KOUjGNZ2H4JFv5gpRDTNh+b+AtzSz/0PdmradcOwFjcsP01aKMOf05h5jMqkl/FuDzZm/3GAwGAwGg8FgMJybvKwz+g9/+MO85S1vYeHChSxdupQf/vCHHD9+nPe+970AfOITn6CtrY1f/OIXgHQhGz9+PDNmzCAajfKrX/2Ku+++m7vvvvvlPIxzkgafm+8um8WOngE2dvZR73FyWUMlVW4nLqvkp5wORfjg2l0MxjK1Ov3ROF944QDfWDqd+VWlL9PeGwz5+CoU0y6DCUul7b3DnStcONyKaZdD9WTYeq8m2AtVE2DONSrtULI5FHOuEZEkMiq+p34GlNbL71UTEAW1SMmYwwvJGFhtEE8U3l/biHGx82BxR9LgGSkhC/Zrnv9j4XHhQeg8CL4KGO6Fh76uSURzx7TtlG5qC24SgW2gU3P/F+UcpDjwjGbBLTB9JTg8cu6GezX7n9HsfhQiQaidAotfB6UNYMvqqBaPimgUHgKbA1wlhTuyGQwGg8FgMBgMhlcOL6sg9PrXv57u7m4+97nP0d7ezsyZM3nggQcYN24cAO3t7Rw/fjw9PhqN8pGPfIS2tjbcbjczZszg/vvvZ/Xq1S/XIZzT1Hic1HiquLyxquDy58/05YhB2dy5+xhfWeol4DB2QsMrC6enuBDh8ikaZkBlCyRi4HCBzZk7vqQabvgPxd6nNEc3i3AzY5WicVaW2ygA82+CF/6Uu36rQ9xG7hJFIq5pXQ67Hyu8LxOXppxLRZQlxL1ksYq4NHC6+DF3HtRMuEDReYg8MSjFnsdh+mXg9Go2/ylXDEqx+Y8wfr6Ee4f6NU/9ILeUrX033PM5zXWfUiKKAaEBza5HNTsezOQ8lTXCyvdDaV3m3EZDss2jmzXhAWiaqyhtyHUtpYgENfGwHH/qnBsMBoPBYDAYDIa/Ly97zc/73vc+3ve+9xVc9rOf/Szn/x/72Mf42Mc+9hLslQFga9dA0WWHB4NEEibM1nBuMpZopJSipBrm3wwzrgSLJT9/x+FWTFsJta2w4wHNcJ+4Z6ZfpiiplDFWm2LWVdKyfnS20cyrxNED4jay2HJDs1NMWCwB2rGgBG4H+wrvc1mj7N/gmeJuo3hEthEegiObig7jxDZNab1ioLNwKZtOwvpfa674EDg9cHgjbLs3d0zvSXjwy5rr/gN85YpoSHNoA6z7eWb/dj2qqWiGVbeBt1z2PxbR9LfD83/UdB6UY59zDTTNzReGhns14UE5JpdfRLps11I2yYQ2GUkGg8FgMBgMBsMoXnZByPDKpcXvgbbCy6rdTmxZwdLd4ShtwyH29g1T63bSWuql0uXEZjGTMMO5idWm8ASKL3f5FHVToXK8uI3sLinHysZXqVj9CRFWDm/QOL0wbaXCXyPPBxF6Lv+g4rFva5JZ5WWlDbDwFoXdqbA5NHOuU6z/Zb7gY3NA/XT5vXpScbeRr1LcTok46CJlbACxkaaMJ3cUF5fOHIJYSNxIW+8pPC7YJ8KQrxyCvbliUIru47DzEc3C18i56z4qmUipvO5YGJ79qWbiEljyZjlnyaSm+xg88R3NULeMs9rFsdV6cea8Agx2aU7ugLYdmpIqTevFCl8F2F25r1MsrAkPidjlcBcP4E5RqFGBwWAwGAwGg8FwrmEEIUNRVtRV8NO9J4gX6Kb01tZGyl0OADqCYT6+YQ/HhkLp5W6rha8tnc7UshLTkcxwXmN3Keyu4st95YpJS6FlIagC3bysdkX9VM1rvijB0cM9mtopikAdeMtkrFKKlkXintnzeKbBmasELr9V4S2X/wdq5V9/bvNGABa9ToKzI8Oa2inFg6yb5sg2HZ7ix2S1y7EkYpJhVIye45qm2Yqjm4uLS/uegplXgMWqWfvzwl3gDm2A2deCywfD3eI+yg7NTsRg011S7teyUB7ra9fc/186Z/92PqJZ8W7FuPkauzPjqtr0BykP1AkR+Ja+RbqzZTuOgv3i9Oo5bmVi2cWE+63YyjVqlOidTEpJnNbg9BV3LRkMBoPBYDAYDC83RhAyFKXa7eBLF0zjM8/vY3gkGdcC3DKxjsXVZQAMx+J8d+fRHDEIIJRI8vENe/jJJXOp8Zi76QbDaPdQzjKHBFtLuHXhcW6/YsFrYPoqGOoCuxM85eAtJS1KeMsUV35EupMd3yKihDsAi16rqJ8h63F6FUveBPd+XpOI5W6jeX6mlK15ruK53xUWciZdKGJUeAicXogMFz6u0gbZr3Dx6lNiYXHmRKPQd6r4uI59UN4IJ3eQIwZls/luTc1kCfNe+zOdL1ZpeObHmuovKuzV0mntgS9lnEYAXUfhvjs0N3xGUSFxdgx1ax75lqb3RGqUC4cHrvooVI7LiELDvZqD6zR7n4R4FMYvgFlXQ0mViHopwkOyb8E+OX+eALiLZCVFhkUkc3pz12EwGAwGg8FgMPytGEHIUBSH1crcSj//e8lc2oNhwokkjV4XZU473pGW8/3ROGs7ego+fyie4PhQyAhCBsPfCYdb4XBDoKb4mJJKxcXvEudOIiYlUJ5ScpwspfVw438qttynObVLnDczr1I0zcl0B3MH4MK3qbxSL38NzL1eYXMoPAHNrNXw/B/y98Ppg4pm+b1prmLXo4XFpdpWsLkgGaRo5zY5dvnZebi422igA5IJEYyKOaCSCeg+JuLb6QPkiEEpdBI23a259L3SsW7Dr7PFICEahIe/rrnxs2qkw5vmkW9qejJ9ENj7JBx+TnPDf0iZIMi4Z3+qObk9M660Hi6/FQI1WY6kXs2pvbDnMU0iLiLc+IXSTS9nP0LiSIoEpWzR7RfRrxCxiB4pizPCksFgMBgMBoPBCEKGs2CzWEa6kRUWdSKJJGNFS/dGMhaEgWiMjmCEh050MhxLcHljJRP8XipGSs8MBsPfh5RwVAyrTTp8LXu7CBsWS75DxeFWTFyiqW1VHNqoCfbAuAWKynGZEGiLVdG6DIa7xRWTKvcqqZJcpFQpW2kDVIwTISYbZYHFb1C4fApl0TTOIkcoyR5XPUl+r2pRHHy2sCjkrwWrFeJFHEQpYhHQWo9ZynZ6r6wnEYPjWwqPiQzBYKe4qrqOkCMGpYgOw46HNBe8UUrSNt2l846x7xQ8+k3N6tvBU6oI9mmeHNXhrfsY7H5MxqREoeFezXN3aY5syJz7umlw8TslvypFsE/TeQj2PK5JJqF1OdRPy7yO6X0NiXMpOiIuufzFA9hjYXEuGXHJYDAYDAaD4dzFCEKGvwmv3UrAYaM/Wrg9/QS/BJH0R2P89kAbvzuUqQl5+OQZppX6+PyiqVS6jShkMLzU2J0K+xgGPodb4WiAhTcXn/S7A4qFr4WZV0JoQEKuXf5M/hFIa/lVt8KuxzR7nxAHT22riEFljTLG6ZFStvuPaUL9udtY9g6FeyTgu2k2bHJK17TRLLhZ4Q4otNb4a2DgdOF9rp4g5Ve+iuKCkKtEhKh4jIK5RilCA9LF7EARkQrg6PMw93oRlw5vLDymvwOGe8XN1XWksMNp8Azsf0Yz9zpZ1+a7NYfX545p3wNPfl9z+a3i9gr2aZ7+oebU7syYjr2asia48kMZUSjYq3nuD7I+rQEFzXPhwrfkCkfBPs3p/bDnSTneKSukw1726w0QDWpCAyIuOTxyPos5lyJDsi6nz4hLBoPBYDAYDC8lRhAy/E1UuBy8e9o4vrrtUN6yBZUBKl12AE4Nh3PEoBR7+oZ45GQnr5/UYMKnDYZzlJQjyT9GKZu3XLHgZphxuQgONmduRzCQkqnrPw2n9sCJbRpfJbQuF6dRKgTaWw6rP654/Dua4ZFqVasd5t8IdVPl/55SxUVvg4e+mh9SPWUFaXGpdZli50OFhZyZV4kIlUyIoBENFj6uQB2gwDqGsGa1S+lZKi+pGMFeiDdq9j5VXFw68CxMvUQyig6uKzym85AIVW4/nDlMjhiUovcEHN0M0y+XgO7n7tIcyhaXtDij4jHNyveKWDPcq3ny+yIIpWjfo6kcLyVvKVFouEez7pea41tJlwA2z4UL35orLg33aE5sh31Py6Cpl0DjrHznUmhAnEvhQRGW3P7CneASCRmnEFHSYrpcGgwGg8FgMIyJEYQMfxNWpVhWV47dovjhnuN0haM4rRauaa7mjZMaKXU60Fpz37Eit+qBPx/p4IrG6rRLqCcS5UwoyomhEJUuB/VeF9Vuk0NkMJzrWG2ZMrJi+CoVrcth0kWFJ/QWq6JqAlz3aQmrTsZl8u8OgM2RGV81Ea77D8Xmu6VcylMKc69VNMzKOFW8FSM5Sb/QOdlFTXOhZZG4iDylmvk3KTb8Ol+kqZ8OnjLZz2mXwuH1hYWcqZfKPiZiYLHJPhc89oqxzw2IsAQiUI0pLvVBSaVmz+PFxaW9T2omXKCIhuDwhsJjTu0Uccnpg4795IhBKbqOSqnflBUSgr3uFyNiUBbHt0oHtkveI+d/uEfz8Ddzs5mePaIpb4YrPpQRlwa7NE98T9N1ODOuthVWvCc3T2mwS7P3Cc2hDeLsal0Ok5flZy4N92gGOsVtFaiDkkoREEcTCWpiI7lWTl9GkDQYDAaDwWA4nzCCkOFvJuCws6qxivmVAcKJJDaLotzpwGG1ADLPGowVmQEBoUQCPTIbOx2M8JlNe9nbn2lbVO6087Wl05ng9/5Dj8NgMLxyOJu7w1um8JYVX253Kqpa4NL3SRaQxVo4J2nSUk39NMWp3ZKh0zBDRKtUuLbFKllKFpvihT+JA8VqF7Fh7vUK94hTJVALk5fDgWdy96OsCSZfpLBYFO6AZuolsPux/P2tbBFxyWZXTL1UHFKFmLxMXDLxiIhDxcrZPH75mRxDNNJJeX40OHZZXHhQzs3eMcSlPU9oxi2QXKXRYlCKk9tHxCUvHN9GXlA3SA7TqV1ynOFBcSRli0EgwtSzP9Vc+q8iLg11ae67QxPszYx54c9waL3m6o9lHEd9pzQPfjV3XKAOrvwwlFTJmGRC098OG+/StO0QcWnCYph/E/irM9dPIi4OtRPbZL01rYraybnZTSBZVcE+OS/KKgHuqWtrNLGIJhEFu1vEU4PBYDAYDIZ/NEYQMvxdUEpRWcTFY1GKyxuqWNNeuBvZ0poySuw2aWG/60iOGATQE4nx0fW7+f7Fs/OcQsFYgiQan91cygaDIR+nR+H0FF9udykCtSLoSLFRPq4SxdQVmqY5ilhYMxTsp7qhBKc787nj9isWvRamLIfdT2riIZi8TFE1MeN2sTkUc64V0WHfGgmZBnEaLf9nlRYKKsdLOHT7ntz9KKmSdVqsCpdfM34RHHkuf3/Lm8FdKsc2ZYWUdRVi0kUiLsVCxc8PiICj9YsTlyLDxceAiE/hIc3+p8d2LjXPE/HoTH41MgBtO8UhZndJflO2yJOivwNO7oQpF0v20SPfzB/X3w5rfqy57ANSwjh4Bu75vE5nVOkEHFov5/C6T4vjKJnQdB6ULnOJWGafXSVwzSegtF5ex1hY074X1v48s92yRljxbihvzHT+iwxr+tph+wOa4S6omgQzVsnrnS0MRUOSy9R/CqwO6TboLs0Xj5IJyeFKJiXTq5gAZTAYDAaDwWBm0YaXhGllPlpK3BwZzJ15uK0W3tLahMtmpW04xLNFRKPuSIzTwUhaEOoOR9nbO8TdR9qJJZOsaqxiSU2ZKS0zGAz/EJRF4SuHWCzOmgfWsHrc6rwxbr/C7ZcJvU4Wdnl4ShWL/wlmXS3iiM2Z3yreU6q45D0SLL073XZeMW5+pgTK4VZc8AaIRzQntmXWXzkeVr4/Iy7VThGBaHQHNF+lrNNiUbhKNA2zoG1H/nFXjs90G2u9GDoPFnEuLRf3S2Ro7PM4Vve70UTPJi6FZHuHigR1Axx8VtOyEIL9UiZWiI594oKyOTQ7HtQFA8uDfXBiK0y7TH5/7L8zYlCK8CA8/UPNFf8G7hIl3eO+nVuO2HsS7v8vzY2fU/irRTQ6uI6cksTu47B/jWb17Yqake56oUHNjvs1Ox4mvT6bAy59n6J+uk6XSwb7NPuf0ex8SMS50npY/E9QMwkcWR3jhns13cfg8EaN0ytCo68KXKOCv0MDmtCAlbkTLyfYY8VTqguWz8XCmmhIXGtuf0bsMhgMBoPB8MrGCEKGl4Qqt5MvL5nOX490cO+x04QTSS6sLeMdU5qo97gACJ+lhX1PJCo/w1G+tvUQ6zszt3p39AzS4HXxzaUzqPYYUchgMLx8WCwKLMWX250Ke/XY6/CUKiZcAA2zRFxyesWJmY23TLHi3eKkiQxlunllO0K8ZYorboNjW8TFkkyIM2jSUpUWl5xexbK3w9N3ajqyMoIqxuWKS40zRWDoG9UfwF8D4xcqlBJxqX564SDruqkiLrl8itYV0HW0WOaSwulVOH1j1LEpOV4sUsJXDItdyr7OJi7FIyLQnSwgiqU48rxm0kUw1FU8ZLzrKEQGwWLVbP5TrhiUIhaGo89rZq9WhAZg4+/yByXj8MxPNKtvB09A0b4bdjw0ap+jIkzdfIeitE6cV+t+qTm2OTOm7xQ88g3Nyvcrxi/UKKUY6hG3VHbJ3u7HNHOvhxlXZkSh/g7Nk9/TdB8HcKOsMH2lZs61mfLLZFwymbb8VXNypwh+M1ZBy+LcznPxqGa4F05ul1K7+unSYXB0d7pEXBPqEzHLYgd3SeEAcRCxKhX6bjKeDAaDwWD4/4cRhAwvGdVuJ++Y2sSNLbVooMRuw22zppd7bVbcVguhRGFZqNErt5YPDwRzxKAUbcNhHjjRyVsmN2IduTt5JhTh2FCI/X1DNPrctAa8VLudWExHM4PBcA7g9Iz9WeX0KpxniVfzliumrdS0LFKgwVmSn9Hkq1Bc9gERl0IDI1k3gVHiUrniyo+ImLH/aSkRm7wcJlyg8I3k9Lh8iuXvhDU/knKpFLWtcPG7VLqzXPMc2NOUnyNUMQ7qZ8jvLj80zJTysNG0LJL9c7gV01bC2p8VFo9mXK6wuxSesuLiktUugpvFKj+HCxtVcfslFDwWLroqABJxEZi6jxUf074Xpq/S9LVlSgdH098uQpZSmi1/Lbz/OgkH12sW3qwI9pEjBmWz4Tea6klSarj3CV0wv2nrPTB+Ibi8Er790Fc1Q91Z20rArkfB6dPMvhasVkV/B/z1c5J9BLK/G38Lx17QXPo+EbPiMRGLnviOTgeh73hQE6iDqz6Scb2Fh6TT3ea7dfocV4yDS94LpXWZ6zDYpzm5Q9YRHpKSy7nXiTCZ7coL9kopXttOjacMGmcrPKX54lGqi10ilrnurfbCQePxsGRBeQLmO4TBYDAYzg+MIGR4SbFZLFQVKeuqcDp4w6QG/ndf/jfVuRV+Klx24skkfz3aUXT9Dx7v5LpxNVS4HLQNh/i39bvpCGb8/z6blW9cOIPJAW/e3XaDwWA4X1FKytnGwlWicJVAWUPxMb5yxYxVMHHJyHN8+eVBvgrFyvdLCVVkGBzefKeHt1xx5YfEkbPvaQ0Kpl6iaJiZcY24fIrl/0xOC3ulRAxa/AaFwy3jmuZA9SToPJi7r01zoHKC/O72i9hx9Pn8Y5q+KtOlbtbVUvZViOmXK6w2hb9G9reQ+8fplX9WG3jL5RwUIlAHVmvhZdloLW6hYiIVQF+bdHAbS4AK9mZcTXufLD7uwFpNRbOi/zQ5YlA2Ox+W0G+HR/PcHzJiUDYd+2CgAzwB2fYT39V5XfH620X8ufBtItK07SKvm1/3MXjgS5rr/0Ouq9CgZsOvNUc2ZcYc3gDHNmuu+5SiYpw8NtQ94oI6mRmnfqO59H2KxtmZsre+Ns0T38+Mszlh/s0w+SLS4mU8KkHjz9+tOb1fXHizVsO4+bnCUCQo7qeD6zSRQRi/SFHelO+CigY1oUEI94PdJcJnoU538agIVVqPjPMV/s6STEqZo9VuwsgNBoPB8H/HCEKGVwx2q4Xrx9dgtSh+c6CN4XgCq1Jc1lDJu6Y1U+p0EEsmSRb6Fj5CUmu01gxEY3xpy8EcMQhgKJ7g9o17+EFWQHV/JMbpUITH2rqIJhKsbKiiyeeizOn4hx6vwWAwnIv8X8SlsfCWS+j1+AVIe3dv/mTWW664+F0SIB0Lgd0j4k5KDAKZcF/2/+DMERGXLBaYtlJKklITdqdXsfTN4C4Vd1MiJpPsmVfBtEtVOoOnfjqMW5DvtJl9jYg4INufthL2PJ5/TIvfIC4Ui1Ux7wYp6RqNUjBlhUJZFKUNGmUt7BIK1EnLe6tNcqBO788fI/ssWVBO79gldlYboCFWICMpRSoUfHRZYDbRoJSrAbRtLz7uyCZN7RTF6QPFXVCHN0oHt5hds/mPhfc/1C+vra8ChrvJEYNSJGIiJl32QclW2npvrhgEIqw8+X3NLV+Sks2hbs39X9I5ol08As/9VoSslOjZfQzu/2JG0IqFYd3PNe274cK3yrUeDWr2Pa3Z9PvMuvY/oylrgis/lOl0F+yX49z/LGlBMVALl9+a64Ia6tJsvVfypRIxqJ4MS94oYeQp91IyqRnqgoNrNe17JBdsxhXgr87Ni4pHpdNd9zF57asmyPGNfr8lYppgv7zPbA4RqrLfZymSSU14QM6n0yedEQ0Gg8Fw7mIEIcMrilKng9dPrOfyhiqC8QROq4Uypw23TS5Vu8XCtc01rO0o0FIGuLyxklKnnVPDEXb0FL412xOJcSYUpdrtpD8S46f7TvCXLNfRX46eZnF1KR+fO4kKV64o1BuJEktqbEpR7jKCkcFgMPytOIs4H9LLz9IpDsRhMW6e5ByJ+FEk0Pt1MOtKETRsTvCU5o71lCouehvMuVZcJ1Y7jF+g8JRlJtAOj4g95Y0iPAz3iKtq4eskBNpilXE1k6WUadt9MnkG6Q52ybsVJRXyf7cfLni9YsNvcsUQi006z6UErUWvhfvuyBdMHB5omi2/lzXKRD5ewLHTOEtKBZUS51Sx0rKJF8j2pOteYewusNllXVZ74e0B2EcCxMODY9zESYx0r4sVD/0GOHNY07JQcXJH8XV17BcxIx6Bg2sLj9FJybfyV0PnoeIOruf/qKmbKvlT636R724CEabmXieOoeFecsSgFL0nYNdjmgU3Axp2P6rZ/0zumP4OePDL4oLyliuGezQPflUzcDozpvMA3PsFzQ2fUVQ0j6x7JKA8XcK4X9xJF75NMWmpxu6SrojHt0oJZzJLlJtyMSy4JVMSGurX7HlSs+NBOX9KwfhFcME/ZcQskFLCA2s1e5+U0sjxCyQgv6Qqk3GmtQhVJ3dA+z5NeSO0LFL4KnJL8VIC1GCnXAf+Gnk/2F2jhKqE5ErFI/L+8RQp6UsJVSCvSep9+Ldgt48RUGYwGAznCUYQMrzisFks1IwRDN1a6mNWeUme4FPlcnDD+FpsFguRsfojA0OxOABHh4I5YlCK5zr72NTZx1XNkvw6GI2xo2eQH+05ztHBIPVeF29rbWRxdRmlTvOFwWAwGF4JFJooZmNzKEqqxl5HultcS/F1uf2KKZdomucpkgkRRka3d3eVKGatlvKqvnZx6Phrcye0dpdi0jJNZYti+wMyka6eBDOuUJRUZtZV1giXfVCx/hfi9gCoaIaL363wjYzzlMLlH1Q88s3cyb+vEpa+WaXzqBa8Bk7uyC/1qhwP5U3ye2mdrC+1rWxmXCHt7tFybHueKHyOJiwe6XTXWqS+DnFB2V0i1Lj8pCf0oymrl3XZxrgPoyyAEnFhdAe4bEL9GlCcOVxcXBrqEsEjmYCeAnlLKdr3asqbFYc3Fl/X3idgxuUifO16tPCYYJ8IQ95ycUNli0EpdAI2/VFz6Xtlv575iS6YZ7X+V5qGGQq7C4Z64Kk788PN962BmilSGpeIiRi05S9Z29Jw5DnJYbrsA3JtD/dqHh4VRr73STjynOb6z0jXPBgRqr6o0yWKRzbClr9orviQom6qxmIToerEdljz48x1qKyw8DXQenGmPC40IM6r7Q+I2Gd1wNRLYPbq3DK7oR7NwbWa/Wtk3ycukXG+ysyYlKPqxHY4c0hTOR6a50n3SEuWKByLiLDU125lcuWlhHqtEMjvrhePakL94rqyO+U9UcgtlYhJ1hVIiW2xz6hkUpOMy+eE6dJnMBheSowgZDjnqHA5+MyCVjad6ePPRzqIJpNc1lDJqsYqakc6lpXYbWMGVNd5XEQTSe4+3F50O384fIolNWX47FaePNXNN7YfTi9rGw7zX1sO8qZJDbyptQHPiINpIBqjKxzl2fYeksCFNWVUu51GNDIYDIbzDKWkPGwsHG6Fwy3uh2I4PYqayXDJeyAeA4crf9LocCvGzdNUjVfSgcsqLojsXCarTVE7RfOaLyradsJAp6ZuqjhKsl0egWq48T8VL/xJJuV2N0y7FFpXqPQk21uuuPrjUvLW3546XgkRn3aZSruqZl8Dbbt0noAx7wYRN0AEqdopkis0miVvEheUTmrmXpvvlAJxctVOkd8bZyk2/raw+DJ+oUy44xER0EaXjKWony77Xt5YXKiSsj/SuVW6iN6TcrNEhgovBxEMtIZEVPatGP2npWTx6Obi4lL7bilZS0SLh5brBPQcFxfU/mcKd7oD2HafpmGmiGc7Hiw85vQBEavcfnEpFQojjwzDrkc0i18v5YRP3anzuvAlE/D4dzU3f0GcQoNdUr6XvW86AZvukiDxhhkiuOx4SLPjgcyYRBR2PSKldxe9VVx7qQD0/qyvc9vuE7fUtZ/MiEKpPKrUa3BovTjBrv6YonqSdOCLBjWHNsKGX6VEVScWK1zwRpi4VKdF1WCfZvv9mr1Pyfmz2mHaZTDrqlyhavCMHMPhjXIdTboIpl8OJVlCVTymGToD+9doek5KSd+ki6REMtu9GBkWAer0ARHPaiZlgvVzXw9NaECuE0eBEtsU4SFNLAQoed+Mdmal1xfU6RJb083PYDg/MYKQ4Zyk0u3k6uYaLqwpJwn4HTasWSHRFU47b5/SxPd3539juqyhkjKnjYTWDMWKBBsAw7EECa3pDke5s8B6AH53qI1rxtXgsdnoj8T45YGT/DFLZPrZvhNc0VjFv04fR1lWidlANEZvJMZALI7fbqPUYSdgRCODwWB41WJ3iaujGEopvOUZoaUQVrs4NfwrQZKv87HYFKX1sPxfRoKm1UgHtVElNqV1itW3i6NmsD9MWZULd0DlTC59FSIcdR6Awxs1rhIJBy+pypTYuf2KS94Lex7X7H5cnB7lzXDBGxSVLSPHZlFMuEC6gu19irRQ4CqBVbep9DF7SmHhLfD8H3OPSR5X6XO45E3w4FfyxZCqiVAy4mSpnSKT3EIumznXidgXC0PTXDi+JX+MUhmhatwCxZ4nCisvDTPAMVI+Z3fL8ReitC5zLMVwemW7ZzFBi7spqRks4DRKEewVESZVZleMgdNQWielYsU4sknEwWiwuBAXC4nzyl2q2fN4caFqy1/FvRMNivhTcHsbYcFNcj5O7iBHDEox3CMd+GZfIzlUT3xX5x1nIgaPf0dK8bzl4uRb9/PcHUsmYP0vNZXjFNWTIBrSbLpL8p2y17PzIYiFNIv/SQSYwS7NvV8QESfFzofg6CbNNZ+U904yoenYC498M1OW2LZTOuhd/TERikGcUtvu1bkOMwWLXw+tyzPvtaFuzTM/0ZzaPTJEwcSlsOh1GaEqEdf0nRLRq2O/OOvGzZeyVH9NlgA1pOk+AVvvkW6DVS1SSuuvIZ25BiKO9ZyEQ+s1dhe0LlP4qnJD0LXWDPfC4GkY7pNr3Vue76pMJsQBGRkS0ctVUrijX6qMMJkU12Cxrn+JmCYSBIslVzwvRDKp87pvGgyvFowgZDinKSai2K0Wrmqqxmu38b97j9MTieG1WXlNSx03tNRS4pDnXVJfwQtd/QXXsbS2jBK7jaODQYbjhYWjhIbOUIR6r4sjg8EcMSjFIyfPsLyunOV1EhrRGYrwpS0HeKEr442fVV7Cp+ZPpsaTOxvoCkUZiMbQQMBho7JIhzaDwWAwGP4vnE2AAplo2T1xnt3yKKunri6YqeIrV/guEIeOslCwg6e3TDHvJgnjTk3iRk8G3QHFoteKy2LwjIgnnjLwlmZKaBwexdRLoX4G7HlCJtvj5kt3umzXRVULrL5dsfHXmu7jIvxMuQRmXpnJZfJWwNUfUzz67cykXSlxcLQskuNwuCVHp+uIziufu+htCndAfi9rkJK7rqO5Yyw2WPQ6hcOjsDo1s66CF/6cf559lRkX2eQLFTseKKyWzLhCXCHKIuV2hYQQlOyLxaJonA3HXii8rqqJYHOJmDGWC8pTKtuzjfH1w+YYEaqK32MDxC2VjBXZ7xGGumSfIsPSYa8Yw73gDowtVB1aD1NWSFbUUFfhMaF+CA2Aw6uLnneAbQ9oLnm3jD24vvCY/WuknM3m0Bx8NlcMSh9fNxzbAtMvk2vqye/nZ1QlYuK0uu7fwVOm6DxUoNxQw3O/g9pWcRWFBjRPfE9z5lDWEA0H14HFplnyRnnPD3bCvZ/X6bJKnZTui6cPaK77tLyPYmHNvjWaTXdl1jXYKUHxV31EUT9dHhvu1Tz+ndxt7nlcM/NKEY9cJQqtNT0n4KGv5ga4V02Alf9PPj9AnEjHX4ANv8k4zAJ1cOl7pZQ19RkQ7NXsflyz+zERbP01cMEboKaVtINLJzWDXbD7Mc3xLSLIzrhSxNlsB1c0JGLX/jVSTtg0V8b4KnI/m0KDmmAPnD4ELm8mmN3qyB0X7JMOgomoiFmFMrFS5y0Wzjg9Czm4dFKuH63lfer0FBarkglxellsxV1e/1ccDpOR+mrDCEKGF4XWGg1YzqFW7QGnnWuaq7mgupRoIondYqHcZcdmsaTHXFBdRrXbQWcoN0zBa7Nyy4Q6HFYL9qzxhXBaLYTjCe46VLwty28PtjG3wo8GvrbtYI4YBLCjZ5A7XjjA5xdNJeC0E00k2NUzxBe3HkjvW5XLwe3zJjGzvARnVr/i4Vic3kiMYDyB12al1GnHazdvbYPBYDC8dJwtxNdqVWO6m0AEH4fnLCV2XkVVC1S8fURcKpDJYncp6qbAlR8ZCUm2yOQsuxTPYlFUtog7JNgvk0tfRf4EzV+juO7T0L4Hjm/V+Cpg8nIpfUpNwDylistvhb1PafY8DtGQTCwXvValA7qtVsWUS2Tiu+exjHhSMQ4ufZ9Kt6f3lEsp3YZf54oTtVNELLJYFJ4ALHsHPPBlndfBbc61pIWqxplyPKPDs5USR5XTo1BKM36RZAaNxlsu58RiVUxbKXlBhZi6Us5vMlF4e6ltBmolB6h6MrTvLbgqKsaJ+DRWXhSA0yPrtFiLj7HaXpxQlYiLCDNWsPlgp5R0RgYp6m7SGsJDImYW6oaX4vB6zaSlimAfeeV1KYa65DxaHZrt9xUXqnY9oln+zpFufIcKjzmwVq4LlHSvK5SxFeqHk9tFtA0N5LvwQMSjZ/5Xc+2/iyByaL0uuM2dD0PL4kzg+kNf03nXxJnDsOn3mmXvkPdR1xHJlMqmv13yqG76vLgOQ4OaNf+raduRGTNwGh79lmbl+xXjF0rp30An3PO53NLFNT/SNM0WZ6TbL6LXkU3w7P9mtnnsBY07ANd8EgI1mfLAZ/5XczKro6LFBpe9X1E/Q6fdUr0nNY/9T6Z8VlklO2z2NRnxOxrUtO2Gjb+RZgRKQfN8EbSyBe3hXs2h9Zpdj4gwWjsNFt0izqrUZ1hK9DrwjObkDnn/zbxaxLNsd1Y0KO6swxslG6t5vqK8ifTnTfr1H5BxvSesTK5cQbjPirUi3zU13CuvZTIuuW+FQt51UjPcB/FwKl8PbAXKDROJkSB4Le+ZQsIYSFllPCznvdiY7G2bDK7/O2bWaBiT/miM9uEI9x47zVAszuWNlUwt9VF1jjhVlFJj7muNx8m3L5rJbw+08fDJMySSmuV15bxjajN1I26dgMPGOJ+bY0P5Pu9Sh50Kl4O41vRHi9/KGooliCc1Q/EEz3UWdiRt7xmkNxoj4LRzKhjhIxt2k8i6ZXcmHOVjG3bzkxVzGe+XljtnQhG+s/MIa9p7RLADVtRX8P4Z43PcRJFEgp5IjNPBCEopatwOyp12HNYxvkkZDAaDwfAKxWJVY4oBkO9CGs2LKcMDcQxMXgYTL6RoWYm3TDHvegkz1lpcSaPv6nsCigU3w/TLZKKXau/uzipncXoUk5dJMPSJbZrIMDTNkVJAd1ZpTNV4uOmziq33a84cFCfP3OsVleMzkyZfpeKaT0intJQA46+BC98qZYMgYy/4J5nodR7I2tcyuPLfVDp/qrReQsQPPJt73BXjpDudsig8ZZolb1QSZD2KmVePdP+yKFqXwc6H84PNlYJ5N0pZYjKhqZ5Mzj6lKKkCV0CEhBmroH1PYcFk2mUKV4kiFtHYnIVL46x2mdTaXeKa6j5ecFVUTxzpsHcWV53dJSKVdQxBy+YUkXK0mDeaZFKEqmDhr42ACC6JeOEA+BSp0kCrXYTNYhx7QadD8At11gMRqiLD8lrtebz4uvY+qalqESGtWFj8kU0Scp+IaZ7/Q+HXMBaWIPDpl0mZY7YYlM3G32qqJykcbs0Lf87PsQJZz0CHCBShAVj70/xthvpFsLnkvfL+3Pd0rhgEIoY89j+S1xaokVK9B76cK3rphAhj3nLN9FVy3Xfshye+k9mm1tLxsfekZvXt8hkS7Nc8/UOd8zq1bYdTuzTXfUrEcBCx7N47co/zxHYpkZy9WoTzaEhzYC054vLepzRlTXDFhzLurOFezVN3Svmi4MLhgSv/DSpbRBRKJjU9x6XEMuW2szpgwc3yuZASocKDmmMvwPN3i9hjsUrZ4oKb8zsW7n5ccrjiEWicLaHygZpMyHsiphk8I58VnQfF1TnnGsmIS5VJprY50CmvVTwsGVzlzfmi13CvZI11HdP4qxUV48BXnhvinoiLc2+4R4RkXyV4igha5xNGEDIUZSAa47cH2vhdlvPl6fZuWkrcfHnJdKrPEVHobNR5XPy/mS28pbURzUggtS3zLbPc5eA/FrRy67qdOZlDDouFzy+aQoXLgQIuqi1jV2/hHrYXVJfis1vpCI1RqI90P4smkvzh0KkcMShFQsPvD7Vx2+yJRBMJvrH9MOtP96aXJ4EnT3WT0JqPzZ2Ez25jKBbnqbYu/nvnUaIjwQMuq4WPzJnI0pqytJsoqTWdoQi7ewY5PBhkSqmPKQEf1QU6vmmtGYonaZzcOubxGAwGg8FwvnC2jBGLVeEtG3sddqfCXj32mFQYeWl98e1ZHYqyRlj29sxkP3uSlKK0XnHZ/4PwsEzyHe7cshmQidrlHxBRYeC0iEu+itwJnNuvWPQ66QK290nJ45m8XASo1MTLYlE0zdFc/XHF83+QUiFfJcy7QVE/I0uoqoBrblc8/UNN/0ijV08ZLHtHxlHl8ikueRc89PXc0HJPKVxxm8I7cgxVE6BxlmQJZVM9SSaZIILPotcq1v8q/3vVvBvFUWW1KWZcIeVDox1FFquUG9rsCrdfU94swd2jqWwRscHplXU9XUAYA+ki6HCLgGa1F+6K5/SOuNU8UDcFDhQpeWuYOdLlLFB4OYh4kxKqnL7i4pFkiUnmzlikSgwL5W+liAZlTLC3+BidlPKqhA1624qP69inmX6ZyivJzGa4R94HWsPRzcXHHdqgqWlVnN5fvEzyxPYRd5YNdhbJsdJJOLFNE7hC0X28sCsOJOC8ZREoq+a53xfe4MBp6GsDb5m41AqJdjoh5XSrbpXzv/43hUWv7feLIOL0yrkf7TQECYff9bBm4S1yDrbemy0GCdGglPnd9AXpeDncLaHs2a95IipliyVVMH6BuHOOboa1P8tsM5kQEbm/Q3P5B7M6Fn5D5+SNHX8B2nZqbvzPjFjddUy2mSod7W2Dk9s1i14nTja7SxEe1Gz+i2Zvljh5+DnJIbv81sxn02Cn5sGvaQY702cUu1vKhivHiasoFpH8rafvzBynxSq5da3Lwek7f0UhIwgZitIejOSIQSmODIb465EO3jG1Kaf86lzGYbWM6SSa4Pfw4xVz2Hymn509A0wKeFlSU06N25EOs17ZUMnvD53Kcwp5bFZubKnFbrVSYrehKOo2psRuIxRPsK9vuOi+7O8fJhRPMBiL54hB2TzT3sO7psXw2W0cGwzytawOaQDhRJIvvHCAH62YzeSAD601B/uH+dC6XTl5SWVOO9+6cAbjSjzpxzpDEZ4+1c3DJ85gsyiu9/WwuLqUSlfu+YsmkvREokQSSdxWKxUuB1Zj4zQYDAaD4e+G3amwn+X+nNOncPrGHuP2K9x+qGg++5jqSUAyt117CodHUT8NrviwTBiVNT/012JTVE2A1beL20QnRajwlOZmUJVUK1Z/AoY6xbVSUiVlZ9lCladUsfyd0HNCcqV0EqaskMDy1GTQaldMXKLxVSqe/6OIUP5qWHCzonZqJiS5pBKu/rhizY8zE8eSKrj4X6RkKXUOLnu/CFWZyaU4ry79V5UOL66fJmJN287c8zNuAekwdXdAMqYKTdqXvkWNdLtTzL4GDm3UeZlKDg9MXCLuLHdAF+2u17JIHFUOl2LW1VI+VYjpqxQWqyJQW1yoCtTJa+VwSebOwbUFV8XEpSPrqi9e7ubwSKmQxSrnua9I8kL5yDXpGuMaVkpKihQiaBXLXbeMzHxjY92f1XJN6iREi38dZ6hbfvacLH6M4cGRnK7E2NlZHfs1DTMVbTuKr6vzQCaU/tSu4us6tUtTVq/G7Fi49ymYeaW40A48U3hMLCzCZ0klnNxZXADcfLemepKIVpvvLrzNzoMi2rn9krVW6DpNROGFP0sJZCwCz/wk/5oHKWccv1BEzv7T5IhBKbqOwqF1mllXSwnvMz/Nfb+CnMtHvqG58bPiFB3qgsf/W+cIhckEPPd7KGuSEtzzFSMIGYry8InOosvuO36aG1tqc0SUSCJJMBbHYbWcdxk2SilqPS6uGefimnGFww1qPS6+u2wWP9pzjGc7ekhqySh674xx1I6Un5U67SyvK2dNe0/e8xdUBShz2nFYLDT6XBwcKPxXqMHjwmW10DZc4C/1CBpxGwVjCX51oPhtl7sOtvPRuRPpj8b49+f25oVn90ZifHbzfr6+dAZlTjudoQgfWreLtuHMX4W9W4eYXubjcwunpMvUusNRfnewjXuOnSaSSFJit/HmyQ1c2VRFqTO/29rOnkEcVsX0shLKnY4ch1b22FhS47Za8dhNqZvBYDAYDC8HFouSGvUxcL2Iu+meUjVmVzUAb6nCWyqhwWdbT91U+f5TKFfK6VM0zxVHUTIuwsDokkKrXVHbCtd+UtqyDw0NU17jwVeWe7D+GsU1n5QJ5NAZ6Vznq8h1XnlKFRf/i4gc+9ZolAWmrhAHVKr0z+ZQTLpQU1qveOEvMmEta4D5NyvKGjK5XCXVcO0nFWt/ruk+JuuvnSKlf77Kke0FFKtulZKe1BiApjmw+A0Kx0jeVeNMyfcZnRm14JZMBz53QELTR2f6WO0ijqUEvrnXwbHNOk8oCNSNiIaI66VY6d/c60iLXvNvkk5wo7HYYMIi2V55s5RxxaN5w2ieP1KSaIWJF8G+J/PHAExaKuuqHeN6KmsUsQpEIC1WRlg/XdZV0Vj8Vq+rRM6bpnhXQ8gEWY8V9G+xvbhSw1S5XzHXEkiZltbyXigk/KUY6tGA4syh4uJSf7sIJ7Hw2NvsOQEV4zSHNxRf14nt4k6KhosLaDrJiPtQs7dId0eAPU+KWyoWLl4qmQqcdwc0+57SRV1jW/6qqRp//rqEzq9Zu+HvyvAYLdlD8WT6oy+aSHIqGOZ3B9vY3TtEpcvOmyY3MsnvfdW1Um/0ufn43Mm8LxZHoymx23LEMZ/dxgdmyq2hZ0ZyfwCW1pTxodkT8I90P3vDpAaeOtVdcBtvmNyAy2Y9q+jmtVmJJBM54s1oTgyHCCcS9EZinAkX+AsLHB4I0heJ4XfYePTkmYLr2907xM7eQS5xOxmMxvj2jiOsac/s/2Aszvd3HyOUSPLGSQ04rBZ6I1F+tu8kfz3akR5nAW6bPYGVDZX4Ro6vPxJjX/8Qv9h/ks5QhCkBH2+d0kiT140rSziKJRJ0R2L0ReJYLYpSh41Kl6Ngx5tYMkk0kcRltRrXksFgMBgM5wGjw20LcbZcKRAxx+6N88zmJ1g9cTWQfxMqLVRNGns9KaEKVbgDn9OraJghneHiUckXGp09ZR1xVF31EXFUocQtM7pEsKRKceW/SWZPJJjpdJU9zh1QXPgWCTs+uV1jc0DjbAkqd3gyQtW4BZobmxQ7HxGhqmYytK5QlFRkba8arv+MYstfNMe2iFgzZQVMW5kJSXf7FSv/FZ67S3PkuZGyRQ/MvR4mXaTSolftVJh7g5RYpQQPhxcu+3+ZMHpPKay6TfHwN3KdI9JpTKVLEueshpPbJLg5mymXgG/E6eUpgwlL4PCG3DHKIkJb6jpZ/AZ48Mv5KkFJVcZNV94sWWCFspLmXCfXQFJLB8Nt9+WPsdigbpr83jRXFS0tm3ShvKaJmFxTxYLZG2bKvjfPU+x6pPC66qaK+KSUCICFOuIBVI6TdVW2KA48W3hd/hqwWkHbxRFYTLByB+Q94PQWF3HsLuS9UnSEoEY0uLHKFlOi11iCF0g5bSIOvcV7AzF05uzrOZcxgpChKJc1VvLwycItFy4aackOUsJ029qdxEdk1eNDIV7o2s0/T2nilgl1eM4zt9DZ8NjHdrBUuZ18bO4k3jUtxnAsjtduo9Rhp8SROU+NXhe3z53EN7YfTuf+OCwWbpvVQrPPDUCZw87MshJ2Fsgtmlfhp3TEbTQ54OV4gUBsgKmlPtxWK6HE2Lcboskk/ZEYD58o3oLj3mOnuaC6jN5IPEcMyua3B9u4qqmKWo+Lbd0DOWIQiMX3G9sPM63Mx+SAj2A8zj3HTvOTvZnbM52hHtZ29PDlJdNZVF0KiOD0RFsXP9h1lFBCzlflSPbT9DJfurRxKBbn1HCYPx5upz0YZm5FgKuaq6hxu7BlCUPxpKY7HGUwFseqRFwqcxVOiIwnk8SSGqfVck514TMYDAaDwfCP58V0PXJ6FU7v2GNcJQpXydhjUmV9L2Y9qcl+IRxuCd1d9nbprmZ35ncStFgUpXXS8W7x6xGhyi8d9bLxliuWvV2ChRMxmfSnnEHp/S5RzF4Nky+SUiybXUQbT1kmu8tqU9RM1tzyRUX7Xhg8o6ltVZQ25AYIl1Qprv13OLFN8mQcbph5haK0MeNcc/kUF7xBSvu2P6AJDYjotfA1ikBdZt8rx8MVH5L8qcEzIkSMWwCLX58RvXwVitUfF3dWytVisUqr+4lL5PW3IsHYXUd1Thmh1QGrbs1kj3lKC3cZLKmW0HibQ2FzwJI3w31fyHdnTV8F7lL5vbQOKidAV25qBMoKi/9J4fQqHB7NwlsUz/wkX6QpayJdKtk0GzYVCWZfcLPCHZDObRMWw6H1+WMcHnG/AbRerNhTxNkzbaUIRxaLBNkXKiNUFnFxWayKiRdKGHohmudJlpJOSmlirPBUiECNXG/VE4uX4pU1nT1Q/lzm1TVTN/yfmOj3MrXUy95ReTZuq4W3T2nCbbPSE4ny1a0H02JQNj/dd4KVDZV5glAimSQJZ23nfj7js9vSDphCeO02Lm2oYG6ln45gBA3UepyUO+3plvMBp51PL5jMfz6/nz19Q+nnzizzcfu8yWm30RsnN/BkW1dePbVNKW5qqcVutVDpcmChcM21y2oh4LCdXa0f+dcRKi7XRxJJBmNxXJEYv9pfvJTtr0c6+NDsCfRGYvxsX75XNwl8bdshvrt8FpUuB/t6h/jmqJykrnCUj6zfxU8vnUuD100onuCptq6cPKUdPYP88fAp/nvZTCYHpDh9KBZnfUcv/7PzCAMxuQXVUuLh3+dPZoLfkxZ9hmJx2ofD/OloB6eDERZWBbikvpI6jzPnLmA8maQ7HGUgGsdmsYwpLoXjCaLJJF6bFeur+P1hMBgMBoPh5cdqV1jPYva3u9SYpU4vesxI4Lp/jNB1q13ynESoKP7N1FehmLZSOlxZrJmcqGw8AcWUFdA8V7J0CrmzHG5F0xzpphcNiRPGWZLf/rysQbH6dnEJxaMj7qyAHFN6e2WKFe+RsOeuI5LFVDFORCDrSB6Xw62YfJGmbpriwFpNsAfGL1JUT8jNziqthxs/K8JK204R4mavVlSMB9eII8xTKmHxe5/Q7H4CYkFxIi1+fSa4WSlF8zzNsrcr6Qw2KILLuPmaC95gSZdBesslX+vx/9bpUHKLDebdkHE32V2Kha+VAOmuI1nn0ANXfkThGRG9SiphznWw7d7c16OyRcQii0XhDsDF/wL3f1HnOXMueENG9KyeQMHsLLsbZl8jApq7VDP/RsXG3+bPVcctlHOnLIpJF8GOB/O3BzD/RnXWlvfnMkYQMhSlwuXg84um8sjJM/zlSAeheIIlNWW8tbWReq+4VAaj8YLt2EHqZff3D9E44mjpi8Q4PhTir0c7CMYTXNFUxcyyknOmhf1LjdNqpdZjTecPFaLG4+KLF0ylNxKjLxqnzGGn1Cn/UjR6XXxpyTS+vOUg3RH5lKtxO7l93iTqRjqIlTrs3NRSx91H8gt239LaSLnTjs1iYXVzNT/YfSxvDMAN42tx2axp51gxXFYr8aQEThfjdChKPKk5PhgiUcRZejoUYSAaw65UjoMom2hS83hbF29tbaI3EuObO47kjQklknx5yyG+tnQapU4H+/uGuGNLbrH7kcEgt63dyY9WzKHO6yIUT/BEWxffyBKXXujq5zcH2vifZbNo8Uvx+WA0xlOnuvnB7mPpfKbxJW4+Pb+VCX5PWjgaiMY4Ohji94fa6A7HWFgVYHVzNbUeV47rKBSX8r7uSBSXxUKp0160LK43EiWRBJ/dmlNaZzAYDAaDwfBq4MVM4t2Bs495MXlXnoCU3o25rRKFu2Ts8HaHR1HugQteX3y/LBaFv0Y6YM25VsSZQsfqLVPMuxGmXirlU3ZXfqmhy6eYfLGmYbYiGtQEw4NU1vnSwhKIG6eqRXP9ZxShAckecvtF9MoW23zlilW3SVey7mMiJJU1gKc84/Ry+hQzr5Kw84NrNZEgTLhAuiZ6s3K4ypvhps+L6HV6v+R0zbpaHFx2V0qoUlzxYdj/9EgL+6h0PJtzrcI/4m6yWiWry+5SbP6TJtQv52HaZTBjlUq7xkoqYPXtiqfuzARQu/ySp1XaUPz1Oh8wgpBhTKrcTv5pUgNXNlWjtWTiZE8u1Vl8I6kOXH2RGD/ec4z7jmeCqtef7j3vWti/HJQ6HTlBzaNxWq0sqirlBxfPpj8aRyHuososl4rXbuPNrQ3UeZ38+kAbvZEYVS4H/zy1maU1ZThGXEkrGyp54HhnXgnarPISppWJw6bS5aDa7aAzlC/4zK3wE3DYsFsszCwvKRiuDbC4OoDDajlrFzuLUkSTSU4UESUB9vYOEU8mOTwwTKJIWtzBgWE5N0px557C4tJQPMHGzj5ubKmlJxLl2zsOFxzzje2HuGPxVPwOOzt6Bvn6KOfS0cEQt67byY9XzKHW42IoFufPRzr46b4TmX3uG+JPRzr4zrKZTPCLh7wvEuMPh07xu0On0sdR5XLw+UVTmFzqS7/XesJRnj/Tz28PttEfjTGvMiAirseF3Zo5n32RKGfCMfb1DVLqsDMx4KXS6cgZA+Lq6ovESGiN22albIxcsKTWpmzOYDAYDAaD4SXgxTi4LNZMDlPRMRaFrxxiJXGeeeApVo/Lz85SSkrbUuVtxUgJY1UTio9xeRUuL1Q0F//OaLVJCPui10rXMZsdbM788b5yxdzrJSMKLWVio8e5ShStF2saZyviUbDaRMyyZnVKtNgU1RNTofKSheQqGel+eJ7njRpByHBWrErliAfZ+B1WJvm9BTtiWRVMCshk9uRwKEcMSnFkMMQDx07zltamdLhvQkt+SziewGG1UOZ04LSa8pm/BaUUVW7nmG6sMqeDm1vqWFFXQSypcVhUumtYimq3k68tnc6G0708dKITq1LcOL6WORWB9DVS5XbypQum8W/rd9Mbyfgum7wuPj53UrqU7e1Tmljb0Zsn0vjtNpbVVaCUotHnwmGxpHOUshlf4ibgsGFB0ehzszerbC6bKaWSIVSorDEbjYgfRwaCRcds6+7nxpZa9vYNFXUu7egZZCAaJ6E1PyomLsUSbOnq5+pmF72RWI4YlCIYT/Dt7Yf5wuKp+Ow21nb08OuDuWV2Z8JRPrROyuJqPS76ozG+u+sIj7dlMpweb+tiTXs33102i9ZSEe26w1G+vOUAz53JpAg6rRbuWDyV2eV+HCPvt85QhF/uP8nDJzqJJjUtJR4+OLOFKWVePLbMn4/ToQjbuwd4pr2bareT1c3V1LidecHnPeEofZEY0aSm1Gmj3GlPi405xx5LMByPYx9xQRkMBoPBYDAYXn28aNHrLEJVStA6Gy/GDXa+YQQhw99EqdPBx+ZO5INrdxJO5E7a3z9jPOVOB1pr7jt2uug67j12mmvH11DpctIfifHkqS5+uu8E/dE4DouFa5qreVNrA5Uu4yL6R2MZEY7Gotrt5PrxtayoLePgwYPMrinFbs/9pJ7g93LnxbM5NhjiVDBMS4mHeo+LSndGWGz0uvj2RTP4+rbDHBkUEWZuhZ8PzZ5A7cg+VDjtfHzuRL7wwoGchp4uq4VPzJtM2Ygz6p1Tm/noht15++qwKC5rkJ6sk/xeijUGbfK68NttKCVZTcVCuCeOuHVixdSgEZJaE0tqjg4WF5d2dA9ydXMN27qKtHYAtvUMMhBLEEkm+VkB0Qik5C0lLp0JRXPEoBSxpObbOw7zxQum4bFZ+fOR9hwxCEQM+8TGPfz80nnUe110h6N8YuMeDmUJZEcGg3xo/S6+deEM5laKL/rUcJhb1+7M6VL3x8PtfHj2BC5vrMRjs6G15vBAkM88v4+TI13qnFYLb29tYvW4agIjImE0keDEcJif7zvBjp5Bypx23jipgQWVgZzcpVA8QXc4ypaufgZjceZXllLjcea5lxLJJF3hGMF4XMRlh71oyP1ANEZSQ4nddtbOc06n+SwyGAwGg8FgMJz7GEHI8Dczwe/lJyvmcP/x02ztHqDG7eR1E+tp8rpx26wktSYULxRXLESTGq0lfPfhk518b9exrGVJ/ny0g7ZgmH+fNzmnjX00kaQ/GkMDPpttzM5ehr8/HquFk4cOMntKa8Hl1W7nmKWADquVmeV+vnHhDIZicSxKJuMpB1FqzIW1Zfz4kjn85UgHJ4dDzCr3c1VTFdXuTLbSlFIvt82awA92H00Lk+VOO59Z2ErNyD6UOe28rbWRn+3PTZ6zKsVH5k6kfERwePuUJj63eX/e/tqU4pJ66bc6vax4m4+WEg8lDhtJLeJSe7BASwZgYkByhoq/M1Jo4klyBJfRpBx6z5/pKzpmV+8QQ7EE4USSPx/pKDgmltRs6eqn3uvi+FAoRwzK5n92HuHrS6fjsFi5c/fRgvv2ze2HmV8ZwOOzcToU5dZ1OxmKZbrZRRJJ7txzjGq3g8sapdB7f3+QW9fuTLvGeiMxvvDCAVY3VfPeGePwO+wE43HWtPfwlS0Hs87dcRZWBfjEvMlUjLyOfZEYj57s5Of7TjIUT2ABltWV8/4ZLdR4MtdldzjK1u5+7j7cTiieZEV9RboTXjbd4SjtwTAH+4cJTJ1NdzROtc2WVyLXH4kxEIuT1Bqf3Zben9FE4gmCiQROi+VV14nRYDAYDAaDwfDKwHwLNfzN2CyKBp+bd05tJphI4rBYckq8LEpxZVMVTxdpRb68rhy/w053OMbP950sOOa5zj66I9G0INQRDPP7Q6d46LiUslxUW8Y7pzbT6HOns1QM5wZlTvuYuTRum42Jfhu3zmohmtA4bZa819jvsLO6uYolNaX0RmJYlaJsVOCy127j5gl1zCgv4Vf72zgTjjC9rIQ3TW6kwZsRCOZXBnjTpAZ+d6gtXRbms1n5z0VTqB5xOJU57dwyoY4/Hs4N4bYqxYfnTEg7l97W2sSXth7MOyaHxcLSGinonlNRvD/s9DIfJXYbsaSmbgxxaVqpCFRjlVZakHap8aROB1wX4vTINsYSlw4NBAklkoQTSZ7tKJwDpZGg7Uafm+3d/TliUDY/2XucuZUBrAq+uf1QwZynB0508tqJ9fgdds6EonxpS/45ff5MP4+c6OR1kxpAw+NtZ/hulricBNa099A+HOHLS6ZR7nLQE47yla0H2diZOdYj+4Lcc7SD7y6bRZ3XNXJOwnxi414OZzm+fPYTfH3pDCYHvFiUQmvN8aEQX916iJ29gwA0eF18ePYEZpSVpLPXIokEp4Yj/O5gG3v6hqj1OHnz5EZa/J6cQPZgLE5PJMaWrn6iSc28Sj+VLkeOYCrrS9ITjhKMJ3DZLJQ5HAXF8URS0xeNobUm4LDnZUUZDAaDwWAwGF59GEHI8HfDarFQUiQEuLXUy9SAl739uVlDPruVN05qwGm1MBSPjzlRPTEUZoLfS2cowofX7eJU1uR4TXsPmzr7+OGKOTSNdDWDUZMlq4UyZ/GSEcMrG5vFgm2MOazjRXRl8zvsLKouY1pZCZFEEo/NintUB65Sp503TW5g9bhqTg1HcFktVLudVLgc2EZKiUocNt48uZG5FX5+daCN7nCUmeUlvLW1KUdcWlJTxhsm1XPXoVNpcSngsPH5RVPT4lK508HrJ9bx+0O54pLTauFDsyekBYB3Tm3mCy/kdj8DcVXNLBdBaGFVadFjv6i2nIDdRjiRpNnnLloWN2tEoCqWGwbgtlqwoojpZNEsJZAcJKBovhPAqWCEeFITSiaLOpIAtvf00+L38ERbV9Exdx1uZ1VTNUmti4rLBwaGOR2KUO5ycGwolCMGpeiJxPjdoTbeP6OFWDLJ/+w8miMGgeRAfWzDbn60Yg7VbienQxE+8OxOBmLx9Ji24TAfXb+b7188mykj+U27e4f4yPrdaeHr+FCI5zr7+MDM8VzTXIPLZmUoGueBE518f9fRnBLHq5uqePe0cenyuZ5wlN8ebOOvRzuIJjVWBSvqK/jX6eNzSj87QxEeOt7JA8c7SWjNyoZKbmqpzXmvaK05HYqwtWuAPb2DTAp4WVBVSrXbmb7uQZyc3eEYvZEoGrl+K1z2vAB4rTXdkRixRBK7xUKFy16wGx6I+AXKuDwNBoPBYDAYXmLMzNjwklDpcvL5xVN54lQXfznSQSSRZHltOa+bVE/9yKTEabEUzXgBKHPK5bq1qz9HDEoRSiT57YGT3DprAk6blZ5wlN8fOsWfj7QTTWoswMX1Fbx/xviCOTmxZBI05s75qwCf3YZvjIA6j92Gx26jwesuOqbUaWdZXQWzyv3EtcZjs+C22fLGvGVyI9eOq6EzFMVptVDpclDhcqRdTiUOG2+c1MjCqlJ+c6CN3pHOYDe31FGXNWFfVF3Ke6aP42f7ThAZKYtr8rr4z0VT0mVx5U47750+jh/sPpazH+VOO++ZPm7kuOB908dx+3N7846p0euixS/HvLi6FKuioOBz7bgaypx2huMJWgNe9vfnh8oDLKiSnKHJI+Hyhah2O7BaFAl9ltyekfDpzlBhlxRIuVZSa4LxRI4wM5rDA0GmlZXwYIGg+xSPn+zizZMbiSaTrCviguqPxmkbDlPtdrKuo7fgNpOIC+o/FrQSSST48taDBV1Q3991jKU15dTbrLQFw3xv19G8MQ+eOMOi6lJWNlQRjif41YGT/Cmr/C+h4Ym2bgaicT69oJWAw86ZUISPrN+dIwD+/tApHjt5hu8un5UWhQ4PSrletpPLZbXwjQtnMK3Uh1KKUDzB5jN9fGnrwfQ4j83Kv82ZwNLqsrTY3heJ8WxHDz/fd4Iz4SiVLgdva21keV1FTkh4VyjCtu4B7h3JmLthfC2zKkry8uI6gxGODYU4MRRifImbJp877zNca01XOMpANI5SIrxWFMmd6wlHiWuN3aLSbr5CROIJlFLpkHWDwWAwGAyG8w0jCBleMqrcTl47oZ5VDVUk0fjt9pwv2mVOOxdUl7GhszfvuaUOO7UeF9FEkicKhOam2NDZxz/HE6AUvzt0irsOnUovSwJPneqmLxLjPxdOSU9MeiJRjgxImUg0qbm6uZrppSU5x+Vw9wAAe9xJREFUAcgGQzECZ+mC9WLEpYAz41yKJTVemyWv+1bAYec1LbVcWl9BfySO3aooddjT2UcgZXHXNNcwrzLAX4500B2OcmFtOUtqSnPcIDMr/Hx2YSvf3XWUzlA0na/zvhnj05PxSpeDzyyYwmc378sRhaaV+njdxHrsVgulVgu3zprAB9fuyBOOltWWUzWyrrmVAdxWC6FEfmLSO6Y0UelyMBSLs6AqwOYz+SHbFki7oC6sLefBE2cKnsfZ5X5cVguJpMamVNHOcqkMIesYGlTKzRJJ6DFznnojMWLJJJvGKLHb2ztEKJ5gKBano0jZX1xrTgyFqHY7+EuRjCeA3xw4xfzKUoLxBPccLRzW//yZfnojMQIOO8+f6SvoBuuOxHjgeCdva22kPxrnPzftyyvrCyeSfOq5vdx58Wyq3E7ag2E+vWlfjmgfjCf4/OYD3DniggrHE/zpSDu/yMrq6gpH+fr2w3SGorxpcgMum5WuUIRPPbc3xzW6tXuAGWU+PrtwSrrD4dHBIB9et4uerI6F1W4H31g6g8YRN2g4nmB7zwBf2XqIrpE8q1qPk0/Om8y0Ul9a5O+LxNh0po+f7TtBRzDM+BIP75o2jhllJZQ4Ml+HzoQi7OwZ5MHjndgtihtb6pjo9+S817TWnAlHOTYYoj0YZoLfQ63HleesS3XNHIjGsChFwGEvmCuV1JqeSIxEUuOwFheqtNYMxRNYjaPKYDAYDAbD3wEjCBleUixK5XypzsZrt/Gh2S18fGOYo4OZCUyJ3cZXl0yjyuUgqTUlY3wJ9tisWJA7wH850l5wzNbuAXojUUqddnrDUb614zBr2jMOgPWne5kS8PKFxVNz7kL3hKOcDkVoGw5T43ZS53HmtWU3GP4WfGcpZ8yUxRUfU+KwMcXh4yNzJhDXhXOFfHYbK+ormVHmz7R3d9hzJphOq5ULakr5xcp5bOkaoCcSZX5lgHqPK+c9PCng4c6L5/DjPcfZ1t1PqdPO6yfWc3GWG6Ta7eRbF83kU8/tTQdQ25TiDZMa0llKPruNW2dO4ANrd9AfzXXafHDWBMpH1jW11Ee9x5nnErRAOnjaYbFwRVMVDxRwAAUcNppGxLmrm2uKiktXNFZR6rCNfObYGCziOBrnc2NTKu10LESm3HBsF1Qq46kzXNwF1ReNEddJhmLxooIXiKhR7XLycJHjA3iirYsbx9fSF41xYqT722h6IjF6RsSluw6dKurg/PWBk3xy3mR6IzF+e7Ct4JjfHmxjdXM1dTYrz3X25ZUQg4Sfb+0e4PLGKrrDUT713N4cMQigMxTlP5/fz9eWTqPU6eDkcJjbN+zJEe46ghH+bf0u/veSuTT53ATjcf5w6BS/ztq3QwNBbt+4h4/OmchVTVVYLRbOhCJ8YuMeDmaVL6493cuy2nI+PHtC+to/PBDkw+t35VyrzT43X14yLe3sC8biPNfZxzd3HE6Pa/C6+NT8yUwO+NKleD3hKE+e6uLXB9roicRoKfHwrzPGMa3UR0lWZtTpYIS1HT083taFy2rhNRPqmFrqy3k/xhJJusJRtnUP0BGMMKO8hJYSd97fqnA8QW8kRnckisMi5dQVLkdeSHo4nqAnEmfioiX0xhJU2WwFS//C8QSDsXg6v61YeWBC6xHRy7iuDAaDwWB4JWAEIcMrihqPi68vnZHu5lPncTG+xEOVW8KBrUpxY0stjxbJEXnNhDrKnHYODgSJJotPlk6HorT4vRwcGM4Rg1Ls6x/mmfYebmqpRSlFx0io7JGsHJFat5OvLJ1Oc1ZmUSyRpCcS5UxY8jWqXA7KnfY8t4fB8I/GarFwtquu0u2gkuJOOKfVSoPXPaa7yWm1Ming5dMLJhOMJ0T0HTUhtCpFa8DL95fPoicSI5pMUu50UOa052Q4NZe4ufPi2azr6GVDZy81bifXj6+hzuPCM1KOV+V28o0LZ/CTvcd5oq2bhNZM8nv44KwJtPhFKXPZrLxjShOnhsNs7R5Ir7/UYecr/197dx4eV10vfvx9zplzzmzJbMlk35ukSfcW6EILBZVNRAUBF+AqLriAAqIioriDiiIIiBuLeq/gVUB+iiheAYGWsrV035OmafZ9mX3m/P44k9NMZiblKhcq/b6eR5+H5PRkZvLNzDmf72dZ0WL1b6py21lbFuDJGQ3vgw6N8xvKUBWFIrvEh5qruG1rW9ZzX1bksXrjnF1TwoNt3TkDJhc1VuDTNQzDLMvrzBF80WSJKrcDXZFZEfTlzJQCswm522YjbJt9Pp1XV5Fls4F5PpoiI0sS8VneK8HsxRZJJmmbpcfTgfEw4WSKkVg87/kShsFwLI5LVfjDgdzZTQAPt/ewvMTHSDSe87UCc7LeSDSBXVH49Z7OnFlc8ZTBI+09XNZaw3A0wf37cgeqfrytneOKvQQdGk92DWQEg6Y80zPEO2tL8ds1+sNRvrBhR1bgsmMizM2b9vHV45oo0FT2j4f56oyJhYcmI1y1bhu/WLuYCped8Vicn+44wGPTAndt4yE+/9wOvry0kVMqipAlid5QhM88u42eaSWTLw2McnKZnysX1OOzayRSKbYNj/P557ZnfP5VuOzcvLLVClSNRuM8cqCX+3YdtIKKfl3l68c3M9frtvpB9Yej3L2zg78dGiCeMiiya3yspYYVJV6rt1kiZdAdivDr3Z083z+Cy6bwnvoyVpcFMrKlJuIJukMRHmnvpS8cZVWpn+VBb1bPt+FonL5wlG1D43g1Gy2+AgL27M/QwUiMkfR7iUdTs95LpgyEo4SSKdR0oMqe4xjDMBiOxkmmJwPmOs/UceFEClWRUGf5uxIEQRCEfyciICQcdQLpHivz/bmnL1W6HFzQUMZvZzThXRIo5KSyAJIk4VCO1I9IJZpMZfTfmOkP7T2cUh5AkSVu2rg3IxgE0BOOct2GHdx64nwCdo1wIskLfWZ/jalmuroi85kFdZxUFsjI/hiKxBiIxOgLRyl26FZfGUH4d+VSbbhmyXCSJIkix5Gz6kqdds6tL+PtNSXYJAlFzs40KHXa+ezCBj48t5qUAU6bjHdGiU2xQ+erxzUxEIlzYCJEQNcod9kpnjZ5zqdrfHpBHadVFfO7/d1EkklOKS/ipLLA4bIyWeYtFUXYZIm7dx5kJBZHkyXOrApycVOl9XNLnRpfWtrITRv3ZmTuvKu21Oql5LdrXLtkDlev25YVsL5yYb0VSFtT5ufXezqzAg6qLHFxUyV2m5IusfXmbIpd5bLj1zXsisK59aU8n6ec7V21pXh1lUgymbekT5EkiuzmuRo8Lnbl6RdVX+jEocizBqDADFAZhlkilU/KMMAwCCXzDxkAs6QtlEiyJ89jArOJdySRoi8czdsAfSKRZDQWR5WlvGV4AA+1dbMwUEhfOGaVps300sAoI7EEkiRx944DOY+JJFP8/dAAFzVWMBxNZASDprtjWzsLA4V4NZXft3VnBIOmPNU9xLn1ZfjsGgORGF/csCNrbR2ajPCjLW18aWkjLtXGywOj/GJnR8YxQ9E4V6/bzr2nLKbcZWcoEuMrL+xix7SG8AORGN/euIfrljTytsoiJEmiczLMx/+xmUh67QxH4/xwSxtP9wzxpSWN+O0ak/EEfznYx4+2tlvn2tA3gl9Xue3E+Vbp30Akxo0b92QEQ1VZ4mvHNbOs2GP1EWsbC3H9Czs5lA4W2iSJ8xvKuLCh3Pp7nIgn2DQwyu1b2+kJR1EkiVMrAnxkbo31tw1mYOkf3YP8bn834zGzbPWDzVVUuOxWYMwwDHpCUZ7qHuS53mGK7Brn1ZdR6XZkTAYMJ5IMRmI83zfMWCzJccHsjEqA8Vic4WicnnCUAtVGkV3L2ddwJBpnNBYnkTIo0MzjZmZwgXk9EUulkCWJgK7lfM80fzcxUgYUqra8vRINwyCWMrDJkpjYKgiCcIwQASHh345HV7mosZK3VRbzt84BIskkp1YUUeVyWBdePl1lVYmPZ3uz+xFVuOwE7Fr6wif/LnsslSIFjEfjGVkG03VORhiKxgjYNbpCEW54MbO/RjSZ4rub9lHjdjAvHeDqCUX40vM7MyYqVbsd3LS8hXLX4d3S0WicvkiUp9MZTGvK/AQdOh4tu2dNKJ4kkkxiVxTRV0J4U8hV6jad3aZQmmcnf4pX1/DqGnNmaWrtt2usKvWzOOBJZwgoWeUuHl3l7JoSVpT4CMeThMbHqCn249QO3+g5bDbWlPmZ51vC3tFJIskUzV43Pl3N6E/T7HHzi7WLebith23D41S4dC5oqKDSZbdueEuddm5fvYDbt7bxfN8IBtDsdXPVgjqrNM2t2rh6YQNfe3EX26fdtFe47Hx7eYsVYG7yuFld6ueZGY2xW31uVpX4AAjoKh+eW83tORpZv29OOT7dhqbInF9fxmMdfVnZOBLw/nRvIK+uUuGyWzfr05U5dXy6SqFm48yqIHtGs7OuAM6qDlKgqfi0BDLkzP6xSRKFmg1dkSl36jl/HkC1245uk9GPEKhSZRkDiM8SqIqlUhiGwVgsnvcYMN/3w4kk+8bzZ1RtHRojnipn/3j+YNZQNG6VKs5W+vfHA30s9BfSns7SymV97zAjsQTRZIp7dh3MeUwsleLZniHObyinNxzNCAZN99MdB1hSVIjTpvDT7QesYNB0L/WP0jkZwW/XGI7GuX1aMGj687tzWztfWtqIrsj8oa0nKzMunjL48gu7+OWpi6lwOegNRbly3daMYGnCMPjN3i6CDp131pYiSxJbBse4/oVd1jFJw+DxzgH2jk5y88p5BOwaw9EYN23cwwvTfuYTXYM82zPEj9cspCH9vnFwIszlMyYI/u3QAB9vreEdNSW4VBuhRIKnuob47qa91jXAvbsPssBfwA3HNVm92QYjMW7dvJ9/TPt7LLZrfGdFC/WF5s8zDIMD42G+vXGP1bDfp6tcMb+WE4I+a3NpPBZn69A4P95+gI6JMAWqjfMbynh7dUnGBtNAJMa6niEeaushkkxyUlmAd9WWUjbteiM1FfTqGmDj4BhVLjvvqC2lxKFnZExNxhMMRuI83zdMNJni+KA5idA7o5feSDTGUDROb8ic6FhkV3M2eR+MxBiNxUkZU43gs4NeqXQfrmgyhabIBHQVJcffczyZYjQWx8DsuZevLDGWTBFOXy/N9jkjSRKlpaV5vy8IgvBmIQJCwr+lQk2lUFNp9Lhzft+l2vjMwnpGX9zF1uHDF7XlTp2blrdYqexnVgXzlmacWl6ER7Pl3QmeMhFPEkum+N0s/TV+taeTryxtJm6k+NbLe7LGa3dMhPnKC7v43spWfLrKcDTOz3cc4E/TeqD8cncnZ1UF+WhrtdVwdDKe4MBEmF/t7uTAeIjaAieXNFVS7XZYE3+mTDU2lTBvpPL1chKEY9GRAqmyJBF06MRtcR59YgNzzjor6xhdUShzKRk3WjOpikyV28HHW2sIJ5PoeW5KqtwOvrKsidFYAiNdyjKzgXmJU+dby1sYjMToCUUosusUOzKzDf12jasX1vPuulIeae8hnjJ4e00JzV6XdZOqKgpvqyym2KHx8x0dHJyMUOrU+WBTFStKfNb0vHKXnRuXt/DtjXusG/JC1cbnFjdQmS4rDNg1vn58M1c+uy2j75JbVfjG8XOtx7a6zM9Dbd1ZvYtq3A6WB81AlU9XObM6mPE+OOW8+jL86RKgi5uqMm7qp0jAefXlqLI53c+j2bKyrqZ+pke3UajaOLW8iP/K0wPprOoS7DYlI3A/k0ORcasKmixT5rQzGssdVKkrcKLK0hH7hqlWlkr+Y1JGCgMYnSVQZWBO0lRlKW/wDLACELvyBIPADDCEE+bPfC7HpsuUp7oGWBgoZOPAaN7PxvW9w4zFEiiyxIN5+v4lDYMX+kaoqHOwe3Qi5+8Q4Fe7O1ld6keWJO7IEdwEaBs3p9UF7Bpdk5Gc6yaWMrhzWxtfO34uALdtbcs5QfAn2w+wutSPS7UxEI7xnU17s47ZMjTOH9t7ubipiqRh8Ju9hzKCQQD9kRhXr9vOT09eSNCh0xuO8ulnMwNQw9E4X39pD7esmseSIg+GYfBC/whff2mPdcx4PMHdOw+yZ3SSaxY14NFUBiMxvvbiLrYMjVvHPbCvi8cO9vHjNQuttbx/LMSnn91qZTc/DzzY1sNXljVxYqkPTVEYjyX444EefrLjcHbZz3Z2sLYswKcX1FnXFH3hKN98eTebBw//zMr0e0dVOhsskUqxa2SSb7282+oH59dVPruogaVFHisINRKN82TXIPftPshwNI5bVbigvpyza0oyrmF6QxEebOvhLwf7MTA4taKI8+vLM/5Wo8kkhyYj/HZfF/vHzOulCxrKqXDZM4Jew9EYByciPHawj5Tqwz4aotrtwDfjmqkvHKVtPET7WIi6Qie1BU6CMzK9oskkQxEzG0zCbHafq43AZDzBcDROOJHEpdrylkCOpoPEkiRRqCoZPcamG4zESBoGmixnBeumJFMGo+lm9/mOMY9LEUsZ6OkSY0EQ3nxEQEh40wo6dL55QguDUfNmKaDrZs+UaR/qiwKF1BU4aBvPnMLj11XeUVuCTZYpUG2zTiwK6BrRVIoDOSb5TDk0ESGSNJtuTr8wm87siRHHp6vsHpnIeRP06ME+Tir3s6LETzyZYl3vMN96+fAFYVcoyrreYW5Y1sRJZX4UWSaWTLJ9eILvbtprXXhVux18YfEcmjwuK3U8kTLoC0d5sX+EfaOTtPgKWFxUSIlDz8qYGI/FGY8laDp+OeGUwexztgRBmElV5LxlG1OOVIYHZtDEp6tHzILy2zUWBgrBIOfP9egqJ5cXscBfSNwwp7TNLGPVFYXjgl5+dvIiRtKNnqcm3dmmlanUFzj52ckL2T48wd7RCeZ43LT63JRMu1kKOnS+v2oeT3YN8OcOM/vl7dVBTi4PWOUzLtXGh+dWU2TX+O/93YQSSdyqwvvmVHBWddDqB1NX4OQzC+q4c1u71b/Irsh8bnEDFS7zXAGHGaj63PrM/jpum8JXljXhTwfZz6kt4S8H+xic0ci6odDJgvSkO6+mcmKpj2d7soMh72+sIKBrqIrMB5uruHbDjqxjFMnMgpIkiSqXPW+53kJ/AR7Nhl1ROLWiiIfbc5c4v726BFmSZl8DuorLpqDKEtVuR1YJ9JR5PvM55iphmmKTJNT071tVZKJ5spKmfj/5vg9moCqFAQZMJvKXCPamy+X2zlIeOBQ1+1cZGHl7TwFsHhpjcZGHZ3uy+wdOeWlgjIl4gpRB3k0jA9g4MEql25HVh2y637f1cHZNKQkjxf/L0ztrJBbnwHiYoEPnpf7RnAEogLu2H+C7K1qIJVPckSPrCuDp7iEuba7Co6nsG53Mec0xGkvwwN5DfGp+HaFEgps27rGCQdOf340b93LfqYspcyp0hSIZwaApT3YPsrzEx5nVQSbjCX60pS0jGARmNvUXp5XY94SiXLVua8bf4lA0bk01bPK6iSaTPNLew93TMtom4knu3nWQnnCUT86rxa3a6AtH+cy6bRkTHB9q6+GprkHuXLOAUqedpGGwaWCML2443Hx+9+gkj3f287XjmllV6sMmywzlGDTyWOdAVlP5A+Mhrpox/bDIrvGDla1UFzjTjzXBE4cG+NHWNut52hWZzy5q4MQSn7Vp1x+O8qOtbTzdPYSB+f5wWmUxH2mpsd6D48kU+8YmuWXzfqtsd0mgkM8srKfG7bCu0YajcTb0DvPL3QfpCUWpK3RyWWsNLd7MSYo9oQiPHezn74cGUGWJd9aWsqrEl1HSHU4k6A5Febith87JCAv9BbytqpgShz3j/X4oEuPgZJh/dA3itNlYWxEgaNczfl7KMOgPx2gbD9EbjtBQ6KLMac/6jAknEgxHE/SEImiKTNCh49czP18AxtJll5FkikLV3ODMtbEyEIkyGU9ik2U8mi1nAD6ZSpkTHg0Du5Jdfj7l1TbOn4wn0tNilVk/4+NJs8wzX4mnILyeREBIeFPz6ipeXaWhMPeFcrFD57srWvlrZz9/PNBLImXuLL2rrtRqdunXVd5VV8rv9mfvXq4p9ePTbdhlmWaPm+3DuXdVGzwunDbFuqjNZzKRIJRI8Nt9XXmPuX9vFwv8hUzEk9yyeX/OY76/eR+tvgJKnDqHJqN8dv12ktMCWh0TYa5at5VfpCfwpAyD3SMTXL1+m5X+/4cDvbhVhVtPnG+9folUigPjYX60pY1NQ2PIwIqSYT4xr9ba+TOPM+iPRHllYIwDEyFafAXM9bgJOnP1SYgxETebERfm+cA+fN6U1ddBEIT/nVfTCPdImYNKOlNq5k74dJIkUeq0U+q0c2pFUd7jgg6d99SX87bKIBJmycjMi2y/XeOixkrOqi4hlkqhyTJF9sySkQLNxlnVQVaU+OiejCBLUtZOvCJJzPMVcM8pi1nXM8Te0RALAgUcV+zNCFSVOu3csWYBj7T38PdDg9hkiXNqSzilvMgKknh0lasXNlDi6OSPB/qIpcybkoubzFLmqZuAFq+bj7ZUc8/Ow82bXTaFLy9rsvrYBOwa3zxhLtdu2JHRjDugq3xu8RyrefOFDeX8o3swa+La8cUeatM3oEW6xoqgl+dy9JX65LxaitL9sz7aUs11z+/MOsahyCwv8QJmACxfoOqtlUX4dBVZkjijsjhvg/BTy83f/ZIiT87vg1kK6bbZSGFQV+DMG6iaOseRgl6qLJEyzBvvXKVsAMF0Zly+5tFg9i6SJYlkKpU3uwmwfmcD4fyZxGZgySCaTM0aHOsKmUGsjQO5A1AA+0YniaZ7Z80MWk63ZzRETYGTPx/M3lia8kTXIBc1VRJKJHM2UgezjLBjIkzQrvPwLD0XH9h3iBVBL5OJZFZ56pTOyQgDkRheTeXPHX05B38YwH27DvKlpY2MxhMZUwGn+3NHH++fU4HLprCuZygjGDRlKBrnzx19XNJUyWA0zo0b92aVnxrAdzft5RdrF1Pi1Nk+PJ5z0MgzPUOcVlnMSeUBBiMxvvzCrqy/xYFIjBte3M33V7bit2scGA/x/RnXaJGkmSX+s5MX0uhxMxaL891N+3hhWp+3pAF/PtiPAXx6fj1O1QzGffrZzADaxsExLn9mCz87aRFlLjuheJL79x7igWnXj/vGzAb1X1g8h9Mqi1Fkc0jKFc9stSZ+Avxg837+7HXzjePnUuTQiCWTrOsd5psv7bHW/8sDozywr4tbT5xPk9fMzh+MxPjGS7sz2ir8ak8nFzdWcn5DGYWaSsow2DM6yWfXb2Mifjjo2FDo5NsntFjvhaPROL9v6+Y/93Ra/d4KVBtfO66J+f5CqwSwazLCjRv3WIFOVZZ4T30ZFzSUZ2TPbxka54db9tMTMrOzjg96+cz8OiqmXasORmI83N7DQ/u7mUgkaSh08ql5tTR73dZmTCKV4tBkhF/u7uTF/hHcqo331JdxUlkgI6A1Eo2zd3SS3+w9xEgszvHFXt6RHooxPbOqNxTlhf5hnukexqervLO2lAqXPSOAFkokGAjHebpnkKFIjOUlPuoLXBQ5Mj+fh6MxekNRdgxP4LdrNHlcFNm1jEBUImWWXPaGo0zGE1S5HXh1NetaeyoYNxKN03DCKsYSSQJq9nbvaCzOaDROIp25nKu3mZEu8wwnzaxUv67lLOGMpQdRGJifjUfKmBX+74hXXjjmFTt03jungjOqghgYeFQ1483UblN4/5wKdEXm9/u7iaTf4M6oCvIfzVVWyu676kp55EBvRuAFzLKFixrNRrCFqi1vTwww697jKSPv7iCYF5eJlMFQNJa1o3f4mCQjsTheXeWBfYeyHhOYafF/aO/hspYaRmJxrn9hZ9YF9EQ8ydde3M0PV83Db9foDkX55DNbrIvaFLCud5htw+P85KSFlDrtZnBpdILPrtuWcTPh11V+eOJ8aypbLJlk72iIH2zeZ12MLisq5DML6q0dNjBTrntCUR472EfHRJjFAQ+rS/2UOPWMD6FEKsVgJM5ILI5NkvDoakY22HSj0Thxw8CpyFmldYIgvH7k9G7rbFRFzmgEnIuuKJQ5FWuSVi42WabC5eD8hopZz1XqtHPp3GrOqy9HIj2xbcYFb8Cu8fHWWi5oKCeWTGG3KVkNfT26yrl1ZZxSXkRvOIpNlgjadQJ21Qps22SZBf5C7j1lMRt6R8z3uKJCWr0FGQH0MpedO9cs4C8H+3miawC7Yk7zWlLksYJ4nnQQ6eG2Hh5s62YykaTCZefjrTUsDnisYNt8fwGfWVDHT7cfsN6jy506Xz2u2Qr0FdnNzZLPP7c943282ePi0rnVVvbP+xoreL5/hO4ZN+Tvn1NBcfrmpcih8daKIv42YzqoTZK4ckGdVQp5+fxaPrt+e9bvo9Jlpz49QbDJ48pb+ndxYyUBu0YyleIdNSX8d45NHFWWWBQw+/mtKQ3wi525+ym9raIIj2Y2XJ/rdbMzTwndVKBqVamfR/IExhb4C7DbzB5VBaoto5RyuroC87Oxdtrn30wlTt3K0JptcEahZkNi9iCwLX2O2Rq8g5nJkDAMBqP5g16jsQRJDMLJ2QNoQ5EYUZeDbcO5M6UB9oxNEk6mGEv3vMrFwCy18+oq/5Nn6iyYQa931ZUyEjWvDXKZSCQZisZwq0rONTPlv/d3sbTYw0gsTkeejPC28RAjsTh2ReFXezrznuu3e7u5ZnEDw9F4RjBousc7+7m4qRJF0vjN3kM5A2gT8SR/7xrgfXMqGI7F+O88m4l3bmtnWbEHv67ySHtPRjBoyo6RCXaOjLPaEWAwGuc7G/dl/S7DyRQ3btzLD1a24tVVnjg0kLPH5q/2dLK6zE+hpjIQjvG59dszgkFgBqvu2NbGtYvn4Ew3u//l7szXbDye4PPP7eDeUxZT6XYwEI7x+ee2Z2QAxlNmDzGnzcwetcky+8YmM7IzDeD5vhGuXLeNO9YsIOjQGY7GuXHjHl6clgG4byzE1eu3853lLSxP99jrmAjziacPX/eOxhLcuqWNdT1DfHFpI35dYywW51d7Ovn9tPWzbyzEIwd6uWP1AmsCatdkhM88mxmM+/PBPj4yt5p31ZXiVm2EE0n+0T3EdzYe7kf2+7Ye6gocfGdFq/Ue3R+O8vWXdmdkAGqyzI3L57LQX4iqyCRSKbYPT3Dd8zus118Czq4p4dK5VVYAbTgS49d7DvFwe491v1BX4OTrxzdnbPYeGA9x48a91vuhT1e5fH4ty6f1NhuLxdnQO8JPdxygPxJDk2XOqg7ygcaKjMzT3lCU+/cd4s8dfUSTKZYVe/jEvFpq3A6x8fsGEHdCgoC5ezzblC+/XeODTZW8o6aEcCKFXZHx6yr6tB3GMqfO91a0cuPGPdabvU9X+dyiBirSdew+XeW0quKcU2VOKvObdeOKwqoSX97JOStL/LhV5Yi13BLmLkO+rCWArUPjhJNJhqLxrN2uKR0TYUZjcVyqjQf2deW8QBuNJXiya5ALGsoZiMS4bsPOrJ3loWicb720m++uaMWjqxyajHLFs1szglUvDYxxxbNbreBSLJnixb5RvvzCTiuI9mzPMPftOmhmLqV3i8djcZ7uGeL2re1WkKzEofOVZU00e13Wh8tINM7WoTF+tbuT/kiMFq+bD86totrtsBr6msfF6A3HeLl/BJdqY2mRh4Bdy9pRnownGInFiSZTuGy2jBu96eLJFOPxBDZZsnb8BUE4etlk+YiTHzVFzhqbPpPDpuA4Qt8hTTEDVefWO/IeA2ag6qLGSs6pLUWRyPleErBr/EdzJe+oLSGR7vsx83kUaipnV5ewssTHaCyBLd1DZPpxNlmiJZ1RtXd0kkOjEywI+iidMTWr1Gnn1hPns2lglCe6BinUbNaO99Tj82gqn5xXy/FBr7l7Hk2wMFDAh5qrrZI+MDOqblo+lx9tbefQZARFkji5LMDHWqutfldBh84PV83POWVsbUUAWZKQFYULG8rZNTLJ5qHDN6uaLPHtEw43XC9yaFw6t4q7ZwSFSh06lzRXoSsyuiJz1cJ6rnhmS9YN+dk1QQJ28zk2FDqpdjuyAgUy8Il5tRRqKi6bwUWNFfx4e/b0uSqXnYp0H6615QHu2XUw50bOJY2V+O0aE/EExwe9PJ8jG8yhyNQWmGVEZ9eU8NfO3A3Jz6oOpnvHSAQdGn05spxkoK7Qia7IrCn15/x5AEuLPLhsCvGkgSpLGdlu05U4dTRFoqbAkXdYR7nTbr32s3HaFBRJmvU4hyJjzpw9sqRhEJ6lbDGcSJJMGUQS+bO8wCyRjKaSdE3mzwg/OBkmmkwyPEuWV9IwAz52JZn3tQIz0PHu2lK6JqN5NxvH4wlGY2a508zA7HR/PNDHCUEfnRORvENX2sZDjMYTpIDf5+n7BfBIew+fXdRAZyiSd5Pzme4hRloTRFIp7s3T7D5hGDzVPcgHGivpDkXyloPev7eL0yqD2G0yd27LPeGxPxJj2/A4QYeebpGQOxvvtq1t3OZxoSsyP97WnvO694X+UbomI/h1jcFIPCMYNCWUSHL71v187fi5KBL8YmdHzmDcz3d2sKbMj1u1MRiJZQSDprSNh/nPPZ18al4dAP+151BWOWgsleKLG3Zw3ylLKHPZ6QvHuGb99ozfpQH8vwO91BU4eXddKSnD4E8dvVm/y7bxEFev28adaxZQ7NDpDUX4zLPbMgKrw9E433hpD99f2cqyYi8pw2BdzzA3TeunFkuleLi9h7bxEF87rhmvrtIfjnLN+m0ZPQRf7B/lE//YzE9OWmQF0ITXjwgICcKrpCoKpc78KeaaorCkqJAfr1nASCxhZhtpakY6pVO18dGWGnRF4dGOXuIpA0WSOL2qmEvnVlsR9jOqgjzU1pP1IVqg2jizOogiy/g0lULVlvODdqqviC7LlDq0vLtZ5S4dXVGIHGG8cyxlMBFP8GKenSwwm4OeU1NCfziWdydu1+ikObZbkblvd+4L3tFYgqe7h3hPfRlD0RjfeHl31kXORCLJjRv3cPPKVry6xt6xEN/dtC/jmN5wlKvXb+PutYupcNmZiJs9E34zbQft2d5h1vcO8730hxmYKcQ3v7KP9dOapUrANYsaOKU8YGUU9YbMuv91PUOkMHuRXNxcyemVQatBo2EYdIei/KG9h3U9QzhVG+fXl7F02q4+mAGjgWiMbUPj9IWjzPcXWtPwpkumzF3asVgCTZbwaGpWo+EpQ9EYyZSBy2YTk+cE4U1CkY+cUWWT5VlL+sDMujLL+mY7j1n6F1AVnt7xCo0Na1BzlBAEHTqnVQU5paIImdw9Mfx2jdOrgpxQ7CVpGDhzvC85VRsrSvw0etyEEsl0oMpmNTUHsxyxrtDJbSfOZyQaJ5pK4dXUrCa8RQ6drx3fRG8oxo7hcXx2lWaPm4D9cOmCW7Xx7toyVgR9PHKgl+FojLXlRSwKFGa8fmZPrEX8155DbBocw6urfGBOOQsChVbQq9hhbgj9ak8nfz1olkM1e1xcsaDOym5SZInTqooJJ1P8Zu8h6yZzSaCQzy+eY73fBx0aNy1v4SsvHN5YkYDz6sqskj63auPKBfVcvW4bPdNK0VVZ4psnzLWyY6vddt5WUcTjM4IAFS4759SWYpNlihwan13YwLUbdmTdhL6vsQJv+jmeEPQR0NWsUjVNlrikqRKHzYaM2Y8mV4n9okBBuh+MzLtqy3ikvTdnNtElTZW4VRuJ9Gu4K8fmWNChEUj/zt9TX5b3xv68+jI8uko0lcqbWea0Kfh1DbdqY215wGqsPtPa8iLcmg1vQkWRsMqaprNJ5ueyQ1Fo9LjyXnu1eN04FIVCbfbbMGe675dfV3OWxYHZu8gmy9htR5qkaGaEKbNsJtpkkCQz43o2KcMgZRhZWT/TjcbMUsmhWQazpDADaDZZysoynG6qd9iBifyTGycT5rRdSZq9Kf6LfSOcUl7E1jz9PAEOTUYIJZIkUkbetQVmv675/sJZr41fGhhjPJZAkuDJrvy9xtb3DlNT4OS5vuG8WXZ/7ujn/XMqAbOnaC6xlMG24XHKXHZe7B/JG9j7zz2dnFQeIJkyuH9v7syy/kiMjokwxQ6dTYNjea/t79p+gJtXuIilUvx0R+5g3CuDY/SFo3h1lR0jE1kDJaYe+907O/jikjkie/91Jl5tQXgNSZJEkUPPaMw3U8Cu8cnWGt7bUE4okcRhU6xpOVNKnTp3rFnAz3cc4JmeIQzDnMrz0ZYaytJlBH67xnVLG/nS8zsyLkwUCa5b0miNb72oqZLn83ygXVBvlsIV2fW8FzgOxWzGp6YDEPkuSvy6mR0TSuQvdwNzt2AynmDzEXa8zqkp4dBkJG8fiL1jIUZjCWRJ4ud5PoCiyRRPHBrgoqZKRqJx7s+RTp0Cvv/KPn60egF+XeXJroGMYBCYOyrfe8Xsy1SX3sH50vM7MvouTCSS/HjbAVRJ5p21pSjpaT6feHpLRonAN1/ew6oSH59b1IDPrhFPptg8ZDa7nL4DPafQybeXt1g3JuOxOP/oHuKu7Qes8831urluSSPVBYczC4YiMdb3DvPAvi5GY3EWBQr5YHMVlS57xmST/nCU3aOTrOsZImDXeEtFEcV2LeND2DAMBiIxq3ljwK7i07ScAaahSIxwMolNkvHp+Uf+TqZLHt2qTTRTFIR/E+Pj+W+epryaHlUzJzXlErBrBF7NMUc4l0/X8Okac325p5GC2X+qQHNztcdFyjByZniqikxNgZOrFtYzmQ5U5QrElzh1rphfx8WNlaQMA6dNyTrOp2u8f045p1cWM5lIoCsKXs2WMS1qanPp3lMW0xWKEk4kqc7R96PcZedHq+ezbyzEK4OjlLvsLCvyUpwOEAB4dY1Pzq/ljOogD+7vJpxMcVplMUuLPRlBr4WBQu46aSF37+xg18gkJQ6NS5qqmO8vsHqplDh1bls9n59uN69LkoZZDnfF/DrK05lyerrEHuAP6amGMrC61M/lC+qszZIyp87Xjmvmxo17rKCXKkt8rKWGxnTmr1dX+fKyJq5aty0jq6JQtfHtE1qs66wmj5u1ZYGsxt7LijwsTW/0BOwan188h+uf35l1s33NonoCdrMs9NSKIn6/vzsr6OXXVd5aWWQ2FNZUzqkp5aEcTd7Pqy/Dl76ee39jBU8cGsja0LJJEu+qK0VVzM/KOYUu9o5lB6FOCHqstfH+ORVc/8KurGMA3lNfhqbIlDj0vCWJ9YVOPJpKoWbjrOoSfrEzuzk4wDtry1BlmeoCR95rwqBDo1BVcasKJwS9eUv2TqkIYJPlWUsgC1UbTps5abOuwJEz+Afm+gSsdZbLVFaZjPn7ytdjaypj3ztLME6RzN+TJJnrMle5HszehyyXXJugU6audUdmyRqLpVKkMEime5Ll05cOErfn6ckGMBiNk0wZRFMpJmbJjGsfD7Os2MumI/U2S5m9zfJVG4A5PKfR4+KJWbLUXuwfYTKRFAGh15l4tQXhDaDbFMpm+SCRJIkqt4MvLG7kk+kP9wI1c0fVJkssKSrkF2sX81BbN/vGQswpdPHuulJKp/XXqStw8al5tdy1/YD1YaTKEp+ZX0ele6pxto0LG8r5rxy7BB9uqbam5rx/Tjk3vLg752M+L31RUua05+1t4LIpFKpm4Mivq3k/OIIOc6rEbB94gPWhONuEt+3D4yRSKfaMTubddekKRRlP7xw+MEtD778e7OOyebX0hqN5m3Det/sgJ5b68Wg27t11MOfF2breYQ6FIvjsGoPRGF/csDPrgmPvWIi7d3Zw5YJ67DaFTYNjfO+VzCyonSMTXLluKz9es5ASp85oNM5tW9oyLoz/0T3Eup5hbl89n7npCUK9oQjXrN+esUPzy92dXLOwnlMri3DabKQMg72jk3zp+Z3Wxbgiwbtry/hAU0VG88atQ+Pcsa2djokwuiJzZlV2vfhwNMbO4Qke2NfFRDzJiaU+zqgKZo1oH0zvSL0yOEaJQ2NRwEORPbsh4UAkxkg0TiKVwjuVEafkDlRFkymU9C5rvtr0iXiCZMrArdlm3UGVJInCwsK83xcE4d+PLElHLMO225SMjZtc9FfR70pTFMpcs5/HJsuUOO2UHKEksdihU+zQWZHud5KLT9dYVqwx319IyjBy3sQ6bArNXjdfWdZEKJFEU2Q8OUoSK1zmdckn4nEMA1yqklW66LdrfLSlhvPqyphIJHHaZLyamjEx0W5TWFni495TFtMbjpEwDMocuhVMmVLpdnDnmgW0jYfYOzpJTYGTOYUugtOa6/rtGp9ZWMe760v544E+kqkUZ9WUUFfgtIKGiiSxtMjDz05exG/2HmL/WIiaAgfvm1NBldtufS6UOu3cvnoB9+87xP90DmAAb6ko4r1zKqzyUKeqcHGT2a/q/n2HmIgnKVBtvH9OBWdUF1uvb6XLzndWtPKdTXsZSH+Gljp0rl0yx9rY8+nm9MPrX9jJ/mnXFAt8BVyzaI4VKJzvL+TdtZlBKAm4rLWGynSPF7+u8Y3jm/ncc9szSvYKVBvXL220MgtPryrm8c7+rOyllSU+GtLZbD5d5T+as8spZcxs6anmxv/RVMUzPUNZ12oVLjsL/ObnZJFdZWmRh5dzBBQ+NLeKIrvZe+1jrTU5e4i5bIq1vivdjpxZagDn1JRYE8neN6eC27e1Zx2jSHBSmRlubvUV5J0gfHJZkdU77rTKIH/syN0f7OQyPwDHpwOPuSwr9lCg2TAMg8X+QjYN5d4MXZl+jicEvfx6T+5m6s1eN05FIWEYlDt1a3LwTPPTEzEX+At5ME8z+Gq3A02WAAmXTck75bEmveFYM0tgL+jQUSQJTZbzBhLBXKPSEfoGutTs4RLC/z0REBKEo5hTVWYt99EVhdoCJ5fPqyOaSqHL2aOsCzQbZ9eUcGKpnwPjIWTJHDvstx++gXbYbFzQUEGV28F9uzrpCUepctn5SEs1S4o81jkXBgo5I0cPpP9oqrSaRXt1lbNrSnKO1/3w3Gqrz84HGiv52ku5g0vvqitFkWWq3Y68TbiL7BoFqs3qv5EvRbjRY/YQypexMkWWJZKGwUg0f4bT1JS4/Tl286aMxhJm2nIcnpplFPHfOvuZ7y9k5/BE3pTev3UO8MHmKrREkp/m6DsBZm+mHSPjlDh1+iLRnOOPE4bBbVvauHFFC3ZF4Ze7O3Om635/834WFXlwus1Rvlet25ZxkZA04Hdt3ZS5dN5dV4YsSWwdGucL05o3RpNmvfjOkXG+fUILfrvGSDTOXdsO8JdpvSz2jk3ycHsPd6xeYF3Q9oaifOG57bRPu1C1SRI3Lm9hUcCcMpJMB6pueGGXVSqhKzKXNldxRlXQ2pEfj8XZMjTOndva6ZyM4LIpnFtXxrvqSjMyCwYjMbYMjfH7/d2EEynWlgd4a2VRVm+YvnCUPaOTbB4cI1jRQF80QVBWsqZ5DEVjDIRjxA2DoF3LusGBw6V/kUQSVZHx67lH5iZTBsOxGBhm35d8a9gwDGIpw5qMJAiCMNORevKAeTPmOsLO/JGuS6Z+1sxg/0xms/hXH/Q6ITh70Munayz0F2JAzvdBh01hjsfF5xY1EEkmsSu5A3xlLjufmlfHB+ZUMDAwQG1pEKeWmY3mt2u8b045p1UVE02a114Be2ZTeV1ROK7Yw11rFjAaSyABhTmGXZS77Ny8spXhiDlKPWA3Nzimjz/36iofmlvFu+pK2TQ4ik2SWRQoxK+rViaFTTYnKd57yhLW9QyybyzEQn8hS4s9GZMUgw6dm1e28nL/KI8d7EOVZc6tK6XJ67ZK2Z02G++qLWWu1819uzrpC0dp8rj44NwqKl2OaY9d5641C/npjgNs6B1GU2TOrA7y3oZyKwPNq2tct2QOv9zdyWPpckqfrnJpcxUnlQes16zJ4+KLS+Zw+9Z2ayOt2u3gK8uarMcfdOh8f9U8rtuwIyMYcmpFgPfOqbA+I0+tKGLr8HhGiZYqS9ywrMlqdh+wq3zt+Ga+8sLOjABGpcvOx1qrrcDeRU0VvDgwkpUd/x9NlVZvs4Bd4/z6sqym5C6bwhXz6qzMvssX1PHJpzdnbQCuLvVTkn5clS4Hrb7sqcUycMX8Wusa5xPzavlyjqyxhkKn1Y+s1VeAT1dz9qr6WEs1PrtGIpXigoZy7snRwymgq9a1/ZpSPz/f0ZEzgHZROkAaTiQ5qSzAEzlK45w2xWqcf1Z1Sd5A1Xl1ZfiPUBYtvPZEQEgQ3gRUJTsQNN2raWzq1VXOrC7hhKCPpGFgk6SsEdQ+XeMTrbWcX1/Ohr5hSCQ4sTJIwK5ZH3hu1calzWaj5v/ae4jhaJwyp85HW2pYVuSxduIWFxVydk2QPx44XAdtfuDVWZOCfLrKe+dU8F85Rs9etaDeGqN8aXNVRlDCel1kibdVFgNmH4h8u0HNXjeedAnTwkBB3prx1emdpRJH/tdRlc1dEompi9LcWyWKZL4OA7NMbkkYRnqnz8gZwJmyZWiMteVFvJin4SfA9pEJJuNJIokUj+dpMmoAG/qGqXI72DY0nnfH6Nd7DnFSmdnA9Udb23Ies3Nkkq5QBL9dozcczQgGTRmNJbh750E+t7gegJ/vPJARDALzNfjS89ObJEa58tmtGU3Lo8kUP95+gDKnnZPKAxiGWfc/PeA4mUjyqz2d7B6d4ItLGvHqKkPRGN9/ZR/rppUI7h2b5KG2bm5fvcC6oTk0Geaqddsymq7etfsQ313RygJ/ATZZJpZMsnlwnK+9tNu6mFVliQ/Preas6qC1iz4SjfN4Zz+/2t3JWDyBJsu8PT2BY3qpaV84ymMdffyxo5dEyuDk8gDn15dn/A0nUga94Sj/c6ifbUPj1BY4Oas6SKlTz8iWCsUTDEXjvDI4RsowWBgoxK9rGWNuwcySGo7GmYgncKkKXk3N2bh4PBa3epcVqLa8jdLH0g3XdUWetZl6LP27PFLQVhAEYTaSJB2xhfSryfTSFBmfqrB+40s0nnVWzmOUV9Gr69W0EQAzc8Kvz14CWZh+P54tU0NVZCpc9iNOUgw6dM6oDrKmzI8sSTmzxgo1lROCPuZ63cRTBg4lOxBok2XqCp1cv7SRibjZv8ebY/OiyKHzqfl1vL+xglgyhcOmWG0NphRoKm+tKGZxwMNYLI5NlvHotqzXpbbAyY9Wz2coGmcinqTIruHV1IzPM79d4+qF9fxHUyU7RiZw22w0elwE7KpVOq8pCsuKPfzy1CVs6B2hNxxlaZGH+kJnRnZzqdPObSfO55XBMf5+aACfpvLOulLKnLr1Mws0Gxc1VrKixMf9ew8xEktwQrGXt9cEMzaXagsc/OzkRfxydycvD4xSoJrZ+StLfFYA0G/X+PpxzTzU1sPD7T1MJpLM9xXwyfm1VgYXwOJAIV87rok7trXTF45hS5c8fqSl2tr0KnHq3LpqHt/auNfaNC1UbVzWWsOigMf6Hb6jpoShaIw/Hui1gmPVbgffPP7w5MnidG+zL8/obXZObQknlprBWodN4eOttRwYD7N/WrmaQ5H57ooWAukAWolD5yNzq/n5jNLFBf4C3lZZLDa23gAiICQIQoYj9WXw6GYj4xqXzjPPPEP5nArUGTuKPrvGefVlrC0PkDAMtBwTe3y6xsdaanhPXTmbh8bQFJn5/gJzxyvdRNSl2rigoYxmr4v7dpu7VI2FLj7SUkNdocNKK23xufnUvFp+tuOAtfPi1VRuWNZkfZj57SqfXzyHb2/ck/E4XDaFzy9qsHZdLmupYePA5qyU1xKHbqXhVrsdeRtUnl5ZbO5uSBJvqyjOm2o8FahqTZdx5VLq0HEoMiDNWmJX6zYvEma7yJUBWTKbQearhwes0rn9s9SeD0fjJFIGSVJ5J34AbB4cY76/kCe78teLP9U9yGWtNaQMg78fyp1RFUsZ7BqdoMxl5/m+kawJdlN+vrODBYECEimDO3KkiwNs6BthID2uuGM8nBEMmjIYjfPAvi4+Oa+WaDLJD17ZlzWBJ54yuG6DOQ63xGmnNxzjCxt2ZPQIiKcM7tp+gNoCJytKfMSTKR7t6OWnOw5fBMVSKR5q76EnHOHaJY14NHMCxxee207b+OHg2ENtPfz90AB3rVloBar2jk5w5bptVu+BDX0j/G5/F988fi7HB73YZJnxWII/dfTyk+0HMkKT59WVcnFTldXToz8c5dYt+3mm5/DrsTRQyLVLG62/oZRhcGA8zK2b91tp7/N9BVy5sJ7aAie29E7vRCzBnrFJ7t7ZQcdEmCqXg0vnVtPocWVctA9GYuwcmeCP6WzCc2pLaEo3/p1iGIaVndU2bpbFNnhcWTdi0fS0xP5wDEmCoN28wZoZKI+kexxEkkmrmWyuQNRkPMFEIokEeFRbxkTJmcdFkymcR7jJTKYMJCl35oIgCMIb4UjZYJB7mmGu8xzpXPqrmMqoyBIlTv2IZZcBu24FF/KZCqDVFbryHmNXlFc14THo0HlbZTFry82NsFxl5R5dZVmxlxZvAfFUCpeqZJWo22SzH9k1i+qZiCfTpezZ19xFDt3KCEsZYFfkrH5kBZrKyeVFzPMVEE6msKVLsWZ+DlUXOPnu8hZGY3FiKYMC1WaV6U3x2zUua6nlgoYKRqIxUtEoZZ4Ciqb9vjRFYXG6t9mhyYjZ26zAiU9TcU/7XC9x6nxvZSvdoQg7hycIOnSavC6K7Lp1jVCg2XhXXSknlvp5smuAiXiSk8r9VLocR7wHEf5viICQIAj/FMMwGB3N32ROlqSMXZZcpj6wa2cZMenVNU4uL2JhoJBEysCuKFmZDYWayjm1Jawu8zMYiaHKZrPGgF2zPrh1RWF1mY+7PYv4Q1sPXaEoS4sKObm8iNJpFx9VBQ5uPXE+t25pY8/opFVz/tGWGusmNOjQuHlFK597bkfG1IWlRR4+2Fxl3Tx+oLGCDX3DWWNGp7I4AMocOvN8brYNZ5e8fXJeLUUOnZRh8IHGCn60tT3rGE2WrQlpx81Sx766zE+hqhI3Usz1utmZp8Tu+KB5jmZP/kasQYdmTiwxzAkz+QJM/5sP9rhhzNpwcThivs47hvM3tz04ESaeMkcHD8wy2WT36ARzPC7+3JF7SgfA3w7184HGCqLJFC8N5K75DydTdExEKHHa+cvBvryP/55dB2nxuQknUvxqd2fOY9b3jjAciePRVDYPjWUEg6aMxhI82N7Nx+bWMBZP8I2X92Q1XU8aZuPyu9cupsSpc3AyzF05yg1/39bDsmIvq0r9TMYT/GhrW0YwCODlwTG+9dJuvn78XDzpKTefemYLoWmZY1uHx7n8mS38/ORFVLodxJMpnuoezOh3NRob5+r12/jswnrOqCpGVRQGIjG+/uLujLHg63uHWVrk4UtLG621s388xFXPbsuYpujXVW5ZNc/aKZ+IJ3jy0AC3bW23yi8disy1S+ZwQtBn7X4PhKP8YmcHf+0cIGmYI9nPrSvl/PpyKxsyaRh0ToT56fYDrO8dRpEl3lpRxCVNVRklMOOxBPvHJvnV7k66w1GaPW4+0FhBpduekZ01EI6xa3SCvxzsw64ovKOmhKp0g+DDvzOD/nCUXSOTdE2GmesroMrlsPp0TAknzDHVveEomixTlG6sbJvRnH0q0yuaTOFWFQK6ipqjv9ZoNE4okUSWJDyaLW9AayyRpH7hEiIpg3y3hinDYDKRRJWkI2ZfCIIg/Dt6NY3zzSyq2d8DHbbM6Ym52GT5iNfQwBGzz+DwRu5spkpBg5rCo08/wdwcmXGvtrfZVNP/+f78/Rbdqg23aqOusPqIj1/4vycCQoIg/FvwHSGdWlcUypyKVW6Wi9Nmo77QxqcX1BNPmaUsM5vX2RWF+f5CvreilclEAmVqjOy0mxxJkpjjcfHTkxfSPRlhKBan2u0goGsZN3plLrNB5TM9QzzZNYDbpvCehnIaCl3WcT67xlePa+Y/9xzi0Y4+YqkU5U6dT86rZVF6soYsSZxaXkTbWJg/dRwe1Vug2vjWCXOtBpsBXeXy+bXcPiNwFNBVLmutsS5UPj2/jiue3ZKVBbXIX0hF+vVr9rrxamrOMaOXNldT5NCJJlOcXhXM2S/KJklWU8m15UX8Js9Y05PLAhRqCpMJc7pevil2LelMqmavO6uH1ZQqtwObJKHKct7eU4A1Rnk2U4UH8VmyqQDG4wniqRT78jQZB+iajBBLppiIJ/JmNwEcCoUpc+r8pSP38wN48tAg722oYDQW51Ce7KzJRJK+cBSfrvK7/fmbpP/nnkPM9xcwFkvwdPdQzmNeGRpnJBbHrSo82tGbEQyaEkmmeLCtm0+01jAYjXN7njLCO7e1c3zQS6lTYePAaEYwaMrLA6NsHhzjlIoiBiIxvvT8zoxgEJh9s7764m5+sKoVn67RPh7i5s37M44JJ1N89cXd/HztIhoKXYzF4vxg8/6MjLBoMsVv9nYRTxl8ZG41dptC92SEj/9js/V7SqUM/nywnxf7R7l99XxKnHYiiSR/7ezLCNAemozwVPcA31neynHpoGp/OMr1z+/MmJzz185+zqoO8tGWany6RtIw2D0ywWfXb894bSvSfUWm3s9Go3Eebu/hl7s7rcCjW1X46nHNLPQXWGUQvaEIP9i8n+f7RjAwd5bfO6eCd9aWWO+hkWSSfaMhbtuyn12jk9gkibdUFPGhuVUZO/jD0Rgv9o3yn3s7GYrEmd83yaVzq6l027FPCzD1hCI82TXIP7oHcdtsXNBQzhyPM6MHSji9Jv9+aICeUJSVpT5afQVZmV4j0Th94Sjbh8fxaCpzve6MMg84PP1wMBIjlEgSTDcjnpmhEE+mGIzGmEiXZnp0NWej5HAiwUg0QTLdcDlfIHs8Zk5blDB31PNle41G4yQNcyc+Xyl3Kj0QQZWlvI3uBUEQBOH1IAJCgiAccxRZQpFn38Hx6mpGcGcmSZIIOvQj9hAoceqcW1fKGVXFKLKUcSM1pdhhBoDeN6ecuGHW6meV2Nk1Pt5aw4VzyumcCONWbQQdOkWOw1lQTtXGGVVBFgUKeaS9l4FIjNWlfo4r9mTs6DR4nNy5ZiF3bWtn89AYBarKufWlnFVVYo2FLnHq3HriPL764m7a0uVjuiJzSVOlNQ1DV2Qubqpk5/A4e6YFRGySxDdPmEuR3Xz9Shw6p1cWZ/UR8mg2Lp1bZe2WXT6vNudo3UWBQkqc5uNaHvThUA7kDKxc2lyF364xGU+wssTHsznKweyKTH06I+2smmDO3kYAb6s0p4wYkLcpI5jjfFVZZp6vgPU5fh5AXYEDXZGxH6FHjkdTkWVp1uPMICYcIU5FPJUinkrRH86fKTUcjZFIGUwkknkn8AGMxOL4dJUX8vTWAjOQM5lIMRKN5w16hZMphqNxnDaFh9q6cx4D8GBbN8cHvQxHY3kDhG3jIUaicTRZ5pe7s5thgtkT6/f7u7lqYT0j0XjO8kCAh9t6OLeujIAk8dt9XTkff38kxoa+Ec6pLWUoGufH27KzrpIGfPeVvdy5eiF+u8rfOgdyjlF+tKOPM6qC+HSNgXCMLzy3IyvQdmgywi2b9/GVZc24VRuvDI1lNf2ciCe59jmzbLHS7WAoEuO653dmBCcjyRT37jqIJktc0FCOTZbpGA/z6WkB4YRh8JfOfrYMjXHrifMpduiMxeL8bEcHj07LolvXO8yGvmFuWTXfGgPdNRnh8me2ZJSzPt8/wturg3ystQaPphJOJHm6e4gbN+6x1tlfOvspdejcsmqelXk1GIlx48Y9GT3cVFni68c1s7TYg64o1vTD657faWUBSsDZNSV8KP33D2ZQ5i+dfdyz86D1+2z1urluaaPVxB7MYNbPdnTwZNcgScOg0mXnivl1GePWw4kkbeMhfrKtna3DE3g1GxfMKeetFcUZ79NDkRgvD4zy231dTCaSrCrx8e66MsqcurXxYBgGPaEoT3QN8GL/KEGHxrvryqhw2TNGyk/EE/SFozxxaJCxeJyTygLUTpuaNWUwEqM7FGHXyCSlTp2GdP+T6SUtiVSKwUicnnCEaDJFhcuOT1OzxjqHE0mGojEmYkkcNhmvnruH2GgszlgsYQW98gXQBsJRYikDmywR0DNLVKbEkylr06FwltLMcCJJOJlEl+VZS5PCiSSGwRGbXr8akiTh8+VvZC0IgvBmIQJCgiAI/8ckSTpifb2WnrgyG7dmw63ZqHLnr3d3qzYaPW6uWugiaRg5U5x1xRwx/PXjmwlP7XjnuGCvKXDyg1WtjEQTxFIpPJoNv565Wx906Ny0opVDkxE2D44SsE+Nij98nFdX+fi8GtZWBHhgrzl2fnWZn9MrizPKcBYXebjphLncsa2dg5MRHIrMObVmSc9UdkPQofODVfP4ygu7rFI8TZb4j+YqlhSbTRJdqo3LF9TRPhHOyKJRZYlvnTDXmvJS7XKwpsyflR1TbNc4v6EcNV2W88l5tXzr5czeUwCnlAesaRinVhTx6z2dWSVcAB9uqaZQM0fYnhD08HxfdmAloKuUOHRUWeZddaX8oyd3xs47a0vxaSqJlJE3g8smSZQ57dhtCicEvWwZyl1mtyhQaPZ+SPfKyRcU8miq2QdslgCpT1NR5dy9FaZTJAnDgFi+ubSYWVkpwyCSyJ9NBRBNmlkWhyZzB40ADoyHiSZSWWWb0yUMg4l4Al2Rea4vd9AI4MmuQd5WWcyhyUjO5vQAfeEYY/E4kgSPHMg9RQXgD+09zPO56QpFsjKgprzQN8pINE48ZQZ18j32v3X288G51fSGo3kz1f5rzyHeUlGMS1X4yfb2nGOBu0JRdgxPUOzQGYrEM4JBU5IG3LJ5Pz9Y1YpDUbhv18Gcvc3+1NHHO2tL8Whm8/abpgWDpvSEo/xkxwG+sHgOqizxcHtPVkP/eMrg+hd28ctTF1PhcuScfmgA/+9AL+UuOxc0lCNjBq/unBG02z4ywVXrtnHnmgUUO3QGwlGuWb89ow9a52SEL2zYwS0r51nvJ7tGJrh63TYr43AwHRB8ZWCMzy9uwKtrDEfjfH/zfp6d9nf73/u7+fPBPn68ZqH1nn1gPMzlz25hIn748T92sJ/PzK/j9OpinDYb47EEjxzo4WfTeo39ob2XFq+bbxzfbJWI9IaifHHDjox+b06bws0rW2n2ulEkiWgyyabBMb724m4r6KhI8P7GSt5TV2aVkQxGYtyzs4M/H+yz1sYCfwHXLW20stQMw6BtPMR3N+2zSo4rXHauXljPPF+BVSo4FovzXO8IP995gL5wjELVzBo7qzqYMaiiNxTl921d/OVgP4mUwUllfi5qqqTcabcCaOFEkoMTYX69p5N9YyEqXDoXNVZRX+jMCKANRmJsHx7nD+09GIYZ7F/kL8wop0mkzH5kz/YMsWN4nCavmzVlfkocekaW1lgsTn8kxnO9w8QCVZSHogQd2b10BsJRukIROiciVLodlLt0a+rUlKneZr2hKJIkUeLQsj5Dwcw+G4klCMWTuFQlZ8bb1PMciyWQJSjUbDkzp+PJFEPROLF0FnRRnmy2yXjCagTt0dS8U+imNg5yletPSaZS6cclzVqaFEumiKVSOBQZZZbMuGQqhSSJqZmC8HoRASFBEIQ3IflVXEwVaCr5W1qbpsb5zmaqXnwqayDfeVaW+FnoN3tBudNT3aZzqzZWlPpp8rqJJFMoktlMe3rZhU2WmOt1c+eaBYzE4sRTBj5NxW/PHN1e5rRz66p5tI2H2Tw4RplLZ0nAQ5Fdsy7+fXaNqxbUc1plMb/b300kkeSUiiJOKQ9YwTlZklgR9PHtE+Zy1/YDdEyE8WjmDc6ZVYenh00Fqr7x0m6601ktBaqNT8+voyHd1NKt2rh6YQPXbthB+7QeQR7NxndWtFqBqrpCF2+pCPA/M5psN3tcrC0PIEkSAbvGVQvruOHF3cz0oWazWbQiSby1otgMws3IQNFkiffOqUBXzH5bJ5b6eSZHEGqBrwCvZjaqvHBOed4sm/c1VuBSbXh1NW8DdL9ujlMu0GycVlXE3m3Z2TMAp1cVU6Da8NvVvKV/mmz2vXHYZBoKnXnL5+Z6XdhtMoV5bmSm2G0KiiThVm1ZDcSnFGo2bLJEjkSHDBISBmawKp9QIkkKcgb0phiYTcf1lEz3LM3b942HrIbf+UykMywkCTYN5u/D9UzPECeVB9iSo5xvStt4iIl4knjS4O+zNIz/e9cATV63Od0uzzFPdw9yWUsNiizx4P7cWWNJw+CFvhEq6hzsGJ7IO/3w/r2HeGtFERISd8+YXjOlPxJj31iIYofO/vFQ3qb4t29r4/srWzEM+OGW/Tkf/7pesz+cV9c4NBnOCAZNmYgnuXtnB59fPId4KsUtm/dlBIOm/GhrGyeU+HDabPSFoxnBoCk7Rib4U0cfFzVWEk0muXNbW1bz/1Aiyeef284vTjZ7iPWFY1y3YWdGf7OkAb/a3UljoYuTygNEkyn+a28nf5wRANwyNM51G3by/ZWt+O0aPeEon35ma8Z7yaHJCJ9bv52fnLSQRq+bRMqcYjm9nHIsnuDnOzs4OBHm8gV1FKi2dGBva8bo8D8f7OfZnmHuOmkh5S47KcPg5YFRrn9+pxVMPDQZ4fm+UT67sJ7TqorRFYXBSIxvvrSbjYOH1+xLA6M0e1x884S5Vh+WvaNmQHAqY+zvXYPcvfMg31/VyjxfAbIkMRKNc9+ugzzUfjiYe9++bt5ZW2q9rwJ0ToS5Zv12esKHH3+ZU+fmFa1UpIN/uXqb2RWZzy1qYGWpzxqe0ReO8r1Ne60MTAk4uTzA5fNrrQBTNJlk+9AE331lr/X5Ulfg5Nolc2godFl9xAYjMR5s6+bB/d2Ekym8msp/NFdySnmR9dgTKYPOyTA/2X6A53qHsckSb6so4uLmqoyS+5FojE2DY9y3q5P+cJQ5HhcfaammvtBpPXYws+we7ejjya5BNFnmvPpSjg96M4JjE/EEhyYj/HbfIXpCMRYFCnh7dQklTntGD7T+cJTtwxM83tmPW1U4p6aUCpc9I8gUTSbpD8dY1zvEockIy4q9zPW6s7K1h6NxekMRNg6MUqCpLC4qJKBrGeX/ScNgIByjYyLMUDRGfaGLYruaUe4KZvBsOBqnOxTBaVModugZPSqnDEZijMTixJIpPJr5eTdzgptZyhpnPG5muHq13P19JuIJsxF00jB7weUJ7A1GYoQTSWyyhE/Xcgb24skkw7EERrosNl+j8PF0ULJ+waKc358yHImRxKBAzR9IjCVTTCaSaPLsG6KRRJKkYeC0KVktHGaez/z8FUHC/wsiICQIgiC8bl7NVBN/nhKEKVK6YfmRGi5OjfudapSd72etKQuwtMhD0jADVTMvOAo0G6tK/cz1uokmkwwPDjKnrARNPXxRZZMlWn0F/Gj1AsZi5hQ2r65mlUqUOu18f+U8ukMR2sZClDrtVLsdBB2adTHk01Uun1/PObWl/KG9h1jS4MzqIM0et9VoWJEkji/2csfqBdy98wD7xsz+Q//RXEWL121dhJY6dX60egG3btnPpvQNU7PHxVUL6ylPX/y7VRufWVBHMmWwflqGzCJ/AdctbbJuJOoKnFzSVMkvZzTGvqChjKZ0E/Iiu8YNy5q45rntGf2XVFniy8uarIvak8uLeLCtJ6skrMJl58QSv1muoWm8q66UB9uyM23e21BhBQEvbqrk6e6hrAwUmyTxztoybLKMX9eoctk5mCMAsKyoEK9mo1BTuaC+nJs27c06BuC8ujJUWabcZUeTZesmb+bjL9RsFKg21pT6+UOO/lqA2Vxblq0JgbkUqDZcNhu6Yo523p6j8TzAQn8hsiTNOplHlSX0dG8tj2bLO7Fwqh+Z3TZ7eaMsSXCE0sVk+pu5AiDWMYZ5U4ZB3kAPQG/6xnu2oNdoLEE8ZWBgzJoRtmtkghUlPl6apQRy31iISDJFImVkBG9nemVgjEaPmycO5Q+M/aN7iE/MSxBLpnglT7ZeCtg+PEaFy85jnfmb3T/c3sPbq0uIpVJ5+35NxJMcnAxT4tR5/GB/3mb39+4+yIJAAZFEiv/Xnnudto2H6I/E8Ns1/tE9mBVYnnrsd+86mB49nuDunbmz2f7S2c9FTZUUqDZe7BvJCAZNGYsneKitm4+11DAci3PzK/tyZi7+aGs7xwW9lDkVtg6NZwSDpuwanWR97zDn1JYyEInx1Rd3Z5WDxlIpbnhhFz85aSHFDp29o5MZwaApf2jv4cQSHyeU+BiOxvjyC7sygkEA3aEoX31pN99b0YJX1ziQo7dZJJniGy/v4WcnL6LRY2M0GufbL++x3pvBDAQ/2TWIIklcvbAel2qjczLCNc9ty8jsaxsP8Zlnt/KLtYuocDkYj8W5c1s7/zNtLY7E4ty6pY1QIskF9WWoikJ3KMInpvVJi6cMHj3Yz4sDo/zoxAWUOHUm4wke2NeV0ftv0+AYlz+zlW8dP5dVpT4kSaJ7MsKnZpSMfmfTPhYHCq33+3Aiyf8cGuCWaa/FtuFxHmzr4bYT59PkNT87+nJM13zsYD/n1ZdxSWMlHl0llkzyUv8oX35hp/Va/KG9l6BD44er5lM+rfz0po17MsqcZeDaJXNYXebHabORNAx2DU/w+ee2Z6zrJYFCvrS00couG47GuG/XQf7Qfrh/o0cz+zfO9bqtDab28RBffn6n9RmjSBLvqS/jvXMq8KU/Q0djcf56sJ+7d3ZYr3+z1831SxszMr+7JiPcuuVwLzi/rvLJebUsD/qsLK2JeIJXBse4Y2sbXaEoqizxtspiPthclREc6wtH+e2+Lv54oJdIMsU8n5vL59dRV+i0WhhEEknax0P8dPsBtg5P4NdVLkTn5PJAxvXYYCTGMz1D/H5/N6FEkpUlPi5sKKfcZbeum+LJFN2hCP+9v5vNg2MU2TU+0FhBQ6ErI/A1HI2xZ2SS3+3vJpxMcmpFEatK/BmfYynDoDcU5R89g2zsH6PCpXN2TQmlTntWoE3414iAkCAIgnDMe7WBqng8zvMbX6KxLHsCB5gBkaIjBLRezQQOn67i0z3M9xVgQM7Gs07Vxjx/AV89fi6RRNJqnDudJEnUFTr5+vHNjMeTGOm+HzOPK3bofHHpHEaiCcbjCdyqgndGE95CTeWChnLeWlnMpoFRUobBkiIPfl2zLlIlyQyM3bN2MX/t7GfXyARNHjenVRVT4tCti8YSh86tq+bzaEcvf+nsRwLOrApyelWQYPqC0KkqXNRYSYlD57/2HmI0lsCvq1zcVMna8iJrZ7LS5eBbJ8zle6/ss3o9BR0a1y1ppDTdeypg1/j28hY+99z2jCDUnEInn1s8x9oxPSHoZWWJL6sf1Pn1ZVQXmBfsAV3lmkUNfHtjZhmhJkt8cckcq6fKBXPK+XvXIOMzSsLqCpy0ppuk++0qq0p8OTOvPjK32hoP/NGWGq5aty3rGIcic2KpHzCDUfmys06vLMavq9gUmfPry/hJjgwUgLdWFgPQ6itAkchZWras2INHs6FIEieV+XmiazD7IOCUiiIAqzl+LnUFzvTfnkFdgdPqVzbTkiKzfKvJm3+EdLFdQ1NkUuk1PvN1n1KdvvEqmSWg7LYp6fHS5H0d4PD7xmyNoZV0PPgIbb+sMsrRaO7HDWamwlT22WwFlUOROMmUkZVBNF1PKEoiZRBKJvNOigToDkWoLXDOGkDbOTJBKJFkLJ6cNbB3aDJCkV3jb7ME0J7uGeK9cyoYjSXy9m6LpfujeVSVh9vz9yP7Q3sPJ5X5GYnGswI4U4aicYajcVw2G/fvO5T3XPfvO8Q8fwHD0XjedbpndJLhaBxNVvj1nvzn+u3eLj63uIGRWDwjGDTdE4cG+FBzFbJkZnTlWoORZIrHOvr5YHMVI7FERjBoul/v7uQtFUX4dInf7OnM2SetLxzjpf4RzqopYTga54E8gyBu2bKfJu8CvJqN3+3vzvl+s2lwjP1jkwTsZjnlbVuyBw1Ekim+u2kvN69sxa3aeKS9J+d0zd/v7+a0ymI8uspgJM5XX9yV9Vr0hWPctqWNLy9rxG5TeKyjL6vnXQq4ceNe7vMuprrARn84ymfXb8t6LTYOjvGfew7xiXm1qLLEk4cGeXhGwHQ0luCz67dzz9rFlLvs9IajXPnstoyMz6Rh8MC+LorsGufWl6FIEs/3jnDHtvaMc+0ameDKZ7fy45MWEnTo9IejXL1+W8bn1FA0zjdf3sO3Tphrvd9vHhzjS8/vtI6Jpwwe7ehj78gkN65oIWDXGIzEuG7DDvZOKyXeNjzB5c9s4fbVC6xhHTtnlMX2hKPcurWNVwbHuGpRvVn6G4nxrZf38PLA4df1/x3o5X8ODfCTkw6Xxe4bm+TTz2613lMOTIR5aWCUDzZVcn5DOS7VxnA0xu1b2zKyoLcMjfPA3i5uPXGelaHdPh7Kykp8sK2H65c1srrUnzHRU/jXiICQIAiCIBylZuuzMKVANTNSZlOo5W4Q+789ZmpUbPUsfaxURabS7eBDzVXEUwaqLOVMBS9x6lzSVMU5taVImH0sZpYR+u0a72ko55SKIuKplNnLaEbqvMOmsKLEx09PWshILJHOglGzxrZXuR386MT59IWj9IVjlLvsFNu1jB1Qv13j84vn0DUZ4anuQXRZZm15gGKHZr02mqKwutTHz05exO/2d9E5EWGe3807akopnRZkKHfaueukBfxmTxdP95jlFGfXlHBmddDKbvNoKlcvqqd6fzd/aOshnExRbNf4cEs1K4M+6/Vo9Li4bskcfrS13Qp0VLnsfHlZk7WjGnTo3LyylS88tyMjQ+aEYi8fbK62GvaeVhXkpYHRjH49EvDZhfUE06+FX9e4emED33tlX8Zr6NVUPjO/3urfcuncal7sH80Kvpxc5qcs/bhKHBorg76M7DMwd+yvXFhn7Z5/an4t16zfzkyVLjv1BWYm1RyPi4CuMpjjJvTSuVUEdJWUARc2lPPzHGVjTptCi8/MSFhe4kXZljvY8+76MgK6SjRpsLrUz1M5snEUCRYGzBuqUyuKeGBf7hvot1YW49FUQokk9YVO9ufp87TAb55rbXmAv+Zpdn9csRenTcEwzCyF0Vju4FF9oRNFllgUKMxZCgrQUOjErsjEUwo2ScrbF8vssSNZEyhzKbJrqLKMfoR6ygLVDLQ5Z8lAcygKsmSuj9nIEhgYzFKZSdIwMJBIHKEL/1QT/nyvJ5hBgETKIHyE3maRZIpoKpm3jBXg4GSYSDKZN+AFZgBjMpHEkVCsnk25vDI4RiSZpDuU/+eFkynG4wlsksSGvpG8xz3RNchbKoromAjnDTgORGLW33u+ABTAHw/0sbTIy76xybxZanvHQunXlZzTSqc82tFLs9fN3rHJvMHLDX3DjMYShBNJ/jtP+elU9tUlzU72jk7mHYDwp44+LpxjNuH/9Z7OnMdEkyk2DoxS7rKzb3Qyb/nvr/d0pku9yfmeBGZfsj2jkwQdOvvGQnmHKfx4WzstXjcGZAWWpuwem6RrMkLArtE2HsoIBk1JGubUz2+dMJeEYXDL5txlsU92D3JJcyUeTaVjIpwRDJoSShwui40mk3zvlX05f0f37e7krZXFZsbbRCSrJB7MQNTv2rr52NwaQokk39m4Nysr0QC+s3EvracsocwlAkKvFREQEgRBEAThNSdJEpoy+w2iIkt5pxRZx6Qn+s1GfpVlhFPHzJvlGF+619E8f/4OW07VRqPHxmcXNhBNN0mdmSUiSRIVLgdXLKjjg81VIJnNt2cGvYrsOh9urubdtWXEpzWCnR5Ec6s23lJRzOKAh9FYHJssm03eZ7x29YUu7lyzgP5IjNFonDKnHZ89M9MrYNf40tJGekJRXuwfwaXaOKHYi9+uWr1BHDaFU8oDtPjc/L/2HnrCMZYHvawo8WWMpq902fnJSQv5fwd6eLZnGLeqcEFDOQv9hVbvMa+ucc3iBv52qJ/f7u1iJJZgvs/Nx+fVUldwuGSuxevmxhPmctvWNrpDURQJTioLcFlrjVW+EXTo3HLifL750m52pye4ORSZS5qqWJUuNVQkOKs6SOdkmMcOHg6s+HWVG5e3WGupyK7x9ePmcsOLuzKCIUuLPLyzthRFlnHK8PHWWnaOTFpla2AG0K5d0kgg/RxLHTrvqCnJuqktsmtc1FiJrsjoisxnFzbwmWe3ZgVfzqsrtSY8Nnlc1BU4srIltHSmmEu1YbcpfGRuNd+fUZI09finJjyuLvVz766DObN2PtpSQ4Gmosoyp1cV86ccTcQrXXaC6all76gt4eH2npyZThc1VuDVVSQJ5vncbMtR3ujVVIodOroic259Oc/05O5Hdm59KT5dI5kyCDq0nD29nDaFYruGS7VxVnWQzXl6Xp1eGcSj2YgmkzgUOWcAQJMl/LqGW1VYHvSyJ8dkQDAnXLpUBa9my9vbTEk3e3YoCo0eFx0TucsN53rdOBQFzyy9zaT089QVmRK7njdIUO7S0RT5iJsCuixbfdJyBVTBDDIqspS3L8wURZLSTZ9nOUYmPRFz9mCcgRnYi80S2ZtMl52OzRKwMzADezZZYXSW3mxTf8f5MsbAzEAzS56NvK8VwP5xc63sG8u9ZsAMJMZSKSSkjPeQmXYMj3NiqX/W/m2dk+akwCTGrAHHLUNjLAgUsr43dzDYPGaccMJs8n0gzzoFMxOpvtA1a/DvmZ4hPhFPEEkm8w42MIAdwxNUuh082pE/+PeXjn4uqC8nnEzlnNIJEEsZtI+HMoaSCP8aERASBEEQBEH4J2iKjHaEmyddkdEdswe9VEWetQcQmMGzoFO3SuryeTWBsalm8VMlA7k4VRv1qo1PtlSzacsWllQ1YrNlXjZKkkS5y86lzdVc0FCOIkk5s8wCdo3z68t5S3kRBmZz3YIZx7lUGytL/TR63YQSSVRJwpujKWu128F3V7RazVsLNRsBXUWdVj7gt2t8an4dH2ispDsUwW2zUeTQKJ4WaNMVheODHn516hK2DY8zEo2zIFBI0KFbWUsAZS47P1o9n+3D4zzXO0yJQ+ctFUUUO3RrspZHV/nw3CpOrSjid/u6GI8nWVse4MTSzJ4YjR4nPzt5Eb/e08mWoTH8usZFjRXM9xdaN/RFDp3vrGjld/u7+OOBPiKJJMcFvVzWWkNl+gbILNcLYJNlfrbjAENRs0HtWdXBdHDGXG8lTp1bT5zPN1/ebfVC8moqn1lQR0OhGYyz2xQ+NLea8XiCf0zLhKorcPLN45utgG2pU+e6JY18Z9NeK6AlAe+pL2NRwCzp82gqX1zSyFXrtmVkqTkUmRuXH57wWF/g4MyqYv58MDMTanGgkJUlfut1uG5JI9es354RQJOAaxfPwZ9+jsuKPTnLDUudOqdWFCFL5tj7y1pr+eGW7ADah5qr8Ns1FFnmrGoz6DWz75XbpnB2TQk2Wcarq5ye47EDnF1dgk/TsNsU3j+ngicODWQFjmySxLvrSlHTDf1bvG525MgAWlXiw6eruFUbFzdV8spz2dlzAO+pPzwRs8iuMZCjf9YCfwGedPPiCxrKszL/pry7rhSbLFPhsmNX5JxTM+cUuvBoZqbomVVB/nNv7tK4c2pKkSWJOR5X3gBatdtBoWoOB1hV6s8bdDgtXco6N53dl0upU8dlU9AUmfn+grzTNafWV7Mn/7kCuopdMQNoFS573uDLfJ9ZDjs1OCIXj2ZDS28WzJbVV5sOjlfMEuRwqwqKLCEZ5O1jB1h/Z/5ZBoKYTZzTwT3yl7Q60+9xswUJbelzmP+f39QeR2KWGOFUADF1hKy+aJ7nLvxzREBIEARBEARByKvr4EEWL1iQ9/uqIuNTZg96yZKUMQY8nyP14ALw6qrV7DyfqVLKqlnKGzVFocylHHGnOejQCTp01pYXzfKYNJboGq1eN4k8U3M0RaGu0MnnFjUwmUiiyrkDaEGHzkfn1nB+fTkG5k2Ze0YGiEdXOaOqmOOKPYSTKbQcU4ambshvWTmP0bhZ8lSo2bJGkRfZNT63aA4fbYkzEo2bmTC6mnFD6bTZOKncz3z/EvaPh4gmkzR63FbQYkql28EdaxawfyzEzuEJqtx2Wv0FBKf1EPOmAzRn15TyaEcv8ZTBGVXF1BQ4MzIGW30F3L12MY8c6GHXyATVbgfn1pdR7rRb0yeLHTrfXdHCk12D/Kmjl5RhTip8a0WxFYxTFZm3VAQoc+r8bMcBOiYiVLjsXDq3ikWBQus1K3Pq3LF6AXelJ3ABrAj6+Pi8GkrT53KpNj7aUoNHU3movYdo0swQPLe+jPPqynCqSvp1sHPTiha+s3GvlWVS4tC5dskcq5zSq2vccFwTX39xN9unBYWOL/Zy5cLDpZmNHheXzq3i3p0HrcCKKkt8dmED5c7DGW83LW/h6nXbGJtWwlnm1Pnikkarb9yKEh/Lg96s0rH3z6mg0mX+rfh1jS8vbeLLL+zMCOS4bQpfXDLHCjieU1vKk92DWQGTk8r8Vs81n6bywblVWc3GbZLENYsarCzHDzZXsb53mNCMbLa5XhcNHpf1HE8q82cELqd8en6d9f7yyXm1fOrpLVlBqHKnTnO6D1l5uhQ1V5+tj7bWWFmal7XU8JUXd2Ud49VUWtMBqgaPC6+m5iwbu6ix0nqO75tTwV3bD2Qd41BkKyN1ScCDJks5y67Ory8noKskDTizupg/5GgGr8oSC9L9CdeUBnJOLAR4Z20JPk0llkqxMk8fO0WCeelzTU1jzeXM6iBezcZkIkWzx5Uzs0cGq1z3zKpiHs9TFntKRRGFmoqEGeTLlRknYQYmhdeOZBhHyOV7kxkbG8Pj8TA6OkphYf5Gh/8b8XicRx99lLPOOgtVnf0CRRDeLMS6F45FYt0Lxxqx5oU3WiKVIpI0yynVPH3VDMNgJBY3+yvpatZI8Ckj0TixlBlAmzlefMpkPMFYLM7o6Cjlfh+F9uxAZjyVYjASI5JMYVdkArpmBammP6aBSMwsdZLSvc1yBDxHomYgbjyRoFC15RxFHkqYTbbbxkLYZJmaAgd+Xc1orGsYBn3hGPvHJjk4GaHR46LKZc8KxA5HYnSFIvyjewhdkTm5PECxXcsITkaTSXpDUf58sJ+DE2EWBwqtjLfpwcS+cJQNvcP8tbMfu6LwnvoyGj2ujHLW0WicvWOT/Hp3J/2RGPN8BbyvsYJyp46WfvxJw6BrMsJ/7ulkXc8wDpvCu2pLeWtlUUbG42AkxuOd/Tywr4vhaJwmj4tPzKul2ePCmQ6gRRJJdo9O8MMtbewfC6FIEqeUB/hIS3VGyWtvKMod29p4pnuIFGYGz8daalhT5rdei7FYnCe7Bvnp9gNWP5tGj4vrlzZSM63ktX0sxJdfODxlzCZJnFdfxnvnlFvls0ORGHfv7OBPHX1WRo5PV/n2CXNp8rpRJIl4MsXW4XGu27Ajo8RxTZmfKxfUWwHT/nCUr7ywKyO7TJMlvnVCC4sChWiKTCiR4IlDg1kZYc0eF988Ya71uh6aDPOZZ7dlZJdJwHVLGllT5sduUxiNxrlv98GsqZ9lTp1bVs2zXtc9oxNc8czWrOyyT7TWcHZNCS7VxlAkxrc37snoYwdmkO3ONQusaXEv9I3w+ee2Z2UvXdhQxsVNVVlBciHT/ybmIQJCrwFxsSQci8S6F45FYt0Lxxqx5oVjkVj3hyVSqVkn6YEZRJMladZx4JPxBNFkCpdNsZrczxRNJBlLn8unqxnBpylJw2A4EiOFWTqVL1twJBpjMpFEkSS8mmqVeE4XiifN8tNUCqdNIWDXsoKJyVSKgUicsbhZmunRcmcoDkViDKdLWT2a2Ytu5usxEU8wEo3THYrisikUObSsjL1EKsVAJMaBiTBj0QRzPE78di2jF9zUz+sORdk2PE5AV2n1FRBIT1u0nl8iwUAkzrM9Q4xE46wo8VHtdmT17usNRdkyNMa6niGCusoZNSUEnbrVV858PeMcnAjzUFsPE/EEb6ksYkmRJ6PHXyJl0BuO8P/ae9k4OEbQrvHeORVUux3WNFIwA3sv9o/w+/3dRJIpTirz8/bqkoxszXAiScdEmLt3drBzZIJiu87FTRUsCniOmCEq/O9iHiK0JgiCIAiCIAiCIGQ5UjAIzFK6V3OM6wj38bpNoXiWoBKYfW9eTfmpV9fwHuEwp6pYZX55f55s9ngrYfaT+WdMrcxlalJn5SylrDZZptRpz8hmmu3nzToAwWaj2m2jek7FrOcqceqUOItZW+rj+eefp8JRhTqjZ9xUqW6Lz00yZeQM6tlkc5jCR1qqCSWSaLKcMxAXsGucXhVkRdBH0jBLWWeuM4dNodnr5ivLmsy+crME/4R/jQgICYIgCIIgCIIgCMIxzDAM+vtz9/eZYpNlbEeIEdpkmULtyIHEmaWRuZiBRBGy+L905N+UIAiCIAiCIAiCIAiC8KYiAkKCIAiCIAiCIAiCIAjHGBEQEgRBEARBEARBEARBOMaIgJAgCIIgCIIgCIIgCMIxRgSEBEEQBEEQBEEQBEEQjjEiICQIgiAIgiAIgiAIgnCMEQEhQRAEQRAEQRAEQRCEY4wICAmCIAiCIAiCIAiCIBxjREBIEARBEARBEARBEAThGCMCQoIgCIIgCIIgCIIgCMcYERASBEEQBEEQBEEQBEE4xoiAkCAIgiAIgiAIgiAIwjFGBIQEQRAEQRAEQRAEQRCOMSIgJAiCIAiCIAiCIAiCcIwRASFBEARBEARBEARBEIRjjAgICYIgCIIgCIIgCIIgHGNEQEgQBEEQBEEQBEEQBOEY84YHhO68807q6uqw2+0sW7aMp59+etbjn3rqKZYtW4bdbqe+vp677rrrdXqkgiAIgiAIgiAIgiAIbw5vaEDogQce4Morr+RLX/oSGzduZM2aNZx55pl0dHTkPL6trY2zzjqLNWvWsHHjRq677jo+/elP8/vf//51fuSCIAiCIAiCIAiCIAj/vt7QgNAPfvADPvzhD/ORj3yElpYWfvjDH1JVVcWPf/zjnMffddddVFdX88Mf/pCWlhY+8pGPcOmll3LzzTe/zo9cEARBEARBEARBEATh35ftjfrBsViMl156iWuvvTbj66eddhrr1q3L+W/Wr1/PaaedlvG1008/nV/84hfE43FUVc36N9FolGg0av336OgoAENDQ8Tj8X/1aQAQj8cJhUIMDg7mfAyC8GYk1r1wLBLrXjjWiDUvHIvEuheORWLdv3mMj48DYBjGEY99wwJCAwMDJJNJSkpKMr5eUlJCT09Pzn/T09OT8/hEIsHAwABlZWVZ/+bGG2/ka1/7WtbX6+rq/oVHLwiCIAiCIAiCIAiCcHQaHx/H4/HMeswbFhCaIklSxn8bhpH1tSMdn+vrU774xS9y9dVXW/+dSqUYGhoiEAjM+nP+N8bGxqiqquLgwYMUFha+JucUhKOdWPfCsUise+FYI9a8cCwS6144Fol1/+ZhGAbj4+OUl5cf8dg3LCBUVFSEoihZ2UB9fX1ZWUBTSktLcx5vs9kIBAI5/42u6+i6nvE1r9f7zz/wWRQWFoo/HuGYI9a9cCwS61441og1LxyLxLoXjkVi3b85HCkzaMob1lRa0zSWLVvG448/nvH1xx9/nFWrVuX8NytXrsw6/q9//SvHHXecqHMUBEEQBEEQBEEQBEF4ld7QKWNXX301P//5z7n77rvZsWMHV111FR0dHXz84x8HzHKvSy65xDr+4x//OAcOHODqq69mx44d3H333fziF7/gmmuueaOegiAIgiAIgiAIgiAIwr+dN7SH0IUXXsjg4CBf//rX6e7uZv78+Tz66KPU1NQA0N3dTUdHh3V8XV0djz76KFdddRV33HEH5eXl3HbbbZx33nlv1FMAzLK0G264Ias0TRDezMS6F45FYt0Lxxqx5oVjkVj3wrFIrPtjk2S8mllkgiAIgiAIgiAIgiAIwpvGG1oyJgiCIAiCIAiCIAiCILz+REBIEARBEARBEARBEAThGCMCQoIgCIIgCIIgCIIgCMcYERASBEEQBEEQBEEQBEE4xoiAUNqNN97I8ccfT0FBAcFgkHe9613s2rUr4xjDMPjqV79KeXk5DoeDtWvXsm3bNuv7Q0NDXHHFFTQ3N+N0OqmurubTn/40o6OjGecZHh7m4osvxuPx4PF4uPjiixkZGXk9nqYgWF6LNT/z2DPPPBNJknj44YczvifWvHC0eC3X/fr16zn11FNxuVx4vV7Wrl1LOBy2vi/WvXC0eK3WfU9PDxdffDGlpaW4XC6WLl3K7373u4xjxLoXjgavZs0/+OCDnH766RQVFSFJEps2bco6TzQa5YorrqCoqAiXy8U555xDZ2dnxjFizQtHi9di3Yv72WOPCAilPfXUU3zqU5/iueee4/HHHyeRSHDaaacxOTlpHfPd736XH/zgB9x+++288MILlJaW8ra3vY3x8XEAurq66Orq4uabb2bLli3ce++9PPbYY3z4wx/O+Fnvf//72bRpE4899hiPPfYYmzZt4uKLL35dn68gvBZrfrof/vCHSJKU82eJNS8cLV6rdb9+/XrOOOMMTjvtNJ5//nleeOEFLr/8cmT58MeqWPfC0eK1WvcXX3wxu3bt4pFHHmHLli2ce+65XHjhhWzcuNE6Rqx74Wjwatb85OQkJ554IjfddFPe81x55ZU89NBD3H///TzzzDNMTExw9tlnk0wmrWPEmheOFq/Fuhf3s8cgQ8ipr6/PAIynnnrKMAzDSKVSRmlpqXHTTTdZx0QiEcPj8Rh33XVX3vP89re/NTRNM+LxuGEYhrF9+3YDMJ577jnrmPXr1xuAsXPnzv+jZyMIR/avrPlNmzYZlZWVRnd3twEYDz30kPU9seaFo9k/u+6XL19uXH/99XnPK9a9cDT7Z9e9y+UyfvnLX2acy+/3Gz//+c8NwxDrXjh6zVzz07W1tRmAsXHjxoyvj4yMGKqqGvfff7/1tUOHDhmyLBuPPfaYYRhizQtHt39m3eci7mff3ESGUB5TaXF+vx+AtrY2enp6OO2006xjdF3n5JNPZt26dbOep7CwEJvNBpi7yh6Ph+XLl1vHrFixAo/HM+t5BOH/2j+75kOhEO973/u4/fbbKS0tzTqvWPPC0eyfWfd9fX1s2LCBYDDIqlWrKCkp4eSTT+aZZ56x/o1Y98LR7J99v1+9ejUPPPAAQ0NDpFIp7r//fqLRKGvXrgXEuheOXjPX/Kvx0ksvEY/HM/4uysvLmT9/vrWexZoXjmb/zLrPdx5xP/vmJQJCORiGwdVXX83q1auZP38+YNbNA5SUlGQcW1JSYn1vpsHBQb7xjW9w2WWXWV/r6ekhGAxmHRsMBvOeRxD+r/0ra/6qq65i1apVvPOd78x5brHmhaPVP7vu9+/fD8BXv/pVPvrRj/LYY4+xdOlS3vKWt7Bnzx7rPGLdC0ejf+X9/oEHHiCRSBAIBNB1ncsuu4yHHnqIhoYG6zxi3QtHm1xr/tXo6elB0zR8Pl/G16f/XYg1Lxyt/tl1P5O4n33zs73RD+BodPnll7N58+aM3d4pM3ukGIaRs2/K2NgYb3/722ltbeWGG26Y9RyznUcQXg//7Jp/5JFH+Pvf/57RPyIXseaFo9E/u+5TqRQAl112GR/60IcAWLJkCf/zP//D3XffzY033pjzHDPPIwhvhH/lGuf6669neHiYv/3tbxQVFfHwww9z/vnn8/TTT7NgwYKc58h1HkF4Pc225v8ZM9ezWPPC0ei1WPfifvbYIDKEZrjiiit45JFHeOKJJ6isrLS+PlUKMzPq2dfXl7WjNj4+zhlnnIHb7eahhx5CVdWM8/T29mb93P7+/qzzCMLr4V9Z83//+9/Zt28fXq8Xm81mpZKed955VgmBWPPC0ehfWfdlZWUAtLa2ZhzT0tJCR0eHdR6x7oWjzb+y7vft28ftt9/O3XffzVve8hYWLVrEDTfcwHHHHccdd9xhnUese+Fokm/NvxqlpaXEYjGGh4czvj7970KseeFo9K+s+ynifvbYIQJCaYZhcPnll/Pggw/y97//nbq6uozv19XVUVpayuOPP259LRaL8dRTT7Fq1Srra2NjY5x22mlomsYjjzyC3W7POM/KlSsZHR3l+eeft762YcMGRkdHM84jCP/XXos1f+2117J582Y2bdpk/Q/glltu4Z577gHEmheOLq/Fuq+traW8vDxrlOvu3bupqakBxLoXji6vxboPhUIAGZP0ABRFsbLmxLoXjhZHWvOvxrJly1BVNePvoru7m61bt1rrWax54WjyWqx7EPezx5zXsYH1Ue0Tn/iE4fF4jCeffNLo7u62/hcKhaxjbrrpJsPj8RgPPvigsWXLFuN973ufUVZWZoyNjRmGYRhjY2PG8uXLjQULFhh79+7NOE8ikbDOc8YZZxgLFy401q9fb6xfv95YsGCBcfbZZ7/uz1k4tr0Waz4XZkwZMwyx5oWjx2u17m+55RajsLDQ+O///m9jz549xvXXX2/Y7XZj79691jFi3QtHi9di3cdiMWPOnDnGmjVrjA0bNhh79+41br75ZkOSJONPf/qTdR6x7oWjwatZ84ODg8bGjRuNP/3pTwZg3H///cbGjRuN7u5u65iPf/zjRmVlpfG3v/3NePnll41TTz3VWLRokbiuF45Kr8W6F/ezxx4REEoDcv7vnnvusY5JpVLGDTfcYJSWlhq6rhsnnXSSsWXLFuv7TzzxRN7ztLW1WccNDg4aH/jAB4yCggKjoKDA+MAHPmAMDw+/fk9WEIzXZs3nO+/MgJBY88LR4rVc9zfeeKNRWVlpOJ1OY+XKlcbTTz+d8X2x7oWjxWu17nfv3m2ce+65RjAYNJxOp7Fw4cKsMfRi3QtHg1ez5u+5556cx9xwww3WMeFw2Lj88ssNv99vOBwO4+yzzzY6OjoyfpZY88LR4rVY9+J+9tgjGYZhvBaZRoIgCIIgCIIgCIIgCMK/B9FDSBAEQRAEQRAEQRAE4RgjAkKCIAiCIAiCIAiCIAjHGBEQEgRBEARBEARBEARBOMaIgJAgCIIgCIIgCIIgCMIxRgSEBEEQBEEQBEEQBEEQjjEiICQIgiAIgiAIgiAIgnCMEQEhQRAEQRAEQRAEQRCEY4wICAmCIAiCIPyTnnzySSRJYmRk5I1+KIIgCIIgCP8rkmEYxhv9IARBEARBEP4drF27lsWLF/PDH/4QgFgsxtDQECUlJUiS9MY+OEEQBEEQhP8F2xv9AARBEARBEP5daZpGaWnpG/0wBEEQBEEQ/tdEyZggCIIgCMKr8MEPfpCnnnqKW2+9FUmSkCSJe++9N6Nk7N5778Xr9fLHP/6R5uZmnE4n73nPe5icnOS+++6jtrYWn8/HFVdcQTKZtM4di8X4/Oc/T0VFBS6Xi+XLl/Pkk0++MU9UEARBEIRjgsgQEgRBEARBeBVuvfVWdu/ezfz58/n6178OwLZt27KOC4VC3Hbbbdx///2Mj49z7rnncu655+L1enn00UfZv38/5513HqtXr+bCCy8E4EMf+hDt7e3cf//9lJeX89BDD3HGGWewZcsWGhsbX9fnKQiCIAjCsUEEhARBEARBEF4Fj8eDpmk4nU6rTGznzp1Zx8XjcX784x/T0NAAwHve8x5+9atf0dvbi9vtprW1lVNOOYUnnniCCy+8kH379vGb3/yGzs5OysvLAbjmmmt47LHHuOeee/j2t7/9+j1JQRAEQRCOGSIgJAiCIAiC8BpyOp1WMAigpKSE2tpa3G53xtf6+voAePnllzEMg6ampozzRKNRAoHA6/OgBUEQBEE45oiAkCAIgiAIwmtIVdWM/5YkKefXUqkUAKlUCkVReOmll1AUJeO46UEkQRAEQRCE15IICAmCIAiCILxKmqZlNIN+LSxZsoRkMklfXx9r1qx5Tc8tCIIgCIKQj5gyJgiCIAiC8CrV1tayYcMG2tvbGRgYsLJ8/hVNTU184AMf4JJLLuHBBx+kra2NF154ge985zs8+uijr8GjFgRBEARByCYCQoIgCIIgCK/SNddcg6IotLa2UlxcTEdHx2ty3nvuuYdLLrmEz372szQ3N3POOeewYcMGqqqqXpPzC4IgCIIgzCQZhmG80Q9CEARBEARBEARBEARBeP2IDCFBEARBEARBEARBEIRjjAgICYIgCIIgCIIgCIIgHGNEQEgQBEEQBEEQBEEQBOEYIwJCgiAIgiAIgiAIgiAIxxgREBIEQRAEQRAEQRAEQTjGiICQIAiCIAiCIAiCIAjCMUYEhARBEARBEARBEARBEI4xIiAkCIIgCIIgCIIgCIJwjBEBIUEQBEEQBEEQBEEQhGOMCAgJgiAIgiAIgiAIgiAcY0RASBAEQRAEQRAEQRAE4RgjAkKCIAiCIAiCIAiCIAjHmP8PR0Fa9+xSmvAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tlca.plot_dynamic_characterized_inventory()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Of course we can also assess the \"standard\" climate change metric Global Warming Potential (GWP):" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "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.17960615
12024-01-01 00:00:0014.10032816
22024-01-01 00:00:003.00000017
32024-12-31 05:49:122.00000017
42028-01-01 00:00:004.68026318
\n", + "
" + ], + "text/plain": [ + " date amount flow activity\n", + "0 2022-01-01 00:00:00 9.179606 1 5\n", + "1 2024-01-01 00:00:00 14.100328 1 6\n", + "2 2024-01-01 00:00:00 3.000000 1 7\n", + "3 2024-12-31 05:49:12 2.000000 1 7\n", + "4 2028-01-01 00:00:00 4.680263 1 8" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tlca.dynamic_lcia(\n", + " metric=\"GWP\",\n", + " time_horizon=100,\n", + " characterization_function_dict=characterization_function_dict,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... and plot it:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIAAAAINCAYAAABGVgRmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7i0lEQVR4nO3deXxV9Z0//vfNQiCQsARZokFw37WV1qVWoS0o49KO1a9TrVttv3bclzrqr4vg1FI7M5aO/tqObQc7nVptv6OtD2vVTAXRrxsq1K1iVRAXEFlKgEBySc73D0vGyFIJufeee3g+H488Ht7POfec9yd5ewkvPuecXJIkSQAAAACQWRWlLgAAAACAwhIAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHFVpS6g0Do7O+Ott96Kurq6yOVypS4HAAAAoFckSRKrVq2KxsbGqKjY8hqfzAdAb731VjQ1NZW6DAAAAICCeP3112OnnXba4j6ZD4Dq6uoi4t1vRn19fYmr6Zl8Ph/3339/TJw4Maqrq0tdDuhJUkU/kjZ6kjTRj6SJfiRtstCTLS0t0dTU1JV9bEnmA6ANl33V19eXdQBUW1sb9fX1ZduUZIueJE30I2mjJ0kT/Uia6EfSJks9+UFueeMm0AAAAAAZJwACAAAAyDgBEAAAAEDGZf4eQAAAAED2JEkS69evj46Ojh69P5/PR1VVVaxbt67Hxyi0ysrKqKqq+kD3+PlrBEAAAABAWWlvb49FixZFa2trj4+RJEmMGDEiXn/99V4JWAqltrY2Ro4cGX369Nmm4wiAAAAAgLLR2dkZ8+fPj8rKymhsbIw+ffr0KMDp7OyM1atXx4ABA6KiIn13yEmSJNrb2+Odd96J+fPnx+67775NdQqAAAAAgLLR3t4enZ2d0dTUFLW1tT0+TmdnZ7S3t0ffvn1TGQBFRPTr1y+qq6vjtdde66q1p9I5QwAAAIAtSGto09t6a57bx3cLAAAAYDsmAAIAAADIOAEQAAAAQMYJgAAoW21rkli7ojI+vM9RsX6dP9IAACgPjzzySFRWVsYxxxxTtHN6ChgAZaezM4k/vxXx2H8msejFiMjVx477JnHIqUkMGhGRq9j6x4ACALD96UiSmLt0ZaxoXx9D+vaJAxrqo7IHj5TfWv/+7/8eF154Yfz4xz+OhQsXxqhRowp+TgEQAGVn9TsRd38zify6vwwkEW8+l4u7v5nEpyfnon5YScsDAKAMzFq0PG589tVY1r6+a2yHvn3iwv3GxJGNDQU775o1a+KXv/xlzJ49OxYvXhy33HJLfOMb3yjY+TawXh6AstKRT+KPD7wn/HmP9taIPz2cRGdHUvzCAAAoG7PeWhaTn3qpW/gTEfHOuvb4xpPzYtZbywp27ttvvz323HPP2HPPPePzn/98TJ8+PZKk8L+/ljQAmjVrVhx//PHR2NgYuVwufv3rX29233PPPTdyuVxMmzataPUBkD7tayPefG7z2994NiK/tnj1AABQXjqSJG58bv4W97npufnRUaBQ5ic/+Ul8/vOfj4iIY445JlavXh2///3vC3Ku9yppALRmzZo48MAD46abbtrifr/+9a/j8ccfj8bGxiJVBkBaVVRF1NRtfnu/unf3AQCATXlmWUu8s659i/ssWdcezyxr6fVzz5s3L5544on4u7/7u4iIqKqqilNOOSX+/d//vdfP9X4l/RV50qRJMWnSpC3u8+abb8YFF1wQ9913Xxx77LFFqgyAtKqpzcUBfxOx+MVN/4vMfpNyUd3XTaABANi05X8l/Nna/bbGT37yk1i/fn3suOOOXWNJkkR1dXWsWLEiBg8e3Ovn3CDV/0ba2dkZp59+elxxxRWx7777fqD3tLW1RVtbW9frlpZ3E7t8Ph/5fL4gdRbahrrLtX6yR09SakN2roi9P5mLP75vpez+x0QMauyMfL6zNIVB+IwkXfQjaaIf6S35fD6SJInOzs7o7Nz63/sG9/lgUcjgPlU9Ov7mrF+/Pv7jP/4j/vmf/zkmTJjQbdvJJ58c//mf/xnnn3/+Ru/r7OyMJEkin89HZWVlt21b8/9TqgOg66+/PqqqquKiiy76wO+ZOnVqTJkyZaPx+++/P2pra3uzvKJrbm4udQnQjZ6klHbZb+845pAd4+15VRGRxPC9OmLZqtejeea8UpcGEeEzknTRj6SJfmRbVVVVxYgRI2L16tXR3r71q3R2ro5o6FO10Q2g32toTVXsXP0/i0p6w29/+9tYsWJFnHTSSTFw4MBu24477rj40Y9+FKeffvpG72tvb4+1a9fGrFmzYv367jW3trZ+4POnNgB66qmn4nvf+148/fTTkct98KX8V199dVx22WVdr1taWqKpqSkmTpwY9fX1hSi14PL5fDQ3N8eECROiurq61OWAniRVhjStj8cffzz22vGjMax619h7/11LXRLbOZ+RpIl+JE30I71l3bp18frrr8eAAQOib9++PTrGhfvvEpOfemmz2y/Yb5cY/L6QZlv94he/iE9+8pPR1NS00bbPfe5zccMNN8TLL78cH/7wh7ttW7duXfTr1y+OPPLIjea7NQFVagOghx56KJYsWRKjRo3qGuvo6IjLL788pk2bFgsWLNjk+2pqaqKmpmaj8erq6rL/kMnCHMgWPUlarFy5Uj+SOnqSNNGPpIl+ZFt1dHRELpeLioqKqKjo2bOtxu04NCZHxI3PvtptJdCwvn3igv3GxJGNDb1T7Hvcfffdm902duzYzT4KvqKiInK53Cb/39ma/5dSGwCdfvrp8alPfarb2NFHHx2nn356nH322SWqCgAAAMiCI0cOif1rK+O1fMSK9vUxpG+fOKChPiq34iqkclLSAGj16tXx8ssvd72eP39+zJ07N4YMGRKjRo2KhobuiVt1dXWMGDEi9txzz2KXCgAAAGRMZS4XBw2t7/FKonJS0gDoySefjPHjx3e93nDvnjPPPDNuueWWElUFAAAAkC0lDYDGjRu32WvcNmVz9/0BAAAAYPOyv8YJAAAAYDsnAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAIAiOOussyKXy3V9NTQ0xDHHHBPPPPNMwc8tAAIAAAAokmOOOSYWLVoUixYtit///vdRVVUVxx13XMHPW1XwMwAAAACkUNIZsejFiHUtSdQOjBi+Z0RFRa6g56ypqYkRI0ZERMSIESPiyiuvjCOPPDLeeeed2GGHHQp2XgEQAAAAsN1Z8FTEYz8fEGv/HBGRRERE/8ERh54WMXpsYUOgDVavXh0///nPY7fddouGhoaCnksABAAAAGxXFjyZxIz/PyKie9CzZkXE729K4pMXFC4Euvvuu2PAgAHvnm/Nmhg5cmTcfffdUVFR2Lv0uAcQAAAAsN3o7EzisZ8nf3m16ZDnsVuT6OxMNrltW40fPz7mzp0bc+fOjccffzwmTpwYkyZNitdee60g59tAAAQAAABsN96e9+5Kny1Zs/zd/Qqhf//+sdtuu8Vuu+0WH/3oR+MnP/lJrFmzJn70ox8V5oR/IQACAAAAthutK3t3v22Vy+WioqIi1q5dW9DzuAcQAAAAsN2oHdi7+22ttra2WLx4cURErFixIm666aZYvXp1HH/88YU54V8IgAAAAIDtxvA9333a15YuA+s/5N39CuHee++NkSNHRkREXV1d7LXXXvGrX/0qxo0bV5gT/oVLwAAAAIDtRkVFLg49bcPNnzd9o+dDT81FRUXvPwXslltuiSRJur5aWlriiSeeiM9+9rO9fq73EwABAAAA25XRY3Mx/vyIfoO6B0D9h0R88oJcwR4BX0ouAQMAAAC2O6MPjhi86+poXVwf61pyUTvw3cu+CrHyJw0EQAAAAMB2KVcRMXKv7IY+7+USMAAAAICMEwABAAAAZJwACAAAACg7SbLpJ3hlTW/NUwAEAAAAlI3q6uqIiGhtbS1xJcWxYZ4b5t1TbgINAAAAlI3KysoYNGhQLFmyJCIiamtrI5fb+ps4d3Z2Rnt7e6xbty4qKtK3PiZJkmhtbY0lS5bEoEGDorKycpuOJwACAAAAysqIESMiIrpCoJ5IkiTWrl0b/fr161GAVCyDBg3qmu+2EAABAAAAZSWXy8XIkSNj2LBhkc/ne3SMfD4fs2bNiiOPPHKbL68qlOrq6m1e+bOBAAgAAAAoS5WVlT0OSCorK2P9+vXRt2/f1AZAvSl9F7kBAAAA0KsEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABkXEkDoFmzZsXxxx8fjY2Nkcvl4te//nXXtnw+H1deeWXsv//+0b9//2hsbIwzzjgj3nrrrdIVDAAAAFCGShoArVmzJg488MC46aabNtrW2toaTz/9dHz961+Pp59+Ou6444546aWX4oQTTihBpQAAAADlq6qUJ580aVJMmjRpk9sGDhwYzc3N3cZuvPHG+OhHPxoLFy6MUaNGFaNEAAAAgLJXVvcAWrlyZeRyuRg0aFCpSwEAAAAoGyVdAbQ11q1bF1dddVWceuqpUV9fv9n92traoq2tret1S0tLRLx7T6F8Pl/wOgthQ93lWj/ZoydJE/1I2uhJ0kQ/kib6kbTJQk9uTe25JEmSAtbygeVyubjzzjvjM5/5zEbb8vl8nHzyybFw4cKYOXPmFgOgyZMnx5QpUzYav/XWW6O2trY3SwYAAAAomdbW1jj11FNj5cqVW8xKIsogAMrn8/G//tf/ildffTUeeOCBaGho2OJxNrUCqKmpKZYuXfpXvxlplc/no7m5OSZMmBDV1dWlLgf0JKmiH0kbPUma6EfSRD+SNlnoyZaWlhg6dOgHCoBSfQnYhvDnT3/6U8yYMeOvhj8RETU1NVFTU7PReHV1ddn+QDfIwhzIFj1JmuhH0kZPkib6kTTRj6RNOffk1tRd0gBo9erV8fLLL3e9nj9/fsydOzeGDBkSjY2NcdJJJ8XTTz8dd999d3R0dMTixYsjImLIkCHRp0+fUpUNAAAAUFZKGgA9+eSTMX78+K7Xl112WUREnHnmmTF58uS46667IiLioIMO6va+GTNmxLhx44pVJgAAAEBZK2kANG7cuNjSLYhScnsiAAAAgLJWUeoCAAAAACgsARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcSUNgGbNmhXHH398NDY2Ri6Xi1//+tfdtidJEpMnT47Gxsbo169fjBs3Lp5//vnSFAsAAABQpkoaAK1ZsyYOPPDAuOmmmza5/Tvf+U7ccMMNcdNNN8Xs2bNjxIgRMWHChFi1alWRKwUAAAAoX1WlPPmkSZNi0qRJm9yWJElMmzYtvvrVr8aJJ54YERE//elPY/jw4XHrrbfGueeeW8xSAQAAAMpWau8BNH/+/Fi8eHFMnDixa6ympiaOOuqoeOSRR0pYGQAAAEB5KekKoC1ZvHhxREQMHz682/jw4cPjtdde2+z72traoq2tret1S0tLRETk8/nI5/MFqLTwNtRdrvWTPXqSNNGPpI2eJE30I2miH0mbLPTk1tSe2gBog1wu1+11kiQbjb3X1KlTY8qUKRuN33///VFbW9vr9RVTc3NzqUuAbvQkaaIfSRs9SZroR9JEP5I25dyTra2tH3jf1AZAI0aMiIh3VwKNHDmya3zJkiUbrQp6r6uvvjouu+yyrtctLS3R1NQUEydOjPr6+sIVXED5fD6am5tjwoQJUV1dXepyQE+SKvqRtNGTpIl+JE30I2mThZ7ccNXTB5HaAGjMmDExYsSIaG5ujg996EMREdHe3h4PPvhgXH/99Zt9X01NTdTU1Gw0Xl1dXbY/0A2yMAeyRU+SJvqRtNGTpIl+JE30I2lTzj25NXWXNABavXp1vPzyy12v58+fH3Pnzo0hQ4bEqFGj4pJLLolvfetbsfvuu8fuu+8e3/rWt6K2tjZOPfXUElYNAAAAUF5KGgA9+eSTMX78+K7XGy7dOvPMM+OWW26Jf/iHf4i1a9fGeeedFytWrIhDDjkk7r///qirqytVyQAAAABlp6QB0Lhx4yJJks1uz+VyMXny5Jg8eXLxigIAAADImIpSFwAAAABAYQmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAZaKurq7UJQAAAABlSgCUYp2dSaxelsSiFyqjof3wWPFaZbSuTEpdFgAAAFBmqkpdAJvW2ZnEsgUR9/5zEu2tERF9IiKiYeckPnVRxICGXCnLAwAAAMqIFUAp1briveHP/1j2WsTsXyaRX2clEAAAAPDBCIBS6s+LYqPwZ4P5syPWthS3HgAAAKB8CYBSqnXF5rclnREd+eLVAgAAAJQ3AVBKDWna/La+dRHV/YpXCwAAAFDeBEAp1X9IxLDdN73t4BNzUTuoqOUAAAAAZUwAlFL96nPxib/PxR5HRlT85Vltfesjjjg7F6M/ElFR4SlgAAAAwAfjMfAp1n9ILg47LeLA45L484pVMXhoXQwYHJET/gAAAABbwQqglKuqyUW/wR0x58WZ0be+Q/gDAAAAbDUBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxPQqAZs2aFevXr99ofP369TFr1qxtLuq9x/va174WY8aMiX79+sUuu+wS1157bXR2dvbaOQAAAACyrqonbxo/fnwsWrQohg0b1m185cqVMX78+Ojo6OiV4q6//vr44Q9/GD/96U9j3333jSeffDLOPvvsGDhwYFx88cW9cg4AAACArOtRAJQkSeRyuY3Gly1bFv3799/mojZ49NFH49Of/nQce+yxERExevTo+MUvfhFPPvlkr50DAAAAIOu2KgA68cQTIyIil8vFWWedFTU1NV3bOjo64plnnonDDz+814o74ogj4oc//GG89NJLsccee8Qf/vCHePjhh2PatGmbfU9bW1u0tbV1vW5paYmIiHw+H/l8vtdqK6YNdZdr/WSPniRN9CNpoydJE/1ImuhH0iYLPbk1tW9VADRw4MCIeHcFUF1dXfTr169rW58+feLQQw+NL33pS1tzyC268sorY+XKlbHXXntFZWVldHR0xHXXXRef+9znNvueqVOnxpQpUzYav//++6O2trbXaiuF5ubmUpcA3ehJ0kQ/kjZ6kjTRj6SJfiRtyrknW1tbP/C+uSRJkq09wZQpU+IrX/lKr17utSm33XZbXHHFFfFP//RPse+++8bcuXPjkksuiRtuuCHOPPPMTb5nUyuAmpqaYunSpVFfX1/Qegsln89Hc3NzTJgwIaqrq0tdDuhJUkU/kjZ6kjTRj6SJfiRtstCTLS0tMXTo0Fi5cuVfzTx6dA+ga665pkeFba0rrrgirrrqqvi7v/u7iIjYf//947XXXoupU6duNgCqqanpdmnaBtXV1WX7A90gC3MgW/QkaaIfSRs9SZroR9JEP5I25dyTW1N3jx4D//bbb8fpp58ejY2NUVVVFZWVld2+ektra2tUVHQvsbKy0mPgAQAAALZCj1YAnXXWWbFw4cL4+te/HiNHjtzkE8F6w/HHHx/XXXddjBo1Kvbdd9+YM2dO3HDDDfGFL3yhIOcDAAAAyKIeBUAPP/xwPPTQQ3HQQQf1cjnd3XjjjfH1r389zjvvvFiyZEk0NjbGueeeG9/4xjcKel4AAACALOlRANTU1BQ9uHf0Vqurq4tp06Zt8bHvAAAAAGxZj+4BNG3atLjqqqtiwYIFvVwOAAAAAL2tRyuATjnllGhtbY1dd901amtrN7rr9PLly3ulOAAAAAC2XY8CIJdkAQAAAJSPHgVAZ555Zm/XAQAAAECB9CgAWrhw4Ra3jxo1qkfFAAAAAND7ehQAjR49OnK53Ga3d3R09LggAAAAAHpXjwKgOXPmdHudz+djzpw5ccMNN8R1113XK4UBAAAA0Dt6FAAdeOCBG42NHTs2Ghsb45/+6Z/ixBNP3ObCAAAAAOgdFb15sD322CNmz57dm4cEAAAAYBv1aAVQS0tLt9dJksSiRYti8uTJsfvuu/dKYQAAAAD0jh4FQIMGDdroJtBJkkRTU1PcdtttvVIYAAAAAL2jRwHQjBkzur2uqKiIHXbYIXbbbbeoqurRIQEAAAAokB6lNUcddVRv1wEAAABAgfR4uc4rr7wS06ZNiz/+8Y+Ry+Vi7733josvvjh23XXX3qwPAAAAgG3Uo6eA3XfffbHPPvvEE088EQcccEDst99+8fjjj8e+++4bzc3NvV0jAAAAANugRyuArrrqqrj00kvj29/+9kbjV155ZUyYMKFXigMAAABg2/VoBdAf//jHOOecczYa/8IXvhAvvPDCNhcFAAAAQO/pUQC0ww47xNy5czcanzt3bgwbNmxbawIAAACgF/XoErAvfelL8b//9/+OV199NQ4//PDI5XLx8MMPx/XXXx+XX355b9cIAAAAwDboUQD09a9/Perq6uJf/uVf4uqrr46IiMbGxpg8eXJcdNFFvVogAAAAANumRwFQLpeLSy+9NC699NJYtWpVRETU1dX1amEAAAAA9I4eBUDvJfgBAAAASLceBUDLli2Lb3zjGzFjxoxYsmRJdHZ2dtu+fPnyXikOAAAAgG3XowDo85//fLzyyitxzjnnxPDhwyOXy/V2XQAAAAD0kh4FQA8//HA8/PDDceCBB/Z2PQAAAAD0soqevGmvvfaKtWvX9nYtAAAAABRAjwKg73//+/HVr341HnzwwVi2bFm0tLR0+wIAAAAgPXp0CdigQYNi5cqV8YlPfKLbeJIkkcvloqOjo1eKAwAAAGDb9SgAOu2006JPnz5x6623ugk0AAAAQMr1KAB67rnnYs6cObHnnnv2dj0AAAAA9LIe3QNo7Nix8frrr/d2LQAAAAAUQI9WAF144YVx8cUXxxVXXBH7779/VFdXd9t+wAEH9EpxAAAAAGy7HgVAp5xySkREfOELX9hom5tAAwAAAKRLjwKg+fPn93YdAAAAABRIjwKgnXfeOSIiXnjhhVi4cGG0t7d3bcvlcl3bAQAAACi9HgVAr776avzt3/5tPPvss5HL5SJJkoiIrsfBuwQMAAAAID169BSwiy++OMaMGRNvv/121NbWxnPPPRezZs2KsWPHxsyZM3u5RAAAAAC2RY9WAD366KPxwAMPxA477BAVFRVRWVkZRxxxREydOjUuuuiimDNnTm/XCQAAAEAP9WgFUEdHRwwYMCAiIoYOHRpvvfVWRLx7b6B58+b1XnUAAAAAbLMerQDab7/94plnnolddtklDjnkkPjOd74Tffr0iZtvvjl22WWX3q4RAAAAgG3QowDoa1/7WqxZsyYiIr75zW/GcccdFx//+MejoaEhbr/99l4tEAAAAIBt06MA6Oijj+7671122SVeeOGFWL58eQwePLjrSWAAAAAApEOPAqBNGTJkSG8dCgAAAIBe1KObQAMAAABQPgRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjUh8Avfnmm/H5z38+Ghoaora2Ng466KB46qmnSl0WAAAAQNmoKnUBW7JixYr42Mc+FuPHj4/f/e53MWzYsHjllVdi0KBBpS4NAAAAoGykOgC6/vrro6mpKaZPn941Nnr06NIVBAAAAFCGUh0A3XXXXXH00UfHySefHA8++GDsuOOOcd5558WXvvSlzb6nra0t2traul63tLREREQ+n498Pl/wmgthQ93lWj/ZoydJE/1I2uhJ0kQ/kib6kbTJQk9uTe25JEmSAtayTfr27RsREZdddlmcfPLJ8cQTT8Qll1wS//Zv/xZnnHHGJt8zefLkmDJlykbjt956a9TW1ha0XgAAAIBiaW1tjVNPPTVWrlwZ9fX1W9w31QFQnz59YuzYsfHII490jV100UUxe/bsePTRRzf5nk2tAGpqaoqlS5f+1W9GWuXz+Whubo4JEyZEdXV1qcsBPUmq6EfSRk+SJvqRNNGPpE0WerKlpSWGDh36gQKgVF8CNnLkyNhnn326je29997xX//1X5t9T01NTdTU1Gw0Xl1dXbY/0A2yMAeyRU+SJvqRtNGTpIl+JE30I2lTzj25NXWn+jHwH/vYx2LevHndxl566aXYeeedS1QRAAAAQPlJdQB06aWXxmOPPRbf+ta34uWXX45bb701br755jj//PNLXRoAAABA2Uh1APSRj3wk7rzzzvjFL34R++23X/zjP/5jTJs2LU477bRSlwYAAABQNlJ9D6CIiOOOOy6OO+64UpcBAAAAULZSvQIIAAAAgG0nAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMqyp1AQAAAADFkiRJtP45on1tZXx4n6OiI5+L6upSV1V4AiAAAABgu9C2Jok3no144vYkWldE5CrrY5ePRow9KYkBDblSl1dQLgEDAAAAtgtvPh8x84fvhj8REUlHxCuPRjR/L4nWPyelLa7ABEAAAABA5q1ZkcTs2zcd8ixfGNGypMgFFZkACAAAAMi89W0Rq5dtfvs7r1oBBAAAAFDWKqoiKrdws+f+Q9wDCAAAAKCs9auP2P3jm95W2SdihzHFrafYBEAAAABA5lX1ycVBx+Vi2O7vH484+vJc1A4uTV3F4jHwAAAAwHah/5BcfOrCd+8FtHR+EhV922Lk7jUxYHBERZVLwAAAAAAyoV99LnYYk4vdPt4RC1bNin6DOjIf/kQIgAAAAIDt1Lp160pdQtEIgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwrqwBo6tSpkcvl4pJLLil1KQAAAABlo2wCoNmzZ8fNN98cBxxwQKlLAQAAACgrZREArV69Ok477bT40Y9+FIMHDy51OQAAAABlparUBXwQ559/fhx77LHxqU99Kr75zW9ucd+2trZoa2vret3S0hIREfl8PvL5fEHrLJQNdZdr/WSPniRN9CNpoydJE/1ImuhH0iYLPbk1teeSJEkKWMs2u+222+K6666L2bNnR9++fWPcuHFx0EEHxbRp0za5/+TJk2PKlCkbjd96661RW1tb4GoBAAAAiqO1tTVOPfXUWLlyZdTX129x31QHQK+//nqMHTs27r///jjwwAMjIv5qALSpFUBNTU2xdOnSv/rNSKt8Ph/Nzc0xYcKEqK6uLnU5oCdJFf1I2uhJ0kQ/kib6kbTJQk+2tLTE0KFDP1AAlOpLwJ566qlYsmRJHHzwwV1jHR0dMWvWrLjpppuira0tKisru72npqYmampqNjpWdXV12f5AN8jCHMgWPUma6EfSRk+SJvqRNNGPpE059+TW1J3qAOiTn/xkPPvss93Gzj777Nhrr73iyiuv3Cj8AQAAAGBjqQ6A6urqYr/99us21r9//2hoaNhoHAAAAIBNK4vHwAMAAADQc6leAbQpM2fOLHUJAAAAAGXFCiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAAAAZV1XqAgCgJ9o7OmN5W3ssW9ceO33ksFjW3hFDKyujqsK/bQAAwPsJgAAoO6359fHI2yviX/7wSqzt6IyIiP5VlXHFQbvGIcMGR7+qyhJXCAAA6eKfSQEoOwtXr4tvPv2nrvAnImLN+o6Y8uRL8eaadSWsDAAA0kkABEBZWbe+I37+pzc2uS2JiF++8la0vScYAgAABEAAlJl1HZ3x+pq1m93+2qrWaOvoKGJFAACQfgIgAMpK38qK2KWu/2a37zawf/StdA8gAAB4LwEQAGWlb1VlnLr7jpHbxLbKXMRJuzRGn0p/vAEAwHv5DRmAsrNT/75x3Uf3ioF9/udhlkNqqmPqIXtHY/+aElYGAADp5DHwAJSdvlWVccjwwfGjow6MP7flY21ra4wcVB9D+9VERW5Ta4MAAGD7ZgUQAGWpMpeLYf1qYkz/mlgw+9EYXF0p/AEAgM0QAAEAAABknAAIAAAAIOMEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxlWVugAAgKz4c1s+2js6omm33UtdCgBAN6leATR16tT4yEc+EnV1dTFs2LD4zGc+E/PmzSt1WQAA3axsy8fDi5bFFY+9EF988Jn42Z87Y96qtbEmv77UpQEARETKA6AHH3wwzj///Hjssceiubk51q9fHxMnTow1a9aUujQAgIiIaF2/Pu6Yvyi+Nnte/GnlmmjJr485y1rigoefi6eXrozOJCl1iQAA6b4E7N577+32evr06TFs2LB46qmn4sgjjyxRVQAA/2NFWz7+809vbHLbd595NfYaNCB26FdT5KoAALpLdQD0fitXroyIiCFDhmx2n7a2tmhra+t63dLSEhER+Xw+8vl8YQsskA11l2v9ZI+eJE30I6X2+uq10bGZRT7L2/Kxsj0fg6pSveiaDPMZSZroR9ImCz25NbXnkqQ81iUnSRKf/vSnY8WKFfHQQw9tdr/JkyfHlClTNhq/9dZbo7a2tpAlAgDbmcrKymg4cGxcPefVze5z00d2i1eeeLSIVQEA24vW1tY49dRTY+XKlVFfX7/FfcsmADr//PPjt7/9bTz88MOx0047bXa/Ta0AampqiqVLl/7Vb0Za5fP5aG5ujgkTJkR1dXWpywE9SaroR0ptWXtHnD1zbqzt6Nxo25i62vjnQ/eK+qrKElQGPiNJF/1I2mShJ1taWmLo0KEfKAAqi0vALrzwwrjrrrti1qxZWwx/IiJqamqipmbj6+yrq6vL9ge6QRbmQLboSdJEP1IqDRWV8bWD94ivP/FivDcC6ldZEf/fh3eLhn59S1YbbOAzkjTRj6RNOffk1tSd6gAoSZK48MIL484774yZM2fGmDFjSl0SAEA31ZUVMXaHgTF9/EHxu4VL4rXVa2Ofun7xyVHDY3h/4Q8AkA6pDoDOP//8uPXWW+M3v/lN1NXVxeLFiyMiYuDAgdGvX78SVwcA8K6aysrYua42zt1n52jLr4/Zjz8WO+y+Y1TmcqUuDQAgIiJS/UiKH/zgB7Fy5coYN25cjBw5suvr9ttvL3VpAAAbyeVyUZmLWL58ealLAQDoJtUrgMrk/tQAAAAAqZbqFUAAAAAAbDsBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZJwACAAAACDjBEAAAAAAGScAAgAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAAAAZJwACAAAAyDgBEAAAAEDGCYAAAAAAMk4ABAAAAJBxZREAff/7348xY8ZE37594+CDD46HHnqo1CUBAAAAlI3UB0C33357XHLJJfHVr3415syZEx//+Mdj0qRJsXDhwlKXBgAAAFAWUh8A3XDDDXHOOefEF7/4xdh7771j2rRp0dTUFD/4wQ9KXRoAAABAWagqdQFb0t7eHk899VRcddVV3cYnTpwYjzzyyCbf09bWFm1tbV2vV65cGRERy5cvj3w+X7hiCyifz0dra2ssW7YsqqurS10O6ElSRT+SNnqSNNGPpIl+JG2y0JOrVq2KiIgkSf7qvqkOgJYuXRodHR0xfPjwbuPDhw+PxYsXb/I9U6dOjSlTpmw0PmbMmILUCAAAAFBKq1atioEDB25xn1QHQBvkcrlur5Mk2Whsg6uvvjouu+yyrtednZ2xfPnyaGho2Ox70q6lpSWampri9ddfj/r6+lKXA3qSVNGPpI2eJE30I2miH0mbLPRkkiSxatWqaGxs/Kv7pjoAGjp0aFRWVm602mfJkiUbrQraoKamJmpqarqNDRo0qFAlFlV9fX3ZNiXZpCdJE/1I2uhJ0kQ/kib6kbQp9578ayt/Nkj1TaD79OkTBx98cDQ3N3cbb25ujsMPP7xEVQEAAACUl1SvAIqIuOyyy+L000+PsWPHxmGHHRY333xzLFy4ML785S+XujQAAACAspD6AOiUU06JZcuWxbXXXhuLFi2K/fbbL+65557YeeedS11a0dTU1MQ111yz0aVtUCp6kjTRj6SNniRN9CNpoh9Jm+2tJ3PJB3lWGAAAAABlK9X3AAIAAABg2wmAAAAAADJOAAQAAACQcQIgAAAAgIwTABXJ1KlT4yMf+UjU1dXFsGHD4jOf+UzMmzev2z5JksTkyZOjsbEx+vXrF+PGjYvnn3++a/vy5cvjwgsvjD333DNqa2tj1KhRcdFFF8XKlSu79lmwYEGcc845MWbMmOjXr1/suuuucc0110R7e3vR5kr6FasfIyJOOOGEGDVqVPTt2zdGjhwZp59+erz11ltFmSfloZj9uEFbW1scdNBBkcvlYu7cuYWcHmWomD05evToyOVy3b6uuuqqosyT8lDsz8jf/va3ccghh0S/fv1i6NChceKJJxZ8jpSXYvXkzJkzN/p83PA1e/bsos2XdCvmZ+RLL70Un/70p2Po0KFRX18fH/vYx2LGjBlFmWevSSiKo48+Opk+fXry3HPPJXPnzk2OPfbYZNSoUcnq1au79vn2t7+d1NXVJf/1X/+VPPvss8kpp5ySjBw5MmlpaUmSJEmeffbZ5MQTT0zuuuuu5OWXX05+//vfJ7vvvnvy2c9+tusYv/vd75Kzzjorue+++5JXXnkl+c1vfpMMGzYsufzyy4s+Z9KrWP2YJElyww03JI8++miyYMGC5P/+3/+bHHbYYclhhx1W1PmSbsXsxw0uuuiiZNKkSUlEJHPmzCnGNCkjxezJnXfeObn22muTRYsWdX2tWrWqqPMl3YrZj//n//yfZPDgwckPfvCDZN68ecmLL76Y/OpXvyrqfEm/YvVkW1tbt8/GRYsWJV/84heT0aNHJ52dnUWfN+lUzM/I3XbbLfmbv/mb5A9/+EPy0ksvJeedd15SW1ubLFq0qKhz3hYCoBJZsmRJEhHJgw8+mCRJknR2diYjRoxIvv3tb3fts27dumTgwIHJD3/4w80e55e//GXSp0+fJJ/Pb3af73znO8mYMWN6r3gyp5j9+Jvf/CbJ5XJJe3t7702ATCl0P95zzz3JXnvtlTz//PMCID6QQvbkzjvvnHz3u98tWO1kT6H6MZ/PJzvuuGPy4x//uLATIHOK9Xtke3t7MmzYsOTaa6/t3QmQKYXqx3feeSeJiGTWrFld+7S0tCQRkfz3f/93gWbT+1wCViIblpMNGTIkIiLmz58fixcvjokTJ3btU1NTE0cddVQ88sgjWzxOfX19VFVVbXGfDeeBTSlWPy5fvjx+/vOfx+GHHx7V1dW9OAOypJD9+Pbbb8eXvvSl+NnPfha1tbUFmgFZU+jPyOuvvz4aGhrioIMOiuuuu85l22xRofrx6aefjjfffDMqKiriQx/6UIwcOTImTZrU7TIJ2JRi/R551113xdKlS+Oss87qveLJnEL1Y0NDQ+y9997xH//xH7FmzZpYv359/Nu//VsMHz48Dj744ALOqHcJgEogSZK47LLL4ogjjoj99tsvIiIWL14cERHDhw/vtu/w4cO7tr3fsmXL4h//8R/j3HPP3ey5Xnnllbjxxhvjy1/+ci9VT9YUox+vvPLK6N+/fzQ0NMTChQvjN7/5TS/PgqwoZD8mSRJnnXVWfPnLX46xY8cWaAZkTaE/Iy+++OK47bbbYsaMGXHBBRfEtGnT4rzzzivATMiCQvbjq6++GhERkydPjq997Wtx9913x+DBg+Ooo46K5cuXF2I6ZEAx/17zk5/8JI4++uhoamrqperJmkL2Yy6Xi+bm5pgzZ07U1dVF375947vf/W7ce++9MWjQoMJMqAA2v2yEgrngggvimWeeiYcffnijbblcrtvrJEk2GouIaGlpiWOPPTb22WefuOaaazZ5nrfeeiuOOeaYOPnkk+OLX/xi7xRP5hSjH6+44oo455xz4rXXXospU6bEGWecEXffffcmj8X2rZD9eOONN0ZLS0tcffXVvV84mVXoz8hLL720678POOCAGDx4cJx00kldq4LgvQrZj52dnRER8dWvfjU++9nPRkTE9OnTY6eddopf/epXW/yLOduvYv295o033oj77rsvfvnLX/ZO4WRSIfsxSZI477zzYtiwYfHQQw9Fv3794sc//nEcd9xxMXv27Bg5cmTvT6gArAAqsgsvvDDuuuuumDFjRuy0005d4yNGjIiI2CiFXLJkyUZp5apVq+KYY46JAQMGxJ133rnJS2neeuutGD9+fBx22GFx8803F2AmZEGx+nHo0KGxxx57xIQJE+K2226Le+65Jx577LECzIhyVuh+fOCBB+Kxxx6LmpqaqKqqit122y0iIsaOHRtnnnlmoaZFGSvWZ+R7HXrooRER8fLLL/fGFMiQQvfjhr+87LPPPl1jNTU1scsuu8TChQt7fT6Uv2J+Rk6fPj0aGhrihBNO6OVZkBXF+D3y7rvvjttuuy0+9rGPxYc//OH4/ve/H/369Yuf/vSnBZxZ7xIAFUmSJHHBBRfEHXfcEQ888ECMGTOm2/YxY8bEiBEjorm5uWusvb09HnzwwTj88MO7xlpaWmLixInRp0+fuOuuu6Jv374bnevNN9+McePGxYc//OGYPn16VFT4MdNdMftxU+eOePcx3BBRvH7813/91/jDH/4Qc+fOjblz58Y999wTERG33357XHfddQWcIeWmlJ+Rc+bMiYgom39JpPCK1Y8HH3xw1NTUdHt8cj6fjwULFsTOO+9coNlRjor9GZkkSUyfPj3OOOMM95BkI8Xqx9bW1oiIjf5uXVFR0bWCsiwU7XbT27m///u/TwYOHJjMnDmz26MMW1tbu/b59re/nQwcODC54447kmeffTb53Oc+1+3xdC0tLckhhxyS7L///snLL7/c7Tjr169PkiRJ3nzzzWS33XZLPvGJTyRvvPFGt31gg2L14+OPP57ceOONyZw5c5IFCxYkDzzwQHLEEUcku+66a7Ju3bqSzJ30KVY/vt/8+fM9BYxNKlZPPvLII8kNN9yQzJkzJ3n11VeT22+/PWlsbExOOOGEksybdCrmZ+TFF1+c7Ljjjsl9992XvPjii8k555yTDBs2LFm+fHnR5016FfvP7f/+7/9OIiJ54YUXijpPykOx+vGdd95JGhoakhNPPDGZO3duMm/evOQrX/lKUl1dncydO7ckc+8JAVCRRMQmv6ZPn961T2dnZ3LNNdckI0aMSGpqapIjjzwyefbZZ7u2z5gxY7PHmT9/fpIkSTJ9+vTN7gMbFKsfn3nmmWT8+PHJkCFDkpqammT06NHJl7/85eSNN94o8oxJs2L14/sJgNicYvXkU089lRxyyCHJwIEDk759+yZ77rlncs011yRr1qwp8oxJs2J+Rra3tyeXX355MmzYsKSuri751Kc+lTz33HNFnC3loNh/bn/uc59LDj/88CLNjnJTzH6cPXt2MnHixGTIkCFJXV1dcuihhyb33HNPEWe77XJJ8pfrMQAAAADIJDeHAQAAAMg4ARAAAABAxgmAAAAAADJOAAQAAACQcQIgAAAAgIwTAAEAAABknAAIAAAAIOMEQAAAH8DMmTMjl8vFn//851KXAgCw1XJJkiSlLgIAIG3GjRsXBx10UEybNi0iItrb22P58uUxfPjwyOVypS0OAGArVZW6AACActCnT58YMWJEqcsAAOgRl4ABALzPWWedFQ8++GB873vfi1wuF7lcLm655ZZul4DdcsstMWjQoLj77rtjzz33jNra2jjppJNizZo18dOf/jRGjx4dgwcPjgsvvDA6Ojq6jt3e3h7/8A//EDvuuGP0798/DjnkkJg5c2ZpJgoAbDesAAIAeJ/vfe978dJLL8V+++0X1157bUREPP/88xvt19raGv/6r/8at912W6xatSpOPPHEOPHEE2PQoEFxzz33xKuvvhqf/exn44gjjohTTjklIiLOPvvsWLBgQdx2223R2NgYd955ZxxzzDHx7LPPxu67717UeQIA2w8BEADA+wwcODD69OkTtbW1XZd9vfjiixvtl8/n4wc/+EHsuuuuERFx0kknxc9+9rN4++23Y8CAAbHPPvvE+PHjY8aMGXHKKafEK6+8Er/4xS/ijTfeiMbGxoiI+MpXvhL33ntvTJ8+Pb71rW8Vb5IAwHZFAAQA0EO1tbVd4U9ExPDhw2P06NExYMCAbmNLliyJiIinn346kiSJPfbYo9tx2traoqGhoThFAwDbJQEQAEAPVVdXd3udy+U2OdbZ2RkREZ2dnVFZWRlPPfVUVFZWdtvvvaERAEBvEwABAGxCnz59ut28uTd86EMfio6OjliyZEl8/OMf79VjAwBsiaeAAQBswujRo+Pxxx+PBQsWxNKlS7tW8WyLPfbYI0477bQ444wz4o477oj58+fH7Nmz4/rrr4977rmnF6oGANg0ARAAwCZ85StficrKythnn31ihx12iIULF/bKcadPnx5nnHFGXH755bHnnnvGCSecEI8//ng0NTX1yvEBADYllyRJUuoiAAAAACgcK4AAAAAAMk4ABAAAAJBxAiAAAACAjBMAAQAAAGScAAgAAAAg4wRAAAAAABknAAIAAADIOAEQAAAAQMYJgAAAAAAyTgAEAAAAkHECIAAAAICMEwABAAAAZNz/A6n4MWtvlg5dAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tlca.plot_dynamic_characterized_inventory()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For most of the functions we used here, there are numerous optional arguments and settings you can tweak. We explore some of them in our other [Examples](../examples/index.md), but when in doubt: Our code is pretty well documented and there are [docstrings](../api/index) everywhere - so please use them ☀️" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "timex", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}