From ee04279a8381492bece8b887672326e994f863f5 Mon Sep 17 00:00:00 2001 From: Henry Wilde Date: Thu, 24 Oct 2024 16:02:47 +0100 Subject: [PATCH] `StableMarriage` rank internals (#175) * Write init test for new single matching * Move to ruff over black for formatting * Remove limit on parallel CI * Write test for SingleMatching repr dunder method * Check dictionary is in single matching repr * Write test for equivalence dunder * Write test for single matching inverter * Remove old SingleMatching tests * Implement SingleMatching class * Move matching classes to subpackage * Write test for instantiating SM classes * Fix ruff config and add pre-commit * Write tests for utility builder * Write test for preference list builder (slow!) * Reduce test size for preference builder * Implement builders for SM * Write input validator tests * Implement input validator * Ensure higher utility leads to higher ranking * Reintegrate tests into modular structure * Translate SM algorithm test to rankings * Write test for player set attribute inverter * Move rank matrices to class attributes * Write tests for solver * Implement solver and algorithm * Rewrite preference converter test * Write test for converting incomplete preferences * Reimplement preference converter * Include preference lookup in attributes * Write optimality tests * Rewrite example tests * Ensure rejections are recorded * Write test for preference matching converter * Revert example tests to use preference terms * Implement a preference matching converter * Reformat code base and drop deprecated np.infty * Bump actions and drop support for Python<3.10 * Stop doctesting paper and fix examples in README * Update all docs that SM touches * Remove creation from instances how-to * Remove SM solver test module * Wrap SR tutorial solution with `dict()` for now The changes to `SingleMatching` are causing issues downstream. Still not sure what this will look like for SR in the future, but this will do for now. * Make small formatting changes * Add in manual matching update for SR test Again, the new `SingleMatching` class is causing issues for SR... * Remove change to SM discussion * Stop rejections leading to immediate forget --- .github/workflows/ci.yml | 14 +- .github/workflows/docs.yml | 8 +- .pre-commit-config.yaml | 18 + CITATION.cff | 2 +- README.md | 46 +-- _quarto.yml | 6 +- docs/discussion/stable_marriage.md | 6 +- docs/how-to/choose_optimality.ipynb | 14 +- docs/how-to/create_from_instances.ipynb | 90 ----- docs/tutorials/hospital_resident.ipynb | 15 +- docs/tutorials/stable_marriage.ipynb | 103 ++--- docs/tutorials/stable_roommates.ipynb | 15 +- docs/tutorials/student_allocation.ipynb | 24 +- pyproject.toml | 26 +- src/matching/algorithms/__init__.py | 2 - src/matching/algorithms/stable_marriage.py | 64 --- src/matching/convert.py | 17 +- src/matching/games/stable_marriage.py | 378 ++++++++++++------ src/matching/matchings/__init__.py | 6 + .../{matchings.py => matchings/multiple.py} | 32 +- src/matching/matchings/single.py | 65 +++ tests/hospital_resident/data/issue_159.json | 2 +- tests/hospital_resident/test_algorithm.py | 2 +- tests/matchings/test_single.py | 106 +++++ tests/stable_marriage/strategies.py | 113 ++++++ tests/stable_marriage/test_algorithm.py | 75 ++-- tests/stable_marriage/test_examples.py | 96 ++--- tests/stable_marriage/test_game.py | 316 +++++++++++++++ tests/stable_marriage/test_solver.py | 192 --------- tests/stable_roommates/test_solver.py | 9 + tests/student_allocation/test_algorithm.py | 2 +- tests/test_convert.py | 35 +- tests/test_matchings.py | 42 +- tex/stable_marriage.tex | 12 +- 34 files changed, 1123 insertions(+), 830 deletions(-) create mode 100644 .pre-commit-config.yaml delete mode 100644 docs/how-to/create_from_instances.ipynb delete mode 100644 src/matching/algorithms/stable_marriage.py create mode 100644 src/matching/matchings/__init__.py rename src/matching/{matchings.py => matchings/multiple.py} (51%) create mode 100644 src/matching/matchings/single.py create mode 100644 tests/matchings/test_single.py create mode 100644 tests/stable_marriage/strategies.py create mode 100644 tests/stable_marriage/test_game.py delete mode 100644 tests/stable_marriage/test_solver.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ca15859..59935c2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,17 +14,16 @@ jobs: run: shell: bash strategy: - max-parallel: 10 matrix: os: [ubuntu-latest, windows-latest] - python-version: [3.7, 3.8, 3.9, "3.10", "3.11"] + python-version: ["3.10", "3.11", "3.12"] steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} cache: "pip" @@ -37,16 +36,15 @@ jobs: - name: Run tests run: | python -m doctest README.md - python -m doctest paper.md python -m pytest docs --nbval --nbval-current-env -p no:randomly python -m pytest tests \ --cov=matching --cov-fail-under=100 --hypothesis-profile=ci - - name: Install and run linters (3.11-ubuntu only) + - name: Install and run linters (3.12-ubuntu only) if: | - matrix.python-version == '3.11' && + matrix.python-version == '3.12' && matrix.os == 'ubuntu-latest' run: | python -m pip install ".[lint]" - python -m black --check . python -m ruff check . + python -m ruff format --check . diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index b2fc4a8..6903968 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -12,13 +12,13 @@ jobs: contents: write steps: - name: Check out repository - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Set up Quarto uses: quarto-dev/quarto-actions/setup@v2 - name: Install Python and dependencies - uses: actions/setup-python@v4 + uses: actions/setup-python@v5 with: - python-version: "3.9" + python-version: "3.12" cache: "pip" - run: | python -m pip install ".[dev]" @@ -28,4 +28,4 @@ jobs: with: target: gh-pages env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..21d9761 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,18 @@ +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.6.0 + hooks: + - id: check-added-large-files + name: Check for files larger than 5 MB + args: [ "--maxkb=5120" ] + - id: end-of-file-fixer + name: Check for a blank line at the end of scripts (auto-fixes) + exclude: '\.Rd' + - id: trailing-whitespace + name: Check for trailing whitespaces (auto-fixes) + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.7.0 + hooks: + - id: ruff + args: [ --fix ] + - id: ruff-format diff --git a/CITATION.cff b/CITATION.cff index 594d326..024243d 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -27,4 +27,4 @@ keywords: - matching - python - game -license: MIT \ No newline at end of file +license: MIT diff --git a/README.md b/README.md index d21fcc4..6cb4767 100644 --- a/README.md +++ b/README.md @@ -76,60 +76,42 @@ We can construct these preferences using dictionaries: Then to solve this matching game, we make use of the `StableMarriage` class, like so: - ```python >>> from matching.games import StableMarriage ->>> game = StableMarriage.create_from_dictionaries( +>>> game = StableMarriage.from_preferences( ... suitor_preferences, reviewer_preferences ... ) ->>> game.solve() -{A: E, B: D, C: F} +>>> matching = game.solve() +>>> dict(matching) +{'F': 'C', 'D': 'B', 'E': 'A'} ``` ## The `Matching` object -This matching is not a standard Python dictionary, though it does +The matching itself is not a standard Python dictionary, though it does largely look and behave like one. It is in fact an instance of the `SingleMatching` class: ```python ->>> matching = game.matching >>> type(matching) - + +>>> isinstance(matching, dict) +True +>>> matching +SingleMatching({'F': 'C', 'D': 'B', 'E': 'A'}, keys="reviewers", values="suitors") ``` -This dictionary-like object is primarily useful as a teaching device -that eases the process of manipulating a matching after a solution has -been found. - -## `Player` classes - -Despite passing dictionaries of strings here, the matching displays -instances of `matching.player.Player`: +This object allows for straightforward manipulation of the underlying +dictionary, for instance by inverting it: ```python ->>> matching = game.matching ->>> for suitor in matching: -... print(type(suitor)) - - - +>>> dict(matching.invert()) +{'C': 'F', 'B': 'D', 'A': 'E'} ``` -This is because `create_from_dictionaries` creates instances of the -appropriate player classes first and passes them to the game class. -Using dictionaries like this can be an efficient way of creating large -games but it does require the names of the players in each party to be -unique. - -With all games, Matching uses a `Player` class to represent the members -of the "applying" party, i.e. residents and students. For HR and SA, -there are specific classes to represent the roles of `Hospital`, -`Project` and `Supervisor`. - ## A note on performance One of the limitations of this library is the time complexities of the diff --git a/_quarto.yml b/_quarto.yml index 73c74a5..6621cb9 100644 --- a/_quarto.yml +++ b/_quarto.yml @@ -34,7 +34,7 @@ website: contents: docs/discussion - title: reference contents: docs/reference - + page-footer: left: > @@ -53,7 +53,7 @@ bibliography: docs/assets/bibliography.bib toc: true -metadata-files: +metadata-files: - docs/_sidebar.yml quartodoc: @@ -61,7 +61,7 @@ quartodoc: package: matching dir: docs/reference sidebar: docs/_sidebar.yml - + sections: - title: Games desc: Objects for handling game instances. diff --git a/docs/discussion/stable_marriage.md b/docs/discussion/stable_marriage.md index f18ed4c..60bec78 100644 --- a/docs/discussion/stable_marriage.md +++ b/docs/discussion/stable_marriage.md @@ -91,10 +91,10 @@ efficient, robust extension of the original algorithm, taken from @GI89, is given below. 0. Assign all suitors and reviewers to be unmatched. -1. Take any suitor $s$ that is not currently matched, and consider - their favourite reviewer $r$. +1. Take any suitor $s$ that is not currently matched but has a non-empty + preference list, and consider their favourite reviewer $r$. 2. If $r$ is matched, get their current match $s' = M^{-1}(r)$ and - unmatch the pair. + unmatch them. 3. Match $s$ and $r$, i.e. set $M(s) = r$. 4. For each successor, $t$, to $s$ in $g(r)$, delete the pair $(t, r)$ from the game by removing $r$ from $f(t)$ and $t$ from $g(r)$. diff --git a/docs/how-to/choose_optimality.ipynb b/docs/how-to/choose_optimality.ipynb index c8db482..9d78354 100644 --- a/docs/how-to/choose_optimality.ipynb +++ b/docs/how-to/choose_optimality.ipynb @@ -47,7 +47,7 @@ { "data": { "text/plain": [ - "{A: X, B: Z, C: Y}" + "SingleMatching({'Y': 'C', 'Z': 'B', 'X': 'A'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 2, @@ -56,7 +56,7 @@ } ], "source": [ - "game = StableMarriage.create_from_dictionaries(\n", + "game = StableMarriage.from_preferences(\n", " suitor_preferences, reviewer_preferences\n", ")\n", "\n", @@ -71,7 +71,7 @@ { "data": { "text/plain": [ - "{A: Y, B: Z, C: X}" + "SingleMatching({'Y': 'A', 'Z': 'B', 'X': 'C'}, keys=\"reviewers\", values=\"suitors\")" ] }, "execution_count": 3, @@ -80,7 +80,7 @@ } ], "source": [ - "game = StableMarriage.create_from_dictionaries(\n", + "game = StableMarriage.from_preferences(\n", " suitor_preferences, reviewer_preferences\n", ")\n", "\n", @@ -90,9 +90,9 @@ ], "metadata": { "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -104,7 +104,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/docs/how-to/create_from_instances.ipynb b/docs/how-to/create_from_instances.ipynb deleted file mode 100644 index 5227249..0000000 --- a/docs/how-to/create_from_instances.ipynb +++ /dev/null @@ -1,90 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Create a game from `Player` instances\n", - "\n", - "Any game in Matching can be made by manually creating instances of the `Player` class (or its child classes) and setting their preferences using those instances.\n", - "\n", - "Consider the following instance of SM." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from matching import Player\n", - "\n", - "suitors = [Player(name=\"A\"), Player(name=\"B\"), Player(name=\"C\")]\n", - "reviewers = [Player(name=\"D\"), Player(name=\"E\"), Player(name=\"F\")]\n", - "\n", - "(A, B, C), (D, E, F) = suitors, reviewers" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The preferences are then set using the `set_prefs` method of whichever `Player` class you're using." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "A.set_prefs([D, E, F])\n", - "B.set_prefs([D, F, E])\n", - "C.set_prefs([F, D, E])\n", - "\n", - "D.set_prefs([B, C, A])\n", - "E.set_prefs([A, C, B])\n", - "F.set_prefs([C, B, A])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, the game can be made by passing the lists of players directly." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from matching.games import StableMarriage\n", - "\n", - "game = StableMarriage(suitors, reviewers)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "matching-docs", - "language": "python", - "name": "matching-docs" - }, - "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.8.16" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/docs/tutorials/hospital_resident.ipynb b/docs/tutorials/hospital_resident.ipynb index 8d48746..d136dba 100644 --- a/docs/tutorials/hospital_resident.ipynb +++ b/docs/tutorials/hospital_resident.ipynb @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -225,13 +225,6 @@ "unmatched_residents" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, @@ -245,9 +238,9 @@ ], "metadata": { "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -259,7 +252,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/docs/tutorials/stable_marriage.ipynb b/docs/tutorials/stable_marriage.ipynb index a172ca2..b4aa2ef 100644 --- a/docs/tutorials/stable_marriage.ipynb +++ b/docs/tutorials/stable_marriage.ipynb @@ -27,74 +27,40 @@ "From here on out, we'll refer to the men and women as suitors and reviewers,\n", "respectively.\n", "\n", - "## Creating the players and their preferences\n", + "## Defining the players and their preferences\n", "\n", - "To begin, we create an instance of the `Player` class for each suitor and\n", - "reviewer:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from matching import Player\n", - "\n", - "suitors = [\n", - " Player(\"Bingley\"),\n", - " Player(\"Collins\"),\n", - " Player(\"Darcy\"),\n", - " Player(\"Wickham\"),\n", - "]\n", - "\n", - "reviewers = [\n", - " Player(\"Charlotte\"),\n", - " Player(\"Elizabeth\"),\n", - " Player(\"Jane\"),\n", - " Player(\"Lydia\"),\n", - "]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To set a player's preferences, we use the `Player.set_prefs()` method.\n", - "\n", - "Each player's preferences must be a list of all the `Player` instances in the\n", - "other party ordered according to how much they like them.\n", - "That is, put your favourite first, followed by your second,\n", - "and so on until you've put your least favourite last.\n", + "To begin, we create a dictionary of preference lists for the suitors and reviewers respectively.\n", + "These preference lists are ordered so your favourite comes first, then your second favourite, and\n", + "so on.\n", "\n", - "::: {.callout-warning}\n", - "The preference lists below are based on\n", - "some very loose interpretations of the original text\n", - "and the need to create full lists.\n", - "Please do not come for me about them.\n", - ":::\n", + "::: {.callout-note}\n", + "These preference lists are based purely on my interpretation of two adaptations of the book:\n", + "Gurinder Chadha's 2004 Bollywood-style adaptation, Bride and Prejudice, and Joe Wright's 2006 film,\n", + "starring Keira Knightley.\n", "\n", - "A nice way to do this is by unpacking `suitors` and `reviewers`:" + "I cannot and will not speak for Austen's intentions.\n", + ":::" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "bingley, collins, darcy, wickham = suitors\n", - "charlotte, elizabeth, jane, lydia = reviewers\n", + "suitors = {\n", + " \"Bingley\": (\"Jane\", \"Elizabeth\", \"Lydia\", \"Charlotte\"),\n", + " \"Collins\": (\"Jane\", \"Elizabeth\", \"Lydia\", \"Charlotte\"),\n", + " \"Darcy\": (\"Elizabeth\", \"Jane\", \"Charlotte\", \"Lydia\"),\n", + " \"Wickham\": (\"Lydia\", \"Jane\", \"Elizabeth\", \"Charlotte\"),\n", + "}\n", "\n", - "bingley.set_prefs([jane, elizabeth, lydia, charlotte])\n", - "collins.set_prefs([elizabeth, jane, lydia, charlotte])\n", - "darcy.set_prefs([elizabeth, jane, charlotte, lydia])\n", - "wickham.set_prefs([lydia, jane, elizabeth, charlotte])\n", - "\n", - "charlotte.set_prefs([collins, darcy, bingley, wickham])\n", - "elizabeth.set_prefs([wickham, darcy, bingley, collins])\n", - "jane.set_prefs([bingley, wickham, darcy, collins])\n", - "lydia.set_prefs([wickham, bingley, darcy, collins])" + "reviewers = {\n", + " \"Charlotte\": (\"Bingley\", \"Darcy\", \"Collins\", \"Wickham\"),\n", + " \"Elizabeth\": (\"Wickham\", \"Darcy\", \"Bingley\", \"Collins\"),\n", + " \"Jane\": (\"Bingley\", \"Wickham\", \"Darcy\", \"Collins\"),\n", + " \"Lydia\": (\"Bingley\", \"Wickham\", \"Darcy\", \"Collins\"),\n", + "}" ] }, { @@ -103,19 +69,19 @@ "source": [ "## Running the game\n", "\n", - "With our now complete `Player` instances,\n", - "we pass the lists of players to the `StableMarriage` class to create a game:" + "We create the game by passing our preference list dictionaries to the\n", + "`StableMarriage.from_preferences()` class method:" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from matching.games import StableMarriage\n", "\n", - "game = StableMarriage(suitors, reviewers)" + "game = StableMarriage.from_preferences(suitors, reviewers)" ] }, { @@ -127,16 +93,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{Bingley: Jane, Collins: Charlotte, Darcy: Elizabeth, Wickham: Lydia}" + "SingleMatching({'Lydia': 'Wickham', 'Elizabeth': 'Darcy', 'Jane': 'Bingley', 'Charlotte': 'Collins'}, keys=\"reviewers\", values=\"suitors\")" ] }, - "execution_count": 9, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -156,13 +122,10 @@ } ], "metadata": { - "interpreter": { - "hash": "a8c967c2db996a903b0ac2ddddd52d1718dfee8994011f28d022363595a494ba" - }, "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -174,7 +137,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/docs/tutorials/stable_roommates.ipynb b/docs/tutorials/stable_roommates.ipynb index 1f07d94..e1f3154 100644 --- a/docs/tutorials/stable_roommates.ipynb +++ b/docs/tutorials/stable_roommates.ipynb @@ -100,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -109,13 +109,13 @@ "{jerry: george, george: jerry, kramer: elaine, elaine: kramer}" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "game.solve()" + "dict(game.solve())" ] }, { @@ -129,13 +129,10 @@ } ], "metadata": { - "interpreter": { - "hash": "a8c967c2db996a903b0ac2ddddd52d1718dfee8994011f28d022363595a494ba" - }, "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -147,7 +144,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/docs/tutorials/student_allocation.ipynb b/docs/tutorials/student_allocation.ipynb index 2a8fb77..303114a 100644 --- a/docs/tutorials/student_allocation.ipynb +++ b/docs/tutorials/student_allocation.ipynb @@ -1083,7 +1083,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1117,7 +1117,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 27, @@ -1126,7 +1126,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACAoAAASUCAYAAADk0n3YAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAC4jAAAuIwF4pT92AADO0ElEQVR4nOzdeXiU5b0//s9AAgHCKqsiIAoKuEBVRGoVFHdaq8UVELEurdZTbT3axYrYql9ra491aesG4lL3BcVdUUGKiruAICqgCLITdgiZ3x/+TBkSIAkhk/i8XteV68xz514+w2TGq+d5z32n0ul0OgAAAAAAAACARKiV7QIAAAAAAAAAgKojKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAADXYK6+8EqlUKuPnlVdeyXZZJMAZZ5yR8XfXoUOHajmO8pk5c2aJz5SRI0dmuywAAKCS5WS7AAAAgOqssLAwpkyZElOnTo2lS5fG0qVLY8OGDdGgQYPIz8+Ptm3bRocOHaJDhw5Rt27dbJcLAAAAAFslKAAAALCJtWvXxmOPPRZ33nlnjB8/PlavXr3VMbm5ubHnnnvG/vvvH4ccckgcccQR0bx58yqoFgAAAADKx9EDAAAAGxk9enTstttuceqpp8YLL7xQppBARMT69evj3XffjVtvvTUGDhwYrVq1iv/5n//ZztUClN0VV1xRYkt5vhs2fV2vuOKKbJcEAABUc3YUAAAAiIh0Oh3nn39+/OMf/6iU+YqKimL27NmVMhcAAAAAVCZBAQAAgIj42c9+Frfeemupv2vXrl0ceuih0a1bt2jRokU0aNAgVqxYEUuWLIlPPvkk3n777Xj//fdj7dq1VVw1AAAAAJSfoAAAAJB4jz/+eKkhge9973vx5z//OQ499NCtbtG9atWqePbZZ+Oxxx6Lxx57LFauXLm9yoUMffr0iXQ6ne0ySKCRI0fGyJEjv7PrJVWHDh18pgAAQAIICgAAAImWTqfjoosuKtF+wgknxH333Rd169Yt0zz169ePE044IU444YRYtmxZjBgxIubMmVPZ5QIAAADANhMUAAAAEm3ChAkxc+bMjLaddtopRo4cWeaQwKYaN24cF1544bYXBwAAAADbQa1sFwAAAJBNzzzzTIm2M844Ixo2bJiFagAAAABg+7OjAAAAkGizZs0q0bbvvvtmoZLqbc2aNfHGG2/Exx9/HEuWLInc3NzYcccdo3PnzvG9730vUqnUdlm3oKAg3nzzzfj6669jwYIFsWbNmmjevHm0aNEi9ttvv9hpp522y7obmz9/fkyaNCk+//zzWLZsWaRSqWjevHkcf/zx0bx58+2+flX6+uuv4/33349Zs2ZFQUFBrF69OvLy8qJ+/frRunXr6NChQ3Tu3Dny8/MrZb0NGzbEO++8E59//nksWLAgli1bFs2aNYsWLVpE586dY6+99qqUdbYmSa8x3/zdffLJJ/Hhhx/GggULoqCgIDZs2BD169ePRo0axc477xy77LJL7LrrrlGr1rZ9x2bdunUxY8aM+Pjjj2PevHlRUFAQERHNmjWLZs2axV577RW77757ZTytaq26vNcXLFgQEydOjM8++yxWrFgRjRs3jpYtW8YBBxwQ7du3r5IaAACg2kgDAAAk2BFHHJGOiIyf5557rsrW//zzz0usP2LEiArNdcghh2TMc8ghh2x1zNixY0usP3bs2OLff/rpp+mhQ4em69evX6Lftz/t2rVL//73v0+vWLGiQnVvas2aNekbb7wx/YMf/CCdk5Oz2XUjIt21a9f01VdfnV6+fHm519nSv1dRUVH63nvvTffq1SudSqVKXXvs2LHptWvXpnfYYYeM9u7du2/zv8HVV19dYr0xY8aU2ndrr+HWLFmyJH3VVVelu3btusV/629/ateund5nn33SF154YXr8+PHpoqKicj+/t956K33KKaekmzVrtsW1dtxxx/TZZ5+dnjFjRrnXSKcr5zWuTMOGDSuxRkWU53Nj03+Divxsbu4hQ4Zk9Gvfvn2Z6q/qcd+aNGlS+qc//Wm6cePGZXrejRo1Svfr1y/9t7/9Lf3FF1+UeZ133303PWzYsPTBBx+crlu37lbXadGiRXro0KHpyZMnl3mN0t735f3Z3L9fZf53qTq819Ppb/69Dj/88HStWrU2W0PXrl3T99xzT4U+0wAAoCZy9AAAAJBoeXl5JdpK22UgiUaMGBF77rlnjBgxIlatWrXZfrNnz46rrroqunbtGi+99NI2rXnvvfdGp06d4oILLohx48ZFYWHhFvtPmTIlfve730XHjh3jgQce2Ka1v/X1119Hnz59YuDAgTFx4sRIp9Ob7VunTp047bTTMtree++9eO+997aphrvuuivjuk2bNnHkkUdu05yleeihh6Jz587x+9//PqZMmVKmMRs2bIj3338//u///i8OOuigmDZtWpnXW7hwYZxyyinRs2fPuP/++2Px4sVb7P/VV1/FbbfdFl26dIlf/vKXsXbt2jKvtSXleY2p+dauXRvnnntu9OzZM+64445YtmxZmcYVFBTEiy++GBdddFEMGDBgq/0//vjj2H333aNHjx4xfPjweO2118r0N7tgwYLiz9uzzz670v7Os6m6vNfXrl0bZ599dvTt2zdeeOGFKCoq2mzfKVOmxKBBg+Koo46KlStXVsr6AABQnQkKAAAAida6desSbQ8++GAWKqle/vGPf8SZZ54Zq1evLvOY2bNnxzHHHBNjxowp93pFRUVx0UUXxaBBg+KLL74o9/gFCxbEKaecEsOGDSv32I3NmzcvevfuHa+99lqZxwwdOrRE24gRIypcw4QJE0rcfD/99NOjdu3aFZ6zNLfffnucfPLJsWDBgkqdd3M+++yz6N27dzzwwAPlvjG/fv36+Pvf/x6HH354LFmyZJvqqMhrTM21bt26OPbYY+PWW2/d4k3iyjBv3ryYPn16hcen0+m4/fbb4+CDDy4+oqAmqi7v9TVr1sTRRx8dt99+e7nGPf/883HMMcfEhg0btml9AACo7nKyXQAAAEA29e7dO2699daMthdffDFuvPHGuOCCC7JUVXZNnDgxLrvssuLrnJycOPTQQ6Nfv36x0047xdq1a2PWrFkxevToePfddzPGrlu3Ln7yk5/EK6+8Er169SrzmgMHDoz777+/RPuOO+4Yhx12WPTo0SOaN28eeXl5sXjx4nj33XfjmWeeidmzZ2f0v/LKK6NFixbxi1/8opzP+puwwkknnRSfffZZcVvHjh3j2GOPjT322COaN28eixYtis8//zwefvjh4j49evSI7t27Z+wicN9998Vf/vKXyM3NLXcdI0eOLNFWWhhhW0yfPj1+8YtflLiJV69evTj00ENj//33j/bt20d+fn4UFhZGQUFBzJ07NyZPnhxvvfVWzJw5s1zrzZ8/Pw466KCYO3duid+1bds2TjjhhOjSpUs0a9Ys5s+fH++//3489thjsWjRooy+48aNi379+sWECROibt265X7eFX2Na7Lddtstli5dGhHf3Mj++uuvM36/zz77bHWOZs2abY/SqsQ111xT6k4nO++8cxxxxBHRtWvXaNWqVeTl5cWqVauioKAgZsyYER999FH85z//2aZvljdt2jT233//6NKlS+y6667RqFGjyM/Pj9WrV8fChQtj8uTJ8fzzz5f4HHvzzTfjrLPO2mJoLT8/P+O1e//99zN+36pVq1KDcBvbcccdK/Cstqy6vNcjIs4888wYO3Zs8fXuu+8eRx99dOyxxx7RrFmzWLZsWbz77rvxyCOPlHhfvPbaa/G3v/0tLr744gqtDQAANUI2zz0AAADItvnz56fr1atX6nnFP/zhD9Pjxo3brutX5lnQWzujuTSlnXOdl5dX/PjAAw9Mf/zxx5sd//TTT6d32mmnEnPsscce6TVr1pSp7uuvv77E+LZt26YffPDBdGFh4WbHrV+/Pn3bbbel8/PzM8bWqVMnPWnSpK2uu+m/V+3atYsf77DDDulRo0Zt9qzqoqKijOd3ww03lHgOjzzySJme/8ZWrVqVbtSoUcY8vXv33uKY0l7DsWPHbnHMT3/60xJjBg0alJ4/f36Z6pw8eXJ6+PDh6Z122ik9derULfYtKipKH3300SXWq1evXvr666/f7Gu8atWq9P/+7/+Weqb4hRdeWKY6K/M1rgzDhg0r8VwqoqKfG5W1/reGDBlSpjPvszVu9erVJT4f6tevn77zzjvTGzZs2Op6a9asST///PPpU089NX3wwQdvtf/YsWPTrVu3Tv/mN79Jv/HGG2Vao6ioKD1mzJh0p06dSrw2Dz300FbHf2vTscOGDSvz2E1V9O+rOr3XN/7vWOvWrbf4b7l8+fL06aefXmLtJk2apFetWlWm9QEAoCZy9AAAAJBoW/r2+ZNPPhk/+MEPom3btnHmmWfGbbfdFu+//34UFhZWcZVVa82aNRER0adPn3j55Zdj991332zfo48+Ol577bUS30z9+OOP489//vNW1/roo4/i0ksvzWjr1atXfPTRR3HiiSducbv9nJycOOuss2L8+PHRqFGj4vZ169Zl7IhQVt9uM92qVat47bXXYvDgwZFKpUrtm0qlMr7lOnDgwKhTp05Gn9J2BtiaRx99tMSW45W9m0BExBNPPJFx3bdv3xg1alS0aNGiTOO7du0al19+ecycOTM6duy4xb7//ve/45lnnsloy8vLiyeffDIuuuiizb7G9erViz//+c/xj3/8o8Tvbrjhhpg0aVKZat3YtrzG1DwvvfRSrFixIqPtlltuiaFDh0atWlv/f4nVrVs3Dj/88LjvvvtK/A2XpmfPnvHFF1/ENddcEz179izTGqlUKo455ph44403okePHhm/u/7667c6vjqpTu/1b/871rFjx5g4cWIMGDBgs33z8/Nj5MiRceSRR2a0L126NB555JFyrw0AADWFoAAAAJB4V155ZRx44IGb/f2cOXNixIgRcc4550T37t2jYcOGccABB8T//M//xMMPP1xiy+Lvgh122CEefvjhyMvL22rfjh07xr333lui/ZZbbon169dvcew111yT0adNmzbx9NNPR+PGjctc6z777BO33HJLRtuzzz6bcRRAedx+++3RtWvXco3ZYYcd4oc//GFG2zPPPFPuv40RI0ZkXNevXz9OPvnkcs2xNcuXL4+FCxdmtJ111lmbvWG+JTk5OSUCEpsq7Wbnn//85zjssMPKtMY555wTP/vZzzLa0un0Nt1ErchrTM2z8RETEd/ckB44cGCF5qpfv36Z+uTkVOyUz6ZNm8aoUaMy2v7zn//ElClTKjRfNlS393pubm48+OCD0b59+632TaVSpa7z3HPPVWhtAACoCQQFAACAxMvLy4unn366xI3ezVmzZk28+eabceONN8aJJ54Ybdq0iT59+sSdd95Z/C3Gmu6KK66IHXbYocz9+/TpEz/5yU8y2ubNm1fim+sbmzlzZokzuP/0pz9F06ZNy1dsRJx22mnRqVOnjLbHH3+83PP07ds3+vfvX+5xEd+ch72xwsLCuPvuu8s8fvbs2fHyyy9ntA0YMCAaNmxYoXo2Z/ny5SXayvNal8fEiRPj7bffzmjba6+94vzzzy/XPNdcc02Jv4uKhnS25TWmZtn0b71x48YVvpFfFfbcc8/43ve+l9E2fvz4LFVTPtXxvX7aaafFvvvuW+b+Xbt2LfHvv+lzAgCA7xJBAQAAgIho0qRJPPHEEzFq1KjYbbfdyjU2nU7Hq6++Gj/96U9j9913L/Xb9TVJXl5eDB48uNzjzjnnnBJtW9qu+/HHH884xqFBgwZxyimnlHvdiG++DXr00UdntL366qvlnuenP/1phdaPiDjyyCNLHMFQnuMH7rrrrkin0xlt2+PYgWbNmpXYPWB73Yx84YUXSrSde+65ZdqSfWNNmjSJU089NaNt/fr18corr5S7pm15jalZNg3AfP311zFjxowsVVM2mwaeJk6cmKVKyqc6vtfPPvvsco/p2bNnxvX06dPLPQcAANQUggIAAAD/v1QqFYMHD46pU6fGk08+Gaeeemo0atSoXHPMnj07Bg0aFEOHDo21a9dup0q3rz59+pRr6/9v9evXr8S/15Zucm16I7979+5l2t57c3bZZZeM63fffbfcc/Tt27fC69euXbtEwGLy5Mnx1ltvlWn8XXfdlXHdsWPHOOSQQypcz+bk5eXF3nvvndH2l7/8Zbucxf3666+XaNt054myOumkk8o0/9Zsy2tMzXLAAQdkXKfT6TjllFPiiy++qLIaPv3007j33nvj0ksvjQEDBsQRRxwRvXr1ih49ekT37t1L/Dz//PMZ42fPnl1ltW6L6vZer1evXomb/mWx6667Zlxv2LAhVqxYUe55AACgJqi++60BAABkSU5OTvTv3z/69+8fGzZsiPfeey/Gjx8fkyZNinfeeSemTZsWGzZs2OIcI0eOjJUrV5bYWr8mKM9WzRurVatW7LPPPjFu3LjitqlTp8aqVatKDQBseuNn8uTJ0b179wqtHRGxePHijOtly5bF+vXrIzc3t0zjW7ZsWWJHgPI688wz49prr81oGzlyZOy///5bHPfaa6/Fp59+mtF2xhlnlPjmf2UZOnRoXHjhhcXXa9asiQEDBkSvXr1iyJAh0b9//2jbtu02r/POO+9kXLdt2zZat25dobn23XffqFWrVhQVFW12/q2pjNeYmqN79+7Ro0ePjNDQ22+/HZ07d46TTjopTjrppDj00EOjXr16lbpuUVFR3HHHHXHbbbeVOSi0OUuXLq2coraz6vZeb9++fZk/+zdWWkhu2bJlkZ+fX+65AACguhMUAAAA2ILatWvHvvvum3HzfNWqVfHGG2/E2LFj46GHHoqPP/641LEPPfRQ3HjjjXHBBRdUVbmVYvfdd6/w2D322CMjKJBOp2PhwoXRrl27jH7r1q2LBQsWZLQtXbq00m+KLV68OFq1alWmvmXttyWdO3eO3r17x4QJE4rb/v3vf8f1118fdevW3ey4ESNGZFzXqlUrhgwZss31bM7PfvazuO++++LNN9/MaJ84cWJMnDgxfv7zn8duu+0WBx10UOy3335x0EEHxd57712u4EI6nS4R3ujSpUuFa87Pz4+dd945Zs2aVdy2cOHCcs1RGa8xNcstt9wSffr0ydjhZc2aNTFq1KgYNWpU1KlTJ/bff//o1atXHHDAAXHwwQdv09/J1KlTY+DAgRXa0aQ0y5Ytq5R5tqfq+F5v1qxZhdYuLVywfv36Cs0FAADVnaMHAAAAyql+/frRt2/fuPLKK2Pq1Knx7LPPRrdu3Urt+6c//SlWrVpVxRVum4ocO7ClsaXd/F+0aFGF1yiP1atXl7lveY+Z2JyhQ4dmXC9ZsiSeeOKJzfZfuXJlPPzwwxlthx12WIlwRWWqW7dujBkzJvr167fZPjNmzIiRI0fGL37xi+jevXs0b948Bg8eHE8//XTGN303p6CgoMTOG02aNNmmups2bZpxvenNya2prNeYmqNXr17x1FNPRfPmzUv9/bp16+L111+Pv/71r3HSSSdF69ato2vXrnH55ZfHtGnTyrXWRx99FIccckilhQQiasZN6ur4Xq/IbgIAAJA0ggIAAADb6Mgjj4y33norjj766BK/mz9/fowePToLVVVcgwYNKnXs8uXLS7QtWbKkwmtsLzk5lbPp3sknn1ziqIVNdwzY2EMPPVTiDOxNwwbbQ/PmzeP555+PBx54oEzHTSxevDjuueeeOPbYY6Nr167xyCOPbLF/aa/7tvxtlTa+tDW2pLJeY2qWfv36xbRp0+K3v/3tZgMDG5s6dWr88Y9/jC5dusSAAQPi888/3+qY9evXx0knnVRip5SIiO9///txxRVXxFNPPRXvv/9+zJ8/P5YvXx6FhYWRTqczfrbnTiLbS3V8rwMAAFsnKAAAAFAJ6tWrF/fff3+pN6FeeumlLFRUcStXrqzUsQ0bNizRVtqZ4BdeeGGJm2bb+tOhQ4cKP5eKatiwYQwYMCCj7fnnn485c+aU2n/TEEGTJk3i+OOP3271bSyVSsVJJ50UkyZNiilTpsRf/vKX+OEPfxg77LDDFsdNmzYtBgwYED//+c8jnU6X2qe0131b/rZKG1/aGlCaZs2axdVXXx1z586NZ599Ni6++OLo2bNn1KlTZ7Nj0ul0PPLII9G9e/d47rnntjj/rbfeGlOnTs1o23XXXeOtt96K8ePHx7Bhw+LYY4+NvffeO1q0aBH5+flRu3btEvOUZxeU6sJ7HQAAaiZBAQAAgErSqFGjOOOMM0q0l3f76oqqrC2qt+VM7NLGlrYFdWmBirJ8a7em2HRHgKKiorj77rtL9Pvss89i3LhxGW2nnnpq5OXlbdf6StOlS5f49a9/HaNHj46FCxfG9OnT44477ojBgwdv9lvY//znP+Pqq68u9XeNGjUqcSO0tGMoymPT8RU9h7ymqwnb0VdXOTk5ceSRR8Z1110Xb7zxRhQUFMS4cePimmuuiT59+pS660RBQUH85Cc/ienTp2923n//+98Z1w0bNowXX3wx9ttvv3LVV94t9qsD73UAAKiZBAUAAAAqUc+ePUu0LVy4cLP9SztHuaI3ARctWlShcZva0s2wrdk0FJFKpUq9ydywYcMSuwp88MEHFV63ujnkkEOiY8eOGW0jR44s0W/kyJElvpFfFccOlEWnTp3izDPPjFGjRsW8efPiySefjP33379Ev6uvvrrUv/FUKlViZ4JNv3FdHitXrozZs2dntJVlG/nqpLLe75X1Xieibt26cdBBB8VvfvObGDt2bMybNy+uvfbaEgGnlStXxh/+8IdS51ixYkX85z//yWg7/fTTK7SjyWeffVbuMdnmvQ4AADWToAAAAEAlaty4cYm2LZ2L3qhRoxJtBQUF5V53/fr1JW6sVNTbb79doXFFRUXx3nvvZbR16dIl6tevX2r/TUMVn3/+eZXtvrC9pVKpErtLTJs2LeNmYjqdjlGjRmX06datW6k347Otdu3a0b9//5gwYUIcffTRGb9btWpVPPvss6WO+973vpdx/eWXX8bXX39doRrefvvtKCoqymjbd999KzRXtlTW+33GjBmVUQ6l2GGHHeKSSy6JiRMnltju/qmnnoq1a9eWGPPVV1+V+Nv8wQ9+UO6158+fXyODAhHe6wAAUBMJCgAAAFSi0m6MtGrVarP9SzunuiI3it58881KO9t67NixFTp+4MUXXyxx07NXr16b7X/44YeXaLvnnnvKvW51NWTIkKhVK/N/do8YMaL48csvvxyzZs3K+P2ZZ55ZJbVVVE5OTlxzzTUl2je3G0Tv3r1LtD388MMVWvuhhx4q0/zVWWnHcFTk/f7qq69WaP3SQksbNmyo0Fzfdbvvvnv89Kc/zWhbtWpVfPrppyX6lrajRkW2yn/ggQfKPeZbm/53pKpfV+91AACoeQQFAAAAKtHLL79com3XXXfdbP9UKhWdO3fOaHvzzTfLve6tt95a7jGbs2bNmgrdsL/ttttKtG367fON/ehHPyrR9ve//71GntFdmnbt2sVhhx2W0fbAAw8UBzo2PYogJycnBg0aVFXlVdgee+xRom1zwZIjjzyyRNutt95a4tvCW7Ns2bK47777Mtpyc3Ojb9++5Zon23bfffcSbeV9vy9btiwefPDBCq2/6TfkI77ZNp/SlfVvvUGDBiXatnTkTGnWr18fN954Y7nGbGzT17aqX1fvdQAAqHkEBQAAgER78skn4/PPP6+UuT799NNSb+D1799/i+M23VJ50qRJMX369DKv+/bbb8e///3vMvcviyuuuCKWLFlS5v7jxo0r8e3R1q1bx3HHHbfZMXvttVeJsEBBQUEMHjy43DeXqquhQ4dmXBcUFMSjjz5a/H83duyxx0bLli2rsrwKmTt3bom2Fi1alNq3Z8+esd9++2W0ffDBB/HPf/6zXGv+/ve/LxEgOemkk2rEv9fG9tlnn8jNzc1o2/Sm6NYMHz68QscVREQ0bdq0RFtN3eq+KpT1b71NmzYl2p5//vlyrTV8+PD45JNPyjVmY5u+tlX9unqvAwBAzSMoAAAAJNqYMWOic+fOMXTo0Pj4448rPM9XX30Vxx9/fKxatSqjvUWLFtGvX78tji3tW/cXX3xxmdadPXt2nHTSSbF+/fqyF1sGCxcujBNPPLHU87g3NXPmzDjttNNKtP/85z8vcVN0U1deeWWJLbOffvrpGDp0aKxZs6Z8Rf//Jk+eHKeffnq5gg7by/HHH19iu/kRI0bEAw88UOJvpaqOHZgwYULccMMNsXz58gqNv+GGG0q07bPPPpvt/6tf/apE28UXX1zm7fPvvPPOuOWWWzLaUqlUXHTRRWUaX53UrVs3+vTpk9E2YcKEeOSRR8o0/u67747/+7//q/D6e+21V4m2p59+usLzVXd/+9vf4oUXXqjQ2IKCghK7fjRu3DjatWtXom/Lli1L7Axz7733xvvvv1+mtUaMGFHqkR7lselr++qrr8bKlSu3ac7y8l4HAICaRVAAAABIvMLCwhg5cmR06dIlevXqFTfddFOp3yQtzapVq+Kf//xn9OjRIz788MMSv7/uuusiLy9vi3OccMIJJc6zfvLJJ+Pss88ucTN5Y48++mj06tWr+JujW1unrL6d56WXXorDDjtsi7sbPPfcc3HwwQfHl19+mdG+xx57xCWXXLLVtfbZZ5/485//XKJ91KhR0atXr3jyyScjnU5vdZ4lS5bEnXfeGUcccUTstddecffdd1eLs9fz8vLi1FNPzWgbO3Zs/PWvf81oa9myZRxzzDFVUtP8+fPjwgsvjLZt28bPfvazeP7558sUNFmxYkVceumlJW5UN27ceIu7Zpx66qklntvq1avj2GOPjZtuummzu0esWbMmfvvb38bZZ59d4m/gwgsvLLETR01x1llnlWg7/fTT4/HHH9/smGXLlsX//u//xpAhQyKdTlf4vb7nnntGo0aNMtquueaaGDlyZPGRGN8lr776ahxxxBGx5557xtVXX13mMNjkyZOjX79+MWvWrIz2k08+OerUqVPqmJNOOinjev369XHUUUfFK6+8stl1li5dGr/85S/jpz/9afH7YNPXp6x69+6dcb1s2bI4+eSTY+rUqRWaryK81wEAoGbJyXYBAAAA1ckbb7wRb7zxRlxwwQXRoUOHOOCAA6Jr167RvHnz2GGHHSKVSkVBQUHMmjUrPvjgg3jppZc2+63Nk046KYYMGbLVNfPy8uLyyy+PCy+8MKP99ttvjzFjxsSAAQOie/fu0bBhw1iyZEl8/PHH8fTTT8e0adOK+55yyikxd+7cMn9zc0uGDRsWl112WWzYsCFef/316NatW/Tr1y8OO+yw2GmnnWLdunUxc+bMePLJJ+Ptt98uMb5OnToxYsSIMt/M/NWvfhVTpkyJO+64I6P9/fffjx/96EfRrl276Nu3b3Tv3j122GGHyMvLi2XLlhX/W7z99tsxefLkKCws3Obnvj0MHTo0/vGPfxRfFxUVZbx2ERGDBw+OnJyq/Z/oBQUF8a9//Sv+9a9/RcOGDeN73/te9OjRI3bZZZdo0qRJNGjQINasWRNffvllvPPOO/Hcc8+Vej77X/7yl6hXr94W1xoxYkR07949I4CzcuXKuOCCC+K6666LE044Ibp06RJNmjSJhQsXxnvvvRePPfZYqee8f+9739vmb19n0wknnBD77rtvxntn1apVcfzxx8eBBx4Y/fv3jw4dOkQqlYqvv/46Jk6cGM8++2zxv30qlYrrr78+zjvvvHKvnZubG4MGDcr41vbKlStj6NChcdZZZ8XOO+8cDRs2jFq1Mr9XcuWVV5Y4JqQmmTx5cvz+97+P3//+99GhQ4fo0aNH7LPPPtGqVato0qRJ5OTkREFBQcyYMSPGjRsXr7/+eokb1jvssEMMHz58s2tcdNFFcdNNN8XSpUuL2+bNmxd9+/aNgw8+OI488sjo0KFD1KpVK+bNmxcTJkyIZ555JlasWFHc/9vP2FGjRpX7OZ5++ulx2WWXZXwOjhkzJsaMGRNNmzaNVq1aRd26dTPG7LjjjpW+o4T3OgAA1ByCAgAAAJsxc+bMmDlzZoXGDhkypMSN7y254IIL4qmnnooXX3wxo33u3Llx4403bnHswQcfHHfeeWepRxhURK9eveLvf/97nH/++RHxzY4Lzz77bDz77LNbHVunTp145JFHolevXuVa87bbbotddtklLr/88hLfOp09e3bcddddcdddd5Vrzupi//33jz333DM++uijzfYZOnRoFVZU0vLly+PVV18td9DkoosuKvUb8ptq2bJljB8/Po466qgS57DPnj27zNvpH3TQQTF69OgSNzxrkpycnLjrrrviwAMPLHH8w3/+85/4z3/+s8XxN9544za91//whz/Eo48+GvPmzcto37Bhw2Y/7zY9M74m+/Zz/bHHHivzmMaNG8ejjz4arVu33myfZs2axb333hs/+tGPSuxm8tprr8Vrr722xTX23HPPeOihhyq8zX6bNm3isssuiyuuuKLE75YsWVLqUSwbhxoqi/c6AADUHI4eAAAAEm3w4MExcODAEufIV1THjh3jiSeeiJEjR0bt2rXLPK5WrVoxevToLW7hXpqBAwfGc889t9VvdJfXeeedF7fddlu5tjjfeeedY8yYMeV+DhHffEv697//fbz44oux3377lXv8xho1ahRnnXVW5Ofnb9M8lWlLQYCePXtGt27dqqyWxo0bb/MxFc2bN4877rgjrr/++jKP6dixY7z++utx0kknRSqVKtd6ubm5ccEFF8QLL7wQTZs2LW+51U63bt1i7Nix0bJlyzKPyc/Pj/vuu684wFNRrVu3jpdffjkR27lv6cZ+WR100EExYcKEOPjgg7fa95hjjomHHnqo3McH9O/fP8aNG7fNf9t/+MMf4qqrrtrs8QhVxXsdAABqBkEBAAAg0b7//e/HPffcE/Pnz4+XXnopLr/88jj00EPLdZO5VatWMXDgwBgzZkxMmzatwlt016tXL5588sl44IEHYu+9995sv1QqFQcddFA8/fTTcc8992zzTd/NOeuss+KDDz6IwYMHbzGIsPPOO8fvfve7mDJlSvTr12+b1uzbt2+89dZb8eyzz8aJJ54YLVq0KNO4XXbZJc4666x46KGHYt68eeUOOWxvgwYNitzc3FJ/V9W7CfTt2zcWLVoUTzzxRJx33nnRvXv3Moda9t133/jLX/4SM2bMiDPPPLPca7do0SIeeOCBePPNN+Pkk0/e6o3ANm3axNlnnx1Tp06Nv//979XqNd1W++67b0ybNi3+93//N5o1a7bZfg0aNIizzz47pkyZEqeeemqlrN2lS5d466234tVXX40LL7ww+vbtG23bto1GjRqVK+BU3f3zn/+MmTNnxs033xwDBgyInXbaqUzj6tWrFwMGDIjRo0fHuHHjomvXrmVe8/jjj48PPvggzj333C1+btaqVSv69OkTTzzxRDz55JOVElarVatW/O53v4s5c+bETTfdFCeffHLsueee0bx58yp/73ivAwBA9ZdKb3roGgAAAJFOp2POnDnxySefxOzZs6OgoCCWL18eqVQqGjVqFA0bNow2bdrEXnvtVSnfWi3NF198Ef/5z39i/vz5sXTp0qhfv37ssssu0atXr2jTpk2lrPHKK69E3759M9rGjh0bffr0yWhbvXp1vPHGG/Hxxx/H4sWLo27dutGmTZvo1KlT7LfffuX+1mhZpdPpmDJlSkyfPj0WLVoUixYtiqKiomjYsGE0adIkdt1119hjjz1883QbrVy5Mj755JP47LPPYt68ebF8+fJYv3595OfnR+PGjWO33XaLvffeOxo3blyp627YsCEmTZoUM2fOjAULFkRBQUE0adIkWrZsGZ07d95iYOa7pKioKN566634+OOPY8GCBbFu3bpo2rRpdO3aNXr16mX79Uo0d+7cmDFjRsycOTMWL14cK1eujFq1akXDhg2jefPm0a1bt9hjjz0iJ2fbT+tcu3ZtvPHGGzFt2rTiz65vP7f233//LQZEvmu81wEAoPoRFAAAAEiwsgYFAAAAAPjucPQAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJEgqnU6ns10EAAAAAAAAAFA17CgAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACZKT7QJgc5YuXRqvvvpq8fXOO+8cdevWzWJFAAAAAAAAAJVj7dq18cUXXxRfH3LIIdGkSZMqWVtQgGrr1VdfjR//+MfZLgMAAAAAAABgu3v88cfjuOOOq5K1HD0AAAAAAAAAAAkiKAAAAAAAAAAACeLoAaqtnXfeOeP68ccfj9122y1L1QAAAAAAAABUnhkzZmQcxb7p/dHtSVCAaqtu3boZ17vttlt069YtS9UAAAAAAAAAbD+b3h/dnhw9AAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJkpPtAgAAAAAAACARRhwbMWt82fu3Pyhi6JjtVw+QWIICsJF0Oh1FRUWRTqezXQqwHaRSqahVq1akUqlslwIAAAAAAJA1ggIkWjqdjjVr1sTy5ctj+fLlsW7dumyXBFSBOnXqRMOGDaNhw4aRl5cnOAAAAAAAACSKoACJtWrVqvjqq69i/fr12S4FqGLr1q2LRYsWxaJFiyI3Nzd23HHHqF+/frbLAgAAAAAAqBK1sl0AZMOqVati9uzZQgJArF+/PmbPnh2rVq3KdikAAAAAAABVQlCAxPk2JJBOp7NdClBNpNNpYQEAAAAAACAxHD1AoqTT6fjqq69KhARyc3OjUaNGkZ+fH7m5uc4rh++odDod69evjxUrVkRBQUHGriLffj7suuuuPgMAAAAAAIDvNEEBEmXNmjUljhto2LBh7LTTTm4MQkLk5uZG/fr1o0WLFjFnzpxYvnx58e/Wr18fa9eujby8vCxWCAAAAAAAsH05eoBE2fiGYMQ3NwyFBCCZUqlU7LTTTpGbm5vRXlBQkKWKAAAAAAAAqoagAImyaVCgUaNGQgKQYKlUKho1apTRtunnBAAAAAAAwHeNoACJkU6nY926dRlt+fn5WaoGqC42/RxYt25dpNPpLFUDAAAAAACw/QkKkBhFRUUl2jbdchxInpycnBJtpX1eAAAAAAAAfFcICpAYpX1D2LEDQK1aJf9TaEcBAAAAAADgu0xQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAoBQdOnSIVCpV4uef//xnhee88847S52zQ4cOlVc4AAAAAAAAbIWgAEA5jBgxosJj77zzzkqsBAAAAAAAACpGUACgHN58882YPHlyucdNnz49Xn/99e1QEQAAAAAAAJSPoABAGeTm5hY/rsiuAhvvJrDxXAAAAAAAAFDVcrJdAEBN0L9//3jsscciIuKee+6J//f//l/k5JTtI3TDhg0xatSo4usf/vCH8eijj26XOgEAAAAA+O54ZcbX0fcX92a7DMiQvmlgtkugEthRAKAMzjzzzOLHX3/9dYwZM6bMY5955pmYO3duqXMBAAAAAABAVRMUACiDXr16RZcuXYqvy3P8wMbHDnTp0iUOOOCASq0NAAAAAAAAysPRAwBlNHTo0LjkkksiImLMmDExf/78aNmy5RbHLFiwIJ566qni68rcTWDKlCnx4YcfxoIFC6KgoCCaNWsWbdq0iYMOOih22GGHbZp7+fLlMWXKlJg+fXosXLgwVq5cGQ0bNoxmzZrFnnvuGXvvvXfUrl27kp7Jf02fPj3ef//9+PLLL6OwsDBatGgR++67b+y1116VvhYAAAAAAEBSCQpARbx7b8R792W7ivJrvVfE0f+v8uab+0HEs7/d9nm6nxbRo/qfZ3P66afH7373uygsLIzCwsK4++6749e//vUWx4waNSrWr18fERE5OTkxePDgbaph0aJFcd1118U999wTc+bMKbVPrVq1onfv3jFs2LDo169fmef+6KOP4oEHHojnnnsu3nnnndiwYcNm+zZs2DAGDRoUF198cXTs2LFM88+cOTN22WWX4ushQ4bEyJEjIyLiqaeeiquuuiomTpxY6tiOHTvGlVdeGQMHVv+/EwAAAAAAgOpOUAAqYunsiFnjs11F9q1ZVjn/Dh0O2vY5qkCrVq3imGOOidGjR0fEN8cPbC0osPERBcccc0y0atUqFi5cWKH1R40aFRdccEEUFBRssV9RUVGMHz8+Dj/88Bg0aFDccccdUadOnS2Oeeedd2Lfffctcy3Lly+Pf/zjHzFy5Mi49dZbY9CgQWUeu7ENGzbEhRdeGDfddNMW+3322WcxaNCg+M9//hM33nhjpFKpCq0HAAAAAACAoABAuZx55pnFQYHJkyfHW2+9Ffvvv3+pfd94442YPHlyxtiKuvzyy+OPf/xjRlsqlYrdd989OnXqFA0bNowlS5bEpEmTYsGCBcV97rnnnpg7d248++yzkZOz+Y/8oqKiEnPvsssu0alTp2jUqFHk5ubGkiVLYvLkyTF79uzifqtXr47BgwdHXl5eDBgwoNzP65e//GXcfPPNxWvuvffe0bFjx6hbt27MmjUr3nrrrSgsLCzuf/PNN0e3bt3i5z//ebnXAgAAAAAA4BuCAgDlcOyxx0arVq3i66+/joiIO++8c7NBgTvvvLP4ccuWLeOYY46p0Jp33XVXRkigVq1acf7558fFF18c7dq1y+ibTqfjiSeeiF/+8pfFN/Rfeuml+MMf/hDXXHPNFtepV69enHLKKXHcccfFYYcdFvn5+aX2++ijj+LKK6+Mhx56qLjtzDPPjIMPPjhatmxZ5uc1ZsyY4t0VzjrrrBg2bFi0bds2o8+cOXPinHPOiaeffrq47Te/+U2cfvrp0aBBgzKvBQAAAAAAwH/VynYBADVJTk5Oxjb7999/f6xZs6ZEv9WrV8cDDzxQfD148ODIzc0t93qzZs3K+PZ83bp1Y8yYMfH3v/+9REgg4ptv5f/4xz+Ot956K3bbbbfi9uuuuy4+//zzza7TuXPnmDNnTtx5551x3HHHbTYkEBGx5557xoMPPhjDhg0rblu+fHnccsst5Xpu34YEbrnllrjttttKhAQiInbaaad44oknMo5FKCgoiPvvv79cawEAAAAAAPBfggIA5bTxEQJLly6Nxx57rESfhx9+OJYtW1Z8PXTo0Aqtdd1118Xq1auLr//2t7/FUUcdtdVxLVu2jPvuu6/4esOGDfG3v/1ts/0bNWoUTZs2LVdtl19+eey9997F1/fee2+5xkdEnHbaaVs9RiAnJyeGDx+e0fbyyy+Xey0AAAAAAAC+ISgAUE5du3aNAw44oPh64yMGSmvr2bNndOvWrdzrrFy5MmOejh07xrnnnlvm8fvvv3/84Ac/KL4ePXp0uWvYklq1asXxxx9ffD1jxoxYsGBBueb4wx/+UKZ+RxxxRNSpU6f4+t133y3XOgAAAAAAAPyXoABABWy8q8DLL78cs2fPLr7+7LPP4tVXXy2+ruhuAuPHj8/YTWDAgAFRq1b5Prb79u1b/HjWrFkZdZbV2rVrY+HChTFr1qyYOXNmxk+9evUy+k6dOrXM83bs2DH22GOPMvXNzc2NXXfdtfh6/vz5ZV4HAAAAAACATDnZLgCgJjrllFPiwgsvjNWrV0dRUVHcddddxd+Ov/POOyOdTkdERL169eLUU0+t0Brjx4/PuN5xxx1j5syZ5Zpj42/hR3wTYmjXrt0Wx3z00UfxwAMPxLhx42Ly5MmxcOHCMq+3ZMmSMvft2rVrmftGRMbRCBsf6wAAAAAAAED5CAoAVECjRo3iJz/5Sdxzzz0RETFy5Mi47LLLIp1Ox6hRo4r7nXDCCdG4ceMKrfHFF19kXF944YVx4YUXVrjmiIjFixdv9nezZs2KCy+8MB5//PEKz1+eG/gb3/gvi9zc3OLHhYWF5RoLAAAAAADAfwkKAFTQmWeeWRwU+Pa4gTVr1mTc4K/osQMREYsWLdrmGje1fPnyUtunTp0ahx12WMydO3eb5i8qKipz3/IeowAAAAAAAEDlcJcGoIL69OkTu+yyS/H1iBEj4s477yy+bt++fRx66KEVnn/dunXbVF9pvj0SYWOFhYVxyimnZIQE8vLyYvDgwTFy5MiYNGlSzJ07N1asWBGFhYWRTqeLf0aMGFHpNQIAAAAAALB92VEAKqJJu4j2B2W7ivJrvVflzpfXuHL+HZq02/Y5siCVSsUZZ5wRw4YNi4iIhx9+ODZs2FD8+zPOOCNSqVSF52/evHnG9YQJE+LAAw+s8Hyb8+ijj8YHH3xQfL3bbrvFc889Fx07dtzq2IKCgkqvBwAAAAAAgO1LUAAqosfAb36Srs3eEUPHZLuKrDrjjDNi+PDhUVRUFKtWrSpu/zZEsC1atWqVcT19+vTtEhR44oknMq5vvfXWMoUEIiK++uqrSq8HAAAAAACA7cvRAwDboF27dnHYYYeVaO/bt2906NBhm+bu3bt3xvXzzz+/TfNtzieffFL8uEGDBtGnT58yj50wYcJ2qAgAAAAAAIDtyY4CANvozDPPjBdeeKFE27Y67LDDonbt2sXHGYwePTrmz58fLVu23Oa5N7Z06dLix40aNSrzcQkzZsyI119/vVJrAQAAAAD4Tjvqmog1y7bYpc/fXyx+vLSo3vauCEgoQQGAbXTCCSfEuHHjMtr233//bZ63adOmMXDgwBg1alRERKxYsSIuvvji4uvK0rRp0+LH8+fPjyVLlmS0bc4ll1wSRUVFlVoLAAAAAMB3Wpu9t9rl1fWzq6AQIOkcPQCwjerUqRMHHXRQxk/dunUrZe4rrrgiY6677747Lr300uJdBspqypQp8dprr5X6u3322af48YYNG+K6667b6nzDhg2Lxx57rFw1AAAAAAAAUD0ICgBUY7vsskvceuutGW1//vOf46CDDoonn3wyCgsLNzt25syZcfPNN8ehhx4a3bp1i5dffrnUfieffHLG9TXXXBOXXXZZrFixokTfadOmxQknnBBXXnllRES0aNGivE8JAAAAAACALHP0AEA1d/rpp8e8efPit7/9bfFW/xMnTowf/ehHUb9+/ejRo0e0atUq6tWrF8uXL4+FCxfGlClTYunSpWWa/7DDDoujjz46nnnmmeK2q666Km644Ybo2bNntGnTJlasWBHTp0+PqVOnFvfp0qVL/OxnP4tf/vKXlfp8AQAAAAAA2L4EBQBqgEsuuST23nvvGDp0aMybN6+4fdWqVfH666+XaY6mTZtu9nf33XdfHH744TFp0qTithUrVmx2F4Lu3bvHU089FS+88EIZnwEAAAAAAADVhaMHAGqIo446Kj7//PO4+eabo3v37pFKpbbYPzc3N3r37h1XXHFFTJ8+fYvf/G/SpEmMHz8+Lr/88mjWrNlm++2+++5x7bXXxsSJE2OnnXaq8HMBAAAAAAAge1LpdDqd7SKgNJMnT44999yz+Pqjjz6Kbt26VXi+wsLC+OSTTzLaOnXqFDk5NtagZlq8eHFMnDgx5s6dG4sXL47169dHfn5+tGzZMjp37hx77LFH1K9fv9zzrl27Nt54442YPHlyLFmyJPLz86N169bRpUuX2GuvvbbDM8kunw0AAAAAQHWS+sW92S4Btih908Bsl/CdUdn3Q8vDXRCAGqpZs2ZxzDHHVPq8devWjYMPPjgOPvjgSp8bAAAAAACA7HP0AAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACRITrYLAAAAAAAAgER45jcR8z7cYpexjb8ufvxeYdu4aOWJ27sqIIEEBQAAAAAAAKAqzPswYtb4LXbpk1tFtQCJ5ugBAAAAAAAAAEgQQQESI5VKlWhLp9NZqASoToqKikq0lfZ5AQAAAAAA8F0hKEBi1KpV8s99/fr1WagEqE4KCwtLtJX2eQEAAAAAAPBd4U4IiZFKpaJOnToZbStWrMhSNUB1sennQJ06dewoAAAAAAAAfKcJCpAoDRs2zLguKChw/AAkWDqdjoKCgoy2TT8nAAAAAAAAvmsEBUiUTW8Arl+/PubMmSMsAAmUTqdjzpw5JY4gadSoUZYqAgAAAAAAqBo52S4AqlJeXl7k5uZm3Bhcvnx5fPrpp9GoUaPIz8+PnJwc55PDd1RRUVEUFhbGihUroqCgoERIIDc3N+rWrZul6gAAAAAAAKqGoACJkkqlYscdd4zZs2dn7CKwfv36WLRoUSxatCiL1QHZ9O3nQyqVynYpAAAAAAAA25WvTZM49evXj3bt2rkZCBRLpVLRrl27qF+/frZLAQAAAAAA2O4EBUikb8MCubm52S4FyLLc3FwhAQAAAAAAIFEcPUBi1a9fP3bddddYu3ZtFBQUxPLly2PdunXZLguoAnXq1ImGDRtGo0aNom7dunYYAQAAAAAAEkVQgERLpVKRl5cXeXl50bJly0in01FUVBTpdDrbpQHbQSqVilq1agkGAAAAAAAAiSYoABtJpVJRu3btbJcBAAAAAAAAsN3UynYBAAAAAAAAAEDVERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEycl2AQAAAAAAAJAI3U+L6HDQFrtc8cwHxY9nbthhe1cEJJSgAAAAAAAAAFSFHgO32mX4I/dWQSFA0jl6AAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASJCfbBSTVhg0bYsaMGTFlypT46quvYtmyZVG3bt1o2rRp7LrrrrHffvtFgwYNKnXN9evXx+uvvx6zZ8+OuXPnRn5+fuy4447Ro0eP6NChQ6WuBQAAAAAAAED1JChQhWbPnh2PPvpovPjiizFu3LgoKCjYbN/atWvH4YcfHr/4xS/i2GOP3aZ1FyxYEMOGDYsHHnggFi9eXGqf3r17x69+9av4yU9+sk1rAQAAAAAAAFC9CQpUkdNOOy3+/e9/l7n/hg0b4tlnn41nn302+vfvH7fffnu0atWq3Os+88wzccYZZ8T8+fO32G/ChAkxYcKEGDhwYPzrX/+q9N0MAAAAAAAAAKgeBAWqyPTp00tt32mnnaJTp07RqlWrKCwsjM8++yzef//9KCoqKu7z1FNPxcEHHxyvvvpqtG7dusxrvvLKK/HjH/841q1bV9yWSqXie9/7XnTs2DGWLl0a7777bixcuLD49/fee28UFBTE448/HrVq1arAMwUAAAAAAACgOnMnOAt69OgRN954Y8yYMSO+/PLLGDt2bNx///3x8MMPxzvvvBOzZ8+Oc845J2PM9OnT48QTT4x0Ol2mNb788ss44YQTMkIC3//+92Py5MkxadKkePDBB+P555+PL7/8Mm644YbIzc0t7vfkk0/GZZddVjlPFgAAAAAAAIBqxY4CVSSVSsWxxx4bV1xxRey3335b7LvTTjvFv/71r9hnn33i/PPPL24fP358PPDAA3HKKadsdb1hw4bFkiVLiq979+4dL774YuTl5WX0q1u3bvzP//xPtGvXLo4//vji9uuvvz7OPffcaN++fVmfIgAAAAAAAFvy7r0RS2dvscuw+h8UP565YYe4a+2B27sqIIEEBarIQw89FB06dCjXmPPOOy9efvnleOSRR4rb7r777q0GBT755JO46667iq/r1KkTI0eOLBES2NiPf/zjGDJkSPG4tWvXxvDhw+POO+8sV80AAAAAAABsxnv3Rcwav8UuV9T/7+NX1ncSFAC2C0cPVJHyhgS+tfGOAhERY8eO3eqY++67LzZs2FB8fcIJJ0SnTp22Ou7SSy/NuH7wwQdjzZo1ZawUAAAAAAAAgJpAUKCa69GjR8b16tWrY+nSpVsc89hjj2VcDx06tExrdenSJQ444IDi65UrV8bzzz9ftkIBAAAAAAAAqBEEBaq5nJySp0OsW7dus/3nzZsX77//fsb473//+2Ver0+fPhnXzzzzTJnHAgAAAAAAAFD9CQpUczNmzMi4zsnJiebNm2+2/0cffZRxvffee0eDBg3KvF7v3r0zridPnlzmsQAAAAAAAABUf4IC1dzDDz+ccb3ffvtFrVqbf9mmTJmScb3bbruVa71dd911i/MBAAAAAAAAULMJClRjK1asiDvuuCOj7fjjj9/imE13IGjXrl251mzfvn3G9aJFi2LJkiXlmgMAAAAAAACA6isn2wWweb/97W9j3rx5xddNmjSJs846a4tjli5dmnHdsmXLcq2Zn58feXl5sWbNmuK2ZcuWRdOmTcs1z6bmz58fCxYsKNeYTUMPAAAAAAAAAGw7QYFq6rHHHoubbropo+2qq66KZs2abXHcihUrMq7r1atX7rXr1auXERRYvnx5uefY1C233BLDhw/f5nkAAAAAAAAA2DaOHqiG3n///Tj99NMz2o444oj4+c9/vtWxmwYF8vLyyr3+puGCTecEAAAAAAAAoOYSFKhmZs+eHccee2zGzfn27dvHPffcE6lUqtzzVdUYAAAAAAAAAGoGRw9UI/Pnz4/DDz885syZU9zWunXreOGFF6JFixZlmiM/Pz/jevXq1eWuY9Mxm85ZEeedd16ceOKJ5RozY8aM+PGPf7zNawMAAAAAAADwX4IC1cTixYujX79+MX369OK25s2bx4svvhidOnUq8zzVNSjQsmXLaNmy5TbPAwAAAAAAAMC2cfRANbBs2bI44ogj4sMPPyxua9q0abzwwgvRrVu3cs3VuHHjjOsFCxaUa/yKFStKBAWaNGlSrjkAAAAAAAAAqL4EBbJs+fLlcdRRR8Xbb79d3NaoUaN49tlno3v37uWeb9PdB2bNmlWu8Zv2b9asWTRt2rTcdQAAAAAAAABQPQkKZNHKlSvjmGOOiYkTJxa35efnxzPPPBM9e/as0JxdunTJuJ4xY0a5xn/22WcZ1127dq1QHQAAAAAAAABUT4ICWbJ69ero379/jB8/vritfv36MWbMmOjdu3eF591zzz0zrj/44INYtWpVmce//vrrW5wPAAAAAAAAgJpNUCAL1qxZEz/60Y/ilVdeKW7Ly8uL0aNHx8EHH7xNc7dp0yb23nvv4uvCwsKMMMLWbFxTRMTRRx+9TfUAAAAAAAAAUL0IClSxdevWxQknnBAvvvhicVvdunXj8ccfj8MOO6xS1jj++OMzrkeMGFGmcR9//HG88cYbxdcNGjSII444olJqAgAAAAAAAKB6EBSoQoWFhXHSSSfFM888U9yWm5sbDz/8cBx55JGVts7AgQOjdu3axdePPvpofPLJJ1sdd+2112Zcn3TSSZGXl1dpdQEAAAAAAACQfYICVWTDhg0xcODAeOKJJ4rbcnJy4oEHHoj+/ftX6lqdOnWKIUOGFF+vW7cuzjjjjFizZs1mxzzxxBMxcuTI4us6derEsGHDKrUuAAAAAAAAALIvJ9sFJMWZZ54ZDz74YEbb1VdfHT169IiZM2eWa67WrVtv9Zv+w4cPj8ceeyyWLFkSERETJkyIfv36xe233x577LFHcb+1a9fGrbfeGr/+9a8zxv/617+O9u3bl6suAAAAAAAAAKo/QYEqMmrUqBJtl1xySVxyySXlnmvs2LHRp0+fLfZp27ZtPProo3HkkUfGunXrIiLi9ddfj65du8a+++4bHTt2jGXLlsU777wTCxYsyBjbv3//+OMf/1juugAAAAAAAACo/gQFvsP69OkTjz32WJxxxhnFYYB0Oh2TJk2KSZMmlTrm1FNPjdtuuy1q165dlaUCAAAAAAAAUEVqZbsAtq9jjjkmPvroo/jZz34WTZs23Wy/Xr16xcMPPxz33XdfNGjQoAorBAAAAAAAAKAq2VGgiqTT6ayt3bJly/jHP/4RN9xwQ7z++usxa9asmDdvXjRo0CB22mmn6NGjR+yyyy5Zqw8AAAAAAACAqiMokCB16tSJvn37ZrsMAAAAAAAAALLI0QMAAAAAAAAAkCCCAgAAAAAAAACQIIICAAAAAAAAAJAgggIAAAAAAAAAkCCCAgAAAAAAAACQIIICAAAAAAAAAJAgggIAAAAAAAAAkCCCAgAAAAAAAACQIIICAAAAAAAAAJAgggIAAAAAAAAAkCCCAgAAAAAAAACQIIICAAAAAAAAAJAgggIAAAAAAAAAkCCCAgAAAAAAAACQIIICAAAAAAAAAJAgggIAAAAAAAAAkCCCAgAAAAAAAACQIIICAAAAAAAAAJAgOdkuAAAAAAAAABKh9V5b7fLKjK+LH79X2HZ7VgMkmKAAAAAAAAAAVIWj/99Wu/T9xb1VUAiQdI4eAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABMnJdgEAAAAAAACQCHM/iFizbItdDsmdXvx4aVG9eH/Dztu7KiCBBAUAAAAAAACgKjz724hZ47fY5ZXGGz1e3yn6LrtoOxcFJJGjBwAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEEEBQAAAAAAAAAgQQQFAAAAAAAAACBBBAUAAAAAAAAAIEFysl0AAAAAAAAAJMLQMVvtkvrFvVVQCJB0dhQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgAQRFAAAAAAAAACABBEUAAAAAAAAAIAEERQAAAAAAAAAgATJyXYBAAAAAAAAkAgjjo2YNX6LXdLN//v4lfWdou+yi7ZzUUAS2VEAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASJCfbBQAAAAAAAEAiHHVNxJplW+zS5+8vFj9eWlRve1cEJJSgAAAAAAAAAFSFNntvtcur62dXQSFA0jl6AAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASRFAAAAAAAAAAABJEUAAAAAAAAAAAEkRQAAAAAAAAAAASJCfbBSTVZ599Fm+99VZMmjQp3nrrrXjnnXdi+fLlxb9v3759zJw5s0Jzp1Kpbart888/jw4dOmzTHAAAAAAAAABUT4ICVeiVV16Ja665JiZNmhSLFy/OdjkAAAAAAAAAJJCgQBV677334vnnn892GQAAAAAAAAAkmKBANVC3bt1o27ZtfPrpp5U+9wEHHBD3339/uca0bdu20usAAAAAAAAAoHoQFKhiubm50a1bt9hvv/1i//33j/322y/22muveP3116Nv376Vvl5eXl506NCh0ucFAAAAAAAAoGYSFKhCQ4YMiZ/97GeRl5eX7VIAAAAAAAAASChBgSrUtGnTbJcAAAAAAAAAQMLVynYBAAAAAAAAAEDVERQAAAAAAAAAgAQRFAAAAAAAAACABMnJdgFsX7Nnz46hQ4fGm2++GV999VWsXLkymjZtGs2bN48ePXrEwQcfHAMGDIhmzZplu1QAAAAAAAAAqoCgwHfc559/Hp9//nlG2/z582P+/PkxZcqUuPfee+NXv/pVnH322fHHP/4x8vPzt0sd8+fPjwULFpRrzIwZM7ZLLQAAAAAAAFnxzG8i5n24xS5jG39d/Pi9wrZx0coTt3dVQAIJChArV66M//u//4unn346Hn300ejWrVulr3HLLbfE8OHDK31eAAAAAACAGmPehxGzxm+xS5/cKqoFSDRBge+onJycOOigg6Jfv36x9957R9u2baNhw4axYsWKmD17dowbNy5GjRoV8+fPLx4zffr06NevX0ycODHat2+fxeoBAAAAAAAA2F4EBb6D/vSnP8XZZ58dLVu2LPX33bt3jx/96Efxxz/+MYYPHx7XXnttpNPpiIiYN29enHDCCTFp0qRIpVJVWTYAAAAAAAAAVUBQ4Dvo97//fZn65eXlxTXXXBNt27aNX/ziF8Xt77zzTvz73/+O0047rdJqOu+88+LEE8t3hs6MGTPixz/+caXVAAAAAAAAAICgABFx/vnnx/PPPx+jR48ubrvlllsqNSjQsmXLze5wAAAAAAAAAEDVqZXtAqgefvvb32ZcT5w4MZYuXZqdYgAAAAAAAADYbgQFiIiInj17RtOmTYuvN2zYEFOmTMliRQAAAAAAAABsD4ICRERErVq1ol27dhltCxYsyFI1AAAAAAAAAGwvggIUq1evXsb16tWrs1QJAAAAAAAAANuLoADFFi5cmHHdvHnzLFUCAAAAAAAAwPYiKEBEfBMS+OyzzzLadtxxxyxVAwAAAAAAAMD2IihARETcf//9UVRUVHzdqlWr6NKlSxYrAgAAAAAAAGB7EBQgvv766/jTn/6U0fbDH/4wUqlUlioCAAAAAAAAYHsRFPgOmTZtWjz55JPlGjNv3rzo379/fP3118VtderUid/+9reVXR4AAAAAAAAA1UBOtgsoq5NPPjnOO++8OOSQQ7Jdyjb58ssvo7CwsET7vHnzMq4LCwtj5syZpc6Rn58fzZs3L9E+d+7c+NGPfhR77bVXDBo0KI4//vjo1KlTqXMsX7487rrrrvjTn/6UERKIiLjsssuiY8eOZXxGAAAAAAAAANQkNSYo8NBDD8XDDz8cnTt3jp///Odx+umnR5MmTbJdVrkddNBBMWvWrK32mzNnTuyyyy6l/m7IkCExcuTIzY798MMP49JLL41LL700GjduHHvuuWc0b948GjZsGCtWrIgvvvgi3n///VIDC+ecc0784Q9/KPPzAQAAAAAAAKBmqTFBgW9NmzYtLrroovjtb38bp5xySpx77rnRs2fPbJdVbS1btixef/31rfZr0KBB/O1vf4uzzz67CqoCAAAAAAAAIFtqZbuA8kqlUpFOp2P16tUxcuTIOPDAA2PfffeN22+/PVatWpXt8rKqS5cu8bvf/S6+//3vR7169co0pnPnznH11VfHzJkzhQQAAAAAAAAAEqDG7CgwevTo+Oc//xnPPvtspNPpSKVSERGRTqfj3XffjXPPPTcuvvjiGDx4cJx77rmx5557Zrni0s2cOXO7zd2qVau46qqrIiKiqKgoPvnkk/j0009jzpw5sXTp0lizZk3Uq1cvmjZtGm3atIn9998/WrRosd3qAQAAAAAAAKD6qTFBgf79+0f//v3jiy++iH/9618xYsSImDt3bkT8d5eBgoKCuOWWW+KWW26J3r17x3nnnRcDBgyI3NzcLFdf9WrVqhW777577L777tkuBQAAAAAAAIBqpMYdPbDzzjvHn/70p5g9e3Y8+OCDcdhhhxX/buNdBiZMmBCDBg2KnXbaKX7zm9/EZ599lq2SAQAAAAAAAKDaqHFBgW/Vrl07BgwYEC+88EJMnz49fvWrX0WzZs0inU4X90mn07Fw4cK47rrronPnznHUUUfFE088EUVFRVmsHAAAAAAAAACyp8YGBTa26667xl/+8peYM2dOjBo1Kr7//e8XBwa+3WWgqKgoXnjhhTjhhBOiffv2ceWVV8ZXX32VzbIBAAAAAAAAoMp9J4IC36pTp04MGjQoxo0bFx999FGcd9550ahRo+LQQDqdjnQ6HXPmzInhw4dHhw4d4ic/+Um8+OKLWa4cAAAAAAAAAKrGdyoosLGuXbvGTTfdFF999VXceuutse+++0bENzsMpFKpSKfTUVhYGI8//ngceeSR0blz5/j73/8ey5cvz3LlAAAAAAAAALD9fGeDAt+qV69eDBkyJC666KJo3759xpEE3x5LkE6nY8aMGXHRRRdFhw4d4tprr43169dns2wAAAAAAAAA2C6+00GBTz/9NC699NJo27ZtDB48OGbPnp0RDvj2JyKKdxlYsmRJ/O53v4v99tsvZs6cmcXqAQAAAAAAAKDyfeeCAhs2bIhHH300jjjiiNh9993jL3/5SyxYsKA4EPBtOKBPnz7x0EMPxfPPPx8DBgyInJyciPhvYODDDz+Mvn37OooAAAAAAAAAgO+UnGwXUFm++OKLuPXWW+POO++MefPmRcQ3oYBvjxhIp9ORn58fgwcPjvPPPz+6dOlSPLZfv37x9ddfx/XXXx833XRTrFmzJtLpdMyePTtuuOGGuOyyy7L1tAAAAAAAAACgUtXoHQXS6XQ89dRT8cMf/jA6duwYV199dcydO7d494Bv+3Tt2jVuvvnmmDNnTtx0000ZIYFvtWrVKq699tp45513olWrVsXhgscff7wKnxEAAAAAAAAAbF81ckeBefPmxe233x633357fPHFFxFRcveA2rVrx/HHHx/nnXdeHHLIIWWee/fdd4/LLrssfvGLX0RExPTp07fLcwAAAAAAAACAbKhRQYEXXngh/vnPf8ZTTz0VhYWFxTsHpFKpiPgmLNCmTZs455xz4pxzzok2bdpUaJ0DDzyw+PHKlSu3vXAAAAAAAAAAqCZqTFCgU6dO8dlnn0VEyd0D0ul0HHLIIXHeeefF8ccfHzk52/a0mjVrFhH/DSAAAAAAAAAAwHdFjQkKfPrpp8U37r8NCOTn58fgwYPj/PPPj65du1b6mt8GEgAAAAAAAADgu6LGBAW+lU6no2vXrvHzn/88hgwZEvn5+ZW+RuvWrWPs2LGVPi8AAAAAAAAAZFuNCQrk5OTEcccdF+eff3706dNnu65Vt27dOOSQQ7brGgAAAAAAAACQDTUmKDBz5szYcccds10GAAAAAAAAANRotbJdQFkJCQAAAAAAAADAtqsxQQEAAAAAAAAAYNsJCgAAAAAAAABAgtSYoMCECROiY8eO0bFjx+jUqVPMnz+/3HN8/fXX0blz5+jYsWPsuuuu8c4772yHSgEAAAAAAACg+qoxQYHbb789Zs6cGbNmzYoePXpEy5Ytyz1Hq1atYp999omZM2fGzJkz4/bbb98OlQIAAAAAAABA9VVjggJjxowpfjxo0KAKzzN48ODix6NHj96mmgAAAAAAAACgpqkRQYGpU6fGggULIiIiNzc3jjrqqArPdeSRR0Zubm6k0+mYO3dufPLJJ5VVJgAAAAAAAABUezUiKDBlypSIiEilUtGtW7eoU6dOheeqW7dudOvWrfh68uTJ21wfAAAAAAAAANQUOdkuoCzmzJlT/Lhdu3bbPF/79u3jvffei4iIL7/8cpvnAwAAAAAAgK3qflpEh4O22OWKZz4ofjxzww7buyIgoWpEUGDFihXFjxs2bLjN8+Xn55c6NwAAAAAAAGw3PQZutcvwR+6tgkKApKsRRw9sfGN/yZIl2zzfsmXLih/n5uZu83wAAAAAAAAAUFPUiKBA8+bNix9/+umn2zzfxnNsPDcAAAAAAAAAfNfViKBAx44dIyIinU7HtGnT4ssvv6zwXF9++WVMnTq1+Lp9+/bbXB8AAAAAAAAA1BQ1Iiiw3377RYMGDSKVSkVExF//+tcKz3X99dcXP87Ly4sDDzxwm+sDAAAAAAAAgJqiRgQFcnJy4vDDD490Oh3pdDr+8Y9/xCuvvFLueV555ZW4+eabI5VKRSqVisMOOyzq1q1b+QUDAAAAAAAAQDVVI4ICERG/+c1vIiIilUrFunXr4sc//nE89NBDZR7/6KOPxvHHHx+FhYWRTqcz5gQAAAAAAACApKgxQYGePXvGiSeeGOl0OlKpVBQUFMQpp5wShx12WDz44IMxf/78EmMWLFgQDz30UPTr1y9OPPHEWLZsWUR8EzY4/vjjo3fv3lX9NAAAAAAAAAAgq3KyXUB53HHHHfHRRx/F1KlTI5VKRTqdjldeeaX4GIJmzZpF06ZNI5VKxeLFi2Px4sXFY78NGKTT6dhzzz3jrrvuytKzAAAAAAAAAIDsqTE7CkRE5OfnxwsvvBA9e/YsvvEf8U0IIJ1Ox6JFi2LGjBnxySefxKJFi4rbI6I4JHDggQfG888/Hw0aNMjmUwEAAAAAAACArKhRQYGIiB133DFee+21+M1vfhP5+fkZQYDSfiK+CRI0atQoLr/88nj11VejdevW2XwKAAAAAAAAAJA1NerogW/VqVMnrr766rjkkkvi7rvvjpdeeikmTJgQCxcuzOjXokWL+P73vx/9+vWLQYMGRaNGjbJUMQAAAAAAAABUDzUyKPCtJk2axAUXXBAXXHBBRERs2LAhFi1aFBERO+ywQ9SuXTub5QEAAAAAAABAtVOjgwKbql27drRs2TLbZQAAAAAAAABAtVUr2wUAAAAAAAAAAFVHUAAAAAAAAAAAEkRQAAAAAAAAAAASJCfbBVSGVatWxbJly2L9+vXlHtuuXbvtUBEAAAAAAAAAVE81Migwe/bsuOOOO+Lll1+O9957L1atWlWheVKpVBQWFlZydQAAAAAAAABQfdWooEBhYWH84Q9/iL/+9a+xYcOGiIhIp9NZrgoAAAAAAADK4N17I5bO3mKXYfU/KH48c8MOcdfaA7d3VUAC1ZigQDqdjpNPPjkef/zx4nBAKpWKVColLAAAAAAAAED19959EbPGb7HLFfX/+/iV9Z0EBYDtosYEBW6++eZ47LHHMsIB6XQ6OnToEF26dImmTZtGbm5utssEAAAAAAAAgGqtRgQF0ul0XHXVVRm7Bxx33HFx1VVXRdeuXbNcHQAAAAAAAADUHDUiKDBp0qT4+uuvi3cTOOOMM+KOO+7IdlkAAAAAAAAAUOPUynYBZfHhhx9GxDc7C+Tl5cX111+f5YoAAAAAAAAAoGaqEUGBhQsXRkREKpWKXr16RePGjbNcEQAAAAAAAADUTDUiKFCvXr3ix23atMliJQAAAAAAAABQs9WIoEDbtm2LH69cuTKLlQAAAAAAAABAzVYjggL7779/1Kr1TanTpk3LcjUAAAAAAAAAUHPViKBA27Zto2/fvpFOp2PatGkxffr0bJcEAAAAAAAAADVSjQgKREQMHz48ateuHRERv/vd77JcDQAAAAAAAADUTDUmKNC7d+8YPnx4pNPpeOyxx4QFAAAAAAAAAKACakxQIOKbnQSuu+66SKVSce2110afPn3ihRdeiMLCwmyXBgAAAAAAAAA1Qk62CyirQw89tPhxkyZNYvHixTFu3Lg46qijol69erHrrrtG06ZNo1atsmcfUqlUvPTSS9ujXAAAAAAAAAColmpMUOCVV16JVCpVfJ1KpSKdTkdExKpVq+LDDz/M+P3WpNPpcvUHAAAAAAAAgO+CGhMUKI0b/QAAAAAAAABQPjUqKPDtDgIAAAAAAAAAQMXUmKBAUVFRtksAAAAAAAAAgBqvVrYLAAAAAAAAAACqjqAAAAAAAAAAACSIoAAAAAAAAAAAJIigAAAAAAAAAAAkiKAAAAAAAAAAACRITrYL2BbvvfdejB49OsaNGxeffvppLF68OJYvXx6pVCoKCwtL9F+6dGkUFBRERETdunWjVatWVV0yAAAAAAAAAGRVjQwKfPjhh3HRRRfF2LFji9vS6fRWx40dOzYGDBgQERENGjSIefPmRf369bdbnQAAAAAAAABQ3dS4owdGjhwZvXr1irFjx5YIB6RSqS2OPe6446Jdu3aRTqdj5cqV8cgjj2zPUgEAAAAAAACg2qlRQYFHHnkkfvrTn8bq1auL29LpdOy8887RvXv3re4qUKtWrTj55JOLr0ePHr3dagUAAAAAAACA6qjGBAXmzp0bQ4YMiYj/7hxw3nnnxaeffhozZ86MRx99tEzzHHfccRHxTcDg1Vdf3T7FAgAAAAAAAEA1lZPtAsrqyiuvjFWrVkVERO3ateP++++Pn/zkJ8W/39qxA9/af//9Izc3N9avXx+LFi2Kzz//PHb5/9i78/Aoy3t//J+BhB1kB8WKAi7g0rqCiBU39LS2otWKWit+tfW09dTj0trWVlBbl+vYatUunh4ttlUUrfYcbRVbCxXFjcUqKMguCLLIvpPw/P7wx5RJWBIySWbyvF7Xlcu5J/f9PJ8Z88kdMu88c8ABtVIzAAAAAAAAABSaoriiQHl5eYwcOTIymUxkMpm44YYbckIC1VFSUhKHHHJIdjxt2rR8lQkAAAAAAAAABa8oggKvvfZarF69OpIkidLS0vjud79bo+Ptu+++2dvz58+vaXkAAAAAAAAAUDSKIigwc+bMiPjk7QWOPfbYaNOmTY2Ot/361atX1+hYAAAAAAAAAFBMiiIosHTp0uztT33qUzU+XqNG/3rYZWVlNT4eAAAAAAAAABSLoggKZDKZ7O3y8vIaH2/58uXZ223btq3x8QAAAAAAAACgWBRFUKBTp07Z2wsXLqzx8aZMmZK93aFDhxofDwAAAAAAAACKRVEEBfbbb7+IiEiSJCZPnhxbtmzZ42O9//778eGHH2bHRxxxRI3rAwAAAAAAAIBiURRBgeOPPz6aN28emUwmNmzYECNHjtzjY917773Z2126dImDDz44HyUCAAAAAAAAQFEoiqBA06ZN49RTT40kSSJJkrjxxhtj5cqV1T7OK6+8Eg888EBkMpnIZDJx7rnn5r9YAAAAAAAAAChgRREUiIi48cYbIyIik8nEhx9+GIMGDYolS5ZUef2YMWPii1/8YmzdujWSJInGjRvH9ddfX1vlAgAAAAAAAEBBKpqgQN++fWPIkCGRJElkMpmYMGFCHHLIIXHrrbfG9OnTY+vWrZXWlJeXx4svvhhDhgyJ0047LVasWJFdf/XVV8f+++9f9w8EAAAAAAAAAOpRSX0XUB0PPvhgTJ8+PSZPnhyZTCZWrlwZw4cPj+HDh0eTJk1y5vbu3TvmzJkTW7ZsiYjIBgSSJIn+/fvHHXfcUR8PAQAAAAAAAADqVdFcUSAionnz5jF69Og45ZRTsi/8R3wSAti0aVPOePr06bF58+ZIkiQiIhsSGDRoUPz5z3+Oxo0b19vjAAAAAAAAAID6UlRBgYiIjh07xl//+te48847o2PHjjlBgG3/3f4j4pPgwF577RU/+clP4s9//nO0adOm3uoHAAAAAAAAgPpUdEGBiE/CAN/5zndi3rx58eCDD8aQIUOiW7du2asGbPto27ZtfP7zn49777035syZE9///vddSQAAAAAAAACAVCup7wJqolmzZnHZZZfFZZddFhGfXDlgxYoVsXnz5ujQoUOUlpbWc4UAAAAAAAAAUFiKOihQUSaTifbt29d3GQAAAAAAAFBZ18N3O2XszMXZ22+V7Vub1QAp1qCCAgAAAAAAAFCw/u2O3U45+apH6qAQIO0a1XcBAAAAAAAAAEDdERQAAAAAAAAAgBQRFAAAAAAAAACAFCmp7wKqqkePHnk/ZiaTiVmzZuX9uAAAAAAAAABQqIomKDB37tzIZDKRJEnejpnJZPJ2LAAAAAAAAAAoBkUTFNimpi/uJ0mS98ABAAAAAAAAABSLogkK7LffftUKCZSXl8eKFSti3bp1EfGvgEHLli2jY8eOtVIjAAAAAAAAABS6ogkKzJ07d4/WzZ8/P5555pn42c9+FrNnz46ysrK48cYb44orrshvgQAAAAAAAABQBBrVdwG17VOf+lR885vfjHfeeSe+/OUvx6ZNm+LKK6+MX//61/VdGgAAAAAAAADUuQYfFNimefPm8cgjj8QJJ5wQSZLEt7/97Zg8eXJ9lwUAAAAAAAAAdSo1QYGIiMaNG8dPf/rTiIgoLy+Pm2++uZ4rAgAAAAAAAIC6laqgQETEcccdF927d48kSeK5556LpUuX1ndJAAAAAAAAAFBnUhcUiIg44ogjIiKirKwsXn311XquBgAAAAAAAADqTiqDAm3atMneXrBgQT1WAgAAAAAAAAB1K5VBge3fbmDNmjX1WAkAAAAAAAAA1K3UBQU2btyY83YD7du3r8dqAAAAAAAAAKBupS4ocOutt+ZcRaBPnz71WA0AAAAAAAAA1K3UBAVWrlwZ1157bdxxxx2RyWQiIqJt27bRr1+/eq4MAAAAAAAAAOpOSX0XUFW33HJLtdeUlZXFypUr4913341XXnklNm/eHEmSREREJpOJa665Jho3bpzvUgEAAAAAAKCyRW9HbFy1yyknlb6fvb1ya/P4Z/mnarsqIIWKJigwfPjw7JUA9sT2AYEkSaJ///7x3e9+N1/lAQAAAAAAwK49//2IeS/vcsrYvba7veXAOHnVNbVcFJBGqXnrgW0hgyRJ4vzzz49nn302mjRpUs9VAQAAAAAAAEDdKporCkT866oAe2LvvfeOU089Nb72ta/FiSeemMeqAAAAAAAAAKB4FE1QYMyYMdVeU1JSEm3atInOnTtHly5daqEqAAAAAAAAACguRRMUOOmkk+q7BAAAAAAAAAAoeo3quwAAAAAAAAAAoO4ICgAAAAAAAABAiggKAAAAAAAAAECKCAoAAAAAAAAAQIoICgAAAAAAAABAipTUdwFVdcstt9TbuW+66aZ6OzcAAAAAAAAA5FPRBAWGDx8emUymXs4tKAAAAAAAAABAQ1E0QYHtJUmyw/srBgmqOm9X56mvcAIAAAAAAAAA1IaiCgps/8L/9i/gb7u/KsGAJEl2Og8AAAAAAAAAGrqiCQqMGTMmIiJmzpwZ3/3ud2PlypWRJEmUlpbGoEGDom/fvnHQQQfFXnvtFRERq1ativfffz9ef/31eOGFF2LLli2RyWSiffv2ceedd0avXr3q8+EAAAAAAAAAQL0omqDASSedFOPHj8+GBDKZTHzrW9+Km266KTp27LjLtcuWLYubb745fvWrX8WKFSviO9/5Tjz77LPRv3//OqoeAAAAAAAAAApDo/ouoKoWLVoUX/ziF2PFihVRWloao0aNinvvvXe3IYGIiI4dO8Z9990Xo0aNipKSkli5cmV88YtfjA8//LAOKgcAAAAAAACAwlE0QYFhw4bF8uXLI5PJxI033hjnnntutY9x7rnnxo033hgREStWrIhhw4blu0wAAAAAAAAAKGhFERTYsGFDPP744xER0bx587juuuv2+FjXX399NG/ePJIkiSeeeCI2bNiQrzIBAAAAAAAAoOAVRVBg3LhxsWbNmshkMtGvX79o0aLFHh+rRYsWcfzxx0dExNq1a2PcuHH5KhMAAAAAAAAACl5RBAUWLFiQvd2lS5caH2/7Y2x/bAAAAAAAAABo6IoiKLBkyZLs7ZUrV9b4eKtWrcreXrp0aY2PBwAAAAAAAADFoiiCAu3bt4+IiCRJYvLkyTU6VpIkMXHixOy4Xbt2NToeAAAAAAAAABSToggKHHDAAdnbixcvjqeeemqPj/XUU0/F4sWLd3hsAAAAAAAAAGjoiiIocNJJJ0WbNm0ik8lEkiTx7W9/O+bNm1ft48ydOze+/e1vRyaTiYiI1q1bx8CBA/NcLQAAAAAAAAAUrqIICjRp0iQuvfTSSJIkMplMLFy4ME444YR47rnnqnyMv/zlL3HiiSfGRx99lD3O0KFDo7S0tBYrBwAAAAAAAIDCUlLfBVTVrbfeGk8++WR89NFH2bDAWWedFccee2xceOGF0bdv3zjwwAOjTZs2ERGxevXqmDFjRrz22msxcuTImDBhQjYgEBGx9957x6233lqfDwkAAAAAAAAA6lzRBAXatGkTf/nLX+K0006L5cuXZ9+G4I033og333xzl2uTJImIyK7p0KFD/OUvf4nWrVvXRekAAAAAAAAAUDCK4q0Htvn0pz8d//jHP+KII47IXh1g24v/u/rYft72xwAAAAAAAACAtCmqoEBERJ8+feLNN9+Mu+66K7p37569WsA220IB20uSJLp37x533XVXvPnmm9GnT5+6LBkAAAAAAAAACkbRvPXA9kpKSuLaa6+Na665Jl566aV4+eWXY8KECbF48eJYsWJFRES0a9cuunTpEsccc0wMGDAgPvvZz1YKEAAAAAAAAABA2hRlUGCbTCYTJ510Upx00kn1XQoAAAAAAAAAFIWie+sBAAAAAAAAAGDPCQoAAAAAAAAAQIoICgAAAAAAAABAipTUdwE19cEHH8S4ceNi1qxZsXz58lizZk1ERDz44IP1XBkAAAAAAAAAFJ6iDAokSRKPPPJI3HXXXfHOO+9U+lwmk9lhUODpp5+O++67LyIi2rdvH08++WSd1AsAAAAAAAAAhaLoggILFy6MCy+8MF5++eWI+CQYEBGRyWSyt3fmxBNPjIsuuig2bdoUmUwmxo8fH/3796/1mgEAAAAAAACgUDSq7wKqY+HChdGvX794+eWXK4UCtl1JYFc6duwY55xzTnY8atSoWqkTAAAAAAAAAApV0QQFysvL46yzzooFCxZk7+vUqVP86Ec/ir///e/x17/+dbdXFIiIGDx4cPb23/72t9ooFQAAAAAAAAAKVtG89cBDDz0Ub731VvaqAeeee248/PDD0bJly4iImDdvXpWOc/rpp0fEJ1cgeO+992LFihXRrl272ikaAAAAAAAAAApM0VxR4K677srePvHEE2PUqFHZkEB1tGvXLvbdd9/s+L333stLfQAAAAAAAABQDIoiKDBnzpyYMWNGdvzzn/88GjXa89IPOuig7O2ZM2fWqDYAAAAAAAAAKCZFERR48803IyIik8nEgQceGJ/+9KdrdLy2bdtmb69YsaJGxwIAAAAAAACAYlIUQYElS5Zkb/fp06fGx2vRokX29rp162p8PAAAAAAAAAAoFiX1XUBVrF27Nnu7ZcuWNT7e6tWr83q8YrBly5Z45ZVX4oMPPohFixZFq1atYp999okjjzwy9t9///ouDwAAAAAAAIA6UhRBgQ4dOmRvL1++vMbH++CDD3Z47Lo0e/bsePPNN2PChAnx5ptvxqRJk2LNmjXZz3fv3j3mzp1b4/MsXbo0hg0bFo8//vhOn7v+/fvHtddeG1/60pdqfD4AAAAAAAB24rI/73ZK5qpH6qAQIO2KIijQuXPniIhIkiT++c9/1uhYa9eujXfeeSc77t69e42OVx1jx46N22+/PSZMmJCXwMPuPPfcczF06NCct27YkfHjx8f48ePj4osvjgceeCA1V1kAAAAAAAAASKOiCAr07ds3e3vRokUxceLEOProo/foWH/4wx+ivLw8IiKaNm2ac+za9tZbb8ULL7xQJ+caO3ZsDB48ODZv3py9L5PJxFFHHRU9evSIlStXxuTJk2PZsmXZzz/yyCOxevXq+NOf/hSNGjWqkzoBAAAAAAAAqFtF8Wpw165d4/DDD8+Ohw0btkfHWblyZdx2222RyWQik8nEiSeeGE2aNMlXmXusadOm0bNnz7wdb8GCBXHuuefmhAROOOGEmDp1akyYMCFGjRoVL7zwQixYsCB+/vOfR2lpaXbeM888Ez/84Q/zVgsAAAAAAAAAhaUoggIREd/4xjeyt5977rn48Y9/XK3169evjy9/+cuxYMGCSJIkIiKuvvrqvNZYFaWlpfGZz3wmrrjiinjggQdi4sSJsWbNmvif//mfvJ1j2LBhsWLFiuy4f//+8be//S169+6dM69p06bx7W9/O0aNGpVz/89+9rOYN29e3uoBAAAAAAAAoHAUTVDgiiuuiAMOOCAiIpIkiWHDhsVFF11UpRe0n3/++TjuuOPixRdfzF5N4JhjjonPfe5ztV12jksvvTRWr14dkydPjt/85jfx9a9/PY466qicv+ivqRkzZsTDDz+cHTdp0iRGjBgRzZo12+mawYMHx6WXXpodb9q0KW6++ea81QQAAAAAAABA4SiaoEBJSUmMGjUqmjdvHplMJpIkiccffzx69uwZxx9/fPzgBz/ImX/nnXfG5ZdfHvvtt198/vOfj3fffTciPgkZ7LXXXjFy5Mg6fwzt2rXb5Qv2+fDoo49GeXl5dnzuuefGgQceuNt1N9xwQ8541KhRsXHjxrzXBwAAAAAAAED9KpqgQETE0UcfHY899li0aNEiMplMRERs3bo13njjjXjsscey85IkiR/84AcxYsSI7FsNbAsXtGnTJp544ono0aNHfT2MWvX000/njC+77LIqrevdu3f07ds3O163bl288MILea0NAAAAAAAAgPpXVEGBiIizzjorXn/99ejTp08kSZLzuW1vK7AtFLDtvohPwgOHHHJIjB8/Pk499dQ6r7sufPTRR/HPf/4zOy4pKYkTTjihyusHDhyYM37uuefyVRoAAAAAAAAABaLoggIREX369Im33347Ro0aFSeeeGKUlJREkiQ5HxGR/e9RRx0VDz30UEyZMiX69OlTn6XXqilTpuSMjzjiiGjZsmWV1/fv3z9nPHXq1LzUBQAAAAAAAEDhKKnvAvZUJpOJ8847L84777xYv359vPbaazF//vz4+OOPY/PmzdGxY8fo0qVLHH/88dGxY8f6LrdOvPvuuznjXr16VWt9z549d3k8AAAAAAAAAIpfUQQFysvLY926ddlxq1atolGjf10MoUWLFnHKKafUR2kFZebMmTnj/fbbr1rru3fvnjP++OOPY8WKFdGuXbsa1wYAAAAAAABAYSiKtx54+OGHo127dtGuXbvo2LFjLFq0qL5LKkgrV67MGXfu3Lla61u1ahXNmjXLuW/VqlU1LQsAAAAAAACAAlIUVxRYvHhxJEkSERFHHXVUdOvWrZ4rKkxr167NGTdv3rzax2jevHls3LgxO16zZk2N64qIWLJkSSxdurRaaypeIQEAAAAAAACAmiuKoEDLli0jIiKTyVT7cvppUjEoUPHqAFXRvHnzWLFixU6Puad++ctfxs0335yXYwEAAAAAAACw54rirQe6du1a3yUUpUwmUydrAAAAAAAAACgeRREUOPjgg7O358+fX4+VFLZWrVrljDds2FDtY1RcU/GYAAAAAAAAABS3onjrgU9/+tPRq1evmDlzZkycODFWrFgR7dq1q++yCk4hBwW++c1vxvnnn1+tNTNnzozBgwfn5fwAAAAAAAAAfKIoggIREV/72tfihhtuiPLy8rjjjjvizjvvrO+SCs5ee+2VM166dGm11q9du7ZSUKBt27Y1LSsiIjp37hydO3fOy7EAAAAAAAAA2HNF8dYDERHXXXdd9OvXL5IkiZ/97Gfx+OOP13dJBefAAw/MGc+bN69a6yvOb9++vSs3AAAAAAAAADQwRXNFgUaNGsVTTz0V55xzTrz++utx0UUXxYsvvhg33HBD9OzZs77LKwi9e/fOGc+cObNa62fPnp0z7tOnT41rAgAAAAAA4P/3289HzHt5l1OSjv+6PXbLgXHyqmtquSggjYomKHDLLbdERMTJJ58c7777bqxZsyYefPDBePDBB+PQQw+NI488Mjp37hytW7eu1nFvuumm2ii3Xhx22GE547fffjvWr18fLVq0qNL6V155ZZfHAwAAAAAAAKD4FU1QYPjw4ZHJZLLjTCYTSZJERMSUKVNi6tSpe3TchhQU2HvvveOII46It99+OyIiysrK4uWXX45BgwZVaf3YsWNzxv/2b/+W7xIBAAAAAAAAqGeN6ruAmshkMtmP6toWMmhozjnnnJzxb3/72yqtmzZtWrz++uvZccuWLascMAAAAAAAAACgeBRVUCBJkrx9NFQXX3xxNG7cODt+6qmnYsaMGbtdd+edd+aMv/zlL0ezZs3yXh8AAAAAAAAA9ato3npgzJgx9V1CUTjwwAPj0ksvjYceeigiIjZv3hxDhw6NF198cacv/P/v//5vjBgxIjtu0qRJDBs2rC7KBQAAAAAAAKCOFU1Q4KSTTqrvEvJiwYIFUVZWVun+jz76KGdcVlYWc+fO3eExWrVqFR07dtzpOW6++eZ4+umnY8WKFRERMX78+DjttNPif/7nf+KQQw7Jztu0aVP893//d1x33XU566+77rro3r17VR8SAAAAAAAAAEWkYIIC1157bfb2TTfdFG3btq2/YmrRgAEDYt68ebud9+GHH8YBBxyww89deumlOVcAqGjfffeNp556Ks4444zYvHlzRES88sor0adPnzj66KOjR48esWrVqpg0aVIsXbo0Z+1ZZ50Vt956a9UfEAAAAAAAAABFpWCCAvfcc09kMpmIiPjP//zP3QYFXnrppeztfv36RZMmTWqzvKIzcODAePrpp2Po0KHZMECSJDFhwoSYMGHCDtdceOGF8Zvf/CYaN25cl6UCAAAAAAAAUIca1XcB20uSpMpzBw4cGCeffHKcfPLJlS7bzyc+97nPxZQpU+Lf//3fo127djud169fv3jyySfj0UcfjZYtW9ZhhQAAAAAAAADUtYK5osCeSJIkexWCYjF37tw6PV/nzp3jV7/6Vfz85z+PV155JebNmxcfffRRtGzZMrp16xZHHnnkTt/iAAAAAAAAAICGp6iDAsUWEqhPTZo0iZNPPrm+ywAAAAAAAACgnhXUWw9UV3XeqgAAAAAAAAAAKPKgAAAAAAAAAABQPYICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIiX1XcD2MplMRES89tprMXfu3Cqvq+787X32s5/do3UAAAAAAAAAUIwKKigQEZEkSVx44YW1Nn97mUwmysrK9mgtAAAAAAAAABSjggsKZDKZSJKkSvO2qcp8AAAAAAAAAKAAgwIRuSGA2pgfIVwAAAAAAAAAQDoVTFBgv/3226MX/AEAAAAAAACAqiuYoMDcuXPruwQAAAAAAAAAaPAa1XcBAAAAAAAAAEDdERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQpqe8CAAAAAAAAIBXOvD1i46pdThl479+yt1dubV7bFQEpJSgAAAAAAAAAdWHvI3Y75R9bPqiDQoC089YDAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIiX1XQAAAAAAAACkwnPfi/jonV1OGbPX4uztt8r2jWvWnV/bVQEpJCgAAAAAAAAAdeGjdyLmvbzLKQNL66gWINW89QAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkSEl9FwAAAAAAAACp8JmLIvYfsMspw597O3t7bnmH2q4ISClBAQAAAAAAAKgLR1682yk3//GROigESDtvPQAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAAClSUt8FAAAAAAAAQCpMfiRi5Qe7nDKsxdvZ23PLO8TDm46v7aqAFBIUAAAAAAAAgLrw1qMR817e5ZThLf51e+yWAwUFgFrhrQcAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUAAAAAAAAAIEUEBQAAAAAAAAAgRQQFAAAAAAAAACBFBAUaoOHDh0cmk9njj6FDh9b3QwAAAAAAAACglggKAAAAAAAAAECKCAoAAAAAAAAAQIqU1HcB1L6RI0dGv379qjy/VatWtVgNAAAAAAAAAPVJUCAFunbtGvvvv399lwEAAAAAAABAARAUAAAAAAAAgLrQ9fDdThk7c3H29ltl+9ZmNUCKCQoAAAAAAABAXfi3O3Y75eSrHqmDQoC0a1TfBQAAAAAAAAAAdUdQAAAAAAAAAABSRFAAAAAAAAAAAFJEUCAFHnjggTjttNOiW7du0axZs2jdunXsv//+cdJJJ8WNN94Y48aNq+8SAQAAAAAAAKgjJfVdALXvscceyxlv2rQp1q5dG/PmzYuXXnopbrvttjjmmGPi9ttvj9NOO61WaliyZEksXbq0WmtmzpxZK7UAAAAAAAAApJmgABERMWHChBg0aFB8//vfjx//+MeRyWTyevxf/vKXcfPNN+f1mAAAAAAAAABUn6BAA9atW7f43Oc+F8cdd1z07t072rdvH40aNYqPP/44Jk2aFM8++2yMHj06Oz9Jkrjtttti69atcfvtt9dj5QAAAAAAAADUFkGBBui4446L0aNHx+mnn77TKwP0798/rrrqqpgwYUJcdNFFMWPGjOzn7rjjjujXr1+cffbZdVUyAAAAAAAAAHUkkyRJUt9FUL+WL18exx9/fLz//vvZ+w455JCYMmVKNG7cOC/nWLJkSSxdurRaa2bOnBmDBw/OjqdMmRKHHnpoXuoBAAAAAAAoRJmrHqnvEmCXkvsvru8SGoypU6fGYYcdlh3X5euhrihAtG/fPkaOHBnHHHNMbMuNTJs2LcaMGROnnXZaXs7RuXPn6Ny5c16OBQAAAAAAAMCea1TfBVAYjjrqqBg0aFDOfc8//3w9VQMAAAAAAABAbREUIOvMM8/MGb/99tv1VAkAAAAAAAAAtUVQgKz9998/Z7x06dL6KQQAAAAAAACAWiMoQFbz5s1zxhs2bKinSgAAAAAAAACoLYICZC1btixn3LFjx3qqBAAAAAAAAIDaIihA1uuvv54z3meffeqpEgAAAAAAAABqi6AAERGxcePGeOqpp3LuGzhwYP0UAwAAAAAAAECtERQgIiLuvPPO+PDDD7Pjxo0bx+c///l6rAgAAAAAAACA2lBS3wWQX7///e9j0KBB0aVLlyqv+c1vfhM333xzzn1Dhw6N7t2757s8AAAAAACA9Fr0dsTGVbucclLp+9nbK7c2j3+Wf6q2qwJSSFCggXnwwQfjyiuvjPPPPz++/OUvx8CBA6Nly5Y7nDthwoS47bbb4umnn865v1u3bvHjH/+4LsoFAAAAAABIj+e/HzHv5V1OGbvXdre3HBgnr7qmlosC0khQoAHasGFD/O53v4vf/e530ahRozjwwANj//33j7322isaN24cH3/8cfzzn/+MxYsXV1rbvn37eP7556Nr1671UDkAAAAAAAAAtU1QoIHbunVrTJ8+PaZPn77buaeeemqMGDEi9t133zqoDAAAAAAAAID6ICjQwFx99dXRrVu3eOWVV2LevHm7nd+yZcsYNGhQfOtb34pTTz21DioEAAAAAAAAoD4JCjQw55xzTpxzzjkREbFy5cqYOnVqzJ8/PxYvXhzr16+PrVu3Rtu2baNdu3bRu3fvOOKII6Jx48b1XDUAAAAAAAAAdUVQoAFr27ZtnHDCCfVdBgAAAAAAAAAFpFF9FwAAAAAAAAAA1B1BAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASBFBAQAAAAAAAABIEUEBAAAAAAAAAEgRQQEAAAAAAAAASJGS+i4AAAAAAAAAUuGyP+92SuaqR+qgECDtXFEAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFKkpL4LAAAAAAAAgFT47ecj5r28yylJx3/dHrvlwDh51TW1XBSQRq4oAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAAClSUt8FAHUrc9Uj9V0C7FJy/8X1XQIAAAAAAECD5ooCAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIoICAAAAAAAAAJAiggIAAAAAAAAAkCKCAgAAAAAAAACQIiX1XQAAAAAAAACkwpm3R2xctcspA+/9W/b2yq3Na7siIKUEBQAAAAAAAKAu7H3Ebqf8Y8sHdVAIkHbeegAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFKkpL4LAAAAAAAAgFR47nsRH72zyylj9lqcvf1W2b5xzbrza7sqIIUEBQAAAAAAAKAufPROxLyXdzllYGkd1QKkmrceAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFCmp7wIAAIpN5qpH6rsE2KXk/ovruwQAAAAAoIC5ogAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApIigAAAAAAAAAACkiKAAAAAAAAAAAKSIoAAAAAAAAAAApEhJfRdA3ZozZ0689dZbsXDhwli7dm3svffe0b179+jfv3+UlpbWd3kAAAAAAAAA1DJBgZR48skn42c/+1m8+uqrO/x8+/bt44ILLohbbrklOnbsWMfVAQAAAAAAAFBXvPVAA7d27dq48MIL4/zzz99pSCAiYvny5fGrX/0qDjvssBg9enQdVggAAAAAAABAXXJFgQasvLw8LrjggvjLX/6Sc3+nTp3iyCOPjL322itmzZoVkydPjiRJIiJi8eLFcfbZZ8ff/va3GDBgQH2UDQAAAAAAAEAtckWBBux73/teTkigtLQ07rvvvliwYEGMHj06Ro0aFRMnTowpU6bE8ccfn523adOmGDx4cCxatKg+ygYAAAAAAACgFgkKNFCzZ8+On//85zn3PfHEE3HVVVdFkyZNcu7v06dPvPjiizlhgY8//jhuvvnmOqkVAAAAAAAAgLojKNBA3XzzzbFly5bseOjQoXH22WfvdH7z5s1jxIgROSGCBx98MGbPnl2rdQIAAAAAAABQtwQFGqANGzbEk08+mXPfDTfcsNt1Bx10UAwePDg7Lisri0cffTTf5QEAAAAAAABQjwQFGqDRo0fH+vXrs+Pjjz8+DjnkkCqtveyyy3LGTz31VF5rAwAAAAAAAKB+CQo0QM8//3zOeODAgVVee+KJJ0ZJSUl2PHny5Fi8eHG+SgMAAAAAAACgngkKNEBTpkzJGR9//PFVXtuyZcs4/PDDc+6bOnVqXuoCAAAAAAAAoP4JCjRA7733Xs64V69e1Vrfs2fPnPG7775b45oAAAAAAAAAKAyCAg3M8uXLY/ny5Tn37bffftU6RsX5M2bMqHFdAAAAAAAAABSGkt1PoZisXLkyZ9yiRYto2bJltY7RuXPnnPGqVatqWlYsWbIkli5dWq01Fa9kMHPmzBrXQUR8vKC+K4Bd8nYnFAXfSylwvpcCAABAgfpwTcSS8ipPn1O2IWKN30VRWPzuKX8qvv65adOmOju3oEADs3bt2pxx8+bNq32MimvWrFlTo5oiIn75y1/GzTffXKNjDB48uMZ1AIXvsMe+V98lABQ930sBAACgoXg3Ivw7n8Lid0+1Z/78+XHUUUfVybm89UADUzEo0KxZs2ofo2JQoOIxAQAAAAAAACheggINXCaTqZM1AAAAAAAAABQHbz3QwLRq1SpnvGHDhmofo+KaisfcE9/85jfj/PPPr9aa1atXx4QJE6JNmzbRtm3b+NSnPhVNmzatcS1pNXPmzJy3b/jTn/4UvXr1qr+CoIjpJ8gPvQT5oZcgf/QT5IdegvzRT5AfegnyQy/l36ZNm2L+/PnZ8UknnVRn5xYUaGAKNSjQuXPn6Ny5c7XXHX/88TU+NzvWq1evOPTQQ+u7DGgQ9BPkh16C/NBLkD/6CfJDL0H+6CfID70E+aGX8uOoo46ql/N664EGZq+99soZr1+/PtatW1etYyxZsiRn3LZt25qWBQAAAAAAAECBEBRoYDp06BDt2rXLue+DDz6o1jHmzZuXMz7wwANrXBcAAAAAAAAAhUFQoAHq3bt3znjmzJnVWj979uxdHg8AAAAAAACA4iUo0AAddthhOeNXX321ymvXrVsXb7/99i6PBwAAAAAAAEDxEhRogM4888yc8dixY6u8dty4cVFWVpYdH3nkkdGlS5d8lQYAAAAAAABAPRMUaIDOOOOMaN68eXb86quvxrRp06q0dsSIETnjc845J5+lAQAAAAAAAFDPBAUaoBYtWsR5552Xc9+dd96523Xvv/9+PP3009lxSUlJXHTRRXmvDwAAAAAAAID6IyjQQA0fPjxKS0uz4xEjRsT//d//7XT+xo0b47LLLovNmzdn77v88sujZ8+etVonAAAAAAAAAHVLUKCB6tGjR1x99dU595133nlx//3354QBIiLee++9OPXUU2P8+PHZ+zp06BDDhg2rk1oBAAAAAAAAqDsl9V0AteeOO+6IqVOnxnPPPRcREVu2bIn/+I//iFtvvTWOOuqoaN26dcyePTsmTZoUSZJk1zVp0iSefvrp2HvvveurdAAAAAAAAABqiaBAA9a4ceMYNWpUXHHFFfH4449n71+yZEk8//zzO1zTuXPnePjhh+PEE0+sqzIBAAAAAAAAqEOCAg1cq1at4rHHHovzzjsvfvrTn8Zrr722w3nt27ePCy64IG6++ebo1KlTHVdJXejUqVPO20n4/wx7Tj9BfuglyA+9BPmjnyA/9BLkj36C/NBLkB96qWHJJNtfc54Gb86cOTFp0qRYuHBhrFu3Lrp27Rrdu3ePE044IZo0aVLf5QEAAAAAAABQywQFAAAAAAAAACBFGtV3AQAAAAAAAABA3REUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQRFAAAAAAAAACAFBEUAAAAAAAAAIAUERQAAAAAAAAAgBQpqe8CIA3mzJkTb731VixcuDDWrl0be++9d3Tv3j369+8fpaWl9V1elJWVxaRJk2Lq1KmxdOnS2Lx5c7Rq1Sq6desWBx10UBx66KFRUlKzbxcrV66M8ePHx4cffhjLli2Ljh07Rrdu3aJ///7Rtm3b/DwQGjy9BPlR6L1UF+xL5It+gvwo1F5avnx5TJgwIebMmRMrV66MJElir732in333TeOPfbY6Nq1a97OZW8iX/QT5Eeh9tKHH34Yr776aixevDhWrVoVHTt2jH322Sf69u0bnTp1yuu57E3kg16Chm/SpEkxY8aM+PDDDyMisr8PP/LII/N6HvtSLUiAWvPEE08kxx9/fBIRO/xo37598o1vfCNZunRpvdT3/vvvJ1/72teSNm3a7LTGiEiaN2+enH766clTTz1V7XNMmjQpGTx4cNKkSZMdHrtp06bJ4MGDk8mTJ+f/AdJgpLGXxowZs8tj7e6je/futf/AKTqF0kvdu3ev0df39h+XXnpptc5tXyJf0thP9iZqQ6H00va2bt2ajBw5MhkwYMBuv66PPPLI5IEHHki2bNmyx+ezN5EvaewnexO1oRB7qby8PPnDH/6QHHHEETutq3Hjxsnpp5+e/PWvf63x+exN5EMae8m+RL7NmjUreeyxx5Lrr78+Oemkk5LWrVsXzNfM5s2bk9tvvz3p2bPnTr+me/Xqldxxxx3J5s2ba3Qu+1LtERSAWrBmzZpkyJAhVf4BoEuXLsnzzz9fZ/Vt2bIl+dGPfpSUlJRU6weVCy64oFrnuf3225PS0tIqHbtJkybJnXfeWUuPmGKV5l7yDwvyqdB6KZ8vbP77v/97lc9rXyIf0txP9ibyqdB6aZtFixYlJ598crW/vo8++uhkxowZ1T6fvYl8SHM/2ZvIp0Lupf79+1fra/vKK69MNm7cuEfnszdRU2nuJfsS+TBmzJhk0KBBSfv27Qv2a+b9999PjjrqqFr5+a4i+1Ltcv1jyLPy8vK44IIL4i9/+UvO/Z06dYojjzwy9tprr5g1a1ZMnjw5kiSJiIjFixfH2WefHX/7299iwIABtVrfhg0b4rzzzqtUXyaTiUMPPTT222+/aNu2baxduzZmz54d06ZNi7Kysmqf57bbbosbb7wx577mzZvHscceG3vvvXcsXLgw3nzzzdi4cWNERGzevDluuOGGyGQy8Z3vfGfPHyANhl6C/Cj0XqqpL33pS1WaZ18iH/QT5Eeh9tLSpUvj5JNPjmnTpuXcX1paGkceeWR07949GjVqFAsWLIiJEydm94yIiIkTJ8bJJ58cL7/8cnTv3r1K57M3kQ/6CfKjUHtp4cKF0a9fv5g/f37O/W3bto2+fftG+/btY/ny5fHaa6/FqlWrsp9/4IEHYsWKFfHYY49FJpOp8vnsTdSUXoKae+utt+KFF16o7zJ26qOPPorTTz895s2bl3N/r1694tBDD40kSWLq1Kkxa9as7OcmTpwYgwYNitdeey06d+5c5XPZl+pAvUUUoIG6/vrrcxJMpaWlyX333Zds2rQpZ97UqVMrXXqpQ4cOycKFC2uttq1btyZf/OIXc87ZrFmz5KabbkoWLFiwwzXr1q1L/vSnPyVDhgxJvvrVr1bpPM8880ySyWRyzvP1r3+90mWklixZklxxxRU58zKZTPLcc8/V+LFS/NLeSxUTyFdffXUyZ86cKn/Mnz8/3w+bIlWIvTR//vxqfT1v+7juuuty6tt///2TrVu37vZ89iXyJe39ZG8iXwqxl5IkSS666KJKf5Hy7//+78nixYsrzV2xYkXyve99L2nUqFHO/DPOOKNK57I3kS9p7yd7E/lSiL20efPmpF+/fjnnatWqVfLLX/6y0iWcN2/enPziF79IWrZsmTP/Rz/6UZXPZ28iH9LeS/Yl8uHuu++u9HNUxCeX1694mf+6vqJAeXl50rdv35wa9t5772T06NGV5j733HNJ165dc+b279+/Sr/LSxL7Ul0RFIA8mjVrVqVLoPzpT3/a6fz169dX+oHoyiuvrLX67r///krfwN99990qr6/K+wSWlZUlBx98cM55rrnmml2u+c///M+c+X369EnKysqqXBcNj16q/A+LYcOG1aBi0qrQe6m6DjnkkJzabrnllt2usS+RL/rJ3kR+FGovzZkzp9Iv4r7//e/vdt19991Xad1rr722yzX2JvJFP9mbyI9C7aVf//rXlV4gGj9+/C7XjBs3Luf9m5s2bZrMmTNnt+eyN5EPesm+RH7cfffdSWlpafKZz3wmueKKK5IHHnggmThxYrJ58+ZKX2N1HRT43e9+l3P+9u3b77I3Zs+enbRr1y5nzciRI3d7HvtS3REUgDz66le/mvONaOjQobtdM3369JwfOkpKSpJZs2blvbZ58+YlrVq1yp6nWbNmydSpU/N+noceeijnOTj44IN3+z5OGzdurPRN/+GHH857bRQPveQfFuRHIfdSdb388ss5j6VRo0bJBx98sNt19iXyRT/Zm8iPQu2le++9N6euLl26VOn9aLdu3ZocccQROWtvvPHGXa6xN5Ev+sneRH4UYi9t3bo1OeCAA3LquvXWW6u0dvjw4TnrLrnkkt2usTeRD3rJvkR+LF++PNmwYcMOP1efQYGysrJK/TRixIjdrvvtb3+bs6Znz55JeXn5LtfYl+pOowDyYsOGDfHkk0/m3HfDDTfsdt1BBx0UgwcPzo7Lysri0UcfzXd58ZOf/CTWrl2bHd94443Rp0+fvJ/nd7/7Xc74mmuuiaZNm+5yTdOmTePqq6/e5XFID70E+VHovVRdDz30UM540KBB8alPfWq36+xL5IN+gvwo5F6aPXt2znjQoEG73S8iIjKZTHzhC1/IuW/GjBm7XGNvIh/0E+RHofbSlClTYs6cOdlxs2bN4qqrrqrS2v/4j/+IZs2aZcdPPPFEzu8xdsTeRE3pJcifdu3a5XztFYqXX345p5+6desWX/nKV3a77pJLLolu3bplx7NmzYrx48fvco19qe4ICkCejB49OtavX58dH3/88XHIIYdUae1ll12WM37qqafyWtuaNWtyfsBq2bJlpW+Y+fDxxx/HuHHjsuMmTZrERRddVKW1F198cZSWlmbH//jHP2L58uV5r5HCp5cgPwq5l6pr7dq1MWrUqJz7Lr/88t2usy+RL/oJ8qOQe2ndunU543333bfKaysGbVasWLHTufYm8kU/QX4Uai+99NJLOeO+fftG27Ztq7S2ffv2ceyxx2bHGzdujD//+c87nW9vIh/0EjR8Tz/9dM74q1/9ajRu3Hi36xo3blwpULCrPrcv1S1BAciT559/Pmc8cODAKq898cQTo6SkJDuePHlyLF68OF+lxeOPP56TdvzSl74UrVu3ztvxt/nrX/8a5eXl2fHRRx9d5fO0adMmjjrqqOy4rKws/vrXv+a9RgqfXoL8KOReqq6KvdepU6c4++yzd7vOvkS+6CfIj0Lupa5du+aMN27cWOW1Fee2b99+p3PtTeSLfoL8KNReWrBgQc74sMMOq9b6ww8/PGe8qxc37U3kg16Chq8mfV5x7nPPPbfTufaluiUoAHkyZcqUnPHxxx9f5bUtW7as9EPH1KlT81JXRMSYMWNyxqeffnrejr29mjwHERH9+/fPGefzOaB46CXIj0LupeqqeJn0Sy65JCcdvDP2JfJFP0F+FHIvnXjiiTnjSZMmVXntxIkTc8bb/+VZRfYm8kU/QX4Uai9V/OvHqv4F9M7mv/POOzuda28iH/QSNGybNm2KmTNn5tzXr1+/Kq+vuFfMmDEjNm/evMO59qW6JSgAefLee+/ljHv16lWt9T179swZv/vuuzWuaZs33ngjZ7ztG+uGDRvi0UcfjS9+8YvRs2fPaN68ebRt2zZ69eoV559/fvz3f/93rFmzpsrnqVhzIT0HFA+9tGNjxoyJc889N3r06BGtWrWK5s2bR7du3eLoo4+Oq666Kv74xz/Gli1banQOGpZC7qXqmDZtWqX3LavqZdLtS+SLftoxexPVVci9dOqpp8bBBx+cHY8bNy7efvvt3a778MMP449//GN2XFpaGhdeeOFO59ubyBf9tGP2JqqrUHupSZMmOeNNmzZVa33F+dOmTYutW7fucK69iXzQSztmX6KhmD59es5f+Xfu3DnatGlT5fVt2rSJjh07Zsfl5eXx/vvv73CufaluCQpAHixfvrxSOnG//far1jEqzp8xY0aN64qIWLlyZU7Sq0mTJtGjR4/4xz/+EYceemhcfPHF8cwzz8Ts2bNj48aNsWrVqpg1a1Y8+eSTceWVV8YBBxwQ9957b5XOVTFRVijPAcVDL+3cSy+9FE8//XTMmTMn1q1bFxs3boyFCxfGpEmT4he/+EWcd9550aNHj/jFL34RSZLk4yFTxAq5l6rrwQcfzBn369cv+vTpU6W19iXyQT/tnL2J6ij0XmrUqFE89NBD0bRp04iI2Lp1a5x33nkxd+7cna5ZvHhxDB48OOf9eH/4wx/GPvvss9M19ibyQT/tnL2J6ijkXurQoUPOeNGiRdVaX3H+xo0b44MPPtjhXHsTNaWXds6+RENR071iR2t21uf2pbolKAB5sHLlypxxixYtomXLltU6RufOnXPGq1atqmlZERHx0Ucf5Yz32WefeOqpp+KUU06JOXPm7Hb9xx9/HFdffXVccsklUVZWtsu5FZ+Hio9pd2rrOaB46KWaWbBgQVx11VXxhS98odJzSboUci9VR1lZWfz+97/Pue+KK66o8nr7Evmgn2rG3sQ2xdBL/fv3j2effTY6deoUEZ/8QumII46Ia665JkaPHh3Tpk2L6dOnx4svvhg/+MEP4tBDD40JEyZk11955ZXxox/9aJfnsDeRD/qpZuxNbFPIvdS7d++c8WuvvVat9Tuav7Pa7E3UlF6qGfsSxaCme8WO1tiXCkNJfRcADcHatWtzxs2bN6/2MSquqellyrep+E117dq18ZWvfCV7iaTu3bvHt771rRgwYEB06NAhli9fHi+//HL84he/yEn7/+EPf4guXbrEXXfdtdNz1fR5qK3ngOKhlypr06ZNnHbaaXHSSSfFoYceGp07d47mzZvHihUr4v3334+//vWv8fjjj8fGjRuza/785z/H4MGD44UXXqh0iTXSoZB7qTqeffbZWLx4cXbcsmXLuOCCC6q83r5EPuinyuxN7Ili6aXTTjst3nvvvbjnnnvikUceiTlz5sQ999wT99xzz07XHHLIIXHLLbfE+eefv9vj25vIB/1Umb2JPVHIvXTSSSfljGfNmhWvvvpqld6n+eWXX47Zs2dXun9ntdmbqCm9VJl9iYamLvvcvlS3BAUgDyp+42rWrFm1j1Hxm1fFY+6pii9uLlu2LHv7/PPPj4cffrjSufv16xdXXXVVfPWrX40nnngie/9Pf/rTOPvss+PEE0/c4blq+jzU1nNA8dBL/9K1a9f47W9/G0OGDNnp83DsscfGxRdfHHfccUf8v//3/+K5557Lfu4f//hHfO9734uf/exn1XmYNBCF3EvVUfEy6RdccEG0atWqyuvtS+SDfvoXexM1UUy9tO3qT9sum74r/fv3j+HDh8dpp51WpWPbm8gH/fQv9iZqopB7qWvXrnHqqafGiy++mL3vuuuui3HjxkXjxo13uq6srCyuu+66HX6uqi/I2JuoLr2Uez77Eg1RXfa5falueesBqAWZTKZO1lTFtr92rujYY4+NRx99dKdprGbNmsWjjz4axx57bM79P/7xj6t87uo+ptp6Diheae6lQw45JIYOHVqlH4S6du0af/7znyv91c0vfvGLKr0tAg1fIfVSVS1atCief/75nPsuv/zyGh3TvkQ+pLmf7E3kU6H20m9+85vo2bNn/PjHP45p06btdv748eNj0KBBccQRR8Qrr7xS7fPZm8iHNPeTvYl8KrReuvHGG3PGr776alxyySWxadOmHc7fuHFjXHzxxfHGG2/s8PONGlXtpQB7EzWV5l6yL5EWddnn9qXaJSgAeVDxr7E2bNhQ7WNUXFPdv/DamZ0d56677oqSkl1fVKSkpKRSevGFF16IJUuWVOlc1X0eaus5oHjopT2XyWRixIgRsffee2fv27x5c6W/ICUdCrmXqurhhx/O/gVaxCfvK9i/f/9qHcO+RD7opz1nb2J7xdBLP/nJT+LrX/96rFu3LnvfMcccEw899FDMmDEj1q1bFxs2bIg5c+bEyJEj4+STT87OmzJlSpx00knx8MMP7/Ic9ibyQT/tOXsT2yv0Xjr55JPj29/+ds59I0eOjN69e8dPf/rTeP3112PGjBnx+uuvx1133RW9e/eOUaNGRcQnf7TQoUOHnLVt27bd4XnsTdSUXtpz9iWKRV32uX2pbgkKQB4U8g9DOzpO9+7d47Of/WyV1g8YMCB69OiRc98//vGPKp3LN3CqSy/VTIsWLSr9w6fiX5CSDoXcS1X10EMP5Yz35K+f7Uvkg36qGXsT2xR6L/3973+PH/3oRzn3DR8+PN5444247LLLolevXtGiRYto1qxZ7L///jFkyJD4+9//Hg888ED2L1bKy8vj8ssv3+VfQtubyAf9VDP2JrYp9F6K+OSPEy688MKc++bMmRPXX3999OvXLw466KDo169ffOc734m5c+dGxCd/7fz73/++Ui2CAtQWvVQz9iWKgaBAwyUoAHmw11575YzXr1+fk5qviop/WZyvHzh2dJx+/fpV6xh9+/bNGb/33ns7nFfxeVi6dGm1zlNbzwHFQy/V3Jlnnpkzfuedd/J+DgpfIfdSVYwbNy5mzJiRHZeWlsYll1xS7ePYl8gH/VRz9iYiCr+XbrzxxkiSJDu+9NJLY9iwYbu9bOXXv/71nMvZlpeXx9VXX73T+fYm8kE/1Zy9iYjC76WIT352e/TRR+Puu++O9u3b73b+AQccEC+++GJ86UtfikWLFuV8rkuXLjtcY2+ipvRSzdmXKHQ13Ssiqt7n9qW6JSgAedChQ4do165dzn0ffPBBtY4xb968nPGBBx5Y47oiPvmL56ZNm+bct/2ljKpin332yRl//PHHO5xXseaKj2l3aus5oHjopZrbf//9c8abN2+OVatW5f08FLZC7qWqqHiJvS984QvRuXPnah/HvkQ+6KeaszcRUdi99OGHH8Zrr72Wc9+wYcOqvP573/teNG/ePDueOHFivP322zuca28iH/RTzdmbiCjsXqroP//zP2POnDnx61//Os4999zo0aNHtG7dOpo1axY9evSIs846K37/+9/H1KlTY+DAgTFr1qzYvHlzdn2vXr12+kKJvYma0ks1Z1+i0NV0r9jRmp31uX2pbgkKQJ707t07Zzxz5sxqrZ89e/Yuj7enGjduHAcffHDOfRVf7NydivM3bty4w3mF+hxQXAr166gue6kmtv+l2jZ7cikoil+h9tLurFmzJp544omc+/b0MunF+hxQeIr1aymf/VQT9ia2KdReeuutt3LGPXr0iAMOOKDK61u2bFnpSlOvv/76DucW6nNA8SnUr6W67KeasDexTaH20o60adMmrrzyyvjjH/8Ys2bNitWrV8eGDRti1qxZ8cwzz8RXvvKV7Nf2q6++mrO24hUOd1VzIT8HFK5i+jqqrV6qCfsShe7ggw+Oxo0bZ8dLliyJNWvWVHn96tWrY9myZdlx48aNd/oCfjF9P2kIBAUgTw477LCcccUfInZl3bp1lRLyFY9XE0cccUTOeOXKldVaX3F+hw4ddjivJs9BRFR678F8PgcUD71UM9v/wFWb56HwFXIv7cpjjz0W69evz467desWZ5xxxh4dy75EvuinmrE3sU2h9lLFn9G6du1a7WNUXLOjr/sIexP5o59qxt7ENoXaSzX14osv5owHDhy407n2JvJBL9WMfYlC17Rp0+jZs2fOfdXp8/Hjx+eMDzzwwJ3+EZ59qW4JCkCeVHwfobFjx1Z57bhx46KsrCw7PvLII/P6Xkef+9zncsZTp06t1vopU6bkjPfdd98dzjv99NNzUmUTJ06scqpszZo1MWnSpOy4pKQkTj/99GrVScOgl2qm4l/bdOrUKUpLS/N+HgpfIffSrlS8TPpll12Ws7dUh32JfNFPNWNvYptC7aWKl4+t7nvqRkSsXbs2Z9yqVasdzrM3kS/6qWbsTWxTqL1UE2vWrIknn3wyO27VqlVccMEFO51vbyIf9FLN2JcoBjXp84pz/+3f/m2nc+1LdUtQAPLkjDPOyLlE0KuvvhrTpk2r0toRI0bkjM8555x8lhZnnXVWTjrrzTffjOXLl1dp7YoVK+KNN97Iue/EE0/c4dyOHTvGgAEDsuPNmzfHo48+WqXzPPLII7Fly5bs+LOf/Wy0b9++SmtpWPRSzVTsudpKOlP4CrmXdubdd9/N+cdxJpOJyy67bI+PZ18iX/RTzdib2KZQe2mfffbJGU+fPj3nahxVsf0voyJ2/lfU9ibyRT/VjL2JbQq1l2ri3nvvzQnpXHTRRdG6deudzrc3kQ96qWbsSxSDir35+9//PsrLy3e7rry8PP7whz/s8ljbsy/VsQTIm0suuSSJiOzH0KFDd7tm+vTpSZMmTbJrSkpKkpkzZ+a9tosvvjintptvvrlK62655Zacdd27d0+2bt260/kPPvhgzvyDDz442bhx4y7PsXHjxuTggw/OWffwww9X6/HRsOilPTNmzJgkk8nknOcPf/hDXs9BcSnkXtqRa6+9NqfeU045pcbHtC+RL/ppz9ibqKgQe6msrCxp165dTl2//vWvq7z+mWeeyVkbEcnChQt3Ot/eRL7opz1jb6KiQuylPfXee+8lzZs3z9bVqlWrZO7cubtdZ28iH/TSnrEvUR1jxoyp9DvmulJWVpYccMABOecfMWLEbteNGDEiZ03Pnj2T8vLyXa6xL9UdQQHIo1mzZiWlpaU534j+93//d6fzN2zYkPTv3z9n/pVXXrnb81T8R/OYMWN2u2b27Nk5P3Q1bdo0GT9+/C7XjB8/PmdNVf6BX1ZWVumb8bXXXrvLNddcc03O/D59+iRlZWW7fUw0XGnvpdGjRydvvfXWbmvZ3muvvZa0b9++0g9QW7ZsqdZxaFgKuZcq2rx5c9KpU6ec4zzyyCPVPk5F9iXyJe39ZG8iXwq1l772ta/lzG/btm3yzjvv7PY88+bNS7p165az9oQTTtjlGnsT+ZL2frI3kS+F2ktJklTra3PatGmVeui+++6r0lp7E/mQ9l6yL1EX8hkU2JNe+t3vfpezpn379smcOXN2On/OnDmVQqQjR47c7XnsS3VHUADy7Prrr8/5ZlRaWprcd999yaZNm3Lmvfvuu5V+EOrQoUOVkvJ7+gvkH/7whznrWrVqlfzyl79MNm/enDNvy5Ytya9//eukVatWOfOPO+64So9jR5555plKKcivf/3rybJly3LmLV26tNIvEDKZTPLcc89V6fHQsKW5l4YNG5ZkMpnkjDPOSH77298mixcv3uncDz74ILn++usr/UOstLQ0efHFF6v0eGjYCrmXtvfkk0/mHKNdu3bJhg0bqn2cHbEvkS9p7id7E/lUiL00f/78nL8ai4ikdevWyX333ZesW7eu0vxNmzYlI0aMSDp27FjpXC+99NJu67M3kS9p7id7E/lUiL2UJJ9c1fCiiy5KnnnmmWT9+vU7nPPhhx8mw4YNq9R3n//856t1JUN7E/mQ5l6yL5FP8+fPT+bMmVPpY+TIkTlfM926ddvhvDlz5iRLly7d5Tn2pJfKy8uTvn375qzbe++9k9GjR1ea+/zzzyddu3bNmdu/f/8q7032pbohKAB5VlZWlvzbv/1bpW+ynTt3Ts4888zk/PPPT44++uhK3+CaNGlSpV8oJcme/wJ569atyfnnn19pfdu2bZMzzzwzueiii5Izzzwzadu2baU53bp1S+bPn1/l5+EnP/lJpWM0b948GThwYDJkyJDkpJNOqvRDV0Qkd955Z5XPQcOW5l4aNmzYDtedcsopybnnnptcfPHFyVlnnZUcdNBBleZFRNK4cePk97//fZUeCw1fIffS9j73uc/lHOOqq66q9jF2xb5EPqS5n+xN5FOh9tJTTz2VNG7ceIf7xYABA5Ivf/nLyZAhQ5KBAwdWCoJu+/jJT35S5efB3kQ+pLmf7E3kU6H20pe+9KXs/NLS0uSII45IvvjFLyYXX3xx8vnPfz45/PDDK9UUEcmgQYN2GMzZHXsTNZXmXrIvkU/du3ff4ddJdT4uvfTSXZ5jT3opSZJk4cKFyX777Vdp/YEHHpgMHjw4Ofvss5NevXpV+vz++++ffPTRR9V6HuxLtU9QAGrBmjVrkgsuuKDK37A7d+5crXTTnn4DT5JP3qflyiuvrNaGctxxxyUffvhhtZ+H2267rVIqcmcfpaWlyR133FHtc9CwpbWXdvQPi6p+9OjRI3n55Zer/DhIh0LupSRJkgULFlT6RfLkyZOr9yCrwL5EPqS1n+xN5Fuh9tKzzz6bdOnSpdpf5y1btqzy5Z23Z28iH9LaT/Ym8q0Qe2n7Fzer8lFSUpJ8//vfr9Fly+1N1FRae8m+RD4VclAgSZJk+vTpyZFHHlnlWo466qhkxowZe/Rc2Jdql6AA1KInnngi6dev306/abVv3z75xje+kSxZsqRax63JN/Bt/va3vyWnn376DhP+2z4OO+ywZMSIETV6H5dJkyYlZ599dqX3Z9/20aRJk+Tss8+ulReEaDjS1ksTJ05MvvnNbyaHH374Lo+7/T9e+vfvnzz88MPJxo0bq/0YSI9C7aUf//jHlf7xUFvsS+RL2vrJ3kRtKcRe+vjjj5Pbbrst6dmz526/1rt06ZJcf/31ydy5c6v5yP/F3kS+pK2f7E3UlkLqpSeeeCI55ZRTkmbNmu3y67t169bJ5ZdfnkybNm0PH3UuexP5kLZesi+RT4UeFEiSJNm8eXNy++23Jz169NhpDT179kxuv/32Sm/ZW132pdqTSZIkCaBWzZkzJyZNmhQLFy6MdevWRdeuXaN79+5xwgknRJMmTeq1tqVLl8Zrr70WixYtimXLlkXr1q2jS5cu0b9//9h3333zdp4VK1bE+PHj48MPP4yPP/44OnToEN26dYv+/ftHu3bt8nYeGrY09tLGjRvj3XffjXnz5sWiRYtizZo1sWXLlmjVqlW0a9cuDjjggDjmmGOiRYsWeXw0NHSF3Et1xb5EvqSxn+xN1IZC7aUFCxbExIkTY9GiRbFy5cpIkiT22muv6NSpUxx55JHRq1evvJ3L3kS+pLGf7E3UhkLqpc2bN8fbb78dM2bMiEWLFsX69eujpKQkOnfuHH369Imjjz46SktL835eexP5kMZesi+RNhMnToz3338/Fi5cGBER++yzTxx00EFx9NFH5/U89qX8ExQAAAAAAAAAgBRpVN8FAAAAAAAAAAB1R1AAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAAAAAABSRFAAAAAAAAAAAFJEUAAAAAAAAAAAUkRQAAAAAKi2sWPHRiaTyX4MHz58l/MHDhyYMz+fx06zuXPn5jxXQ4cOre+SAAAAKAKCAgAAAFCPRowYkfNC78CBA/f4WBVfYN9///3zVicAAADQcAgKAAAAQAoNHTo0J1Qwd+7c+i4plYYPH57z/2Hs2LH1XRIAAAApICgAAAAAAAAAACkiKAAAAAAAAAAAKVJS3wUAAAAAxWfgwIGRJEnRHbuh2X///T1XAAAAVJsrCgAAAAAAAABAiggKAAAAAAAAAECKeOsBAAAAoMEoKyuLKVOmxJQpU2LZsmWxdu3aKC0tjVatWkW3bt2iZ8+e0adPn2jcuHG1jz1r1qyYNm1azJs3L1avXh2ZTCbatWsX++yzT/Tt2zc6depUC4+o9iVJEpMmTYpp06bFkiVLYtOmTdGpU6fo1q1bDBgwIFq1apX3873xxhsxY8aMWLhwYTRp0iS6du0aAwYMiH333Tev5wIAAGDHBAUAAAAgJUaMGBGXXXbZDj93wAEH7HRd9+7dY+7cuTn3jR07Nk4++eTseNiwYTF8+PB8lLlHx168eHH85Cc/iUcffTQ+/vjjXc5t0aJFDBgwIC688MIYOnToTuetW7cunn322Xjqqadi7NixsWTJkl0e96ijjoprr702hgwZsssgQsXHt72d3b9NkiQ547lz5+b8v7v00ktjxIgRuzzGNsuWLYvbbrst/vCHP8TSpUt3OKdJkyZxyimnxPDhw6Nv375VOm7Fr7Pf/va3MXTo0Ni6dWvcc889cf/998ecOXN2uPbEE0+M//qv/6ryuQAAANgz3noAAAAAKGp///vf4+CDD4777rtvtyGBiIj169fHCy+8ED/84Q93Oe/CCy+MIUOGxKhRo3YbEoiImDRpUnzlK1+JQYMG7fSF90Lxpz/9KXr06BF33333LmvdvHlzPP/889GvX7+48soro6ysbI/Ot2TJkjjllFPiuuuu22lIICJi3LhxceKJJ8ajjz66R+cBAACgalxRAAAAAChaM2bMiLPOOis2bNiQc3/37t2jd+/e0a5du4iIWL16dcyZMydmzJgRW7ZsqdKxt27dmjNu06ZN9OnTJzp37hytW7eOjRs3xoIFC+Ltt9/OOf/f//73OPPMM2P8+PHRtGnTGj7C/HvooYfia1/7WqXHt+1tGVq0aBEffPBBvPHGG1FeXp79/H//93/HBx98EM8880yUlFT9V0obNmyIs846K958882IiGjatGkcc8wx0a1btygvL4/33nsv3n333ez8LVu2xNChQ+Owww6LI444ooaPFgAAgB0RFAAAAICUOO+882LgwIEREXH99dfHH//4x+znxo0bt9P3h6/Oi8J17aabbsp5kf6UU06Jn/3sZ/HpT396h/M3bdoU//jHP+Lpp5+OsWPH7vb4n/70p+MrX/lKfO5zn4s+ffrscM769evj0UcfjRtvvDF75YFJkybFsGHD4o477qg0v1+/ftm/qr/nnnvi5z//efZzI0eOjH79+u22rj311ltvxTe+8Y2ckMBnPvOZ+MUvfhH9+/fPmbt06dL40Y9+FA888ED2vueffz5uuummuO2226p8zptuuimWLVsWzZs3j5tvvjm++c1vRsuWLXPmvPHGG3HxxRfHzJkzI+KTsMA111wTL7744p48TAAAAHajcP+lDwAAAORVq1atolWrVtnb29t3331j//33r4eq9lySJPHMM89kxwcddFD85S9/2eVf8Tdt2jQGDRoUgwYNqnQVgoruv//+Kj0nLVq0iCuuuCIGDRoUAwYMiPnz50dExK9+9av4wQ9+EG3atMmZ36xZs+xx27Ztm/O5rl271ur/h8svvzw2b96cHQ8YMCBGjx4dLVq0qDS3U6dO8etf/zp69eoV3/nOd7L333nnnXHhhRfG4YcfXqVzLlu2LFq2bBljxoyJY489dodzjjvuuHjxxRfjsMMOizVr1kRExJgxY2LmzJnRq1ev6jxEAAAAqqBRfRcAAAAAsCeWLVsW69aty46/8IUvVOtS/82bN9/l56v7gv1+++0Xd999d3a8evXqnCBDfRszZkxMmjQpO27Tpk08/vjjOwwJbO/666+Ps846KzveunVrzuOsirvvvnunIYFt9ttvv7jyyiuz4yRJYsyYMdU6DwAAAFUjKAAAAAA0CNsu+1+fvvCFL0STJk2y4/Hjx9djNbkefvjhnPG3vvWt2Geffaq0tuJbKIwcOTI2bdpUpbXdunWLyy67rEpztw8kRERMnjy5SusAAACoHkEBAAAAoCh17NgxOnbsmB0/+eSTMW7cuFo/79atW2PNmjWxcOHCmDt3bs7HwoULo3379tm57733Xq3XU1Uvv/xyzvgrX/lKldceeuihcdRRR2XHGzdujIkTJ1Zp7RlnnBElJVV798vevXvnjAsh/AEAANAQCQoAAAAARSmTycSQIUOy4w0bNsTJJ58cQ4YMiT/96U+xdu3avJxn3bp18fjjj8dFF10Uffr0iaZNm0abNm2iW7duccABB1T6+Oijj7JrV6xYkZcaamrFihUxa9as7Lht27aVXpTfnf79++eM33zzzSqt69OnT5XP0a5du5zxqlWrqrwWAACAqqtanBsAAACgAA0fPjyee+657Ivg5eXl8fjjj8fjjz8ejRs3js985jNx/PHHx4ABA+Kzn/1s7L333tU6/v/8z//ED37wg1i6dOke1VcoL3RXrP/AAw+MTCZTrWMccsghOeOq/rV/xRf/d6W0tDRnvGXLliqvBQAAoOpcUQAAAADqUcUXa7du3brHxyovL9/lsRuiDh06xKuvvhpf+tKXKn2uvLw8Jk6cGPfff38MGTIkunXrFv37948HH3ywSi9AX3PNNfG1r31tj0MCETX7/5lPFa9ssNdee1X7GBXXLF++vErrGjXy6ycAAIBC419qAAAAUI9at26dM67J5fLXrFmTM27Tps0eH6uYdOrUKZ588sl455134rvf/W4cfvjhOwxJJEkSr776alxxxRVx+OGHxz//+c+dHvOJJ56Ie+65J+e+Qw89NG699dYYPXp0TJ8+PVauXBkbN26MJElyPrp3757vh1hjSZLkjPMRIklDEAUAAKCh8tYDAAAAUI8qXpZ95cqVe3ysimurc8n3huCwww6LO++8M+68885YuXJlvP766/HKK6/E2LFj49VXX42ysrLs3OnTp8epp54ab775ZhxwwAGVjjVs2LCc8a233ho33nhjlV4cX716dc0fTJ61b98+Z7wnb4lQcU3avr4AAAAaElcUAAAAgHq0995754znzZsXGzZs2KNjTZs2LWfctWvXPa6r2LVt2zbOOOOMuOWWW+Kll16KxYsXx3/913/lXD7/448/jh/96EeV1s6YMSPee++97Pizn/1s/PCHP6xSSGDDhg01CnvUlk6dOuWM33///WofY/r06Tnjzp0716gmAAAA6o+gAAAAANSjgw8+ONq2bZsdb926NSZPnrxHx5o4cWLOuF+/fjudm7bLxrdv3z6uv/76GD16dM5j/7//+7/YunVrztwZM2bkjM8666wqn+fVV1+tdJn/Xamr/w/t2rWLnj17ZscrV67MCUNUxfjx43PGxx57bF5qAwAAoO4JCgAAAEA9ymQy0b9//5z7nnjiiWofZ8mSJTF27Nic+0444YSdzm/atGnOeNOmTdU+ZzHq27dvHHbYYdnxmjVrYtmyZTlzKl4RYPurEOzOiBEjqlVPXf5/GDBgQM74kUceqfLa9957LyeI0qxZszj66KPzVhsAAAB1S1AAAAAA6tnQoUNzxg899FAsWrSoWse44447oqysLDs+7LDDdvkX39tfxSAiqn2+YlZSUpIzrvhifbt27XLGFd/SYWcmTJgQjz32WLVqqcv/D1/96ldzxvfff3989NFHVVr7/e9/P2c8ZMiQSs8bAAAAxUNQAAAAAOrZueeem3NZ+NWrV8eFF14Ya9asqdL6J554Iu69996c+66//vpdrundu3fO+IUXXqhitYXjrbfeiqeffjrKy8urvObtt9+Of/7zn9nx3nvvXemKAZ/+9Kdzxg8//PBuX1CfPXt2nH/++bFly5Yq1xJRt/8fTjnllPjMZz6THa9atSouvPDC2LBhwy7X3X333fG///u/2XEmk4lrrrmmtsoEAACgDggKAAAAQD37/9q7v9Cu6j+O46/lzzn/ZDZFQQMLBvaPLzIV/LNhXrToNiMqyEqWxqSELnalV66LGHqh3wtxDbpICFKpriOKubLByJtgm8q+aahZNgRJXbl1N/j+5r8ySzmPB+zie/b+nJ3Dvnfnec6ZMmVKPvjgg6o73b/66qusWLEiH3/8cUZHR6+5bnh4OG1tbXnxxRerLpY/++yzk+4e/39r165NTU3NxOedO3dm+/btOXz4cI4dO5ZKpTLx8+OPP97mGd4ZlUplIrJob2/P119/fd0L9X/88UcOHDiQZ555JmNjYxPbX3311UmzCxcurHpM/6+//pp169blyJEjk2avXLmS999/PytXrkylUkldXV1mzZp1y+ewfPnyqvmPPvoob731Vr744osMDQ1V/R8qlcot7/d6uru7U1tbO/H5yy+/THNzc7799ttJs7/88ku2bNmSd955p2p7e3t7SqXSbR8LAAAA/53/3XwEAAAAuNOamppSLpfT1tY2cSF7cHAwL7zwQqZPn57GxsYsWLAgdXV1GRkZydDQUE6cODFpP6VSKR9++GFVBHAtDz/8cJ577rkcPHgwSTI6OpqOjo50dHRMml28ePE/cpH6Tvnhhx/S2dmZzs7O1NbW5vHHH8+iRYsyZ86cXL16NWfPns13332XCxcuVK179NFHs23btmvu87333svatWsnXucwMDCQVatWZcmSJXnyySdTW1ubn376KX19fbl48eLEuj179qSjo6Nq243MnDkzmzdvzs6dO5Mk4+PjKZfLKZfL15wfHx+/pf1eT2NjY8rlct58882J71l/f39WrlyZhoaGPPHEE6mrq8upU6fS19dX9TqLJHn66aezY8eO2zoGAAAA/ntCAQAAALhLbN68OY888kheeeWVnDt3bmL7pUuX0tvbe9P1L7/8crq6ujJjxoxb+nv79u3L6dOn88033/ztY77bjI6O5ujRozl69OgN59asWZNDhw5l5syZ1/z96tWr09XVlU2bNlU9pWBwcDCDg4OT5qdMmZJdu3altbX1mrHFjbz77rs5duxYPvvss7+07u9644038uCDD+b111+vChqOHz+e48ePX3fdxo0bs3fv3kydOvXfOEwAAADuIK8eAAAAgLtIS0tLhoeHs3v37pRKpZs+GeCBBx7ISy+9lP7+/uzfv/+WI4Ekqa+vT09PTz755JNs2LAhpVIp9fX198yF4JaWlhw6dCitra1paGi46XxNTU2am5uzf//+9PT0ZP78+Tecf+2119LT05OnnnrqujN1dXVZv359+vr68vbbb//VU0iSTJs2LZ9++mk+//zzbNq0KcuWLcvcuXOrXhHwT3v++edz4sSJbN26NfPmzbvu3NSpU9PS0pLe3t50d3ffM98NAAAAbqxm/HafWQcAAADcMSMjIzly5EjOnDmTkZGRXL58OXPmzEl9fX0ee+yxlEql3Hef+wCS5Pz58/n+++8zPDyc8+fP57fffsu0adMye/bsNDQ0ZOnSpZk7d+7f2vfJkyfT29ub06dP5/fff8/8+fOzcOHCrFmzJvfff/8/fCb/rrGxsfT392dgYCA///xzrly5knnz5uWhhx5KU1PTPX9+AAAATCYUAAAAAAAAAIACccsBAAAAAAAAABSIUAAAAAAAAAAACkQoAAAAAAAAAAAFIhQAAAAAAAAAgAIRCgAAAAAAAABAgQgFAAAAAAAAAKBAhAIAAAAAAAAAUCBCAQAAAAAAAAAoEKEAAAAAAAAAABSIUAAAAAAAAAAACkQoAAAAAAAAAAAFIhQAAAAAAAAAgAIRCgAAAAAAAABAgQgFAAAAAAAAAKBAhAIAAAAAAAAAUCBCAQAAAAAAAAAoEKEAAAAAAAAAABSIUAAAAAAAAAAACkQoAAAAAAAAAAAFIhQAAAAAAAAAgAIRCgAAAAAAAABAgQgFAAAAAAAAAKBAhAIAAAAAAAAAUCBCAQAAAAAAAAAoEKEAAAAAAAAAABSIUAAAAAAAAAAACkQoAAAAAAAAAAAFIhQAAAAAAAAAgAIRCgAAAAAAAABAgQgFAAAAAAAAAKBAhAIAAAAAAAAAUCBCAQAAAAAAAAAoEKEAAAAAAAAAABSIUAAAAAAAAAAACkQoAAAAAAAAAAAFIhQAAAAAAAAAgAL5ExnirfzLt7SqAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1202,7 +1202,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1235,7 +1235,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 30, @@ -1244,7 +1244,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1572,7 +1572,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAACAwAAASYCAYAAACeDs3kAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAC4jAAAuIwF4pT92AADlh0lEQVR4nOzdd5hV1b0//s/Qe5MuVVBBFHsBUYpYEDvhem2xiy25N0ZN7JpYE2M0dlTURL1GjR27ERURRAQUaYIMHaXL0Mv+/ZEf8/VwBpgzMzAznNfrec7zsNfstdZnnzrMfp+1c5IkSQIAAAAAAAAAyCoVSrsAAAAAAAAAAGD7ExgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAGCHM2TIkMjJyUm5DRkypLTLArYgNzc37XX71FNPbbf5vW+wI1m6dGk88MAD0b9//9h1112jQYMGUbFixZTn9z777FPaZQIAAGVApdIuAAAAdmTr1q2Lb7/9NiZOnBhLliyJJUuWxPr166NmzZpRq1ataNGiRbRp0ybatGkTVatWLe1yAYBy7pFHHomrr746li1bVtqlAAAA5YDAAAAAlLDVq1fHK6+8EoMGDYqhQ4fGypUrt9qncuXKseeee8aBBx4Y3bt3j6OOOioaNmy4HaoFAHYUf/zjH+PGG28s7TIAAIByxCUJAACgBL3++uvRvn37OO200+L9998vVFggImLt2rUxevToGDhwYJxxxhnRpEmT+PWvf12ovj169EhZYrhHjx7FOAKykaXYdxweS8heo0aNiptvvjmtPScnJ1q1ahWdO3eOvffeO/+2++67b/8iAQCAMscKAwAAUAKSJInLLrssHn744RIZb8OGDTFjxowSGQsA2PHdc889sWHDhpS2a665Jq688spo0KBBKVUFAACUdQIDAABQAi6++OIYOHBggT9r1apV9OrVKzp16hSNGjWKmjVrRl5eXixevDi+++67GDVqVIwdOzZWr169nasGAHYEGzZsiDfeeCOlrX///nH77beXUkUAAEB5ITAAAADF9OqrrxYYFthvv/3iT3/6U/Tq1StycnK2OMaKFSvinXfeiVdeeSVeeeWVWL58+bYqF4AC9OjRI5IkKe0yoEgmTJgQy5YtS2k79dRTS6kaAACgPBEYAACAYkiSJH7zm9+ktZ9yyinx3HPPRdWqVQs1To0aNeKUU06JU045JZYuXRpPPvlkzJ49u6TLBQB2QAVdxmj33XcvhUoAAIDyRmAAAACKYdiwYZGbm5vStvPOO8dTTz1V6LDApurWrRv/+7//W/ziAICssHTp0rS2mjVrlkIlAABAeVOhtAsAAIDy7O23305rO+ecc6J27dqlUA0AkI1WrVqV1ra1yyEBAABEWGEAAACKZfr06Wlt+++/fylUsmNLkiRGjRoV3333XcyZMyfWrl0bDRo0iA4dOsRBBx0U1apV2y51zJgxI77++uuYP39+zJ8/PypWrBgNGzaM5s2bR5cuXaJWrVrbvIbvvvsuRo0aFbNnz47Vq1fHTjvtFM2bN49u3bpF/fr1t/n8ZcmMGTPiyy+/jOnTp8fy5cujdu3a0b59++jatWtG98WECRNi9OjRMXfu3FizZk00btw42rVrF926dYtKlUruv815eXkxceLEmDx5cixcuDCWLVsWVatWjfr160fjxo3jgAMOiKZNm5bYfNvD0qVLY+TIkfHDDz/kH1PNmjWjQYMGsdtuu8Uee+wRderUKfF5x40bF6NHj4558+bF+vXro2HDhtGyZcvo1q1bmf1W9cqVK2P48OExceLEWLx4cVSvXj0aNWoUe+65Z+y9994lfnJ36dKlMWzYsJgzZ0788MMPUbVq1WjevHnsu+++0aFDhxKda1tbtWpVjBgxIv++q1y5cjRv3jx222232G+//bb5ifEVK1bEF198Ed99910sWrQo1q1bF3Xr1o2ePXtGp06dCjVGkiTxzTffxNSpU2P+/PmxcOHCqFmzZjRq1CjatGkTBx54YIm+32wLP/zwQ3z11Vcxf/78+PHHH2PDhg3RqFGjaNKkSRxyyCHRoEGDbV7DjBkzYvTo0TF9+vRYtmxZVKxYMZo0aRKnnnpq1KhRo1BjrFixIkaMGBHz5s2L+fPnx/Lly2OnnXaKRo0axT777BNt27bdxkfxn9fn8OHD47vvvoulS5dGrVq1olGjRrHffvtt09fnd999FxMmTIgFCxbEggULYsOGDVG7du1o3rx5dOjQIXbbbbeoWLFiicy1ZMmS/M+H+fPnx+rVq6Nhw4bRuHHjOPDAA6NZs2YlMk/Ef15f33//fXz99dcxb968+Omnn2LdunVRvXr1qFWrVrRo0SLatGkTu+22W5l/nQEAlIoEAAAosqOOOiqJiJTbu+++u83n3XTOotymTZuWNu6TTz5ZqP2KUuNNN92U8Rh5eXnJddddl7Rq1Wqzx1GzZs3k/PPPT77//vv8fh999FHafh999FGRjmPWrFnJb3/726RDhw5bvD8rV66cHHbYYcnzzz+fbNiwIeN5tnR/rV+/Phk0aFCy5557bnb+ihUrJkcccUTy+eefF2q+m266qdjPobPPPjvj4yyM7t27p8zTvXv3lJ//85//TA444IDN1lW1atXkrLPOSmbOnLnZOVatWpXcd999Sfv27Tc7Tr169ZJrrrkmWb58eZGOY+3atcm7776b/PrXv046d+6c5OTkbPU+bdeuXXLDDTck8+fPL/Q82/uxXLJkSXLbbbclBx10UFKxYsUtjluxYsXkkEMOSW699dZk1qxZWxx32rRpaf2ffPLJ/J+vWrUqueeee5I2bdpsdr4qVaokJ598cjJ+/PhCH89GRX3fKOj+/7kpU6Yk55xzTlKjRo3N1t2kSZPklltuSfLy8jKue1NDhw5Njj322KRKlSqbna99+/bJ3/72t2TNmjX5/c4+++yUfVq3bl3sWrZma/f51KlTk3PPPXeL912rVq2S6667rkj33dYeu2HDhiUnn3xyUrVq1QLnLszn2siRI5OzzjoradKkyRZfK7Vr105OOeWUZMSIEYWqfdPHa1u95hctWpTcfPPNyb777rvF97AKFSokBxxwQPLII4+kPK8Kq3Xr1putb82aNclDDz2U7LXXXpudf2u/q6xduzZ57LHHkl69em3xtbHxffiaa65JFi5cmPFxbO11NHr06KRfv35J5cqVNzt/69atk/vvv79I92NBxowZk5x33nlJy5Ytt/q8qFevXnLKKackzz//fLJ69eqM51qxYkXyl7/8JenSpctWPx86deqU3HnnncV635s0aVLy61//equvr423GjVqJIcddlhy2223JZMmTSryvAAAOxqBAQAAKIYTTjgh7Y+RAwcO3ObzFuckwZb+uF6WAgMffPDBFoMCBf0R+KmnnkqSpGQCAytWrEiuvPLKpFq1ahnft507d06++eabjObb3P01a9aspEuXLhnNf+211251vvIYGFi6dGnSt2/fQtdXt27d5MMPP0wbf/z48VsMX2x6a9++fTJjxoyMjuGf//xn0rBhwyLftzVq1EgeeOCBQs21vR7LdevWJbfeemtSr169Is1RsWLFLZ4M3VJg4Ntvv91qaGfTuR5++OFC3X8bbYvAwAMPPJDRe0ibNm2SyZMnZ1T3RitXrkzOP//8QgVTNt46d+6cH7Yqa4GBQYMGJdWrVy/0sbRq1Sr54IMPMpp/c4/dmjVrkssuu2yr9+WWPtdyc3OTU045pUivlVNOOSVZvHjxFmvf1oGBdevWJXfccUeRXu9t27ZNhgwZktFjsbnAwOTJkwv1fr2l31VeeeWVLYbDNnerU6dOod+HN9rc62jDhg3J9ddfv9WT6D+/7bvvvskPP/yQ0fw/9/333ycnnXRSRu8JP7/ttddeGc332GOPJc2aNct4niZNmiQvvvhiRnNtvD+3Fv7Y2rwAAPxHhQAAAIqsoOXDX3jhhVKoZMfy5ptvxrHHHhszZswodJ8VK1bEOeecE4888kix5583b1706NEj7r777gKvC701X3/9dXTt2jXeeuutYtXx/fffx8EHHxyff/55Rv1uv/32uP7664s1d1mzbNmy6NmzZwwePLjQfZYuXRrHH398jBkzJr9tzJgxcdhhh8W4ceMKPc6UKVOiR48esXTp0kL3GT9+fCxYsKDQ+29qxYoVcfnll8cll1xS5DFK0qJFi+KYY46J66+/PpYsWVKkMdavXx8rVqzIuN/IkSOjS5cuMXHixIzmuuSSS+Kxxx7LeL6Scu2118bll1+e0XtIbm5udOvWLWbPnp3RXCtXrozjjz8+nnjiiUiSpND9Nr5X5ebmZjTftvbwww/HeeedFytXrix0nxkzZsSxxx6b0XtEQdavXx+/+MUv4sEHH8zovvy54cOHx0EHHRQvv/xykfq//PLLccghh8SUKVOK1L+4li1bFieccEJcc801RXq9T5s2LY488sgYNGhQseqYOHFidOnSJaP3659LkiRuuummOPnkk4t0X/70009x+eWXx4ABA2L9+vVFqiEiYsOGDXHWWWfFrbfemtE4o0ePjsMPPzzy8vIynvOjjz6KAw88MF599dUiP49/+umnQu23du3auOCCC+LCCy+MuXPnZjzPDz/8EP/1X/8Vf/zjHwvd5+yzz45bb7011qxZk/F8AACkc9EmAAAohq5du8bAgQNT2j744IO4//7741e/+tU2m3fvvffO//eUKVNi+fLl+ds1a9aM9u3bb3WMKlWqbJPaiuvzzz+Pfv36pf0ROCcnJw455JA49thjo2XLllGpUqWYNWtWvPvuu/HJJ5/k/xH+8ssvj9tvv73I8//www9xyCGHxPTp09N+tueee0b37t2jU6dOUa9evYiI+PHHH+Pzzz+Pt956K5YtW5a/77Jly6Jfv34xbNiw2HfffTOuY9myZdGnT5/8E4c5OTnRtWvX6N27d7Rq1Spq1aoV8+fPj88++yxeeeWVtJOSd955Zxx//PFx8MEHFzh+06ZN859HeXl5MXXq1JSft2vXLmrVqrXFGlu1apXxcRXVL3/5y/jqq6/yt/fff//o06dPtG3bNmrVqhXz5s2Lf//73/HGG2/Ehg0b8vdbsWJFnH322fHVV1/FggUL4rjjjouFCxdGRETlypWjZ8+e0atXr2jevHlUqlQpcnNz47XXXosRI0akzP/999/HNddcEw899FCR6m/dunXsu+++sccee0SLFi2idu3aUb169cjLy4s5c+bEmDFj4t13300LJTzyyCOx1157xaWXXrrZsbf1Y7l06dI49NBDCzxhX7ly5ejSpUv06NEjdt5556hfv34sX7485s+fH2PGjInhw4fH999/v8W5t2TWrFlx1VVX5Z+4qlSpUvTo0SN69uwZO++8c1SrVi3mzp0bH330UQwePDjtZNwVV1wRRx55ZLRp06bINRTFo48+GnfccUf+dqNGjaJPnz5x4IEHRqNGjWLVqlUxZcqUeOWVV+Lbb79N6fvjjz/GgAED4s033yz0fKeddlp88MEHae3169ePE044Ifbff/9o3LhxLFu2LKZOnRqvv/56jB8/PiL+E5A6+eSTo1OnTkU82pI1fPjwlMBTpUqVolevXtG7d+/YeeedY/Xq1TF9+vR4/fXXY/To0Sl916xZE/369YshQ4bEIYccUqT5b7zxxnj99dfztxs0aJD/2DVu3DhWrlwZs2bNirfffjtycnLS+g8ZMiT69OmT9p5coUKFOOyww6Jr167Rtm3bqFevXv5YH3/8cXz44Ycpz99JkybFscceG19++WXUqVMnbZ5WrVql/C6waNGimDlzZso+HTt23Oxn/eZe8ytWrIgePXqkvN9u1K5du+jZs2d07tw5GjRoEJUqVYoFCxbEyJEj46233or58+fn77vxJHKTJk2ib9++Bc61JStWrIgTTjgh//064j+fwX369Il27dpF/fr148cff4zJkyfHiy++WOAYl1xySTz66KNp7Q0aNIgjjzwy/3VRo0aNWLJkSXz77bfxzjvvxKRJk1L2HzhwYNSrVy/uuuuujI8jIuK6666LZ599Nn+7ZcuW0bdv39hrr72iYcOGkZeXFxMmTIh//etfMW3atJS+kyZNit///vfxwAMPFHq+wYMHx0knnRTr1q1L+1nDhg2jd+/eccABB0SjRo2iWrVqsWTJkpgxY0Z8+eWXMWzYsJTfZbZmw4YNcdJJJxUYkGzevHkcccQRse+++0bDhg2jWrVqsWjRohg9enS8/fbbKaHQJEnixhtvjIYNG241KPf000/HP/7xj7T2Ro0axdFHHx177bVXNG/ePKpXrx4rV66MZcuWxbRp0+Lbb7+Nzz//PBYvXlzo4wMAyBqlur4BAACUcz/++ONml0w+/vjjk08//XSb17C1671norQvSbBy5coClx3fbbfdks8++2yz/caOHZvsv//++fsX9JgUZmnx9evXJ7169Urr27Vr12T48OFb7Lt48eLkiiuuSFv6t23btslPP/201bk3nfPny5gffPDByahRozbbd9q0acl+++2XNsbRRx+91XmTpGQu4VCSNn1O//z64W3btk3ef//9zfb98ssvC7yW8XPPPZccf/zx+du9e/fe4tLvgwYNSls6ukKFCsnMmTMLdQw33XRTstdeeyX33ntvoZeYX7VqVfK3v/0tqVOnTtrxz5o1q1BjlPRjuWHDhpT7beMtJycnueCCCwpV15gxY5KrrroqqVu37hZrKeiSBD9/HfTp02eL9+XYsWOTNm3apI0xYMCAQh1rSV6SYGPdlStXTu64445k5cqVBfbdsGFDct999yUVKlRIG+Pzzz8vVN1PP/10gZ9Bv/nNb7Z4bfAXX3wxady48WbfN0vrkgQ/f8y7dOmSTJw4cbP933rrrWTnnXdOG6NDhw7JqlWrtjp/QY/dxtd9xYoVkxtuuGGL9+Gmj+vcuXMLfP8599xzk+nTp2+xlilTpiRHH310Wt9f/OIXWz2OJCm5z++CLnWwxx57JO+9916yYcOGzfZbsWJFcscddySVK1dO6Vu/fv1CvW9uekmCn7//tmnTJnnzzTc323fdunXJ2rVrU9oGDRqUdhwNGjRIHn300c2+HpPkP6/Jl19+OeW1sfH2xhtvbPU4Nr3/qlSpkv97Qe3atZOBAwcm69atK7Dv6tWrk9/97ncFPicL+xnw3XffFXgZiSZNmiQPP/xw2v20qVWrViWvvfZacuyxxyZt2rTZ6nw33nhj2lwtWrRIXnjhhc0eZ5Ikydq1a5PHHnssqVWrVtr9taXfd5IkSbu8RMWKFZM//elPhXrNr1u3Lhk6dGhy0UUXJe3atdvq/gAA2UJgAAAAiumqq64q8GTNxtvOO++cnHvuucnAgQOTMWPGbPWPtZnakQIDt9xyS1q/jh07JvPnz99q37y8vKRLly6bfRwKc+LvrrvuSut32WWXbfEkyaYKOklx1113bbXf5uo+7rjjtnhyY6OFCxemnaiqUKHCVk9SJUnZDwz8/Lkwd+7crfb/7LPP0oIbPz/5c9pppxXqdXjrrbem1XDbbbcV6hiWLFlSqP0KMnbs2LTQwDXXXFOoviX9WD788MNp41WtWjX5v//7v4zHWrp0abJw4cLN/rygwMDG20UXXZSsX79+q3NMmTIl7cR3nTp1kuXLl2+1b0kGBjbeTx988MFW+ydJktx2221p/c8///yt9lu+fHnSoEGDtL5/+9vfCjXv+PHjCzwxGlF6gYGNtx49ehTqvW/q1KlJ8+bN0/r/4Q9/2GrfzT12FSpUSF544YWMj6dPnz5pJzKfffbZQvffsGFDcu6556bVM2LEiK32LYnP73/+859pY5x00knJ6tWrCz3Gu+++mxYauOSSS7bab9PAwMbb7rvvnsyePTuj45g2bVpSo0aNlHF22223Qge+kiRJZsyYkbRo0SJljE6dOm3194GCAhcR/wkrjBkzplBzX3jhhWn9//jHPxaq78EHH5zWt1OnTsmMGTMK1f/ntvb8GTZsWFrYqUuXLhl9/o0ZMybt865Pnz6b3X/cuHFpx3fzzTcXer6fK8znAgBAthAYAACAYlq5cuUWT1RveqtWrVpy0EEHJb/61a+SF198MZk3b16x5t9RAgNr1qxJmjZtmtKncuXKyfjx4ws957x58wr8Zl1hTvwtX748adiwYUqfvn37Fnrun7vgggtSxmnatOlWT7gUVHObNm0y+sP7Qw89lDbG448/vtV+5SEwULVq1eTrr78u9BjHHnvsZk8+FfYkwcqVK9OeT926dSvqYWXkgQceSJm3cePGhepXko/lmjVrklatWqWNN3DgwCKNtzWbCwwcdNBBGQWtrr766rQxCnPivqQDA4U9aZ8k/7mvN/2mfIsWLbba7/HHH0+b99RTTy30vEmSJK+//nqB9ZdmYGCnnXZKFixYUKxxmjZtmqxZs2aL/Tb32P32t7/N+Fi++OKLtHH+9Kc/ZTzOmjVrko4dO6aMc/LJJ2+1X3E/vzds2JB06tQppf/ee++91fuwIJuGrapVq5b88MMPW+xTUGCgUqVKyVdffZXx/JdeemnKODVr1ky+//77jMcZOnRoWk2vvfbaFvtsLjCwtX4/t3DhwpSVNgr72fPuu++mzduwYcNkzpw5hZ47E5t+zjZv3jxZvHhxxuM888wzaXVvLlxR0PtVpoESAADSVQgAAKBYqlWrFm+99VYcf/zxhdp/1apV8cUXX8T9998f/fv3j2bNmkWPHj1i0KBBsXr16m1cbdn16quvxrx581LaLr/88ujYsWOhx2jSpEnccMMNRZp/0KBBsWDBgvztChUqxP3331+ksW688caUa1vPmzcvPv/884zHuemmm6Ju3bqF3v+///u/o2LFiilto0aNynjesuiss86Kvfbaq9D79+vXr8D2G2+8MWrUqFGoMapVqxbHHXdcStvYsWMjSZJC11FUZ555ZspzaOO1uren559/PuUa0xERRx99dFx44YXbtY677rorKlWqVOj9zzzzzLS27f062GWXXeKyyy4r9P6VK1eOU089NaVt1qxZ8eOPP26x38CBA1O2K1asGHfffXfhC42I448/Pnr37p1Rn23t5ptvjp122qnQ+/fo0SPtNT9v3rx47bXXMp67du3acfPNN2fcb9Pr27dv3z6uuOKKjMepXLlyXHvttSltb7/99jb//WDw4MHx7bffprTdd999Ubly5YzHuuKKK6J27dr526tWrYq3334743HOOuus2HfffTPqM3/+/HjyySdT2q666qpo27ZtxvMfeuihccQRR6S0vfLKKxmP07179zjhhBMKvX+DBg3i2GOPTWkbM2ZMbNiwYYv9Nn0ORkTcf//90axZs0LPXVjjxo2Lt956K6Xt9ttvj3r16mU81umnnx677rprSturr75a4L7Lli1La8vkvQIAgIIJDAAAQAmoV69evPbaa/H3v/892rdvn1HfJEni448/jvPPPz922223ePbZZ7dRlWVbQScTinJi8pxzzokqVapk3O+ll15K2e7Vq1eRTjBERLRs2TLt5PaQIUMyGqNmzZpx+umnZ9Snfv36aX90nzRpUkZjlFXnn39+RvsXdJKpdu3a0b9//2KNs2zZspg9e3ZGYxRF3bp1o3Hjxiltw4cP3+bz/tzrr7+e1nb11Vdv1xp23XXX6NGjR0Z9OnXqFDVr1kxp296vg/POOy8qVMjsTy4HHXRQWtuW6l62bFl8+eWXKW1HH310tGjRIqN5IzJ/fW1L1apVi7POOivjfhdddFFaW1FOUp966qlRq1atjPqsWrUq3nzzzZS2c845Jy3AVVibnixetWrVNn/9b/oZuOuuu0b37t2LNFb16tWjZ8+eKW2ZfgZGFO15OXjw4Fi5cmVK2wUXXJDxOBv17ds3Zbsox1GU32U2fT/Iy8vb4mfPTz/9FB9//HFKW5s2bTL+zCusTZ8vtWvXTgs9FVZOTk706dMnpW1z93NB4YChQ4cWaV4AAP4fgQEAACghOTk5cdZZZ8WECRPijTfeiNNOOy3q1KmT0RgzZsyIM888M84999ysW21g05MhHTp0yGh1gY0aNGiQ8QnG1atXx4gRI1LaDj300Izn/rlNwwajR4/OqP8hhxxSpOBDu3btUraXLl2a8RhlTY0aNeKAAw7IqE/r1q3T2g455JCMvy3bpk2btLYlS5ZkNEbEf4JBX375ZTz66KNx+eWXx0knnRRHHHFEHHjggbHPPvsUeFu0aFHKGJt+239b2hhk+rmdd945evXqtd1qiIg4/PDDM+5ToUKFtMdte78OinKiddPXbsSW6/7iiy/SvnG86Ynmwjr22GNTVrQoTT169MhoZZWNevfunfaZW5ST7Jue6C6MESNGpH1mF+czpEGDBmn3QaafIZna9PXetWvXYo1X3M/A6tWrxyGHHJLxvJseR+vWrWPnnXfOeJyNNj2O3NzcjD8Dtsf7waeffhrr169PaTv99NOLHFrZmk3v5/322y+qVatW5PEK+3w58MAD08JYF154YdrqGAAAZKbwa/oBAACFUqlSpTjuuOPiuOOOi/Xr18eYMWNi6NChMXLkyBg9enRMmjQp7Y+6m3rqqadixYoV8c9//nM7VV26VqxYERMnTkxp23///Ys83v777x/vvfdeofcfNWpUrFq1KqVt0KBBm10StzA2Pbn788sdFMamKwUU1qYnmXaEwEDr1q0zWpI+IlKWw94o09U/NjdOJvfp0qVL4+67745//OMfMX369Izn/7miBBWKaurUqTF//vyUtuKeQCyK8vo6KErdBZ0k31Ld33zzTVrbfvvtl/G8ERF16tSJdu3axZQpU4rUvyQV9b2/QoUKsffee8enn36a3zZhwoRYsWJFoS9DElG0+/Czzz5La7v00kuLFPraaMWKFSnbmX6GZGLOnDmRm5ub0vbOO+/EPvvsU+QxN73EUKb1d+7cuUgnuzd9LBYsWFCs48jLy0trW7BgQaGX3q9WrVqRVv3I9P2goMseFTf4uDnr169PC+N8/fXXxbqfNw3ILV26NNauXZsW8mvQoEGccMIJKb+fTZs2Lfbee+848cQT47TTToujjjoq48AuAEC2ExgAAIBtqGLFirH//vunnABZsWJFjBgxIj766KN48cUX006Ub/TCCy9Et27d4le/+tX2KrfUzJ8/P+268LvvvnuRx+vQoUNG+8+aNSutbebMmTFz5swi17CphQsXZrR/gwYNijTPpn9cX7t2bZHGKUvq16+fcZ+CVhIoqXEKe5++9tprMWDAgPjhhx8ynrcg2/Okd0E1b3qZje2hvL4OilJ3ps+1gt5TCloRo7Datm1bJgIDxX3v/3lgIEmSWLBgQbRq1arQY2x6KZDCKOgzZMKECRmPsyWZfoZkoqD6f/jhhxJ774rIvP6iPA4R6ceyfPnyGDt2bJHG2pyFCxcWOoBWUu9hEVt+P9ie79kLFy5MC1kuXrw4Fi9eXKLzLFq0KJo0aZLWfvfdd8cnn3ySEjJYv359vPzyy/Hyyy9HxYoVY999940uXbrEgQceGIcffniBqw4BAPD/uCQBAABsZzVq1IiePXvGH/7wh5gwYUK888470alTpwL3vfXWW9O+ZbgjKuib00VZkrqofbfliZiNNr2m8tZkunT+jqyk7ovteZ8+99xz0a9fvxI94bY9T3pv+m3PiKIFLoqrvL4OtkfdBZ2c257vm9tKSR9DpitzFOWbyWXxMyQT26P+TU8wb01RHoeVK1du0/vp5/MU1vZ6D9ue79nb4/kSsfn7uV27dvHBBx+kXcZgo/Xr18eXX34Z999/f/zyl7+MNm3aRNu2beO3v/1tfPXVV9uyZACAcktgAAAAStnRRx8dI0eOjD59+qT97Mcff4zXX3+9FKravpYtW5bWVrNmzSKPl2nfkv5WHNlt6tSpcd5556VdeqRy5cpx8sknx1//+tf44IMPYtKkSbFo0aJYvnx5bNiwIZIkSbmV5jcif/rpp7S2WrVqlUIlbM7q1avT2oqzBH7VqlWLU06JKen3/oI+X7Yk08ufRJT/z5CyWH82Pg7FUdB7dnFeS1tSFu7nfffdN8aNGxd33XVXtGzZcqv75+bmxj333BP7779/9O7dO8aMGbPtiwQAKEcEBgAAoAyoXr16PP/889GwYcO0n3344YelUNH2VdB14pcvX17k8TLtW7169bS2hx9+OO0EbnFum14fmh3X73//+7STucccc0xMnz49Xn755fjf//3fOOKII2K33XaL+vXrR40aNSInJydtnO3xTdnNKejbvQVdy5vSU9C36TM9Of5zBZ1wLA0l/d5f0OdLSSvoM2TChAkl+hny1FNPbdf6f/e735Vo/Ztedmh7HcfBBx9c4sfRo0ePbX4smSroPbs4r6UtKeh+PvXUU0v8ft7aJVZq1KgRV199dUyfPj0+/vjjuP766+Pwww8vsL6f+/DDD+Pggw+Op59+ujh3AwDADkVgAAAAyog6derEOeeck9Y+adKk7V9MMWW6dHq9evXS2opzvfZM+xYU1ChoeV/YmuXLl8cbb7yR0rbffvvF66+/Hs2aNctorNL8FudOO+2U1lYWvlXK/1PQcuPFWSp8ey0zvjUl/d5f0OdLSSvvnyHlvf6N6tWrl7YyQXk8jqLYnu/ZZe35kpOTE4cffnj88Y9/jI8//jh++umnGDlyZNxzzz1x7LHHFhggWLNmTZx//vnxySeflELFAABlj8AAAACUIQcddFBa24IFC7bb/AVda7co103P9MRTo0aN0r5hXZygxMSJEzPav0mTJmlt06dPL/L8ZK9PPvkkbXWBa665JuPrWM+cObNIr72S0rRp07S2r7/+uhQqYXMKWob7m2++KdJYSZLEuHHjiltSiZg8eXKR+276uZGTk1Pgyc2SVt4/Q8p7/Rvl5OREo0aNUtpmz54d69atK6WKtp/t+Z5d0O9sZen5UqlSpTjggAPiN7/5TQwePDh+/PHHeOSRR6J58+Yp+61fvz6uuuqqUqoSAKBsERgAAIAypKAlpotyHd+iKmhJ26IsUz1lypSM9q9Ro0Z06NAhpW3UqFEZz1vUvgcccEBUqJD63yPfOqMoZs6cmdZ22GGHZTzO559/XhLlFNkuu+ySdhJx2LBhpVQNBSkoYDZ8+PAijTV+/Pgyc0mCor73b9iwIe265B07dowaNWqUQFVbdvDBB6e1lafPkPbt20eDBg1S2oYNGxbr168vpYqKbtPHYsWKFcX6faK86NKlS1rbZ599tk3mqlatWuy9994pbZMnT44ffvhhm8xXXLVq1YoBAwbEV199lRa0+uKLLwr83AYAyDYCAwAAUIYU9MfWgr7593ObBgqK8wf+gpZu/v777zMe5+OPP864zyGHHJKyPXHixIxXCoj4zxK8Q4YMyahPgwYNYv/990+bf/z48RnPXx4VFEopjyeKyoKCVgTZ9ERcYfzzn/8s0vwl+Vh27949ZXvOnDnx4YcfFmksSt7uu++e9tx6/vnni3St+Geffbakyiq2jz76qEiXJfjggw/SQg+bfq5sKz179kx77b355pulukpIJipUqBBHHHFESlteXl689957pVRR0R155JFpbS+//HIpVLJ9devWLe05+H//93/b7LO8PN7PTZo0id/+9rdp7UVdmQUAYEciMAAAAGXIv//977S2du3abbFP7dq1U7bz8vKKPP/uu++e1vbFF19kNMb69evjiSeeyHjuPn36pLU99thjGY/z9NNPx5o1azLud+KJJ6a13XnnnRmPUx5t+hyKKN7zKJvVrFkzrS3Ty4pMnTo1XnvttSLNX5KP5cknn5zW9uc//7lIY1HycnJyon///iltM2bMyDhssnjx4nj88cdLsrRiWbVqVTzzzDMZ9yvo86Kgz5VtoU6dOtGjR4+UtlmzZsU//vGP7TJ/SSjoM/COO+4ohUqKp2/fvlGxYsWUtkceeSSWLFlSOgVtJ7Vr104LfeTm5sYLL7ywTeYr6Ply9913l/nLP2y6mlVEFCmgBACwoxEYAACAYnjjjTdi2rRpJTLW1KlTC/zDbt++fbfYr379+inb06ZNK9I3TCMiGjduHC1atEhpe+GFFzL6htqDDz5YpPvkpJNOSltN4YEHHki7JvWWzJ8/P/7whz9kPHdExOWXX562wsIzzzwTr7zySpHGK082fQ5FFG1lCSKaNWuW1pbJt3Q3bNgQ5513XpG/FVqSj2X//v1jl112SWl79913ixTkYdu45JJL0tquuOKK+PHHHws9xm9+85uYP39+SZZVbDfffHMsXry40Pt/8skn8dJLL6W0NW3atMCTmtvK9ddfn9Z25ZVXlpv30lNPPTXat2+f0vbpp5/GX//611KqqGhat24dZ511VkrbTz/9FOeee26RfzcqL373u9+ltf3617+OuXPnlvhchx56aFpI5vvvvy/wG/xlSUH3RaNGjUqhEgCAskVgAAAAimHw4MGx2267xbnnnluk5fM3mjNnTpx88smxYsWKlPZGjRoVuOzrz+21114p20uXLi3WtcY3/UbmjBkz4t577y1U3w8//DCuvvrqIs1buXLluPTSS1Pa1qxZE/369YuFCxdutf+KFSvilFNOyegk08/VrVs3rrrqqpS2JEnil7/8ZZG/7R0R8fbbbxd4Uq8sadmyZdStWzel7a233iqlasq3ww47LK3t1ltvLdT14Tds2BADBgwo1rXPS/KxrFixYlx33XVp7b/61a+KdMmEn376KRYtWlSkWijY3nvvHSeccEJK29y5c6N3794xZ86cLfZdv359/Pa3v42nn356W5ZYJAsWLIj+/fvH6tWrt7pvbm5unHHGGWntl1xySVSuXHlblFeg7t27p31eL168OI455piYMGFCkcZctWpVPProo3HPPfeURIlbVKlSpbjlllvS2q+++up49NFHizzusGHD4vTTTy9OaRm78cYbo2rVqiltr776alx00UWFek4VJDc3N371q1/FuHHjSqLEbaJnz55pn0ELFiyIo446KmbNmpXxeLm5uVv8+a233ho5OTkpbX/729/ipptuKnI4Y9y4cfHLX/5ys7/LPfXUU/Gvf/2rSKG6tWvXxkMPPZTSVqFChdhzzz2LVCsAwI5EYAAAAIpp3bp18dRTT0XHjh3jkEMOiQceeKDQ3+ZasWJFPPLII7HvvvsWeA3VP//5z1GtWrUtjtG1a9e0tvPOOy8++uij2LBhQ+EO4mcuuOCCtLbf/e538eijj272D8CrVq2Ku+66K/r06ROrV6/eas2bc/XVV6ddFuHbb7+Nbt26xfDhwzfbb9y4cdGjR48YOnRoRERUr169yPP37t07pS0vLy9OPvnkuOiiiwr9TdHvvvsubr/99thzzz3j2GOPjU8//bRI9WwvOTk50aVLl5S2Dz74IK655pqMvqnMf1YY6NatW0rblClT4uijj47p06dvtt+kSZPimGOOyV8avlKlSlGjRo2M5y/px/K8886Lfv36pbStXr06TjvttBgwYEDMnj17q2OMGzcufv/730erVq3i66+/zrgGtuzhhx9OWx3lm2++iY4dO8add96Z9rxbsWJF/Otf/4oDDzww/0R05cqVY//9999eJW/Rxs+PDz/8MI444oiYPHnyZvd999134/DDD087GdqhQ4cih9eK46mnnormzZuntH333Xdx0EEHxR133FGopc+TJIlhw4bFb37zm2jTpk1cfPHF222VgtNPPz3OPffclLZ169bFxRdfHP369Sv063fWrFlx3333xSGHHBKHHnpovP7669ui3M1q27ZtgSGHxx9/PA455JB48803C3VCe9myZfHcc8/FSSedFO3bt48HHnggVq1atS1KLjH/+Mc/okGDBilt48aNiwMOOCAGDhy41UsGrFmzJt588804/vjjo1evXlvc99BDD42bbroprf0Pf/hD9OrVq9C/+yxcuDAef/zxOPLII6Nz587xj3/8Y7OBgDFjxsQvfvGLaN++fVx//fXx1VdfFWqO6dOnxwknnBAjR45Mae/du3c0bdq0UGMAAOzIKpV2AQAAsCMZMWJEjBgxIn71q19FmzZt4uCDD4499tgjGjZsGDvttFPk5OTETz/9FNOnT4+xY8fGv//971i+fHmBY/3Xf/1XnH322Vudc+Mc48ePz2+bPHly9OrVK6pXrx4tWrQo8MTjW2+9lXZiIyLioIMOihNPPDHlW/Xr16+Piy++OB588ME4+eSTo3379lGlSpWYP39+jBo1Kt56662Uk5H33ntvXHzxxVutfVPVqlWLJ598Mnr06BFr1qzJb584cWJ07do1unbtGscee2y0bNkyKlSoELNnz4733nsvhgwZkv/H5YoVK8ZNN90Uv//97zOev1KlSvHCCy9E165dU1aMSJIkHnvssRg0aFAccMABcfjhh0fbtm2jQYMGsWHDhliyZEnMnz8/vv766xg1atRWv5VXFp133nnxzjvvpLTdeeedceedd0azZs2iQYMGUalS6n8hTzjhhCJfAmJHdsstt6RdS3r48OGx2267xYknnhjdunWLpk2bxqpVq2L27Nnx/vvvx6effppyIufGG2+MJ554Yoshg80p6cdy0KBBMWHChJT3mCRJYuDAgfHkk09G165do2fPntG8efOoX79+LF++PBYsWBBff/11DB8+fIsnfCm+5s2bxzPPPBOnnHJKyvvmTz/9FNdcc01cc8010bBhw2jUqFEsW7Ysfvjhh1i7dm3KGLfddlt8++23MWrUqPy2Ta8Dv73cdNNNcf3118f69evjs88+i06dOkXv3r3jiCOOiJ133jnWrFkTubm58cYbb6TUu1HVqlXjySefLHJwrTiaN28er732WvTo0SPlsz0vLy+uvfbauO2226Jbt27RtWvXaNasWdSvXz9WrlwZS5YsiTlz5sRXX30Vo0aNKtSqOtvKI488ElOmTEk72fvyyy/Hyy+/HHvvvXd07949dt1119hpp52iQoUKsWTJkli4cGGMGzcuRo0aFd99912pL/9/9tlnx4QJE+Kuu+5KaR8zZkwcf/zx0apVq+jZs2fsvffesdNOO0WNGjVi6dKlsWTJkpg8eXKMGjUqvvnmm5TXVHnQunXrePbZZ+OEE05IeZ3/8MMPMWDAgLj++uvjyCOPjP333z8aNWoU1apViyVLlsTMmTPjq6++iqFDh+YHW1q3br3V+W688caYOHFiPP/88yntQ4YMicMPPzx222236NGjR3Tq1CkaNGgQVatWjSVLlsTixYtj/PjxMWrUqJgwYULGKwbk5ubGbbfdFrfddls0a9Ys9ttvv9hnn32iefPmUa9evahSpUrk5eVFbm5uDBs2LIYMGZL2vle1atX4y1/+ktG8AAA7KoEBAADYRnJzc4t84vjss8+OJ554otD733///XHUUUel/cF15cqV8d133xXYZ0t/BH/kkUdi5MiRaUtaf/PNNwWuhPBzV111VQwYMKBIgYGIiC5dusS//vWv6NevX0qNSZLEZ599Fp999tkW+99///3RsWPHIs0d8Z9rwA8bNizOOuusGDx4cMrP1q9fnx8K2dH069cvjjjiiPjwww/TfjZ37twCV83YZ599tkNl5U+vXr3i97//fdx5550p7WvWrIkXX3wxXnzxxS32P/PMM+P666/P6D3g50r6saxTp04MHTo0+vfvnzbm2rVr4+OPP46PP/64SLVSMvr27Rsvv/xy/OIXvyjwG9ALFiyIBQsWFNj3t7/9bVx11VVx5plnprTXqVNnm9S6NYccckjcd999cfnll0fEf77h/s4776SFYApSpUqVeOmll+KQQw7Z1mVu1gEHHBDDhw+Pfv36pYVlli9fHu+++268++67pVTd1lWpUiXee++9uOyyy2LQoEFpPx87dmyMHTu2FCrL3J133hktW7aMK664Iu13nhkzZpTJy3GUhGOOOSbee++96NevX9plYObPnx/PPfdcPPfccyUyV05OTjz77LPRrl27uP3229OCIpMnT97mobG5c+fG4MGD035n25KqVavGP/7xD5cjAAD4/7kkAQAAFMNZZ50VZ5xxRtpy0EW1yy67xGuvvRZPPfVURt/u7NWrV7zyyivRpEmTEqmjadOmMXTo0Gjfvn2h+1SpUiX+8pe/xJ/+9Kdiz3/cccfF4MGDo2XLloXuU7169XjiiSfikksuKfb89evXjzfeeCPuvffeYt+nrVu3TlviuSyqUKFCvPTSS9v9WtM7qttvvz2uv/76tOs7b0nFihXj2muvjaeffjqjfpvaFo9l/fr145133ombb745ateuXaQxqlWrVmonobNB37594+uvv067rMrmNGnSJJ599tm4++67IyLSrhlet27dEq+xsC677LJ47LHHMloloGXLljF48OA47rjjtmFlhbPnnnvGyJEj4/LLLy/2SgcHHnhg9O3bt4QqK5xq1arFE088Ec8880zssssuxRqrcePGcemll5ZQZZm77LLL4tNPP027VEymqlevHv/93/8drVq1KqHKtq0ePXrEF198UaznTmF//6lQoULceuut8dZbb8Xee+9d5Pki/vO+c8EFF0StWrUK/Hnjxo2L9fkY8Z/X57///e/o379/scYBANiRCAwAAEAxHHroofHMM8/Ejz/+GB9++GHceOON0atXr83+obMgTZo0iTPOOCMGDx4ckyZNihNOOKFItRx//PGRm5sbL7zwQpx//vlx0EEHRdOmTaNmzZpF+uNq27Zt4+uvv47bb789mjVrttn9qlSpEqeeemqMHj06rrjiiiLVXpDevXvH+PHj47rrrtticKB69epx9tlnxzfffBPnnXdeic2fk5MT//M//xO5ubnx0EMPRc+ePQt14qdChQqx3377xdVXXx1DhgyJadOmxW9/+9sSq2tbqlevXjz77LMxceLEuPnmm+O4446Ldu3aRf369aNy5cqlXV65kpOTE3/84x9j6NCh0adPn6hQYfP//a5Ro0acfvrpMWrUqLjtttu2uG9hbYvHslKlSnHTTTfFtGnT4oYbbojOnTtv9b2lSpUq0aNHj/jrX/8as2fPjv32269Ic1M4u+66a7z//vvxxRdfxFVXXRUHHnhgNG/ePCpXrhw1a9aMXXfdNfr37x9PP/105ObmpoRK5s2blzLWptdB394uuOCC+Prrr+Oss86K6tWrb3a/li1bxrXXXhvjx48vdFhie6hTp07cf//9kZubG9dff33su+++hXptV69ePY444oi44447Yvz48fHFF19Enz59tkPF6c4444yYPHlyPPvss9GnT59Ch4X22GOP+PWvfx1vvfVWzJ49u0SChMVx0EEHxaeffhqffvppnHHGGQVejqkgzZs3j7POOiv+/ve/x9y5c+P//u//onHjxtu42pLTrl27ePPNN2P48OFxxhlnRKNGjbbap3HjxnHGGWfEm2++GZ9//nlG8x1zzDExZsyYeOONN+KUU04p9HvILrvsEhdeeGG89NJLMXfu3C2Gha699tqYO3duPPHEE3HGGWdE27ZtCzVH5cqVo0+fPvHss8/GmDFjomvXroU+LgCAbJCTlPZFxQAAYAeUJEnMnj07vvvuu5gxY0b89NNPsWzZssjJyYk6depE7dq1o1mzZtG5c+cSWxVgW/v6669j7NixsWDBglixYkXUrVs3dt999+jSpUtGAYmiSJIkvvzyy5g8eXLMnTs31qxZEw0aNIgOHTrEwQcfvMWTSSVp9erV8eWXX8bs2bNj4cKFsXjx4qhUqVLUrl07GjZsGLvttlvsvvvupXLtbMq2JUuWxNChQ2PGjBn5z5uGDRvG7rvvHgceeGBUrVq1tEssknnz5sVXX30VP/74YyxYsCDWrFkTtWrVyj+2jh07Ro0aNUq7TLZi5cqVUadOnVi3bl1+2w033BB/+MMftum8Q4YMiZ49e6a0ffTRR9GjR4+0+kaMGBETJ06MRYsWRdWqVaNZs2ax6667xgEHHFDsbxxvL4sXL44vv/wyfvzxx1i4cGH89NNPUaNGjfzfCXbffffYZZddMlphaHtat25djB49OqZPnx4LFy6MRYsWRYUKFaJ27dpRv3792HXXXaNDhw7b/HeCkjB58uSYMGFCLFy4MBYuXBhr166N2rVrR506daJt27bRoUOHchUOKIwkSWLs2LExderUmD9/fixatCj/d5iWLVtGx44dY5dddimx11OSJPHNN9/E1KlT8+/nDRs2RO3ataNevXrRrl276NixY7FX6Vq4cGF899138f3338eCBQsiLy8vIiJq164dDRo0iI4dO0anTp3K7ecsAMD2IDAAAAAAkMVeffXVOPnkk1Pa3njjjW2+vH9hAwMAAABsOy5JAAAAAJDF/vznP6dsV65cObp06VJK1QAAALA9CQwAAAAAZKk///nPMWzYsJS2U045JXbaaadSqggAAIDtSWAAAAAAoBz77LPP4qmnnorVq1cXus+GDRviD3/4Q/z+979P+9nll19ekuUBAABQhgkMAAAAAJRjM2fOjHPPPTdatGgRF1xwQbz66qsxc+bMAvedNGlSPPjgg9GxY8e46aabYsOGDSk/v+CCC6Jbt27bo2wAAADKgEqlXQAAAAAAxbdgwYJ44okn4oknnoiIiNq1a8dOO+0UtWrViry8vFiwYEHk5eVttn/nzp3jvvvu217lAgAAUAYIDAAAAADsgJYtWxbLli0r1L59+/aN5557LmrUqLGNqwIAAKAscUkCAAAAgHJst912iwMOOKBIfTt27BhPPfVUvP7661GnTp0SrgwAAICyzgoDAAAAAOXYfvvtFyNHjoyZM2fGxx9/HMOHD4+JEyfG9OnTY8GCBbFixYpIkiTq1asXDRo0iNatW0e3bt2ie/fucdhhh0VOTk5pHwIAAAClJCdJkqS0iwAAAAAAAAAAti+XJAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAslCl0i4AtmbJkiXx8ccf52+3bNkyqlatWooVAQAAAAAAAJSM1atXx8yZM/O3u3fvHvXq1dsucwsMUOZ9/PHHcdJJJ5V2GQAAAAAAAADb3KuvvhonnnjidpnLJQkAAAAAAAAAIAsJDAAAAAAAAABAFnJJAsq8li1bpmy/+uqr0b59+1KqBgAAAAAAAKDkTJkyJeUS7ZueH92WBAYo86pWrZqy3b59++jUqVMpVQMAAAAAAACw7Wx6fnRbckkCAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZKFKpV0AAGSjnMufLe0S2IaSB84o7RIAAAAAAGCrrDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkoUqlXQDb16pVq2LYsGExceLEWLx4cVSpUiVatGgRBx98cOyyyy6lXR4AAAAAAAAA24nAQBl22mmnxfPPP5/S1rp168jNzc14rPnz58ctt9wSTz31VCxfvrzAffbff/+44YYb4sQTTyxKuQAAAAAAAACUIy5JUEa98cYbaWGBohoyZEjsscce8eCDD242LBARMWrUqDjppJPi7LPPjjVr1pTI3AAAAAAAAACUTVYYKIOWLl0al1xySYmMNXTo0Dj22GNj5cqVKe316tWLtm3bxuLFi2PmzJmxfv36/J/9/e9/j7y8vHjppZciJyenROoAAAAAAAAAoGyxwkAZdNVVV8Xs2bMjIqJmzZpFHmfx4sVx6qmnpoQFWrduHa+++mosWrQovvrqq5g2bVrk5ubGgAEDUvq+/PLL8de//rXIcwMAAAAAAABQtgkMlDFDhgyJxx9/PCIiKlSoEDfddFORx/rzn/8cc+bMyd9u27ZtDBs2LE488cSUlQNatGgRjzzySNx2220p/f/whz/E4sWLizw/AAAAAAAAAGWXwEAZsnLlyrjgggsiSZKIiPjVr34VBx54YJHGmj9/ftx///0pbY899lg0b958s32uueaaOPzww/O3ly5dGnfffXeR5gcAAAAAAACgbBMYKENuuOGGmDp1akREtGrVKm699dYij/X8889HXl5e/vbhhx8eRxxxxBb75OTkpK1oMGjQoPwAAwAAAAAAAAA7DoGBMmLkyJFx77335m8/+OCDUatWrSKP99prr6Vsn3/++YXq17Nnz2jbtm3+9rx582L48OFFrgMAAAAAAACAsklgoAxYu3ZtnH/++bF+/fqIiOjfv38cd9xxRR4vLy8vPvnkk5S2o446qlB9c3Jyonfv3iltb775ZpFrAQAAAAAAAKBsEhgoA+6444745ptvIiKiXr168be//a1Y43377bexdu3a/O22bdtG06ZNC93/0EMPTdkeM2ZMseoBAAAAAAAAoOwRGChl48ePj9tuuy1/+6677sro5H5BJkyYkLK9xx57ZNR/0/03HQ8AAAAAAACA8k9goBRt2LAhzj///FizZk1ERBx22GFx4YUXFnvcSZMmpWy3bNkyo/6b7j99+vRYtWpVsesCAAAAAAAAoOyoVNoFZLO//e1vMXz48IiIqFKlSgwcODBycnKKPe6PP/6Yst2iRYuM+jdp0iQqVaoU69ati4j/BBsWLlwYO++8c4nUNn/+/Iz6TJkypdjzAgAAAAAAAJBKYKCUTJs2La6//vr87WuuuSY6dOhQImPn5eWlbNesWTOj/jk5OVG9evVYtmzZZscsqoceeihuueWWEhkLAAAAAAAAgKJzSYJSctFFF8Xy5csjIqJDhw5x7bXXltjYm57cr1atWsZjVK9efYtjAgAAAAAAAFC+CQyUgieeeCI++OCDiPjPt/kHDhwYVapUKbHxV61albJdlLGrVq2asr1y5cpi1QQAAAAAAABA2eKSBNvZ3Llz48orr8zfvuCCC+Kwww4r0Tk2XVFgzZo1GY+xevXqLY5ZVJdeemn0798/oz5TpkyJk046qUTmBwAAAAAAAOA/BAa2s8suuyyWLFkSERFNmzaNP/3pTyU+R61atVK2N11xoDA2XVFg0zGLqnHjxtG4ceMSGQsAAAAAAACAonNJgu3oxRdfjFdeeSV/+7777ot69eqV+Dybntxfvnx5Rv2TJNlmgQEAAAAAAAAAygaBge3oqquuyv93375947/+67+2yTybfoN/1qxZGfX/4YcfYt26dfnbFSpUiIYNG5ZIbQAAAAAAAACUDS5JsB1tvBRBRMTgwYMjJycn4zGmT5+e1m/06NGxzz775G/vvvvuKT+fMWNGRnNsun/r1q2jWrVqmRUKAAAAAAAAQJlmhYEdUIcOHVK2x48fn1H/CRMmbHE8AAAAAAAAAMo/gYEdUKdOnaJy5cr527m5uTF37txC9//ss89Stn++egEAAAAAAAAAOwaXJNiOXnvttVi7dm1GfcaOHRtXXnll/naTJk3imWeeSdmnffv2Kdu1a9eOww8/PD788MP8tvfffz9++ctfbnW+JEnigw8+SGk7/vjjM6oZAAAAAAAAgLJPYGA76t69e8Z9KlVKfYiqVasWvXv33mq/E044ISUw8MQTTxQqMPDRRx/FtGnT8rebNGkSBx98cAYVAwAAAAAAAFAeuCTBDuq///u/o2bNmvnbn3zySfz73//eYp8kSeKWW25JaTv33HOjQgVPEwAAAAAAAIAdjTPBO6jGjRvH5ZdfntJ2wQUXxJw5czbb54477ohPPvkkf7tu3bpx1VVXbbMaAQAAAAAAACg9AgM7sKuvvjqaNm2avz1t2rTo2rVrvP7665EkSX77rFmz4uKLL47rrrsupf91110XDRo02G71AgAAAAAAALD9VCrtAth2GjRoEP/85z/j6KOPjlWrVkVExPTp0+PEE0+MevXqRdu2bWPJkiUxY8aMWL9+fUrfE088Ma688srSKBsAAAAAAACA7cAKAzu4ww8/PAYPHpy2UsCSJUti9OjRMW3atLSwwOmnnx7//Oc/IycnZ3uWCgAAAAAAAMB2JDCQBXr16hXjx4+PSy65JGrUqLHZ/fbdd9/417/+Fc8++2xUrVp1O1YIAAAAAAAAwPbmkgRlXI8ePSJJkmKP06RJk3jooYfiL3/5SwwbNiwmTJgQS5YsiSpVqsTOO+8cBx98cLRv374EKgYAAAAAAACgPBAYyDLVq1ePI444Io444ojSLgUAAAAAAACAUuSSBAAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFlIYAAAAAAAAAAAspDAAAAAAAAAAABkIYEBAAAAAAAAAMhCAgMAAAAAAAAAkIUEBgAAAAAAAAAgCwkMAAAAAAAAAEAWEhgAAAAAAAAAgCwkMAAAAAAAAAAAWUhgAAAAAAAAAACykMAAAAAAAAAAAGQhgQEAAAAAAAAAyEICAwAAAAAAAACQhQQGAAAAAAAAACALCQwAAAAAAAAAQBYSGAAAAAAAAACALCQwAAAAAAAAAABZSGAAAAAAAAAAALKQwAAAAAAAAAAAZCGBAQAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAsJDAAAAAAAAABAFhIYAAAAAAAAAIAsJDAAAAAAAAAAAFmoUmkXkO3WrFkTEydOjNzc3Jg9e3YsW7Ys1q5dG3Xq1ImddtopOnfuHB07doyKFSuWyHzr1q2LESNGxLhx42LhwoVRsWLFaNasWey///7RqVOnEpkDAAAAAAAAgLJPYKAUvPTSS/HBBx/EZ599FhMnTox169Ztcf+6devGaaedFv/zP/8THTp0KNKceXl5ceedd8bDDz8cixYtKnCf3XffPX73u9/FOeecEzk5OUWaBwAAAAAAAIDywSUJSsH//u//xqOPPhrjxo3balggImLp0qXxyCOPROfOnePmm2+OJEkymu+bb76Jzp07x2233bbZsEBExKRJk+K8886LPn36xNKlSzOaAwAAAAAAAIDyxQoDZUS1atWiVatWUbdu3diwYUMsWLAgZsyYkRIOWLt2bdxyyy0xc+bMeOKJJwo17qRJk6JXr16xYMGClPZatWrFLrvsEitXrozc3NxYu3Zt/s/efffd6NOnT/z73/+OatWqlcwBAgAAAAAAAFCmWGGglDRv3jwuvPDC+Mc//hFTpkyJ5cuXx6RJk+KLL76IL7/8MnJzc2PhwoUxcODAaNGiRUrfQYMGxZNPPrnVOdatWxf9+/dPCQs0aNAgnn766Vi0aFGMHTs2Jk+eHPPmzYvrrrsuKlT4f0+Hzz//PK6++uqSO2AAAAAAAAAAypScJNP17Sm2r7/+Ovbaa6/Iyckp1P6LFy+O3r17x1dffZXf1qxZs5g1a1bKSf5NDRw4MAYMGJC/Xb9+/Rg6dGjsscceBe7/3HPPxRlnnJG/XalSpRg/fnzsuuuuhapzW/n2229jzz33zN8eN25cdOrUqRQrAii+nMufLe0S2IaSB87Y+k4AAAAAABClez7UCgOloHPnzoUOC0T850T/M888k9Jn7ty58dlnn222z5o1a+LWW29Nabv77rs3GxaIiDj99NPjzDPPzN9et25d3HzzzYWuEwAAAAAAAIDyQ2CgnOjYsWPsv//+KW0TJkzY7P7vvvtuzJw5M3+7TZs2ce655251nptvvjklmPDiiy/G0qVLi1AxAAAAAAAAAGWZwEA50q5du5TtBQsWbHbf1157LWX73HPPLdSqBu3atYvu3bvnb69duzbeeuutDCsFAAAAAAAAoKwTGChHVq1albJdr169ze47ePDglO2jjjqq0PMceeSRKdtvvvlmofsCAAAAAAAAUD4IDJQTSZLEyJEjU9o2vUTBRj/88EPMmzcvf7tq1aqx3377FXquQw89NGV7zJgxhS8UAAAAAAAAgHJBYKCcGDRoUMyZMyd/u0OHDnHQQQcVuO+ECRNSttu3bx9VqlQp9Fx77LFHyvaUKVNi3bp1GVQLAAAAAAAAQFknMFAOPP3003HppZfmb1eoUCEeeOCByMnJKXD/SZMmpWy3bNkyo/kaNWoU1apVy99es2ZNTJs2LaMxAAAAAAAAACjbKpV2AURMnjw5ZsyYkb+9du3aWLx4cYwbNy5ee+21GD9+fP7PqlSpEgMHDowjjjhis+P9+OOPKdstWrTIuKbmzZvH999/nzLmrrvumvE4BdU2f/78jPpMmTKl2PMCAAAAAAAAkEpgoAx46KGH4r777tviPjk5OXHMMcfEHXfcEXvvvfcW983Ly0vZrlmzZsY1bdpn0zGL6qGHHopbbrmlRMYCAAAAAAAAoOgEBsqJ/v37x69//euthgUi0k/u//zyAoVVvXr1LY4JAAAAAAAAQPlWobQLoHBeeOGF6NatWxx++OFbXaJ/1apVKdtVqlTJeL6qVaumbK9cuTLjMQAAAAAAAAAou6wwUAbce++9ce+99+Zvr1y5MhYuXBhjx46NV155JZ577rn8E/affvppHHjggfH+++/HAQccUOB4m64osGbNmoxrWr169RbHLKpLL700+vfvn1GfKVOmxEknnVQi8wMAAAAAAADwHwIDZVD16tWjRYsW0aJFi+jbt2/8/ve/j/79+8eYMWMiImLJkiVx0kknxbhx46JevXpp/WvVqpWyvemKA4Wx6YoCm45ZVI0bN47GjRuXyFgAAAAAAAAAFJ1LEpQD7du3j/fffz9atmyZ3zZ79uz485//XOD+m57cX758ecZzbtqnpAIDAAAAAAAAAJQNAgPlRMOGDeOWW25JaXvqqacK3HfTb/DPmjUr4/nmzJmzxTEBAAAAAAAAKN8EBsqRk08+OXJycvK358yZE9OnT0/bb/fdd0/ZnjFjRkbz/PjjjymXMahSpUrssssuGVYLAAAAAAAAQFkmMFCO1KtXLxo0aJDSNm/evLT9OnTokLI9derUWLNmTaHnmTBhQsp2u3btolKlShlUCgAAAAAAAEBZJzBQzlWuXDmtrWnTptG0adP87dWrV8eoUaMKPeZnn32Wsr3PPvsUuT4AAAAAAAAAyiaBgXJk2bJlsWjRopS2Jk2aFLhv3759U7bff//9Qs+z6b7HH398ofsCAAAAAAAAUD4IDJQjgwcPjiRJ8rcbNWoUzZo1K3DfE044IWX7ySefTOm7OVOnTo2PP/44f7ty5cpx7LHHFrFiAAAAAAAAAMoqgYFyYuXKlXHTTTeltB133HFRoULBD+HRRx8dLVq0yN/Ozc2NJ598cqvz3HzzzSnBgn79+kXdunWLWDUAAAAAAAAAZZXAwHZ29dVXx8iRIzPqs2jRojjhhBNi8uTJ+W0VK1aM3/zmN5vtU7Vq1bjuuutS2q688soYP378Zvs899xz8cwzz6TMccstt2RUKwAAAAAAAADlQ7kKDJx22mkxZMiQ0i6jWN5777046KCD4uCDD4577rknxowZE2vXrk3bL0mSmDhxYvzxj3+M3XffPT744IOUn//mN7+Jvfbaa4tznX/++dGpU6f87cWLF8dhhx0Wf//732PdunX57YsWLYobbrghzjrrrJT+AwYMiN12260ohwkAAAAAAABAGZeTFObC9mVEhQoVIicnJ3bZZZe48MIL45xzzonGjRuXdlkZ2WeffWLs2LEpbVWqVImdd9456tWrF1WqVIlly5bFzJkzY9myZQWOcfbZZ8egQYM2ezmCn5swYUJ069YtFi1alNJeq1ataNeuXaxcuTKmTZuWFlo46KCDYsiQIVG9evUMj7Dkffvtt7Hnnnvmb48bNy4lCAFQHuVc/mxpl8A2lDxwRmmXAAAAAABAOVGa50PL1QoDG02dOjWuueaaaNmyZfziF7+Id955p7RLKpY1a9bEtGnTYvTo0TFixIgYP358gWGBOnXqxEMPPRRPPvlkocICEREdO3aMf//739G6deuU9ry8vBg7dmxMnjw5LSzQu3fvePfdd8tEWAAAAAAAAACAbaNcBgZycnIiSZJYu3ZtvPLKK9G3b99o06ZN/PGPf4xZs2aVdnlb9H//939x1113Re/evaNOnTpb3T8nJyc6d+4cf/7zn2PKlClxySWXRE5OTkZz7r333vHNN9/ENddcE/Xr19/sfrvuums89thj8d5770W9evUymgMAAAAAAACA8qVcXZLg9ddfj8cffzzefvvtWL9+ff6J842HkJOTExUqVIijjz46LrroojjuuOMK/U380rBhw4b47rvvYsqUKTFjxoz46aefYu3atVG7du2oW7dutGnTJvbbb79CBQsKa+3atTFixIgYN25cLFy4MCpWrBjNmjWL/fbbL/baa68Sm6ckuSQBsCNySYIdm0sSAAAAAABQWKV5PrRcBQY2mjNnTjzxxBPx5JNPRm5ubkT8v1UHNv47IqJp06Zx7rnnxgUXXBBt2rQppWopLoEBYEckMLBjExgAAAAAAKCwSvN8aNn9+v0WNG/ePG644Yb4/vvv4913341+/fpF5cqVIyJSVh2YO3du3HHHHdG+ffs46qij4qWXXop169aVZukAAAAAAAAAUCaUy8DAzx155JHx4osvxqxZs+JPf/pT7LbbbmkrDWzYsCE+/PDDOPXUU2PnnXeOq6++OiZNmlSaZQMAAAAAAABAqSr3gYGNGjZsGFdeeWVMmDAhPvnkkzjzzDOjWrVqkSRJyqoD8+fPj7/85S+xxx57RPfu3ePZZ5+N1atXl3L1AAAAAAAAALB97TCBgZ/r1q1b/P3vf485c+bE/fffH507d05ZdSBJkkiSJIYOHRq//OUvo3nz5vE///M/8c0335Ry5QAAAAAAAACwfeyQgYGN6tatG5dddlmMHj06RowYERdeeGHUqlUrcnJyUoIDixcvjgceeCD22Wef6Nq1azz33HOxdu3a0i4fAAAAAAAAALaZHTow8HMHHnhgXHHFFXHaaaelrDaw8Rbxn0sWjBgxIs4666xo165dDBw4sDRLBgAAAAAAAIBtZocPDKxevTqeeeaZ6N69e+yxxx7x2GOP5QcEIiJ/lYGNIYKNbbNmzYpLLrkkDj300Jg7d25plA4AAAAAAAAA28wOGxj45ptv4te//nU0b948zj777Bg6dGh+KGBjQKBmzZpx4YUXxueffx5PPPFEdOnSJWX1gSRJ4vPPP4+ePXvGihUrSvNwAAAAAAAAAKBE7VCBgeXLl8fjjz8ehxxySOyzzz7x4IMPxuLFi9NWD9h7773joYceijlz5sSjjz4aBx98cJx77rnx2WefxdixY+P000+PiMhfieC7776L+++/v1SOCQAAAAAAAAC2hR0iMDBy5Mi46KKLolmzZjFgwIAYOXJkykoBERHVqlWLs88+Oz7//PMYPXp0XHzxxVGrVq20sfbaa6945pln4oMPPoiqVavmrzTwr3/9a7seEwAAAAAAAABsS5VKu4CiWrp0aTzzzDPx2GOPxTfffBMRkRYSSJIkOnbsGAMGDIizzz476tatW+jxe/bsGRdeeGH+ygKTJk0q4SMAAAAAAAAAgNJT7gIDQ4cOjcceeyxeeumlWLVqVUpIYONqAFWqVIl+/frFgAED4rDDDivyXN26dcsPDOTl5ZVI/QAAAAAAAABQFpSrwEDHjh1j8uTJEZG6mkCSJJEkSey6665x0UUXxTnnnBM77bRTsedr0KBB/hwAAAAAAAAAsCMpV4GBSZMm5Z+83xgUqFSpUpx44okxYMCAOOKII7bJvEmSCA0AAAAAAAAAsEMpV4GBjZIkiTZt2sSFF14Y5513XjRp0mSbzLP//vvHRx99tE3GBgAAAAAAAIDSVK4CAxUrVoy+ffvGxRdfHEcfffQ2/9Z/vXr1onv37tt0DgAAAAAAAAAoDeUqMJCbmxs777xzaZcBAAAAAAAAAOVehdIuIBPCAgAAAAAAAABQMspVYAAAAAAAAAAAKBkCAwAAAAAAAACQhcpVYODrr7+OXXbZJf/28ccfF2mcIUOG5I/Rrl27mDx5cglXCgAAAAAAAABlW7kKDDz88MORm5sbubm5UaNGjejevXuRxunRo0dUrVo1f6xHH320hCsFAAAAAAAAgLKtXAUGXnvttYiIyMnJiTPPPLNYY/3yl7+MiIgkSeKVV14pdm0AAAAAAAAAUJ6Um8DAhAkTYt68efnbJ554YrHG+3n/6dOnx7Rp04o1HgAAAAAAAACUJ+UmMDB+/Pj8f9eqVSs6duxYrPE6duwYtWrVyt8eN25cscYDAAAAAAAAgPKk3AQGZs+eHRH/uRxBy5Ytiz1eTk5OtGrVKn97xowZxR4TAAAAAAAAAMqLchMYyMvLy/93nTp1SmTM2rVr5/972bJlJTImAAAAAAAAAJQH5SYw8POT+4sXLy6RMZcsWZL/7ypVqpTImAAAAAAAAABQHpSbwEDDhg0jIiJJkpg5c2asXbu2WOOtWbMmZs6cmb/dqFGjYo0HAAAAAAAAAOVJuQkMtGvXLv/fK1eujI8//rhY43388cexYsWK/O3WrVsXazwAAAAAAAAAKE/KTWDggAMOiLp160ZOTk5ERNxxxx3FGu/OO+/M/3fNmjWjS5cuxRoPAAAAAAAAAMqTchMYqFChQhx77LGRJEkkSRJDhgyJv/71r0Ua65577omPPvoocnJyIicnJ44++uioXLlyCVcMAAAAAAAAAGVXuQkMRERcd911UaFChcjJyYkkSeKqq66KG2+8MdavX1+o/uvXr48bbrghrr766vwxcnJy4oYbbtjGlQMAAAAAAABA2VKuAgN77LFHXHTRRfkn+jds2BC33XZbdOjQIf7617/GxIkTC+w3ceLEuOeee6JDhw5x++23x4YNGyIiIicnJ84///zo3Lnz9jwMAAAAAAAAACh1lUq7gEz97W9/i2+//TY+/fTT/FUCpk6dGldeeWVceeWVUbNmzWjYsGHUqlUr8vLyYsGCBbF8+fKIiEiSJCIiv1+PHj3iwQcfLM3DAQAAAAAAAIBSUa5WGIiIqFSpUrzxxhtx0kkn5a80sDEAkCRJ5OXlRW5ubowbNy5yc3MjLy8v/2c/3/cXv/hFvPbaa1GpUrnLTAAAAAAAAABAsZW7wEBERJ06deLll1+Ohx9+OFq2bJmycsDmbhH/WWGgdevW8fjjj8cLL7wQtWvXLs3DAAAAAAAAAIBSU66/Xj9gwIC44IIL4uWXX4733nsvPv300/j+++9j3bp1+ftUqlQp2rdvH4cddlgcc8wxceKJJ0aFCuUyJwEAAAAAAAAAJaZcBwYiIipWrBj9+/eP/v3757ctW7Ysli1bFrVr17aKAAAAAAAAAAAUoNwHBgoiKAAAAAAAAAAAW2ZtfgAAAAAAAADIQgIDAAAAAAAAAJCFBAYAAAAAAAAAIAtVKu0CSsratWtj6dKlsXLlykiSJOP+rVq12gZVAQAAAAAAAEDZVG4DA4sXL45nnnkm3n777fjqq69i/vz5RR4rJycn1q1bV4LVAQAAAAAAAEDZVi4DA/fee2/ccMMNsWLFioiIIq0oAAAAAAAAAADZrNwFBi6++OJ47LHH8kMCOTk5kZOTIzQAAAAAAAAAABkoV4GBp59+OgYOHBgRkR8SSJIk6tevH3vttVc0btw4atasWcpVAgAAAAAAAEDZV64CAzfeeGNE/L+wwN577x133nlnHHnkkVGhQoVSrg4AAAAAAAAAyo9yExgYPXp0zJw5M3JyciIiomvXrvH+++9H9erVS7kyAAAAAAAAACh/ys3X8seMGRMREUmSRETEAw88ICwAAAAAAAAAAEVUbgID8+fPz/938+bNY5999im9YgAAAAAAAACgnCs3gYGNlyLIycmJnXfeuZSrAQAAAAAAAIDyrdwEBlq1apX/77y8vFKsBAAAAAAAAADKv3ITGOjatWtERCRJErm5ubFmzZpSrggAAAAAAAAAyq9yExho2bJl9OzZMyIiVq5cGW+//fb/x959h0lZnf8DfmbpggLSlA42wKiICgajYCHYNVGwJqIYjcSoUUSNsWDvGmPUWGJJFLsYFRVRsIABNAgqCNKld6TX+f3hj/k6S9uFZWeX976vay/nnD3nvM8uy7jM+5lzclwRAAAAAAAAAJRepSYwEBFxxx13RJkyZSIi4tprr43ly5fnuCIAAAAAAAAAKJ1KVWDgoIMOinvvvTfS6XSMGjUqTjnllFi0aFGuywIAAAAAAACAUqdUBQYiIi655JJ45JFHoly5cvHuu+/GvvvuG4899ljMnz8/16UBAAAAAAAAQKlRNtcFFMYRRxyReVyrVq2YOnVqTJo0KS666KLo1q1bNG7cOGrXrh0VK1Ys1LqpVCo++OCDoi4XAAAAAAAAAEqsUhUYGDBgQKRSqUx73eN0Oh3pdDrGjx8fEyZMKNSa6XQ6a00AAAAAAAAASIJSFRjYGDf8AQAAAAAAAKBwSl1gIJ1O57oEAAAAAAAAACj1SlVgYO3atbkuAQAAAAAAAAC2C3m5LgAAAAAAAAAAKH4CAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQGVzXcDWGjt2bLz++uvxySefxKhRo2LevHmxcOHCiIjo27dvHHHEEevNmT59eqxatSoiIipVqhS1atUq1poBAAAAAAAAINdKbWBg/PjxccUVV8Sbb74Z6XQ6IiLz34iIVCq10bk33nhjPPHEExERUatWrZg6dWqUKVNm2xYMAAAAAAAAACVIqTyS4NVXX41WrVrFf/7zn1i7dm3W5zYVFFjniiuuiIgfAwazZ8+Ot956a5vUCQAAAAAAAAAlVakLDPTp0ydOP/30+OGHHzJ96XQ66tSpEwcddFDWLgMbs+eee8YhhxySab/22mvbpFYAAAAAAAAAKKlKVWBg9uzZccYZZ8SaNWsilUpFOp2OTp06xfDhw2PatGkxePDgiCjYLgOnnHJKRPwYNujXr982rRsAAAAAAAAASppSFRi4+eabY9GiRZn2XXfdFS+++GLss88+hV7r8MMPzzyeMWNGTJ48uUhqBAAAAAAAAIDSoNQEBtauXRv//ve/I5VKRSqVilNPPTW6d+++xeu1aNEiypcvn2mPGjWqKMoEAAAAAAAAgFKh1AQG/vvf/8aCBQsinU5HRMRf/vKXrVqvbNmyUa9evUzbDgMAAAAAAAAAJEnZXBdQUN99913mce3atbfoGIL8qlWrlnm8cOHCrV4PACCXUhc/l+sS2EbSD52V6xIAAAAAgO1QqdlhYPbs2RERkUqlon79+kWyZtmy/5eXWL16dZGsCQAAAAAAAAClQakJDOTl/V+pa9euLZI1582bl3lcvXr1IlkTAAAAAAAAAEqDUhMYqFWrVkREpNPpmDFjxlavt3Tp0pg0aVKkUqms9QEAAAAAAAAgCUpNYKBx48aZxzNmzIhJkyZt1Xr9+/eP1atXRzqdjoiIli1bbtV6AAAAAAAAAFCalJrAwMEHHxxVqlTJ7Ajw9NNPb9V6999/f+Zxw4YNo2nTplu1HgAAAAAAAACUJqUmMFCuXLk4+uijI51ORzqdjvvuuy8mTpy4RWs98cQT8eGHH0YqlYpUKhWdO3cu2mIBAAAAAAAAoIQrNYGBiIgbbrgh8vLyIpVKxaJFi6Jjx46FDg384x//iIsvvjhSqVSk0+moVKlSdO/efdsUDAAAAAAAAAAlVKkKDOy9995x0UUXRTqdjlQqFd99913ss88+cd1118WYMWPWG7/u+IIZM2bE888/H23bto1u3brFypUrM2vceOONUatWreL+UgAAAAAAAAAgp8rmuoDCeuCBB+K7776Lvn37RiqViiVLlsRtt90Wt912W1SuXDkiIhMG6Ny5cyxbtiyWLVuWmb/uc+l0Ojp37mx3AQAAAAAAAAASqVTtMBARUaZMmXj99dfjN7/5Tebmf8SPQYDFixdntefOnRtLly6NdDod6XQ6s0Y6nY4LL7ww/vWvf+XkawAAAAAAAACAXCt1gYGIiEqVKsUzzzwTvXr1ir322isTBlgXFkilUut9RPwYFNh9992jV69e8cgjj0TZsqVugwUAAAAAAAAAKBKl+o75aaedFqeddlq899570adPn/jkk09i1KhRsWLFisyYsmXLRqNGjeLwww+Po48+Ok4++eTIyyuVOQkAAAAAAAAAKDKlOjCwTseOHaNjx46Z9tKlS2PBggWxww47RLVq1XJXGAAAAAAAAACUUNtFYCC/HXbYIXbYYYdclwEAAAAAAAAAJZa9+QEAAAAAAAAggQQGAAAAAAAAACCBBAYAAAAAAAAAIIEEBgAAAAAAAAAggcrmuoDCaNq06TZZN5VKxbhx47bJ2gAAAAAAAABQEpWqwMDEiRMjlUpFOp0u0nVTqVSRrgcAAAAAAAAAJV2pCgysUxQ3+NPp9DYJHwAAAAAAAABAaVCqAgMNGzYsdFhg6dKlMX/+/Fi9enVE/F/YoHr16rHTTjsVeY0AAAAAAAAAUBqUqsDAxIkTt2jemjVr4ssvv4wXXnghHnvssVi0aFHk5eXFI488EkcffXTRFgkAAAAAAAAApUBergsoDmXKlIkDDjgg7r777hgxYkTsv//+MXfu3DjxxBPjtddey3V5AAAAAAAAAFDsEhEY+KlGjRrFu+++G/Xr14/Vq1fHb37zmxgzZkyuywIAAAAAAACAYpW4wEBERK1ataJnz54REbF8+fLo0aNHjisCAAAAAAAAgOKVyMBARESnTp2iXLlykU6n46233oqZM2fmuiQAAAAAAAAAKDaJDQxUqVIlmjZtGhER6XQ6PvnkkxxXBAAAAAAAAADFJ7GBgYiIqlWrZh5PmjQph5UAAAAAAAAAQPFKdGBg9uzZmcerV6/OYSUAAAAAAAAAULwSGxgYN25cTJgwIVKpVERE1KxZM8cVAQAAAAAAAEDxSWRgIJ1Ox5/+9KfM44iIvffeO5clAQAAAAAAAECxSlxg4Lvvvovjjz8+3nrrrazdBdq0aZPjygAAAAAAAACg+JTNdQGFcdNNN23RvGXLlsXMmTNj2LBhMWLEiEx/Op2OVCoV11xzTSY8AAAAAAAAAABJUKoCAzfeeONW3dhfd/xAKpWKVCoV6XQ6jjvuuLjkkkuKqkQAAAAAAAAAKBUSdSTBT4MCqVQqLr744nj55ZcjLy9R3wYAAAAAAAAAKF07DET83y4BWyKVSsWee+4Zxx57bHTt2jVatGhRhJUBAAAAAAAAQOlRqgID/fv3L/ScVCoVFStWjJ122ikaNGgQlStX3gaVAQAAAAAAAEDpUqoCA+3atct1CQAAAAAAAACwXcjLdQEAAAAAAAAAQPETGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABCqb6wIK46abbsrp9a+//vqcXh8AAAAAAAAAikqpCgzceOONkUqlcnZ9gQEAAAAAAAAAthelKjDwU+l0eoP9GwoUFGbsxq6Vy6ACAAAAAAAAABS1UhcY+OnN//w38dPpdIHDAZsaCwAAAAAAAADbu1IVGOjfv39ERMycOTOuvvrqmDRpUuamf8uWLaN9+/axzz77RI0aNaJy5cqxZMmSmDt3bowYMSI++uij+PLLLyPix/BAkyZN4o477ojatWvn6ssBAAAAAAAAgJwpVYGBdu3axddffx1nn312TJs2LdLpdHTo0CHuvvvu2HfffTc7f/jw4XHllVdGv379YuLEidG9e/d49913o3nz5sVQPQAAAAAAAACUHHm5LqAw5s6dG0cffXRMnTo1IiL+8pe/xHvvvVegsEBExH777Rd9+/aNa6+9NtLpdHz//ffRsWPHmDdv3rYsGwAAAAAAAABKnFIVGPjzn/8c06ZNi1QqFb/+9a/jpptu2qJ1br755vj1r38dERFTp06Na6+9tijLBAAAAAAAAIASr9QEBhYvXhzPPvtspr2lYYH889PpdDzzzDOxZMmSrVoPAAAAAAAAAEqTUhMY+OSTT2LFihWRSqWibt260bx5861ar0WLFlG/fv2IiFixYkV8/PHHRVEmAAAAAAAAAJQKpSYw8N1332Ue161bt0jW3HXXXTe4PgAAAAAAAABs70pNYOCnRwYsWLCgSNb86TqOJAAAAAAAAAAgSUpNYKBmzZoREZFOp2PChAkxZ86crVpvzpw5MWHChEilUlnrAwAAAAAAAEASlJrAQNOmTSMiIpVKxZo1a+LRRx/dqvUefvjhWL16daTT6az1AQAAAAAAACAJSk1goF27drHzzjtHxI+7DNx6663x0UcfbdFaAwYMiNtuuy2zu0D16tWjXbt2RVYrAAAAAAAAAJR0pSYwULZs2fjd734X6XQ6UqlUrFixIo455ph44IEHYs2aNQVaY82aNXH//ffHscceG6tWrcqsdcEFF0TZsmW38VcAAAAAAAAAACVHqQkMRETccMMNsfvuu0fEj0cTLF++PK644opo0qRJ9OjRI/r06ROTJ0+OJUuWRDqdjiVLlsSkSZPi7bffjh49ekSTJk2ie/fusXz58syau+22W1x//fW5+pIAAAAAAAAAICdK1dvqK1asGO+9914cccQRMWnSpEilUpFOp2PKlClx7733xr333rvJ+el0OiIiM69Ro0bx7rvvRsWKFYujfAAAAAAAAAAoMUrVDgMREU2aNIlBgwZFx44dM0cKpFKpiPgxELCxj4jIGnfUUUfFp59+Gk2bNs3Z1wIAAAAAAAAAuVLqAgMREbvuumu888478cILL0SbNm2yQgERkQkRrAsIRPxfmKBNmzbRq1ev6Nu3b9SrVy8X5QMAAAAAAABAzpWqIwny69y5c3Tu3Dm+/fbbGDBgQAwZMiQmTJgQCxYsiMWLF0flypWjWrVq0bRp0zjooIOiffv20bx581yXDQAAAAAAAAA5V6oDA+s0a9YsmjVrFr///e9zXQoAAAAAAAAAlAql8kgCAAAAAAAAAGDrCAwAAAAAAAAAQAIJDAAAAAAAAABAApXNdQFFYfbs2fHJJ5/EqFGjYt68ebFw4cJYu3Zt9OjRI5o1a5br8gAAAAAAAACgxCnVgYE33ngj7r333hg4cOAGP3/22WdvMDBw9dVXx5AhQyIiolGjRvHUU09t0zoBAAAAAAAAoKQplYGBuXPnRpcuXaJPnz4REZFOpyMiIpVKZT3emIMPPjjuuuuuzLju3bvH3nvvvY2rBgAAAAAAAICSIy/XBRTWnDlz4uc//3n06dMnEw5YJ51ObzIosM5JJ50UDRo0yLSff/75Iq8TAAAAAAAAAEqyUhUYSKfTceKJJ8bYsWMzfVWqVIk//elP8c4778TXX3+9XohgQ1KpVJxyyimZ9nvvvbdN6gUAAAAAAACAkqpUHUnw7LPPxn//+9/MLgJt27aNV199NerUqZM1riC7DBx33HHxwAMPRDqdji+//DIWLVoUO+644zapGwAAAAAAAABKmlK1w8Bdd90VET/uNLDbbrtFnz591gsLFNQBBxyQeZxOp2PkyJFFUiMAAAAAAAAAlAalJjAwceLEGDVqVKRSqUilUnHbbbfFTjvttMXrVatWLXbddddMe8yYMUVRJgAAAAAAAACUCqUmMDBkyJCI+HE3gIoVK8aJJ5641WvuvPPOmcfz58/f6vUAAAAAAAAAoLQoNYGBWbNmRUREKpWKpk2bRvny5bd6zSpVqmQeL1myZKvXAwAAAAAAAIDSomyuCyioxYsXZx7/9Eb/1li0aFHmceXKlYtkzcJKp9MxceLE+Oqrr2LKlCmxYMGCqFChQlSvXj322GOPOOigg6JixYpFes1FixbFwIEDY8yYMfHDDz9EpUqVolGjRtG2bduoW7dukV4LAAAAAAAAgJKp1AQGatSokXk8b968Illz6tSpmcc1a9YskjULYv78+dG7d+94991348MPP4w5c+ZsdGy5cuXiuOOOi8suuyzatWu3VdedMGFCXH/99fHSSy/FypUr1/t8KpWKdu3aRc+ePeOwww7bqmsBAAAAAAAAULKVmiMJdtlll4j48R35EyZMiKVLl27VeiNGjIiFCxdm2k2aNNmq9QrqD3/4Q+yyyy5x3nnnxUsvvbTJsEBExKpVq6J3797Rvn37OOecc+KHH37Youu+9NJL8bOf/Sz+/e9/bzAsEPHj93bAgAHRvn37uPrqqyOdTm/RtQAAAAAAAAAo+UpNYODggw+OVCoVqVQq1qxZE2+//fZWrffUU09lHleuXDlat269tSUWyODBgzd4w75MmTJRv379OOCAA2LfffeNqlWrrjfm2WefjQ4dOmQdz1AQL7/8cpxxxhnrhSxq1aoVrVq1ivr160cqlcr0p9PpuPPOO+Pyyy8v1HUAAAAAAAAAKD1KTWCgVq1accABB2Te9X7bbbfFmjVrtmit0aNHx+OPP54JIBxxxBFRpkyZoiy3QKpVqxbdunWLt99+O+bPnx/ff/99fP755zF8+PCYO3du9O/fPw499NCsOUOGDIkuXboU+Brjxo2Lc889N9auXZvp22+//eLDDz+MWbNmxRdffBHff/99jBo1Kn79619nzX3ggQfitdde26qvEQAAAAAAAICSqdQEBiIiLr744szjESNGxB//+MdCrzFlypQ4+eSTY+nSpZnwwZVXXllkNRZE48aN44knnohp06bF3//+9zj22GNjxx13zBpTpkyZaN++ffTv3z8uuOCCrM+9+uqr0b9//wJd67rrroslS5Zk2gcddFB8/PHHcfjhh2eN22uvveKVV15Z71o9evSI1atXF+bLAwAAAAAAAKAUKFWBgd/85jex7777RsSP2+b/4x//iBNOOCG+++67zc5duXJl/OMf/4gDDzwwxowZk9ldoGPHjnHIIYds69IzevbsGaNHj46uXbtGpUqVNju+TJky8fDDD8eBBx6Y1f/EE09sdu4333wTL774YqZdvnz5eOaZZ2KnnXba4PhUKhV//etfY4899sj0jRs3Luv4BgAAAAAAAAC2D6UqMJBKpeLll1+OGjVqRCqVioiIPn36RLNmzeLnP/95ZseBdTsH/POf/4yLL744jj766KhZs2Z069YtZs2alRnToEGD+Ne//lWsX8Nxxx0X5cuXL9ScMmXKRI8ePbL63nvvvc3O++c//5l1FMHpp58ezZs33+ScihUrxtVXX53VV5BwAgAAAAAAAAClS9lcF1BYe+yxR7z55ptx0kknxaxZsyKVSkU6nY4hQ4bEkCFDMuPS6XT06tUrqx0RmfENGjSIt956K2rUqFHsX8OWOPTQQ7Pac+fOjaVLl8YOO+yw0Tn/+c9/stpdu3Yt0LVOO+20uOSSSzJHGQwdOjSmTZsWdevWLWTVAAAAAAAAAJRUpWqHgXXatGkTw4cPj44dO2aCAOusO2pg3Q4EP+2P+DE40LFjx/j888/jZz/7WbHVvLWqV6++Xt/ChQs3On706NExduzYTLty5crRtm3bAl0r/9h0Oh1vv/12IaoFAAAAAAAAoKQrlYGBiIg6derEO++8E5999ll07tw5dtppp0in0xv9qFSpUhx//PHx0UcfxTvvvBO1atXK9ZdQKFOnTl2vb1O7I3z55ZdZ7datW0fZsgXfUOKQQw7Z5HoAAAAAAAAAlG6l7kiC/Nq0aRMvvPBCpNPp+Oqrr2LUqFExd+7cWLBgQeywww5Rs2bNaNKkSbRu3TrKlSuX63K32CeffJLVbtSoUZQvX36j40eNGpXVbtGiRaGul398/vUAAAAAAAAAKN1KTWBgzZo1sWTJkky7UqVKWQGAVCoV++67b+y77765KG+b++c//5nVPvbYYzc5fvTo0VntBg0aFOp6+cfnXw8AAAAAAACA0q3UHEnwzDPPRPXq1TMf+d9xvz3r06dPfPzxx1l9Xbp02eScWbNmZbXr169fqGvWq1cvqz179uxCzQcAAAAAAACgZCs1OwzMnDkz0ul0RERUq1YtjjjiiBxXVDzmzZsXF154YVbfySefHK1bt97kvMWLF2e1K1euXKjr5h+/atWqWLFiRVSoUKFQ6+Q3a9asQocPxo4du1XXBAAAAAAAAGB9pSYwUKVKlYj48eiBRo0a5bia4rF27do4++yzY8qUKZm+qlWrxoMPPrjZufkDAxUrVizUtStVqrTBNbc2MPDwww9Hz549t2oNAAAAAAAAALZeqTmSYNddd811CcXuyiuvjHfeeSer7x//+Ec0aNBgs3OXL1+e1S5fvnyhrr2hYMCyZcsKtQYAAAAAAAAAJVepCQw0b948IiLS6XR8//33Oa5m23vwwQfjvvvuy+rr0aNHnHbaaQWan39HgZUrVxbq+itWrNjsmgAAAAAAAACUXqXmSIK999479t577/jmm29i/vz5MXjw4GjTpk2uy9omnn/++bjsssuy+rp06RJ33HFHgddYd4TDOvl3HNicDe0mkH/NLdGtW7fo1KlToeaMHTs2Tj755K2+NgAAAAAAAAD/p9QEBiIiLrjggrj00ksjIuKGG26Id999N8cVFb233norzjnnnEin05m+X//61/HEE09EKpUq8Dr5b+4vWbKkUHXkH1+2bNki2WGgdu3aUbt27a1eBwAAAAAAAICtU2qOJIj48d3phxxySKTT6Xj//feje/fuuS6pSPXv3z86deoUq1evzvR16NAhevXqFWXKlCnUWvlvyk+ZMqVQ86dOnZrVrlWrVqHmAwAAAAAAAFCylarAQJkyZeLNN9+MX/ziF5FOp+P++++Pww47LAYMGJDr0rba4MGD48QTT8w6OqBt27bx+uuvR/ny5Qu93l577ZXVnjx5cqHm5x/frFmzQtcAAAAAAAAAQMlVqo4kuOmmmyIiol27dvHdd9/FzJkzY+DAgXHkkUdGnTp14sADD4wmTZrETjvtFOXKlSvU2tdff/22KLlARowYEcccc0wsXrw407f//vtHnz59onLlylu0Zv4b/CNHjizU/FGjRm1yPQAAAAAAAABKt1IVGLjxxhsjlUpl2qlUKtLpdEREzJgxI95+++0tXjtXgYHRo0dHhw4dYv78+Zm+5s2bx3vvvRdVq1bd4nVbtmyZ1R46dGisXr06ypYt2B/5wIEDN7keAAAAAAAAAKVbqTqSYENSqVTmY0usCxzkwqRJk+Koo46KWbNmZfqaNGkS77//ftSqVWur1m7WrFnstttumfaSJUti0KBBBZq7ZMmS+OyzzzLtVCoVxx9//FbVAwAAAAAAAEDJUuoCA+l0ukg/cmX69Olx5JFHxpQpUzJ99erViw8++CDq1atXJNc48cQTs9pPPvlkgea9+OKLWccjHHjggVG3bt0iqQkAAAAAAACAkqFUHUnQv3//XJdQJObNmxcdOnSIcePGZfpq1aoV77//fjRp0qTIrnPeeefFAw88kAlGvPDCC3H11VdH8+bNNzpn+fLlcccdd2T1de3atchqAgAAAAAAAKBkKFWBgXbt2uW6hK22aNGiOProo+Obb77J9FWrVi369u27yRv5W+JnP/tZdO7cOV588cWIiFi5cmWcc8450a9fv9hpp53WG59Op+Oyyy6L7777LtPXtGnTOO+884q0LgAAAAAAAAByr0QFBi6//PLM427dusXuu++ew2q2jRNPPDGGDh2a1Xf55ZfHnDlzol+/foVa64ADDojq1atvcswtt9wSb775ZixdujQiIoYOHRqHHXZYPPDAA9G+ffvMuDFjxsQ111wTr732Wtb8O+64I8qVK1eougAAAAAAAAAo+UpUYOCBBx6IVCoVERHHH3/8ZgMDCxYsiBEjRmTahx122DatrygMGDBgvb7rr79+i9bq379/1k3/Ddl9993jySefjDPPPDNzNMHw4cPj8MMPj1q1akXDhg1j1qxZMWXKlMzn1/njH/8YnTp12qLaAAAAAAAAACjZSlRgIOLHbfHXhQY254svvohf/vKXERGRSqVi9erV27K0Uuv000+PdDodXbt2jWXLlmX6Z8+eHbNnz97gnO7du8ddd91VXCUCAAAAAAAAUMzycl1AfgUNC6yTTqczH2zcGWecEV9//XWceeaZmzxi4LDDDosBAwbE3XffXeg/CwAAAAAAAABKjxK3w8D2LpfBhqZNm8Zzzz0XjzzySHz66afx3XffxaJFi6JixYrRsGHDOOSQQ6JevXo5qw8AAAAAAACA4iMwkEA77bRTHHvssbkuAwAAAAAAAIAcKnFHEgAAAAAAAAAA257AAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJFDZXBewMcOHD4+yZTdd3vDhw7Pan3zySaTT6S263mGHHbZF8wAAAAAAAACgNCqRgYF0Oh3du3cv9Jz27dtv0fVSqVSsXr16i+YCAAAAAAAAQGlUIgMDqVSqwDsFpFKpzOMt3V0AAAAAAAAAAJKmRAYGIrKDANtyjpABAAAAAAAAAElUogIDDRs23KKb/gAAAAAAAABA4ZSowMDEiRNzXQIAAAAAAAAAJEJergsAAAAAAAAAAIqfwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACSQwAAAAAAAAAAAJJDAAAAAAAAAAAAkkMAAAAAAAAAAACRQ2VwXQPFavnx5DBo0KL799tuYP39+lC9fPurXrx9t2rSJpk2b5ro8AAAAAAAAAIqJwECOTZ06NYYMGRKDBw+OIUOGxOeffx6LFi3KfL5Ro0YxceLErb7O7Nmzo2fPnvH000/HkiVLNjjmgAMOiOuuuy5OOumkrb4eAAAAAAAAACWbwEAODBw4MO69994YPHhwTJs2bZtfb8CAAdGpU6eYM2fOJsd98cUXcfLJJ8dvf/vbePzxx6N8+fLbvDYAAAAAAAAAckNgIAeGDh0ar7/+erFc69NPP41jjz02li1bltVfrVq1aNKkScyfPz++//77WLNmTeZzzz77bCxevDheeeWVSKVSxVInAAAAAAAAAMUrL9cFkK1KlSpFttb8+fPjtNNOywoLNGrUKHr37h3z5s2L//3vfzFhwoSYOHFiXHjhhVlzX3vttbj//vuLrBYAAAAAAAAAShaBgRzacccdo3379nHllVfGyy+/HBMnTow333yzyNa/++67s448aNKkSQwaNChOOumkrJ0D6tevH48++mjceuutWfNvuummmD9/fpHVAwAAAAAAAEDJ4UiCHDjhhBPil7/8ZTRr1izy8rIzGxMmTCiSa8yePTv+9re/ZfU9/vjjUbdu3Y3Oueaaa+K9996Ljz/+OCIiFi5cGPfcc896QQIAAAAAAAAASj87DOTAbrvtFi1atFgvLFCUXnjhhVi8eHGmfdhhh8WRRx65yTmpVCpuuOGGrL5//vOfkU6nt0mNAAAAAAAAAOSOwMB26o033shqd+3atUDzDj/88GjSpEmmPWPGjPjvf/9bpLUBAAAAAAAAkHsCA9uhxYsXZ44VWOeXv/xlgeamUqk46qijsvreeuutIqsNAAAAAAAAgJJBYGA79M0338SqVasy7SZNmsQuu+xS4PmHHHJIVvvLL78sqtIAAAAAAAAAKCEEBrZDo0aNymq3aNGiUPPzj8+/HgAAAAAAAACln8DAdmj06NFZ7QYNGhRqfv7xkyZNiuXLl291XQAAAAAAAACUHGVzXQBFb9asWVnt+vXrF2p+nTp1omzZsrF69eqIiFi7dm3MnTs36tWrVyS1zZ49u1Bzxo4du9XXBQAAAAAAACCbwMB2aPHixVntypUrF2p+KpWKSpUqxaJFiza65pZ6+OGHo2fPnkWyFgAAAAAAAABbzpEE26H8N/crVqxY6DUqVaq0yTUBAAAAAAAAKN0EBrZDy5cvz2qXL1++0GtUqFAhq71s2bKtqgkAAAAAAACAksWRBNuh/DsKrFy5stBrrFixYpNrbqlu3bpFp06dCjVn7NixcfLJJxfJ9QEAAAAAAAD4kcDAdqhKlSpZ7fw7DhRE/h0F8q+5pWrXrh21a9cukrUAAAAAAAAA2HKOJNgO5b+5v2TJkkLNT6fT2ywwAAAAAAAAAEDJIDCwHcr/Dv4pU6YUav7MmTNj9erVmXZeXl7UrFmzSGoDAAAAAAAAoGQQGNgO7bXXXlntyZMnF2p+/vGNGjWKihUrbnVdAAAAAAAAAJQcAgPboWbNmmW1R44cWaj5o0aN2uR6AAAAAAAAAJR+AgPbob333jvKlSuXaU+cODGmT59e4PkDBw7Mards2bKoSgMAAAAAAACghBAY2A7tuOOOcdhhh2X1vf/++wWam06no1+/fll9J5xwQpHVBgAAAAAAAEDJIDCwnTrxxBOz2k8++WSB5vXv3z8mTJiQadepUyfatGlTpLUBAAAAAAAAkHsCA9up008/PSpXrpxpf/zxx/Hhhx9uck46nY6ePXtm9Z177rmRl+fHBAAAAAAAAGB7407wdqp27dpx8cUXZ/Wdf/75MW3atI3Ouf322+Pjjz/OtKtWrRpXXnnlNqsRAAAAAAAAgNwpm+sCkmrgwIGxbNmy9fqHDx+e1V6+fHn069dvg2vUrVs3WrRosdFr9OjRI5555pmYMWNGRERMmDAh2rZtGw8++GCccMIJkUqlIiJiypQpccstt8Q//vGPrPnXXntt7LzzzoX6ugAAAAAAAAAoHQQGcuSss86KSZMmbXbczJkzo0OHDhv83DnnnBNPP/30RufuvPPO8eKLL0bHjh1j+fLlERExadKkOOmkk6JatWrRpEmTWLBgQUyePDnWrFmTNfekk06K7t27F/wLAgAAAAAAAKBUcSTBdu6www6Lt99+e72dAhYsWBDDhg2LCRMmrBcWOPPMM+PFF1/M7EAAAAAAAAAAwPZHYCABjjjiiBg5cmRcdNFFscMOO2x03P777x+vvvpqPPfcc1GhQoVirBAAAAAAAACA4uZIghyZOHFisV6vTp068fDDD8e9994bgwYNilGjRsWCBQuifPnyUa9evWjTpk3svvvuxVoTAAAAAAAAALkjMJAwlSpViiOPPDKOPPLIXJcCAAAAAAAAQA45kgAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASSGAAAAAAAAAAABJIYAAAAAAAAAAAEkhgAAAAAAAAAAASqGyuCwByqGfVXFfAtnLDwlxXAAAAxSZ18XO5LoFtJP3QWbkuAQAAYLtmhwEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEgggQEAAAAAAAAASCCBAQAAAAAAAABIIIEBAAAAAAAAAEigsrkuAAAAgORIXfxcrktgG0o/dFauSwAAAAAKwQ4DAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAZXNdAAAAUDKlLn4u1yWwDaUfOivXJQAAAACQY3YYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQSGAAAAAAAAACABBIYAAAAAAAAAIAEEhgAAAAAAAAAgAQqm+sCAAAAAAC2d6mLn8t1CWwj6YfOynUJAABbzA4DAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQGVzXQAAAAAAAAC5l7r4uVyXwDaUfuisnFzXz9X2K1c/UxQtOwwAAAAAAAAAQAIJDAAAAAAAAABAAgkMAAAAAAAAAEAClc11AeTGuHHjYsiQITFlypRYuXJlVK9ePZo1axZt27aNihUr5ro8AAAAAAAAALYxgYGE6d27d9x8883xv//9b4Ofr1KlSnTp0iVuuOGGqFmzZjFXBwAAAAAAAEBxcSRBQqxYsSLOPvvs+NWvfrXRsEBExOLFi+Ohhx6KFi1axMcff1yMFQIAAAAAAABQnAQGEmDt2rVx2mmnxXPPPZfVX6ZMmWjSpEm0bNkyqlatmvW52bNnxzHHHBOfffZZcZYKAAAAAAAAQDERGEiAu+++O954442svt///vcxefLkGD9+fAwbNizmzZsXr732WjRs2DAzZunSpdG5c+dYuHBhcZcMAAAAAAAAwDYmMLCdmzt3btx6661Zfbfffns88sgjUbdu3UxfXl5e/OpXv4pBgwZF48aNM/1TpkyJ++67r7jKBQAAAAAAAKCYCAxs5+66665YtGhRpn3YYYfFVVddtdHx9erViyeeeCKr7/7774+5c+dusxoBAAAAAAAAKH4CA9uxtWvXxlNPPZXVd+ONN0YqldrkvCOPPDIOPfTQTHvRokXx0ksvbZMaAQAAAAAAAMgNgYHt2KBBg2L27NmZdtOmTaN9+/YFmtu1a9esdu/evYuwMgAAAAAAAAByTWBgO/b2229ntTt06LDZ3QV+OvanBgwYEEuWLCmy2gAAAAAAAADILYGB7diXX36Z1W7btm2B59atWzcaN26caa9cuTJGjhxZRJUBAAAAAAAAkGsCA9uxUaNGZbVbtGhRqPn5x+dfDwAAAAAAAIDSS2BgO7Vs2bKYPHlyVl+DBg0KtUb+8aNHj97qugAAAAAAAAAoGcrmugC2jTlz5kQ6nc60y5UrF7Vr1y7UGvXq1ctqz5o1a6vrmjVrVsyePbtQc/IfhTB27NitroP/b9aaXFfAtvLNN7mugM2ZOyXXFbANfZOrv4N+rrZbfqbYFvxcsS34uaKo5exnCrYFz1XbLc9VbFc8V23X/L5OUfP/wKKT//7nihUriu3aqfRP7yqz3Rg1alTWkQJVq1aNBQsWFGqN++67L6644opM+/TTT49evXptVV033nhj9OzZc6vWAAAAAAAAANhe9e7dO0466aRiuZYjCbZTixcvzmpXrFix0GtUqlRpk2sCAAAAAAAAUHoJDGynli9fntUuX758odeoUKFCVnvZsmVbVRMAAAAAAAAAJUfZXBfAtpF/R4GVK1cWeo38Z2NsyS4F+XXr1i06depUqDk//PBDfP7557HTTjtFtWrVokGDBuuFGWBjxo4dGyeffHKm3bt379h9991zVxAkjL+DQGnguQooDTxXAaWF5yugNPBcBZQ0K1asiO+//z7TbteuXbFdW2BgO1WlSpWsdv4dBwoi/44C+dfcErVr147atWsXet7Pf/7zrb42RETsvvvusffee+e6DEgsfweB0sBzFVAaeK4CSgvPV0Bp4LkKKAlatWqVk+s6kmA7lf/m/tKlSyOdThdqjSVLlmxyTQAAAAAAAABKL4GB7VTNmjUjlUpl2qtWrYpZs2YVao2pU6dmtbdkZwAAAAAAAAAASiaBge1UpUqVomHDhll9kydPLtQa+cc3a9Zsq+sCAAAAAAAAoGQQGNiO5b/BP3LkyELNHzVq1CbXAwAAAAAAAKD0EhjYjrVs2TKrPWjQoALPnT59ekycODHTLleuXLRo0aKIKgMAAAAAAAAg1wQGtmPHH398Vrtfv36RTqcLNLdv375Z7cMPPzyqVKlSZLUBAAAAAAAAkFsCA9uxtm3bRs2aNTPt8ePHx4ABAwo098knn8xqn3TSSUVZGgAAAAAAAAA5JjCwHcvLy4suXbpk9fXs2XOzuwx88MEH8cknn2TaO+64Y3Tu3HlblAgAAAAAAABAjggMbOeuuuqqrKMEPvroo7jzzjs3On7q1Klx/vnnZ/VdeumlWTsVAAAAAAAAAFD6CQxs52rWrBl//vOfs/quueaa6NatW0ybNi3Tt3bt2ujdu3e0bds2Jk6cmOmvW7duXHHFFcVVLgAAAAAAAADFRGAgAa666qo4/vjjs/oeeeSRaNiwYey2227RqlWrqFGjRvzqV7+KyZMnZ8ZUqlQpXnrppahWrVoxVwwAAAAAAADAtlY21wWw7eXl5cXLL78c5557brzwwguZ/jVr1sT48eM3OKdGjRrxyiuvxCGHHFJcZcI2UatWrbjhhhuy2kDx8XcQKA08VwGlgecqoLTwfAWUBp6rAP5PKp1Op3NdBMXn1VdfjVtuuSW+/PLLDX6+cuXKcc4558QNN9wQtWvXLt7iAAAAAAAAACg2AgMJNXbs2Bg8eHBMnTo1Vq5cGdWqVYvmzZvHIYccEhUrVsx1eQAAAAAAAABsYwIDAAAAAAAAAJBAebkuAAAAAAAAAAAofgIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEACAwAAAAAAAACQQAIDAAAAAAAAAJBAAgMAAAAAAAAAkEBlc10AABs2ceLEaNKkSaZ9zjnnxNNPP527gnIslUplHrdr1y4GDBiQu2IokHHjxsWQIUNiypQpsXLlyqhevXo0a9Ys2rZtGxUrVsx1eUCCpdPpmDhxYnz11VcxZcqUWLBgQVSoUCGqV68ee+yxRxx00EGepwAAtsLo0aNj+PDhMWXKlFi6dGlUqlQp6tSpE3vuuWfst99+UaFChVyXCCTUihUrYtiwYTFq1KiYP39+LFu2LHbaaaeoXbt2tGrVKnbfffes1yEBkkBgAAAoUr17946bb745/ve//23w81WqVIkuXbrEDTfcEDVr1izm6oCkmj9/fvTu3Tvefffd+PDDD2POnDkbHVuuXLk47rjj4rLLLot27doVY5UABXPGGWfECy+8kNXXqFGjmDhxYm4KAoiIRYsWxd/+9rd44oknYsKECRsdV758+WjdunWceuqpcemllxZjhUCSffHFF3H//ffHK6+8EitWrNjouHr16kXXrl3j0ksvjZ133rkYKwTIHUcSwEY8/fTTkUqlMh/t27ff4rUGDBiQtVbjxo2LrE6AkmLFihVx9tlnx69+9auNhgUiIhYvXhwPPfRQtGjRIj7++ONirBBIqj/84Q+xyy67xHnnnRcvvfTSJsMCERGrVq2K3r17R/v27eOcc86JH374oZgqBdi8N998c72wAECuvfXWW7HHHnvEtddeu8mwQETEypUr49NPP43bb7+9mKoDkmzt2rVx9dVXR+vWreO5557bZFggImLq1Klx0003RYsWLeLdd98tpioBcktgAEi0/GGOG2+8MdclQam0du3aOO200+K5557L6i9Tpkw0adIkWrZsGVWrVs363OzZs+OYY46Jzz77rDhLBRJo8ODBsXLlyvX6y5QpE/Xr148DDjgg9t133/WepyIinn322ejQoUMsXry4OEoF2KSFCxfGRRddlOsyALLcf//9ceKJJ8bMmTOz+itWrBhNmzaN1q1bxz777GOHOSAnLrzwwrjzzjtj7dq1Wf077LBD7LPPPtG6devYbbfd1juGYObMmXHSSSfFO++8U5zlAuSEwAAAsNXuvvvueOONN7L6fv/738fkyZNj/PjxMWzYsJg3b1689tpr0bBhw8yYpUuXRufOnWPhwoXFXTKQUNWqVYtu3brF22+/HfPnz4/vv/8+Pv/88xg+fHjMnTs3+vfvH4ceemjWnCFDhkSXLl1yUzDAT1x55ZUxderUiIioXLlyjqsBiHjyySfj8ssvj3Q6nek75phj4p133okFCxbEuHHjYvDgwTFixIiYPXt2TJ06Nf71r3/FKaecEuXLl89h5UASvPLKK/HEE09k9bVo0SLefvvtWLhwYYwYMSIGDx4cY8eOjZkzZ0bPnj2znptWrlwZ55xzTsyfP7+4SwcoVgIDAMBWmTt3btx6661Zfbfffns88sgjUbdu3UxfXl5e/OpXv4pBgwZlHc0yZcqUuO+++4qrXCChGjduHE888URMmzYt/v73v8exxx4bO+64Y9aYMmXKRPv27aN///5xwQUXZH3u1Vdfjf79+xdnyQBZBgwYkHnBOy8vL2644YYcVwQk3dixY+Piiy/OtMuVKxfPP/989OnTJ44++uioUKHCenPq1q0bZ599drzyyisxfPjw4iwXSKCePXtmtQ888MAYMmRIHHvssVG2bNmsz9WqVSuuv/76eOedd7I+N3v27Hj00UeLpV6AXBEYAAC2yl133RWLFi3KtA877LC46qqrNjq+Xr1666W777///pg7d+42qxFItp49e8bo0aOja9euUalSpc2OL1OmTDz88MNx4IEHZvXnf+4CKC7Lli2L888/P/MO3j/+8Y9x0EEH5bgqIOkuuOCCWL58eab93HPPxRlnnFHg+dWrV98WZQFERMT48ePj66+/zup7+OGHN7tL0xFHHBFdu3bN6nvzzTeLvD6AkkRgAADYYmvXro2nnnoqq+/GG29c79y3/I488sisLb8XLVoUL7300japEeC4444r9Ja3ZcqUiR49emT1vffee0VZFkCBXXfddTFu3LiIiGjYsGHccsstOa4ISLo33ngja/elTp06RadOnXJYEUC20aNHZ7Xr169f4MDlKaecktUeO3ZskdUFUBIJDAAAW2zQoEExe/bsTLtp06bRvn37As3Nn9bu3bt3EVYGsPV+GmyK+PEIlqVLl+aoGiCphg4dGg888ECm/fe//z2qVKmSu4IAIuKxxx7LajsmBShp5s2bl9Vu0KBBgec2bNgwq71gwYKiKAmgxCq7+SFASbJw4cL4+OOPY+zYsbFs2bKoUaNG7L777vGLX/xig2fDbak1a9bEZ599FuPHj49p06ZFhQoVolmzZtG+ffvNbuX7ww8/xKeffhpjxoyJpUuXRs2aNWPfffeNNm3abPZdx5uyYMGC+Prrr2P06NExf/78WLlyZVSrVi1q164dBx10UDRq1GiL194WFixYEJ999llMnz495syZE2vXro1q1arFbrvtFvvtt1/Url17q68xevToGDx4cEybNi3KlCkTtWvXjtatW0fz5s2L4CuIWLp0aQwcODCmTp0as2bNylyjRYsW0apVq63681zn888/j2+++SamT58eZcuWjUaNGkXbtm2jXr16RfAVsK29/fbbWe0OHToU+OeiQ4cOWe0BAwbEkiVLNrs1HEBx2dA2uQsXLowddtghB9UASbRq1aro2rVrrFmzJiJ+fAfv8ccfn+OqgKSbOnVq1s5LLVu2jL333juHFQGsr2rVqlntZcuWFXhu/rE1a9YskpoASiqBAShh2rdvHx999FGmve6MyunTp8e1114bzz33XKxcuXK9eZUrV47LLrssrrnmmgLdbHv66afj3HPPzbSfeuqp6NKlSyxfvjzuvPPOePzxx2Pq1KnrzatWrVpcc8010b1798jLy96kZObMmXHdddfFv/71r6wz7NZp3LhxPPDAA3HSSSdttr51hg0bFi+88EL07ds3hg8fnvl+bEjTpk3j0ksvjd/97nebDTVs7IZmz549o2fPnhud179//02+e3rt2rXx4osvxoMPPhhDhw7NvLC3oevvv//+cdZZZ8W5555b6HP7+vbtG9dee218/vnnG/x88+bN484774wTTjihUOuuM3DgwLj11lvjww8/jBUrVmxwTO3atePCCy+MK6+8MnbcccdCX+Opp56KW2+9NbO16k+lUqno0KFD3H333bHvvvsWem2Kz5dffpnVbtu2bYHn1q1bNxo3bhwTJ06MiIiVK1fGyJEjnccLlBgb+l2oRo0aOagESKrbb789vvrqq4j48d9iDz74YI4rAoh49913s17vOPzww3NYDcCGtWzZMqs9atSoAr9RZciQIVnt1q1bF2VpACWOIwmgFPjkk0/iZz/7WTz11FMbDAtERCxZsiRuvfXWOPzww9fbbqmgZs6cGW3bto0bb7xxgy+QR/z4rvmrrroqzjjjjFi7dm2mf+jQobHffvvF448/vsGwQETExIkT4+STT46//vWvBarnoYceilatWsVdd90VX3755SbDAhER48ePj0svvTQOPPDAnJwr9e2330bLli3jzDPPjP/+978bDQtE/BgE+d///hdXXHFFgb8f6/To0SM6duy40bBAxI+/AJ944olx8803F2rtJUuWROfOneMXv/hFvPPOOxsNC0REzJo1K26++ebYc889Y+jQoQW+xvLly+OEE06I8847b4NhgYgfvz99+/aNgw46KHr16lWor4HiNWrUqKx2ixYtCjU///j86wHk0ieffJLVbtSoUZQvXz5H1QBJM3LkyLj11lsz7TvvvDN22WWXHFYE8KP8rwHst99+mcfDhg2LSy65JPbbb7+oXr167LDDDtG4cePo0KFD3HPPPRt9vQmgqNWvXz/rjS0rVqwoUPhyxYoVWcdBRax/rCbA9kZgAEq4L774Io455phMCCAvLy922223aN26deyxxx7rvVN+6NCh0aVLl0JfZ/ny5XHcccfFsGHDMn2NGjWKgw46aIPXeemll+KOO+6IiB9vlHfo0CFmzpwZERFlypSJPffcMw466KCoX7/+etf605/+FJ9++mmBaspvxx13jL322itat24drVq12uDZUyNHjoxDDz00Zs2atdlrFJX+/fvHz3/+88y7f36qVq1ase+++8aBBx4YTZs2XW9nhsK4+uqr4+677860d9xxx9h7773jwAMPjFq1aq03/vrrr4/XXnutQGvPmjUr2rVrFy+//PJ6n6tfv34ccMAB0bJly/V2Q5gxY0a0b9++QH+mq1evjlNOOSXeeuutDV7jwAMPjN122y3zPVq5cmX89re/jQEDBhToa6B4LVu2LCZPnpzVV5jz4DY0fvTo0VtdF0BR+ec//5nVPvbYY3NUCZA0a9euja5du2YC44ceemj87ne/y3FVAD/KHxho2rRpLF68OLp27RqtWrWKv/3tbzFixIhYsGBBLFu2LCZNmhT9+vWLK6+8MvbYY4/485//HKtWrcpR9UCS3HnnnVmvxV5//fXxzDPPbHT8ggUL4tRTT816Q8sJJ5ywxbu4ApQWAgNQwnXu3DmWLFkSO++8c9x3330xa9asGDt2bAwePDjGjBkTU6ZMWS8g8Oabb8Y777xTqOvceeed8cUXX0ReXl5cfPHFMXHixJg4cWIMGTIkxowZE5MnT45TTjkla86tt94aU6dOjU6dOsXChQujWrVqcf/998fs2bNj9OjRMWTIkPj+++9j8ODB8bOf/SwzL51Ox6WXXlqguipUqBCdO3eOZ599NiZNmhQ//PBDfPvttzF48OD44osvYvLkyTFnzpx45JFHom7dupl5M2bM2OQLau+//368//77cc8992T1/+Y3v8l8bkMfP03NrzNx4sQ45ZRTYsGCBVl1X3HFFfHNN9/ErFmzYvjw4TF06NAYN25cLFy4MPr27RsXXHBBVKlSpUDfh4iIjz/+OO68886IiGjTpk307ds35s2bF19//XUMHTo0Zs6cGf37949mzZplzbvkkkti9erVm1x77dq1cfrpp8cXX3yR6atVq1bcfffdMX369Pj+++/j888/j2HDhsWcOXPi008/jSOOOCIzdunSpXHGGWfE3LlzN3mde+65J/r06ZPVd/rpp8eoUaPi+++/j6FDh8bYsWNj6tSp8ec//znKli0bq1evzjo+g5Jjzpw5WTt/lCtXLmrXrl2oNerVq5fVLs6gD8Cm9OnTJz7++OOsvi0JZQJsiQcffDD++9//RkRE+fLl47HHHtvosWoAxS3/ro55eXlx2GGHrRe23JBly5bF7bffHscee2wsWrRoW5UIEBERv/jFL+Khhx7K/B61evXq6NKlS7Ru3TruuOOOeP311+Pdd9+Nf//73/HHP/4xdtttt6w3OnXo0MHup0AypIENeuqpp9IRkflo167dFq/Vv3//rLUaNWq00bHt2rXLGhsR6caNG6fHjh27yWv87ne/y5pz8sknb3J8/q8vItJ5eXnpl156aaNz1qxZkz7qqKOy5jRv3jwdEelddtklPXLkyI3OnTVrVrpWrVpZc4cNG7bJGr/++uv0zJkzNznmp+bNm5c+4IADsq7xzTffbHJO/j+bG264ocDXW+fnP/951hp169ZNjxgxokBz586du9Hvw4QJE9b7M4qIdJcuXdKrV6/e6JqzZs1K161bN2tO7969N1nHHXfckTW+TZs2m/3er1mzJn3xxRdnzbvkkks2On7ixInpihUrZo2/5ZZbNnmNPn36pMuVK7fe92Br/j5SdEaOHJn151K1atVCr3HvvfdmrXH66acXfaEAhTR37tx0/fr1C/W7FUBRGT9+fLpy5cqb/TdKYf6dCVBU1qxZk06lUlnPP61atco8TqVS6RNOOCH9yCOPpN988830Cy+8kL7qqqvWe50iItK//vWvc/3lAAnxwQcfpPfee+8Nvta6oY+mTZumH3300fSaNWtyXTpAsbDDAJRwZcqUiZdffjl22223TY678847o2LFipl23759Y+3atYW61pVXXhmdOnXa6Ofz8vLilltuyepbtz3TM888E82bN9/o3Fq1asWf/vSnrL7N7YKw9957F+rdytWrV49evXplbTP19NNPF3j+lujbt2989tlnmXaFChXi3XffjX322adA83feeedo2bJlga934IEHxmOPPRZlypTZ6JhatWrFddddl9W3qe/10qVL46677sq0d9111+jTp89mv/d5eXnxwAMPxMEHH5zp++c//5m108JPPfroo1nHTBx//PFx7bXXbvIaxxxzTNxwww2bHEPuLF68OKv90+eggqpUqdIm1wQobmvXro2zzz47pkyZkumrWrVqgc66BCgKF1xwQSxZsiQiIpo1axZ//vOfc1wRwP9ZuHBh1k5zERH/+9//IiKiRo0a8dFHH8V//vOf+P3vfx/HH398nHbaaXHHHXfE6NGj48wzz8ya99prr8Wzzz5bbLUDyXXEEUfE0KFDo3v37pt8XTUiomHDhtG9e/c488wzt+poWYDSxLMdlHCnnHJKHHjggZsdV7169fjlL3+ZaS9dujS+/fbbAl+ncuXKcfXVV292XJs2baJOnTpZfb/4xS+yrr0xJ510UlZ72LBhBa6voPbYY49o3bp1pj1o0KAiv8ZPPfDAA1ntHj16FDgssCVuuummKFeu3GbHde7cOau97h/vG/Lss8/GvHnzMu0bb7wxdt555wLVU6ZMmbjmmmsy7cWLF8d777233rh0Or1eeGPd8Qqb071799hll10KNJbi9dMASMSP2+UWVoUKFbLay5Yt26qaALbWlVdeuV7Q7h//+Ec0aNAgRxUBSfLkk09Gv379IiIilUrFY489tkW/YwFsKxsLeZcpUybefvvtOPTQQzf4+SpVqsS//vWv9V4/uu2229YLIAAUtUcffTR22223uOeee2LNmjWbHDt58uTo1q1bNG7cuEBHrQBsDwQGoIQ77bTTCjw2/zvVv//++wLPPeqoo6JatWoFGrv33ntntU899dQCzdtrr72ybnZPnjy5wPUVRpMmTTKPt0UoYZ1Vq1bFgAEDMu2yZctGt27dttn1qlatGh07dizQ2J133jkaNmyYaW/qZ6FPnz6Zx2XLlo3TTz+9UHUdeeSRWWnbTz75ZL0x3377bcyYMSPTPuCAA6JFixYFWr9ChQqFronikX9HgZUrVxZ6jRUrVmxyTYDi9OCDD8Z9992X1dejR49C/T4GsKWmT58e3bt3z7TPP//8jd54A8iVjf2b7fzzz482bdpscm5eXl488sgjWa8hjB49Oj766KMirRFgnVWrVsWpp54aF110UUyfPj0ifnzd9Prrr48hQ4bE/PnzY+XKlTFt2rT4z3/+E7/61a8ilUpFRMS8efOia9euceWVV+bySwAoFgIDUMIVZHeBdfJvIb9w4cICzz3ggAMKPLZGjRpZ7VatWhVoXpkyZbJCCT/88EOBrzlz5sz429/+FmeddVbss88+UadOnahUqVKkUqn1Pnr16pWZt3Tp0m32juXPP/88a+39999/m74TvlWrVoXaBuunPw8b+1lIp9MxcODATHvPPfeMnXbaqVB1Va5cOetnYt0xFT81ZMiQrHb79u0LdY3Cjqd4VKlSJaudf8eBgsj/9zP/mgDF5fnnn4/LLrssq69Lly5xxx135KYgIHH+8Ic/ZI732mWXXbKODQMoKTb2b7bf/e53BZrftGnTOOqoo7L6BAaAbeWiiy6KV199NdNu3bp1fPPNN9GzZ8846KCDolq1alGuXLnYdddd44QTTojXXnstevfunRWOuueee+Kpp57KRfkAxUZgAEq4zZ0j/1OVK1fOahfmRnmtWrUKPHaHHXYokrkFqW/OnDlx3nnnRb169eKSSy6J559/Pr7++uuYNWtWgW9OrnvRraiNGzcuq12YcMeWKMzPQkT2z8PGvtczZ87MOo5g5MiRGwxhbO5j9uzZmTV+ut46EyZMyGr/7Gc/K9TXsi2PeWDL5X+haOnSpYXeSnLd+bwbWxOgOLz11ltxzjnnZD2H/frXv44nnngi8+4SgG3p5Zdfjtdffz3T/utf/1rgHeAAilOlSpXWO/97xx13jP3337/Aa7Rr1y6r/fnnnxdJbQA/NWDAgHjyyScz7dq1a8dbb7212Td8nXjiifH3v/89q+/KK690jCawXRMYgBJua7bnLsyNu625zpbO3Vx948aNi/333z+eeuqpzZ4ttSn5tzwvKvlvjBf2hn5hbYut2ufOnVvka25oN4P8oY38u1RsTmHHUzxq1qyZdSNt1apVMWvWrEKtMXXq1Kz2tv57BJBf//79o1OnTrF69epMX4cOHaJXr17rvRgOsK38dKvb4447Ljp37pzDagA2Lf+/23bfffdC7Yi41157ZbUL++9IgIJ48MEHs9qXXXZZgd/41qVLl9hzzz0z7blz58Zrr71WpPUBlCRlc10AlFRly2b/9diam8753wlfrly5LV4rKVauXBnHHntsTJkyJat/jz32iHbt2sVee+0V9erVi8qVK2eOJljn7rvvjr59+27zGhctWpTVLo3vjN4Wuy+sXbt2vb7FixdntfPvUrE5+XfPoGSoVKlSNGzYMCZNmpTpmzx5ctSpU6fAa0yePDmr3axZsyKrD2BzBg8eHCeeeGLW72pt27aN119/PcqXL5/DyoCk+env5W+//fYW7W4yadKk9eYNGzYsWrZsuZXVAWRr3rx55izwiCj00Yb5x8+fP79I6gJYJ51Ox4cffpjVd8IJJxR4fl5eXhx33HExZsyYTN/HH38cZ511VpHVCFCSCAzARuTf/jH/Dc/CyH9j2daSm/foo49m/UJWp06dePrpp+Poo4/e7NyfbjW1Le24445Z7a35GcmV/DfuW7RoEX/961+3as1KlSqt15f/hv/SpUsLtWb+bespOZo1a5YVGBg5cmQcdNBBBZ4/atSo9dYDKA4jRoyIY445Juv/3/vvv3/06dNHUA0AYBNatGiRdSOusG+yyf/GmsK+qQBgc+bPn7/eLqhNmjQp1Br5x+ffJRNgeyIwABuR/6b+zJkzt3it/FurCQxs3gsvvJDVfv311+PnP/95gebmPypgW9l5552z2qVxC72aNWtmtdPpdBx11FFFfp38P/Nz5swp1PxtcXQCRaNly5bx3nvvZdqDBg2Kc845p0Bzp0+fHhMnTsy0y5UrFy1atCjqEgHWM3r06OjQoUPWu9maN28e7733XlStWjWHlQEAlHytWrXKahf2NbP8r584hhAoahsKMuXfUXhz8u8SvDVH5gKUdAIDsBH5E4SzZ8+OOXPmrHeDtSC++eabrHbjxo23prTt3tq1a2Po0KGZdsuWLQscFohY//u9reyxxx5Z7c8//7xYrluUdtlll6hUqVIsW7YsIn7cxnTVqlVFfmxG06ZNs9pff/11oeaPGDGiKMuhCB1//PFx5513Ztr9+vWLdDpdoG108x8dcvjhh5fKoz2A0mXSpElx1FFHZb1Q3aRJk3j//fcLfJ4lQFF74403YtWqVYWaM3z48OjevXumXadOnfj3v/+dNWb33XcvkvoAfuq4446LvLy8zJGEEyZMiHnz5q33xoqN+eKLL7Lae+21V5HXCCTbhoJI06ZNK9QuA/l3FPDvRWB7JjAAG1GvXr2oX79+TJkyJdM3cODAOOmkkwq91sCBA7Pahbn5nURz586N1atXZ9qF+YfjmDFjCrU9VF5eXlY7nU4XeG6rVq1ihx12yGyvP2zYsJgxY0bssssuBV4j18qVKxeHHHJI9OvXLyJ+PCpg8ODB8Ytf/KJIr5N/i/qPPvqoUPMLO57i07Zt26hZs2Zm14jx48fHgAED4vDDD9/s3PzHh2zJ8ytAYUyfPj2OPPLIrN/v6tWrFx988EHUq1cvh5UBSdeuXbtCz8n/LrmKFStuk93CAPKrXbt2HHLIIfHJJ59k+l577bU4//zzNzt39erV8frrr2f1tW/fvqhLBBKufPnyseuuu8b06dMzfR9++GF07dq1wGt88MEHWe3ddtutyOoDKGnyNj8Ekiv/izb5t8kviJEjR6737ujDDjtsq+ra3uW/ab9y5coCz3344YcLda38ZxSvu/lfEOXKlYsjjzwy0169enWhr18SHH300Vntv/3tb0V+jebNm0edOnUy7S+++CJGjhxZoLkrVqyIXr16FXlNFI28vLzo0qVLVl/Pnj03G7754IMPsl5c2nHHHaNz587bokSAiPjxyKIOHTrEuHHjMn21atWK999/v9BnWQIAJN2FF16Y1b777rs3uAV4fo8//njMmDEj095pp52iY8eORV4fwE9ft42IeOCBB7LepLYpH330UXz22WebXA9geyIwAJvwu9/9Lqv98ssvx7Bhwwq1xtVXX53VPvzww20LuRk1atTIerfMf//73wL9Mvfll18W+oZ9/u3yJkyYUKj5l156aVb7rrvuiq+++qpQa+Ta+eefH9WqVcu0X3nllXj77beL9BqpVGq9m8pXXXVVgebec889hT4PkeJ11VVXZR0l8NFHH2UdU5Df1KlT13vnyaWXXrpFR74AFMSiRYvi6KOPzjq2qFq1atG3b99o3rx5DisDACidzjjjjNhnn30y7TFjxsSFF16YOaZgQwYPHhw9evTI6uvWrVtUrVp1m9UJJNfZZ5+d1f7666+jW7dum3yeiogYO3ZsnHnmmVl9e+yxh12Dge2awABsQrt27bK2Ul+zZk2ceuqpMX78+ALNv+666+LNN9/M6vvpGZNsWJkyZaJNmzaZ9vTp0+Pee+/d5JyxY8fGSSedVOhzPxs1apR1o/ODDz6I+fPnF3j+kUceGYceemimvWLFijj66KMLHBqYN29efPnllwW+3rZQtWrVrJv3a9eujTPOOCP+85//FGqdL774Ik477bSNfv73v/99VKhQIdN+66234rbbbtvkmu+++2707NmzUHVQ/GrWrBl//vOfs/quueaa6NatW0ybNi3Tt3bt2ujdu3e0bds2Jk6cmOmvW7duXHHFFcVVLpBAJ554YgwdOjSr7/LLL485c+ZEv379CvVRmN8TAAC2V3l5eXH//fdHKpXK9D3zzDPRsWPH+OKLL7LGLly4MO6777446qijYvHixZn+Pffcc71/SwIUlY4dO653ZObjjz8e7dq1iw8++GC9N6jNnTs37r333jjwwAOzXs+KiLjtttuiTJky27xmgFwpu/khkGxPP/10HHTQQZmt6sePHx/7779/XHHFFXHWWWetd3bRsmXL4qOPPorbb789Pv7446zPdenSJY499thiq700++1vfxsDBw7MtK+55pqYPXt29OjRI2rXrp3pnzNnTjzzzDNx8803x8KFCyOVSsWee+4Zo0ePLtB18vLy4sgjj4w33ngjIiIWLFgQBx98cJx33nnRrFmz9Y4sOOCAA6J69epZff/+979j//33j3nz5kVExLRp06J169Zx8cUXR9euXaNZs2ZZ45csWRKDBg2Kl19+OXr16hVXXHFFtGzZssDfm22hR48e8cknn0SfPn0i4sd3Yp588slx8sknx8UXXxyHHHJI1s3+iIjly5fHiBEjol+/fvHqq6/G//73v4iIePHFFzd4jcaNG8d1110Xf/nLXzJ91157bXz99ddx/fXXZ32fZs6cGX/729/izjvvjNWrV0fjxo2zbjBT8lx11VUxaNCgeOuttzJ9jzzySDz22GPRqFGjqFq1akyYMCEWLFiQNa9SpUrx0ksvZe1yAVDUBgwYsF7f9ddfv0Vr9e/f3zm7AADx45sobr/99qzdNfv16xcHHnhg7LLLLlG/fv1YsmRJjBs3br3jJmvUqBGvvPJK7LjjjsVdNpAgzz//fLRt2zZrV9lPP/00jjrqqKhSpUo0adIkKlWqFHPnzo3x48dv8IjNK664Ik499dTiLBug2AkMwGa0aNEinnnmmTj77LMzZ7H98MMPccMNN8QNN9wQtWvXjjp16kSlSpVi3rx58f3332/wzLbDDjss/v73vxd3+aXWueeeG4888kjm3ffpdDruvffeuP/++2OPPfaIatWqxdy5c2PChAmxZs2azLxrrrkmpk6dWuDAQETEn/70p/jPf/6T+YVwzJgx6x0lsc6GbhI0bNgwXnvttTj55JMzN0OXL18e99xzT9xzzz1Ru3bt2HXXXaN8+fIxd+7cmDhx4ma3vipueXl58fzzz8fJJ5+cuamSTqfj9ddfj9dffz0qVKgQjRo1iurVq8fy5ctjwYIFMWXKlKzvfUGsCya89957mb5evXpFr169okGDBrHLLrvE/Pnzs/5cy5YtG0899dR6iWBKlry8vHj55Zfj3HPPjRdeeCHTv2bNmo3uyrLuBaJDDjmkuMoEAACgCF111VWxww47xBVXXJG16+OMGTNixowZG5yz1157xZtvvhl77LFHcZUJJNQuu+wSH330Ufz2t79dL0i+ePHiTe4SW65cubj55pvXO0oFYHvkSAIogFNPPTUGDBgQDRs2XO9zs2bNiq+++iqGDBkSY8eOXS8skJeXF926dYt+/frFDjvsUFwll3rlypWLN954Y71/PK5duzZGjx4dgwcPjrFjx2bdsL788svjlltuKfS12rVrF3/961+jXLlyW1xvu3btYuDAgRs8B3nWrFkxfPjwGDp0aIwfP77EhQXWqVq1arz//vtx+eWXR9my2XmyFStWxJgxY2Lw4MExfPjwmDRp0gbDAg0aNNjkNcqVKxevv/56HHPMMet97vvvv4+hQ4dm/bmWL18+/vWvf3knZylRsWLF6NWrV7zyyiub3DWjcuXK0a1btxg5cqQ/WwAAgFLuj3/8Y4wYMSJOO+20Tb620qRJk/jrX/8aI0aMEBYAik2DBg3igw8+iJdeeinat28feXmbvi1WtWrVuOiii+Krr76Kq666KuvoFYDtlR0GoIAOPvjg+O677+LZZ5+NRx99NIYNG7bJG781atSIE044IXr06LHBm8hsXsOGDWPo0KHxl7/8JZ544olYvnz5BscdfPDB0bNnz/jlL3+5xdf64x//GMcee2w8++yz8emnn8a3334bCxYsiGXLlm1wK6oNadGiRXz11VfxzDPPxEMPPRRffvnlRueWKVMm2rRpE2eddVb85je/2eK6i1rZsmXj3nvvjT/84Q9x5513Ru/evWPWrFmbnNO4ceP45S9/GaeeemoceeSRm71GpUqVok+fPvHkk0/GbbfdttF3n3fo0CHuueee2HfffbfoayF3TjnllDjllFNi7NixMXjw4Jg6dWqsXLkyqlWrFs2bN49DDjkkKlasmOsygQQp6P/LAUqT9u3be34DSoxmzZrFCy+8ED/88EMMGjQovvvuu1i4cGFUqVIl6tSpE61atYq99tor12UCCZWXlxedOnWKTp06xaJFi+Lzzz+P8ePHx4IFC2L58uWx0047RY0aNWLfffeNFi1abDZUwP9r786DqyrPP4A/ZAEk7Ju4QSKggigo1doKCmoVdFodi4JrsVYYtS3Wus5PRge0KoL71Ap1gdoRXOqClbqAW6siWsWiKAZECQlkgUQNyBLy+8PxlgtZbiQY7f18ZjLDc+77vue5J/wD53veA/yvaVbtX5fwjVRUVMT8+fOjsLAwysrKYsOGDdG+ffvo1KlT9O3bN/r16yd92Ii++OKLeOWVVyI/Pz8qKipil112ib322isOO+ywGnd++C5YvXp1vPbaa7F69eooKyuLrKys6NChQ/Tu3TsGDBjwvXhne3V1dbz33nvx3nvvRWlpaZSXl0eLFi2iXbt2kZeXF3379o3dd999h86xYMGCWLRoUaxatSqysrKie/fuMWjQoNhjjz0a6VsAAAAAAABQE4EBAAAAAAAAAEhD9lUBAAAAAAAAgDQkMAAAAAAAAAAAaUhgAAAAAAAAAADSkMAAAAAAAAAAAKQhgQEAAAAAAAAASEMCAwAAAAAAAACQhgQGAAAAAAAAACANCQwAAAAAAAAAQBoSGAAAAAAAAACANCQwAAAAAAAAAABpSGAAAAAAAAAAANKQwAAAAAAAAAAApCGBAQAAAAAAAABIQwIDAAAAAAAAAJCGBAYAAAAAAAAAIA0JDAAAAAAAAABAGhIYAAAAAAAAAIA0JDAAAAAAAAAAAGlIYAAAAAAAAAAA0pDAAAAAAAAAAACkIYEBAAAAAAAAAEhDAgMAAAAAAAAAkIYEBgAAAAAAAAAgDQkMAAAAAE2iuro6Zs+eHWeccUb06tUr2rRpE82aNUv8DBkypKlbBAAAgP9pWU3dAAAAAJB+ysvLY8SIETF37tymbgUAAADSlsAAAAAAfEtyc3Pjk08+qXNMRkZGtGvXLjp06BB9+vSJQw45JE455ZTo27fvt9Tlt2PkyJHCAgAAANDEmlVXV1c3dRMAAACQDlIJDNTm6KOPjrvuuit69+7dyF19+55++uk44YQTEnXr1q3jwgsvjB/+8IfRpk2bxPEOHTrEwIEDm6JFAAAASAt2GAAAAIDvgblz58aAAQPikUceieHDhzd1OztkxowZSfWTTz4ZQ4cObaJuAAAAIH3ZYQAAAAC+JdvuMDB58uTo379/0piqqqooKyuLf//73zFz5sxYuXJl0uc5OTnx6quvxoEHHvit9Lwz9OjRIz799NOIiOjdu3csWbKkiTsCAACA9CQwAAAAAN+SbQMDL7zwQgwZMqTW8Rs3bozLLrssbrvttqTjxxxzTDz33HM7q82d6ssvv4xddtklUZ900knx2GOPNWFHAAAAkL4ymroBAAAAoGbNmzePW2+9Nc4444yk488//3wsWrSoibraMRUVFUl127Ztm6gTAAAAQGAAAAAAvuNuuOGGyMhI/if8s88+20Td7Jgvv/wyqW7WrFkTdQIAAABkNXUDAAAAQN323HPP6N+/f7z99tuJY//5z38atEZZWVm8/vrrUVhYGCUlJdG6desYNmxY7LPPPnXO27hxY7z++uuxfPnyKCkpiS1btkSXLl2id+/ecdhhh0VmZmaD+tgZb0b88MMPY+HChVFSUhIVFRXRsWPH2H333WPQoEHRsWPHRj3Xhg0b4l//+lcUFBREUVFRZGZmxiGHHBJHHnlknfOqq6vj3XffjcWLF0dxcXFUVlZG586dY88994zBgwdH69atG7XPioqKePnllyM/Pz/Wr18fnTp1il69esWgQYOiRYsWjXKODz/8MN59990oLS2NNWvWRMuWLaNLly7Rp0+f6N+/fzRv3vwbrVtVVRVvvvlm5OfnR3FxcWzYsCG6dOkSeXl5cfjhhzda/wAAAAgMAAAAwPfC3nvvnRQYKC0tTfo8Nzc3Pvnkk4iI6NGjRyxfvjwiIl577bW4/vrr4x//+Eds2rQpac4tt9xSa2Bg0aJFMWHChJgzZ0588cUXNY5p3759nHnmmTF+/Pjo2rVrrb0PGTIkXnrppRo/mz59ekyfPn2740ceeWS8+OKLta75xRdfxJQpU2L69Onx8ccf1zgmMzMzBg8eHBMmTIjBgwfXutbWRo8endTPxx9/HLm5uVFQUBATJ06Mhx56KMrLy5PmnHjiibUGBkpKSuL666+PmTNnRlFRUY1jmjdvHsOGDYuJEyfGgQcemFKf217Tr4MYRUVF8X//93/x17/+NTZu3LjdvJycnLjoooviyiuvjJycnJTOtbXS0tK46aab4sEHH4wVK1bUOi4nJyd+8pOfxHnnnRfDhw9PaSeJ5cuXx8SJE+Pxxx+PNWvW1DimVatWcfLJJ8eECRMiLy+vwf0DAACQzCsJAAAA4HsgOzs7qd68eXO9cyZNmhSHH354zJ49e7uwQG02b94cv/nNb6J///7x8MMP1xoWiIgoLy+PO++8M3r16hV///vfU1q/MTz11FPRs2fPuOaaa2oNC0R89aT6iy++GEcccUSMHTs2pWtWk+effz769esXU6dO3S4sUJd77rknevbsGbfcckutYYGIr3ZxePLJJ+Oggw6KCRMmfKMeIyJeeeWV6NevX9x33301hgUiIiorK+O6666LoUOH1npTvjZ333135OXlxaRJk+oMC3x9nscffzxOOOGERJClLtdee23su+++ce+999bZ17p16+KBBx6I/fbbL+65554G9Q8AAMD27DAAAAAA3wOFhYVJdadOneocf/fdd8fll1+eqJs3bx65ubnRrl27KCws3G69iK9uxp588snxzDPPbPdZt27dolu3bpGRkREFBQVRXFyc+Ozzzz+PE088MR588ME45ZRTGvrVGmTq1KlxwQUXRFVVVdLxVq1aRY8ePaJNmzaxZs2aWLZsWWzZsiVp3urVq+Oxxx5L6Wn3r7399ttx5plnxrp16xLHevToEV26dIm1a9fGp59+WuO88ePHx7XXXrvd8bZt28Zee+0VOTk5UVxcnNgJIiJiy5YtcfXVV0dZWVncdtttKfcYEfHWW2/F8OHDo7KyMiIiMjIyIi8vLzp16hRr166N/Pz8pNdBLFiwIEaPHh1PPvlkSutfdNFFNfaUmZkZ3bt3j86dO8eXX34Zq1atipKSkpT7rqqqinPPPbfGXSY6deoUe+yxRzRv3jyKiopi5cqVic82btwYv/rVr+Kzzz6L3/3udymfDwAAgGR2GAAAAIDvuHXr1sWCBQuSjtW1HfuaNWsSN1F32223uOeee6K0tDQ+/PDDeOONN6KgoCCWLl0axxxzTNK8888/Pyks0Lp16xg/fnwsW7YsioqK4u2334633norVq9eHe+8806MGDEiMfbrG7/5+fnb9TNlypR47rnn4rnnnosHHngg6bNjjz028dnWP1OmTNlunblz58b555+fFBb46U9/Gi+++GJUVFTE+++/H/Pnz4+PPvooSkpK4sYbb4w2bdokxj7xxBMxadKkWq9bTc4///xYt25dtGzZMq666qooKCiI5cuXx4IFCyI/Pz+Ki4vj4osvTppz3333JYUFmjVrFmeffXYsWLAg1q5dG4sWLYr58+fHxx9/HCtXrowrr7wyaQeJ22+/PR566KEG9XnqqadGZWVldOzYMW6++eYoLi6O/Pz8mD9/fixZsiQKCgpi9OjRSXNmz54dc+bMqXft2267bbuwwN577x33339/lJSUxLJly+KNN96Id999N4qLi+PTTz+NadOmxVFHHVXv2hMmTEgKC2RnZ8e4cePivffei9LS0li4cGEsWLAgCgoKIj8/P8aOHZsU+Ljsssvi1Vdfrfc8AAAA1KxZ9dbxcgAAAGCnyc3NTdqe/YUXXoghQ4bUO+/GG2+MK664IunYvHnzYujQobWuHRHRp0+fmDdvXnTr1q3ec8yaNStGjRqVqHv27BnPPPNM9OzZs855N910U1x22WWJ+mc/+1k88cQTtY5fvnx5UtjhF7/4Rdx///319ldeXh59+vSJVatWRcRXT9BPmzYtfvnLX9Y57/33348hQ4Yknnpv3rx5fPLJJ7Vek9GjR2/3tHvr1q1jzpw5MWjQoHr7XLZsWRxwwAGJHQl22WWXePTRR2P48OF1znv55Zdj2LBhsX79+oiI6Nq1a3zyySfRsmXLGscPGTIkXnrppaRjubm58fzzz9f5OxszZkxMmzYtUZ900knx2GOP1Tp+0aJFcfDBBye90mLEiBHxwAMPRIsWLer8ThFf7XzQq1evaNeu3XafvfrqqzF48ODEThCdO3eOOXPmxA9+8IM615w1a1acfvrpiXkHHnhgLFy4sN5eAAAA2J4dBgAAAOA7bPbs2TF+/PikY3l5efXevM7Ozo6HHnoopbBAdXV1XHPNNYm6VatWKYUFIiIuvfTSpNcQzJ49O5YsWVLvvIb605/+lAgLRERcd9119YYFIiL69u2bFEjYuHFj3HnnnQ069+TJk1MKC0RETJo0Ken1Bffee2+9YYGIiCOOOCImT56cqIuLi7fbjaEumZmZ8fDDD9f7O7vxxhuTQgjPPvts0qsbtvWHP/whKSwwaNCgmDVrVkphgYiIgQMH1hgWiPhqd4Gvz52RkRFPPPFEvWGBiIiRI0fG73//+0T97rvvxvPPP59SPwAAACQTGAAAAIDvkKqqqigtLY1nnnkmTj/99DjxxBOTbthGRFx77bVJW9jXZOTIkdGvX7+UzvnMM8/EBx98kKjHjRuXUljga1dddVXiz9XV1XU+sf5NVFVVxR133JGou3fvnnTDuD7HH398HHTQQYn60UcfTXlu9+7d47zzzktp7Jo1a2LGjBmJ+kc/+lHSrg31Oe+886Jr167fqM+f//znKd1s79ChQxx77LGJet26dUm/+60VFRUlvRohIyMj7r333sjI2PH/Tlq8eHHS6y9GjhwZP/7xj1Oef/nll0dWVlaibsi1AgAA4L8EBgAAAKCJDB06NJo1a5b0k5WVFV26dIlhw4bFgw8+GNu+SfDiiy+O008/vd61TzvttJT7ePrpp5Pqs846K+W5EV9tCb/1TgavvPJKg+bXZ+HChVFYWJioR40aVW9gYltb3yT/4IMPorS0NKV5I0eOTPkG+Ysvvph4pUBEw69jdnZ20msmXn311Tqf/t+2z1QNGDAgqV6xYkWN4+bOnRtVVVWJevjw4dG7d++Uz1OXOXPmJNUNvVadOnWKgQMHJurG/jsHAACQLgQGAAAA4HsgJycn/vjHP8aUKVNSGn/ooYemvPbWN1tzcnJiv/32a3B/e+21V+LPixcvbvD8umx7MziVJ+m31b1796Q61R6/6XWM2PE+P/vss1i5cmVK8xpyrq13MYiIqKioqHHctt/n+OOPT/kc9Wnsa/XBBx9sF64BAACgfln1DwEAAACaQsuWLeOggw6Kk08+OUaPHh2dO3dOaV7r1q1THhuRfPO8srJyh7ecX7NmzQ7N39a2N/dPPfXUHV4z1R7z8vJSXnPbPhsSNqjNmjVrksIYtdk2BFCXnJycpHrrXRG2tnTp0qT6m9zUr82216oh/dekqqoqPvvss2jXrt0OrQMAAJBuBAYAAACgiUyePDn69++fdCwzMzPatGkT7du3j9zc3KT3tKeqbdu2KY+trKyMDRs2NPgcdantifVvqqysrFHXi0i9x4Zcy6bss2XLlt/4HLU9mb9tqGJHb+pvbWddK4EBAACAhhEYAAAAgCYycODAGDJkSKOvm52dnfLY8vLyRj9/Y28NvzN63LJlS0rjmvpaptrnzvD5558n1a1bt260tf/XrhUAAMD3lcAAAAAApLFWrVol1R07doxZs2Y1UTc127bHG264IQYOHLhDa+6///47NL8m2/Z53333xZ577rlDa267A8W3qU2bNkn1F1980aBXXdSlVatW8dlnnyXqOXPmfKPdNLbWrVu3HW0LAAAg7QgMAAAAQBpr3759ZGVlxebNmyPiq/fZH3PMMU3cVbJtb1Ln5eV953qM2L7Pvn37xqGHHtpE3ey4jh07JtXFxcWRm5vbKGt37tw5KTBw8MEHN+orDwAAAEhNRlM3AAAAADSdZs2aRY8ePRL1+vXro7CwsAk72l5eXl5SnZ+f30Sd1O370meqevfunVS/+eabjbb2/9q1AgAA+L4SGAAAAIA0N3To0KR63rx5TdRJzb7r/X3t+9JnqgYPHpxUP/3004229v/atQIAAPi+EhgAAACANDds2LCk+s4772yiTmp26KGHRocOHRL1vHnz4v3332/Cjmp2zDHHRFbWf9/+OHPmzCgrK2vCjnbM0UcfnfR95syZEx999FGjrL3t37mpU6fGpk2bGmVtAAAAUicwAAAAAGnupJNOil69eiXq+fPnx1133dWEHSXLzs6Oiy66KFFXV1fH2LFjv3M3mHfdddc466yzEnVlZWVceOGFTdjRjtl1111j1KhRiXrLli1x7rnnxpYtW3Z47YEDBybtMrBixYq46qqrdnhdAAAAGkZgAAAAANJcZmZmTJw4MenYuHHjYtq0aQ1aZ8mSJTFmzJhYuXJlY7aX6GfXXXdN1P/85z9jxIgRUVFRkfIalZWVcfvtt8c999zT6P197aqrropWrVol6lmzZsXYsWNj48aNKa+xZs2auPbaa2P27Nk7o8UGufLKK6NFixaJ+pVXXolRo0bFhg0bUpr/5ptv1vo7mjhxYmRk/Pe/piZNmhQTJkyI6urqlPsrKCiISy+9NBYsWJDyHAAAAP5LYAAAAACIUaNGxdixYxP1pk2bYsyYMXH00UfHU089FZWVldvN2bRpUyxcuDBuvfXWGDx4cOy3334xbdq0nfLkf7t27eLhhx+O7OzsxLEnn3wy9t9//5gyZUp8+umnNc5bsWJFPPLII3HmmWfG7rvvHuPGjYsVK1Y0en9f23vvvbcLJEydOjUOOOCAmDZtWqxevXq7OdXV1bF06dL4y1/+EieffHLsueeeMX78+O/E6wz69u0bkydPTjr28MMPx/777x/Tp0+PtWvXbjenoKAg/vznP8fQoUPjkEMOqXFMRMThhx8e1113XdKxq6++Og455JCYOXNmjfOqqqpi8eLFMXXq1DjuuOMiLy8vJk+eXOPfTwAAAOqXVf8QAAAAIB3ccccdsXbt2njooYcSx+bNmxfz5s2LrKys6NGjR3Ts2DE2b94c5eXlsXLlygY9Ob+jBg8eHDNmzIhzzjknvvzyy4iIWLlyZVxyySVxySWXxG677RZdu3aNFi1aREVFRRQXF9d6s3pnGjVqVBQWFsall16a2L7/690XxowZE3vttVd07tw5srKyory8PFatWhWff/75t95nqn7961/HsmXL4pZbbkkcW7p0aYwePToyMzOjR48e0alTp9iwYUMUFRVFSUlJymtfccUVUVxcnLT2W2+9FaeddlpkZGRE9+7do1OnThERUV5eHkVFRbFu3brG+3IAAABpTmAAAAAAiIiI7OzsmDVrVgwcODCuueaaWL9+feKzzZs3x9KlS2Pp0qV1rtG5c+fYZZdddlqPo0aNit69e8fpp58eS5YsSfqsqKgoioqK6pyfmZkZu++++07r72sXX3xx7L///nHOOeds19OKFSvq3eWgRYsW0bVr153ZYoPcfPPN0atXr7j00kuTbthXVVXFsmXLYtmyZTu09oABA2LcuHFRXl6eOL5ly5ZYvnx5LF++vM75bdq0ifbt23/j8wMAAKQzryQAAAAAklx22WXx8ccfxyWXXBLdu3evd3y3bt3izDPPjL/97W9RWFgYu+66607tb+DAgfH+++/HjBkz4rDDDovMzMw6x7do0SKOOuqomDx5cqxYsSLGjBmzU/v72nHHHRfLli2L22+/PQ488MBo1qxZneNbt24dJ5xwQtx1111RVFQUxx9//LfSZ6ouuOCCWLp0afz2t7+t93fcvn37OO2002Lu3LmRm5tb79pnn312LF++PCZOnBj77LNPveM7dOgQI0aMiBkzZsSqVatiwIABKX4LAAAAttasurq6uqmbAAAAAL678vPz45133omSkpJYu3ZtZGVlRbt27aJ79+7Rp0+flG4I70wVFRXx+uuvR2FhYZSWlsamTZuiTZs20bVr19hvv/1i3333jZYtWzZpjxERJSUlMX/+/Fi1alWUlZXFli1bom3bttGtW7fo06dP9O7dO7Kzs5u6zZRUV1fHO++8E4sXL46SkpL4/PPPIycnJ7p16xZ9+/aNfv361RvkqMvKlStjwYIFUVxcHGVlZZGRkRFt27aNPfbYI/r06RM9e/aMjAzPwQAAAOwogQEAAAAAAAAASEOi2AAAAAAAAACQhgQGAAAAAAAAACANCQwAAAAAAAAAQBoSGAAAAAAAAACANCQwAAAAAAAAAABpSGAAAAAAAAAAANKQwAAAAAAAAAAApCGBAQAAAAAAAABIQwIDAAAAAAAAAJCGBAYAAAAAAAAAIA0JDAAAAAAAAABAGhIYAAAAAAAAAIA0JDAAAAAAAAAAAGlIYAAAAAAAAAAA0pDAAAAAAAAAAACkIYEBAAAAAAAAAEhDAgMAAAAAAAAAkIYEBgAAAAAAAAAgDQkMAAAAAAAAAEAaEhgAAAAAAAAAgDQkMAAAAAAAAAAAaUhgAAAAAAAAAADSkMAAAAAAAAAAAKQhgQEAAAAAAAAASEMCAwAAAAAAAACQhgQGAAAAAAAAACANCQwAAAAAAAAAQBoSGAAAAAAAAACANCQwAAAAAAAAAABpSGAAAAAAAAAAANKQwAAAAAAAAAAApCGBAQAAAAAAAABIQwIDAAAAAAAAAJCGBAYAAAAAAAAAIA0JDAAAAAAAAABAGhIYAAAAAAAAAIA09P+5rVJ6QdYFyAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1618,7 +1618,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 36, @@ -1627,7 +1627,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1891,9 +1891,9 @@ "metadata": { "celltoolbar": "Tags", "kernelspec": { - "display_name": "matching-docs", + "display_name": "matching", "language": "python", - "name": "matching-docs" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1905,7 +1905,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.11.10" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index 848d786..3033b7c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,7 +10,7 @@ authors = [ ] description = "A package for solving matching games" readme = "README.md" -requires-python = ">=3.7" +requires-python = ">=3.10" license = {text = "MIT License"} keywords = [ "game-theory", @@ -30,7 +30,7 @@ classifiers = [ ] dependencies = [ "numpy>=1.21.6", - "scipy>=1.11.3" + "scipy>=1.11.3", ] dynamic = ["version"] @@ -50,13 +50,8 @@ docs = [ "PyYAML>=6", "quartodoc>=0.5.0; python_version>'3.8'", ] -lint = [ - "black[jupyter]>=22.6.0,<23", - "ruff>=0.1.1", -] -dev = [ - "matching[docs,lint,test]", -] +lint = ["ruff<1.0"] +dev = ["matching[docs,lint,test]", "pre-commit"] [project.urls] homepage = "https://github.com/daffidwilde/matching" @@ -66,26 +61,25 @@ changelog = "https://github.com/daffidwilde/matching/blob/main/CHANGES.md" [tool.setuptools.dynamic] version = {attr = "matching.__version__"} -[tool.black] -line-length = 79 - [tool.coverage.report] omit = ["src/**/__init__.py"] [tool.ruff] extend-include = ["*.ipynb"] +line-length = 79 + +[tool.ruff.lint] extend-select = ["D", "I", "W"] ignore = ["D105", "D107", "D202"] -line-length = 79 -[tool.ruff.isort] +[tool.ruff.lint.isort] known-first-party = ["matching"] -[tool.ruff.per-file-ignores] +[tool.ruff.lint.per-file-ignores] "docs/*" = ["D100", "D103", "E402"] "tests/**/*.py" = ["D104", "D401", "E741"] "src/**/*.py" = ["D105", "D107"] "src/matching/base.py" = ["D401"] -[tool.ruff.pydocstyle] +[tool.ruff.lint.pydocstyle] convention = "numpy" diff --git a/src/matching/algorithms/__init__.py b/src/matching/algorithms/__init__.py index 56b2fff..853ea60 100644 --- a/src/matching/algorithms/__init__.py +++ b/src/matching/algorithms/__init__.py @@ -1,13 +1,11 @@ """Top-level imports for the `matching.algorithms` subpackage.""" from .hospital_resident import hospital_resident -from .stable_marriage import stable_marriage from .stable_roommates import stable_roommates from .student_allocation import student_allocation __all__ = [ "hospital_resident", - "stable_marriage", "stable_roommates", "student_allocation", ] diff --git a/src/matching/algorithms/stable_marriage.py b/src/matching/algorithms/stable_marriage.py deleted file mode 100644 index 39cfe86..0000000 --- a/src/matching/algorithms/stable_marriage.py +++ /dev/null @@ -1,64 +0,0 @@ -"""Functions for the SM algorithms.""" - -from .util import _delete_pair, _match_pair - - -def _unmatch_pair(suitor, reviewer): - """Unmatch a (suitor, reviewer) pair.""" - - suitor._unmatch() - reviewer._unmatch() - - -def stable_marriage(suitors, reviewers, optimal="suitor"): - """Solve an instance of SM. - - This function uses an extended version of the original Gale-Shapley - algorithm that makes use of the inherent structures of SM instances. - A unique, stable and optimal matching is found for any valid set of - suitors and reviewers. The optimality of the matching is with - respect to one party and is subsequently the worst stable matching - for the other. - - Parameters - ---------- - suitors : list of Player - The suitors in the game. Each must rank all of those in - ``reviewers``. - reviewers : list of Player - The reviewers in the game. Each must rank all of those in - ``suitors``. - optimal : str, optional - Which party the matching should be optimised for. Must be one of - ``"suitor"`` and ``"reviewer"``. Defaults to the former. - - Returns - ------- - matching : Matching - A dictionary-like object where the keys are given by the members of - ``suitors``, and the values are their match in ``reviewers``. - """ - - if optimal.lower() == "reviewer": - suitors, reviewers = reviewers, suitors - - free_suitors = suitors[:] - while free_suitors: - suitor = free_suitors.pop() - reviewer = suitor.get_favourite() - - if reviewer.matching: - current_match = reviewer.matching - _unmatch_pair(current_match, reviewer) - free_suitors.append(current_match) - - _match_pair(suitor, reviewer) - - successors = reviewer.get_successors() - for successor in successors: - _delete_pair(successor, reviewer) - - if optimal.lower() == "reviewer": - suitors, reviewers = reviewers, suitors - - return {s: s.matching for s in suitors} diff --git a/src/matching/convert.py b/src/matching/convert.py index f2aac69..8022059 100644 --- a/src/matching/convert.py +++ b/src/matching/convert.py @@ -4,19 +4,22 @@ from scipy.stats import rankdata -def preference_to_rank(preference, others): - """Convert a preference dictionary to a rank array.""" +def preference_to_rank(preferences, others): + """Convert a preference list dictionary to a rank array.""" - rank = np.array( - [[others.index(o) for o in prefs] for prefs in preference.values()] - ) + sorted_preferences = sorted(preferences.items(), key=lambda x: x[0]) + sorted_others = sorted(others) + ranks = [ + [prefs.index(o) if o in prefs else len(others) for o in sorted_others] + for _, prefs in sorted_preferences + ] - return rank + return np.array(ranks) def utility_to_rank(utility): """Convert a utility array to a rank array.""" - rank = rankdata(utility, method="ordinal", axis=1, nan_policy="omit") + rank = rankdata(-utility, method="ordinal", axis=1, nan_policy="omit") return rank - 1 diff --git a/src/matching/games/stable_marriage.py b/src/matching/games/stable_marriage.py index a24e3ec..b0ff8d5 100644 --- a/src/matching/games/stable_marriage.py +++ b/src/matching/games/stable_marriage.py @@ -1,192 +1,304 @@ """The SM game class and supporting functions.""" -import copy +import warnings -from matching import BaseGame, Player, SingleMatching -from matching.algorithms import stable_marriage -from matching.exceptions import MatchingError +import numpy as np +from matching import convert +from matching.matchings import SingleMatching -class StableMarriage(BaseGame): - """Solver for the stable marriage problem (SM). + +class StableMarriage: + """ + Solver for the stable marriage problem (SM). Parameters ---------- - suitors : list of Player - The suitors in the game. Each suitor must rank all elements in - ``reviewers``. - reviewers : list of Player - The reviewers in the game. Each reviewer must rank all elements - in ``suitors``. + suitor_ranks : np.ndarray + The rank matrix of all reviewers by the suitors. + reviewer_ranks : np.ndarray + The rank matrix of all suitors by the reviewers. Attributes ---------- + num_suitors : int + Number of suitors. + num_reviewers : int + Number of reviewers. matching : SingleMatching or None Once the game is solved, a matching is available. This uses the - suitors and reviewers as keys and values, respectively, in a - ``SingleMatching`` object. Initialises as ``None``. - blocking_pairs : list of (Player, Player) - The suitor-reviewer pairs that both prefer one another to their - current match. Initialises as ``None``. + indices of the reviewer and suitor rank matrices as keys and + values, respectively, in a `SingleMatching` object. + Initialises as `None`. """ - def __init__(self, suitors, reviewers): - suitors, reviewers = copy.deepcopy([suitors, reviewers]) - self.suitors = suitors - self.reviewers = reviewers + def __init__(self, suitor_ranks, reviewer_ranks): + self.suitor_ranks = suitor_ranks.copy() + self.reviewer_ranks = reviewer_ranks.copy() - super().__init__() - self.check_inputs() + self.num_suitors = len(suitor_ranks) + self.num_reviewers = len(reviewer_ranks) + self.matching = None + self._preference_lookup = None - @classmethod - def create_from_dictionaries(cls, suitor_prefs, reviewer_prefs): - """Create an instance of SM from two preference dictionaries.""" + self.check_input_validity() - suitors, reviewers = _make_players(suitor_prefs, reviewer_prefs) - game = cls(suitors, reviewers) + @classmethod + def from_utilities(cls, suitor_utils, reviewer_utils): + """ + Create an instance of SM from utility matrices. + + Higher utilities indicate higher preferences. If there are any + ties, they are broken in order of appearance. + + Parameters + ---------- + suitor_utils : np.ndarray + Suitor utility matrix. + reviewer_utils : np.ndarray + Reviewer utility matrix. + + Returns + ------- + game : StableMarriage + An instance of SM with utilities resolved as rank matrices. + """ - return game + suitor_ranks = convert.utility_to_rank(suitor_utils) + reviewer_ranks = convert.utility_to_rank(reviewer_utils) - def solve(self, optimal="suitor"): - """Solve the instance of SM. Return the matching. + return cls(suitor_ranks, reviewer_ranks) - The party optimality can be controlled using the ``optimal`` - parameter. + @classmethod + def from_preferences(cls, suitor_prefs, reviewer_prefs): + """ + Create an instance of SM from preference list dictionaries. + + Each dictionary contains a strict ordering of the other side by + each player. The ranking is taken by the order of the preference + list. + + Parameters + ---------- + suitor_prefs : dict + Suitor preference lists. + reviewer_prefs : dict + Reviewer preference lists. + + Returns + ------- + game : StableMarriage + An instance of SM with preference lists resolved as rank + matrices. """ - self.matching = SingleMatching( - stable_marriage(self.suitors, self.reviewers, optimal) - ) - return self.matching + suitors, reviewers = sorted(suitor_prefs), sorted(reviewer_prefs) - def check_validity(self): - """Check whether the current matching is valid.""" + suitor_ranks = convert.preference_to_rank(suitor_prefs, reviewers) + reviewer_ranks = convert.preference_to_rank(reviewer_prefs, suitors) - unmatched_issues = self._check_for_unmatched_players() - not_in_matching_issues = self._check_for_players_not_in_matching() - inconsistency_issues = self._check_for_inconsistent_matches() + game = cls(suitor_ranks, reviewer_ranks) + game._preference_lookup = {"suitors": suitors, "reviewers": reviewers} - if unmatched_issues or not_in_matching_issues or inconsistency_issues: - raise MatchingError( - unmatched_players=unmatched_issues, - players_not_in_matching=not_in_matching_issues, - inconsistent_matches=inconsistency_issues, - ) + return game - return True + def _check_number_of_players(self): + """ + Check whether the player sets are the same size. - def check_stability(self): - """Check for the existence of any blocking pairs.""" + Warns + ----- + UserWarning + If the sizes of the player sets do not match. + """ - blocking_pairs = [] - for suitor in self.suitors: - for reviewer in self.reviewers: - if suitor.prefers( - reviewer, suitor.matching - ) and reviewer.prefers(suitor, reviewer.matching): - blocking_pairs.append((suitor, reviewer)) + ns, nr = self.num_suitors, self.num_reviewers + if ns != nr: + warnings.warn( + f"Number of suitors ({ns}) and reviewers ({nr}) " + "do not match. Your matching will not be truly stable.", + UserWarning, + ) - self.blocking_pairs = blocking_pairs - return not any(blocking_pairs) + def _check_player_ranks(self, player, ranks, side): + """ + Check that a player has made a strict ranking of the other side. + + Parameters + ---------- + player : int + Player to check. + ranks : np.ndarray + The player's ranking. + side : str + Name of the side to which the player belongs. + + Warns + ----- + UserWarning + If the player has not made a strict and unique ranking of + the other side in the game. + """ - def _check_for_unmatched_players(self): - """Check everyone has a match.""" + others = "suitors" if side == "reviewer" else "reviewers" + num_others = getattr(self, f"num_{others}") + if not np.array_equal(np.sort(ranks), np.arange(num_others)): + warnings.warn( + f"{side.title()} {player} has not strictly ranked " + f"all {num_others} {others}: {ranks}. " + "You may not be able to find a stable matching.", + UserWarning, + ) - issues = [] - for player in self.suitors + self.reviewers: - issue = player.check_if_match_is_unacceptable(unmatched_okay=False) - if issue: - issues.append(issue) + def check_input_validity(self): + """ + Determine whether this game instance is valid or not. - return issues + Invalid games can still be solved, but the matching will not be + truly stable in the absence of blocking pairs. - def _check_for_players_not_in_matching(self): - """Check that everyone appears in the matching.""" + Warns + ----- + UserWarning + If (a) the player sets are not the same size; or (b) any + player has not made a strict, exhaustive, and unique ranking + of the players on the other side of the matching. + """ - players_in_matching = set(self.matching.keys()) | set( - self.matching.values() - ) + self._check_number_of_players() - issues = [] - for player in self.suitors + self.reviewers: - if player not in players_in_matching: - issues.append(f"{player} does not appear in matching.") + for suitor, ranks in enumerate(self.suitor_ranks): + self._check_player_ranks(suitor, ranks, "suitor") - return issues + for reviewer, ranks in enumerate(self.reviewer_ranks): + self._check_player_ranks(reviewer, ranks, "reviewer") - def _check_for_inconsistent_matches(self): - """Check the matching is consistent with the players'.""" + def _invert_player_sets(self): + """ + Invert the attributes associated with each set of players. - issues = [] - for suitor, reviewer in self.matching.items(): - if suitor.matching != reviewer: - issues.append( - f"{suitor} is matched to {suitor.matching} but the " - f"matching says they should be matched to {reviewer}." - ) + That is, `suitor_ranks` and `reviewer_ranks` switch. As do + `num_suitors` and `num_reviewers`. + """ - return issues + self.suitor_ranks, self.reviewer_ranks = ( + self.reviewer_ranks, + self.suitor_ranks, + ) + self.num_suitors, self.num_reviewers = ( + self.num_reviewers, + self.num_suitors, + ) - def check_inputs(self): - """Raise an error if any of the game's rules do not hold.""" + def _stable_marriage(self): + """ + Execute the algorithm for SM given some rankings. - self._check_num_players() - for suitor in self.suitors: - self._check_player_ranks(suitor) - for reviewer in self.reviewers: - self._check_player_ranks(reviewer) + Returns + ------- + matching : dict + Solution to the game instance. + """ - def _check_num_players(self): - """Check that the number of suitors and reviewers are equal.""" + matching = {} + suitor_ranks, reviewer_ranks = self.suitor_ranks, self.reviewer_ranks + free_suitors = list(range(self.num_suitors)) - if len(self.suitors) != len(self.reviewers): - raise ValueError( - "There must be an equal number of suitors and reviewers." - ) + while free_suitors: + suitor = free_suitors.pop() + reviewer = suitor_ranks[suitor].argmin() + reviewer_rank = reviewer_ranks[reviewer] - return True + current = matching.get(reviewer) + if ( + current is not None + and (suitor_ranks[current] < self.num_reviewers).any() + ): + free_suitors.append(current) - def _check_player_ranks(self, player): - """Check that a player has ranked all of the other group.""" + matching[reviewer] = suitor - others = self.reviewers if player in self.suitors else self.suitors - if set(player.prefs) != set(others): - raise ValueError( - "Every player must rank each name from the other group. " - f"{player}: {player.prefs} != {others}" - ) + successors = np.where(reviewer_rank > reviewer_rank[suitor]) + suitor_ranks[successors, reviewer] = self.num_reviewers + reviewer_rank[successors] = self.num_reviewers - return True + return matching + def _convert_matching_to_preferences(self): + """ + Replace the rank indices with preference terms in a matching. -def _make_players(suitor_prefs, reviewer_prefs): - """Make a set of suitors and reviewers from two dictionaries.""" + This internal function is included for users who wish to create + a matching from a set of preference list dictionaries. - suitor_dict, reviewer_dict = _make_instances(suitor_prefs, reviewer_prefs) + Attributes + ---------- + matching : SingleMatching + The converted matching instance. + """ - for suitor_name, suitor in suitor_dict.items(): - prefs = [reviewer_dict[name] for name in suitor_prefs[suitor_name]] - suitor.set_prefs(prefs) + converted = {} + suitors, reviewers = self._preference_lookup.values() + for reviewer, suitor in self.matching.items(): + converted[reviewers[reviewer]] = suitors[suitor] - for reviewer_name, reviewer in reviewer_dict.items(): - prefs = [suitor_dict[name] for name in reviewer_prefs[reviewer_name]] - reviewer.set_prefs(prefs) + self.matching = SingleMatching( + converted, valid=self.matching.valid, stable=self.matching.stable + ) - suitors = list(suitor_dict.values()) - reviewers = list(reviewer_dict.values()) + def solve(self, optimal="suitor"): + """ + Solve the instance of SM. + + This method uses an extended version of the Gale-Shapley + algorithm that makes use of the inherent structures of SM + instances. The algorithm finds a unique, stable and optimal + matching for any valid set of suitors and reviewers. + + The optimality of the matching is with respect to one party and + is subsequently the worst stable matching for the other party. + + Parameters + ---------- + optimal : {"suitor", "reviewer"}, default "suitor" + Party for whom to optimise the matching. Must be one of + `"suitor"` or `"reviewer"`. Default is `"suitor"`. + + Raises + ------ + ValueError + If `optimal` is anything other than the permitted values. + + Returns + ------- + matching : SingleMatching + A dictionary-like object containing the matching. The keys + correspond to the reviewers in the instance, while the + values are the suitors. + """ - return suitors, reviewers + if optimal not in ("suitor", "reviewer"): + raise ValueError( + "Invalid choice for `optimal`. " + f'Must be "suitor" or "reviewer", not "{optimal}".' + ) + + keys, values = "reviewers", "suitors" + if optimal == "reviewer": + self._invert_player_sets() + keys, values = values, keys -def _make_instances(suitor_prefs, reviewer_prefs): - """Create ``Player`` instances for the names in each dictionary.""" + matching = SingleMatching( + self._stable_marriage(), keys=keys, values=values + ) - suitor_dict, reviewer_dict = {}, {} - for suitor_name in suitor_prefs: - suitor = Player(name=suitor_name) - suitor_dict[suitor_name] = suitor - for reviewer_name in reviewer_prefs: - reviewer = Player(name=reviewer_name) - reviewer_dict[reviewer_name] = reviewer + if optimal == "reviewer": + matching = matching.invert() + self._invert_player_sets() - return suitor_dict, reviewer_dict + self.matching = matching + if self._preference_lookup: + self._convert_matching_to_preferences() + + return self.matching diff --git a/src/matching/matchings/__init__.py b/src/matching/matchings/__init__.py new file mode 100644 index 0000000..c7b049e --- /dev/null +++ b/src/matching/matchings/__init__.py @@ -0,0 +1,6 @@ +"""Classes for different types of matchings.""" + +from .multiple import MultipleMatching +from .single import SingleMatching + +__all__ = ["MultipleMatching", "SingleMatching"] diff --git a/src/matching/matchings.py b/src/matching/matchings/multiple.py similarity index 51% rename from src/matching/matchings.py rename to src/matching/matchings/multiple.py index 8afc634..da253c3 100644 --- a/src/matching/matchings.py +++ b/src/matching/matchings/multiple.py @@ -1,37 +1,9 @@ -"""A collection of dictionary-like objects for storing matchings.""" +"""Classes for handling multiple match matchings.""" -from matching import BaseMatching +from matching.base import BaseMatching from matching.players import Player -class SingleMatching(BaseMatching): - """Matching class for games with singular matches like SM or SR. - - Parameters - ---------- - dictionary - A dictionary comprised of ``Player, Optional[Player]`` pairs. - """ - - def __init__(self, dictionary): - super().__init__(dictionary) - - def __setitem__(self, player, new): - """Set a player's new match and match them to the player, too. - - First check if the player and match are valid and present. - """ - - self._check_player_in_keys(player) - self._check_new_valid_type(new, (type(None), Player)) - - player.matching = new - if isinstance(new, Player): - new.matching = player - - self._data[player] = new - - class MultipleMatching(BaseMatching): """Matching class for games with multiple matches like HR or SA. diff --git a/src/matching/matchings/single.py b/src/matching/matchings/single.py new file mode 100644 index 0000000..73f5648 --- /dev/null +++ b/src/matching/matchings/single.py @@ -0,0 +1,65 @@ +"""Classes for handling single match matchings.""" + + +class SingleMatching(dict): + """ + Dictionary-like object for solutions to games with singular matches. + + Parameters + ---------- + dictionary : dict + Dictionary of matched up pairs. + keys : str + Name of the key-side party. Renamed `keys_`. + values : str + Name of the value-side party. Renamed `values_`. + valid : bool or None + Validity of the matching. Initialises as `None`. + stable : bool or None + Stability of the matching. Initialises as `None`. + """ + + def __init__( + self, + dictionary=None, + *, + keys="reviewers", + values="suitors", + valid=None, + stable=None, + ): + super().__init__(dictionary or {}) + + self.keys_ = keys + self.values_ = values + self.valid = valid + self.stable = stable + + def __repr__(self): + return ( + f"SingleMatching({super().__repr__()}, " + f'keys="{self.keys_}", values="{self.values_}")' + ) + + def __eq__(self, other): + return super().__eq__(other) and vars(self) == vars(other) + + def invert(self): + """ + Invert the keys and values in the dictionary. + + Creates a new matching instance with keys and values reversed, + and passes over the validity and stability attributes. + + Returns + ------- + inverted : SingleMatching + An inverted matching. + """ + return SingleMatching( + {val: key for key, val in self.items()}, + keys=self.values_, + values=self.keys_, + valid=self.valid, + stable=self.stable, + ) diff --git a/tests/hospital_resident/data/issue_159.json b/tests/hospital_resident/data/issue_159.json index 837041c..94f9d4b 100644 --- a/tests/hospital_resident/data/issue_159.json +++ b/tests/hospital_resident/data/issue_159.json @@ -153,4 +153,4 @@ "98": [1, 28, 48, 21], "99": [] } -} \ No newline at end of file +} diff --git a/tests/hospital_resident/test_algorithm.py b/tests/hospital_resident/test_algorithm.py index b1c6426..204ef6c 100644 --- a/tests/hospital_resident/test_algorithm.py +++ b/tests/hospital_resident/test_algorithm.py @@ -62,7 +62,7 @@ def test_hospital_optimal(players_): assert set(hospitals) == set(matching.keys()) for hospital, matches in matching.items(): - old_idx = -np.infty + old_idx = -np.inf for resident in matches: idx = hospital.prefs.index(resident) assert idx >= old_idx diff --git a/tests/matchings/test_single.py b/tests/matchings/test_single.py new file mode 100644 index 0000000..a9085e2 --- /dev/null +++ b/tests/matchings/test_single.py @@ -0,0 +1,106 @@ +"""Unit tests for the SingleMatching class.""" + +from hypothesis import given +from hypothesis import strategies as st + +from matching.matchings import SingleMatching + + +@st.composite +def st_single_params(draw, min_size=2, max_size=5): + """Create a parameter set for a SingleMatching instance.""" + + size = draw(st.integers(min_size, max_size)) + midpoint = size // 2 + players = list(range(size)) + keys, values = players[:midpoint], players[midpoint:] + dictionary = draw(st.sampled_from((None, dict(zip(keys, values))))) + + keys = draw(st.text()) + values = draw(st.text()) + valid = draw(st.sampled_from((None, False, True))) + stable = draw(st.sampled_from((None, False, True))) + + params = dict( + dictionary=dictionary, + keys=keys, + values=values, + valid=valid, + stable=stable, + ) + + return params + + +@st.composite +def st_singles(draw, min_size=2, max_size=5): + """Create a SingleMatching instance.""" + + params = draw(st_single_params(min_size, max_size)) + + return SingleMatching(**params) + + +@given(st_single_params()) +def test_init(params): + """Check that a SingleMatching can be created correctly.""" + + matching = SingleMatching(**params) + + assert isinstance(matching, SingleMatching) + assert isinstance(matching, dict) + + dictionary = params["dictionary"] or {} + assert matching.items() == dictionary.items() + assert vars(matching) == { + "keys_": params["keys"], + "values_": params["values"], + "valid": params["valid"], + "stable": params["stable"], + } + + +@given(st_singles()) +def test_repr(matching): + """Check that the string representation of a matching is correct.""" + + repr_ = repr(matching) + + assert isinstance(repr_, str) + assert repr_.startswith("SingleMatching") + assert str(dict(matching)) in repr_ + assert matching.keys_ in repr_ + assert matching.values_ in repr_ + + +@given(st_single_params()) +def test_eq(params): + """Check the equivalence dunder works as expected.""" + + matching1 = SingleMatching(**params) + matching2 = SingleMatching(**params) + + assert matching1 == matching2 + + if params["dictionary"] is not None: + key = next(iter(params["dictionary"].keys())) + matching2[key] = None + + assert matching1 != matching2 + assert vars(matching1) == vars(matching2) + + +@given(st_singles()) +def test_invert(matching): + """Check the matching inverter works as it should.""" + + inverted = matching.invert() + + assert isinstance(inverted, SingleMatching) + assert set(inverted.items()) == set( + (val, key) for key, val in matching.items() + ) + assert inverted.keys_ == matching.values_ + assert inverted.values_ == matching.keys_ + assert inverted.valid == matching.valid + assert inverted.stable == matching.stable diff --git a/tests/stable_marriage/strategies.py b/tests/stable_marriage/strategies.py new file mode 100644 index 0000000..97616e0 --- /dev/null +++ b/tests/stable_marriage/strategies.py @@ -0,0 +1,113 @@ +"""Composite strategies for SM unit tests.""" + +from unittest import mock + +import numpy as np +from hypothesis import strategies as st +from hypothesis.extra import numpy as st_numpy + +from matching.games import StableMarriage + + +def mocked_game(suitor_ranks, reviewer_ranks): + """Create an instance of SM that mocks the input validator.""" + + with mock.patch( + "matching.games.StableMarriage.check_input_validity" + ) as validator: + game = StableMarriage(suitor_ranks, reviewer_ranks) + + validator.assert_called_once_with() + + return game + + +@st.composite +def st_single_ranks(draw, size): + """Create a single rank matrix.""" + + rank = draw( + st.lists(st.permutations(range(size)), min_size=size, max_size=size) + ) + + return np.array(rank) + + +@st.composite +def st_ranks(draw, pmin=1, pmax=5): + """Create a set of rankings for a test.""" + + size = draw(st.integers(pmin, pmax)) + suitor_ranks = draw(st_single_ranks(size)) + reviewer_ranks = draw(st_single_ranks(size)) + + return suitor_ranks, reviewer_ranks + + +@st.composite +def st_player_ranks(draw, pmin=1, pmax=5): + """Create a set of ranks, and choose a player from it.""" + + suitor_ranks, reviewer_ranks = draw(st_ranks(pmin, pmax)) + side = draw(st.sampled_from(("suitor", "reviewer"))) + side_ranks = suitor_ranks if side == "suitor" else reviewer_ranks + player, ranks = draw(st.sampled_from(list(enumerate(side_ranks)))) + + return suitor_ranks, reviewer_ranks, player, ranks, side + + +@st.composite +def st_single_utilities(draw, size): + """Create a single utility matrix.""" + + utility = draw( + st_numpy.arrays( + dtype=float, + elements=st.floats(0, 1, allow_nan=False), + shape=(size, size), + ) + ) + + return utility + + +@st.composite +def st_utilities(draw, pmin=1, pmax=5): + """Create a set of utility matrices.""" + + size = draw(st.integers(pmin, pmax)) + suitor_utility = draw(st_single_utilities(size)) + reviewer_utility = draw(st_single_utilities(size)) + + return suitor_utility, reviewer_utility + + +@st.composite +def st_preferences(draw, pmin=1, pmax=5): + """Create a set of preferences for a test.""" + + size = draw(st.integers(pmin, pmax)) + suitors, reviewers = ( + draw(st.lists(elements, min_size=size, max_size=size, unique=True)) + for elements in (st.integers(), st.text()) + ) + + suitor_prefs = {s: draw(st.permutations(reviewers)) for s in suitors} + reviewer_prefs = {r: draw(st.permutations(suitors)) for r in reviewers} + + return suitor_prefs, reviewer_prefs + + +@st.composite +def st_preference_matchings(draw, pmin=1, pmax=5): + """Create a set of preferences and a matching to go with them.""" + + suitor_prefs, reviewer_prefs = draw(st_preferences(pmin, pmax)) + matching = dict( + zip( + range(len(reviewer_prefs)), + draw(st.permutations(list(range(len(suitor_prefs))))), + ) + ) + + return suitor_prefs, reviewer_prefs, matching diff --git a/tests/stable_marriage/test_algorithm.py b/tests/stable_marriage/test_algorithm.py index 6057ec9..8c4a478 100644 --- a/tests/stable_marriage/test_algorithm.py +++ b/tests/stable_marriage/test_algorithm.py @@ -1,41 +1,60 @@ """Integration tests for the Stable Marriage Problem algorithm.""" -from matching.algorithms import stable_marriage +import numpy as np +from hypothesis import given -from .util import STABLE_MARRIAGE, make_players +from .strategies import mocked_game, st_ranks -@STABLE_MARRIAGE -def test_suitor_optimal(player_names, seed): - """Test that the suitor-optimal algorithm is suitor-optimal.""" +def _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks): + """Assert that the matching has the right shape and elements.""" - suitors, reviewers = make_players(player_names, seed) - matching = stable_marriage(suitors, reviewers, optimal="suitor") + assert isinstance(matching, dict) - assert set(suitors) == set(matching.keys()) - assert set(reviewers) == set(matching.values()) + assert (np.sort(list(matching.keys())) == np.unique(suitor_ranks)).all() + assert ( + np.sort(list(matching.values())) == np.unique(reviewer_ranks) + ).all() - for suitor, reviewer in matching.items(): - idx = suitor.prefs.index(reviewer) - preferred = suitor.prefs[:idx] - for rev in preferred: - partner = rev.matching - assert rev.prefs.index(suitor) > rev.prefs.index(partner) +@given(st_ranks()) +def test_stable_marriage_suitor_optimal(ranks): + """Test that the SM algorithm is valid and suitor-optimal.""" -@STABLE_MARRIAGE -def test_reviewer_optimal(player_names, seed): - """Test that the reviewer-optimal algorithm is reviewer-optimal.""" + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(*ranks) - suitors, reviewers = make_players(player_names, seed) - matching = stable_marriage(suitors, reviewers, optimal="reviewer") + matching = game._stable_marriage() - assert set(suitors) == set(matching.keys()) - assert set(reviewers) == set(matching.values()) + _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks) - for suitor, reviewer in matching.items(): - idx = reviewer.prefs.index(suitor) - preferred = reviewer.prefs[:idx] - for suit in preferred: - partner = suit.matching - assert suit.prefs.index(reviewer) > suit.prefs.index(partner) + for reviewer, suitor in matching.items(): + suitor_rank = game.suitor_ranks[suitor] + preferred_reviewers, *_ = np.where(suitor_rank < suitor_rank[reviewer]) + for preferred in preferred_reviewers: + preferred_rank = game.reviewer_ranks[preferred] + partner = matching[preferred] + assert preferred_rank[suitor] > preferred_rank[partner] + + +@given(st_ranks()) +def test_stable_marriage_reviewer_pessimal(ranks): + """Test that the SM algorithm is valid and reviewer-pessimal.""" + + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(*ranks) + + matching = game._stable_marriage() + + _assert_matching_is_valid_shape(matching, suitor_ranks, reviewer_ranks) + + for reviewer, suitor in matching.items(): + reviewer_rank = game.reviewer_ranks[reviewer] + lesser_suitors, *_ = np.where(reviewer_rank > reviewer_rank[suitor]) + + for lesser in lesser_suitors: + lesser_rank = game.suitor_ranks[lesser] + partner = next( + rev for rev, sui in matching.items() if sui == lesser + ) + assert lesser_rank[partner] < lesser_rank[reviewer] diff --git a/tests/stable_marriage/test_examples.py b/tests/stable_marriage/test_examples.py index 496d8a5..18c1cd2 100644 --- a/tests/stable_marriage/test_examples.py +++ b/tests/stable_marriage/test_examples.py @@ -1,7 +1,9 @@ """A collection of example tests for SM.""" -from matching import Player -from matching.algorithms import stable_marriage +import numpy as np +import pytest + +from matching.games import StableMarriage def test_pride_and_prejudice(): @@ -10,56 +12,58 @@ def test_pride_and_prejudice(): This example appears in the SM Discussion documentation. """ - suitors = [ - Player(name="Bingley"), - Player(name="Collins"), - Player(name="Darcy"), - Player(name="Wickham"), - ] - - reviewers = [ - Player(name="Charlotte"), - Player(name="Elizabeth"), - Player(name="Jane"), - Player(name="Lydia"), - ] - - bingley, collins, darcy, wickham = suitors - charlotte, elizabeth, jane, lydia = reviewers - - bingley.set_prefs([jane, elizabeth, lydia, charlotte]) - collins.set_prefs([jane, elizabeth, lydia, charlotte]) - darcy.set_prefs([elizabeth, jane, charlotte, lydia]) - wickham.set_prefs([lydia, jane, elizabeth, charlotte]) - - charlotte.set_prefs([bingley, darcy, collins, wickham]) - elizabeth.set_prefs([wickham, darcy, bingley, collins]) - jane.set_prefs([bingley, wickham, darcy, collins]) - lydia.set_prefs([bingley, wickham, darcy, collins]) - - matching = stable_marriage(suitors, reviewers) - assert matching == { - bingley: jane, - collins: charlotte, - darcy: elizabeth, - wickham: lydia, + suitor_preferences = { + "B": ("J", "E", "L", "C"), + "C": ("J", "E", "L", "C"), + "D": ("E", "J", "C", "L"), + "W": ("L", "J", "E", "C"), + } + reviewer_preferences = { + "C": ("B", "D", "C", "W"), + "E": ("W", "D", "B", "C"), + "J": ("B", "W", "D", "C"), + "L": ("B", "W", "D", "C"), } + game = StableMarriage.from_preferences( + suitor_preferences, reviewer_preferences + ) + matching = game.solve() + + assert dict(matching) == {"J": "B", "C": "C", "E": "D", "L": "W"} + def test_readme_example(): """Verify the example used in the README.""" - suitors = [Player(name="A"), Player(name="B"), Player(name="C")] - reviewers = [Player(name="D"), Player(name="E"), Player(name="F")] - (A, B, C), (D, E, F) = suitors, reviewers + suitor_preferences = { + "A": ["D", "E", "F"], + "B": ["D", "F", "E"], + "C": ["F", "D", "E"], + } + reviewer_preferences = { + "D": ["B", "C", "A"], + "E": ["A", "C", "B"], + "F": ["C", "B", "A"], + } + + game = StableMarriage.from_preferences( + suitor_preferences, reviewer_preferences + ) + matching = game.solve() + + assert dict(matching) == {"E": "A", "D": "B", "F": "C"} + + +def test_matchingr_example(): + """Test the example from the MatchingR vignette.""" + + uM = np.array([[1.0, 0.5, 0.0], [0.5, 0.0, 0.5]]) + uW = np.array([[0.0, 1.0], [0.5, 0.0], [1.0, 0.5]]) - A.set_prefs([D, E, F]) - B.set_prefs([D, F, E]) - C.set_prefs([F, D, E]) + with pytest.warns(UserWarning, match="do not match"): + game = StableMarriage.from_utilities(uM, uW) - D.set_prefs([B, C, A]) - E.set_prefs([A, C, B]) - F.set_prefs([C, B, A]) + matching = game.solve() - matching = stable_marriage(suitors, reviewers) - assert matching == {A: E, B: D, C: F} + assert dict(matching) == {0: 1, 1: 0} diff --git a/tests/stable_marriage/test_game.py b/tests/stable_marriage/test_game.py new file mode 100644 index 0000000..7881353 --- /dev/null +++ b/tests/stable_marriage/test_game.py @@ -0,0 +1,316 @@ +"""Unit tests for the StableMarriage class.""" + +import warnings +from unittest import mock + +import numpy as np +import pytest +from hypothesis import given +from hypothesis import strategies as st + +from matching.games import StableMarriage +from matching.matchings import SingleMatching + +from .strategies import ( + mocked_game, + st_player_ranks, + st_preference_matchings, + st_preferences, + st_ranks, + st_utilities, +) + + +@given(st_ranks()) +def test_init(ranks): + """Test for correct instantiation given some rankings.""" + + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(suitor_ranks, reviewer_ranks) + + assert (game.suitor_ranks == suitor_ranks).all() + assert (game.reviewer_ranks == reviewer_ranks).all() + + assert game.num_suitors == len(suitor_ranks) + assert game.num_reviewers == len(reviewer_ranks) + assert game.matching is None + assert game._preference_lookup is None + + +@given(st_utilities()) +def test_from_utilities(utilities): + """Test the utility matrix builder.""" + + suitor_utility, reviewer_utility = utilities + + with ( + mock.patch( + "matching.games.StableMarriage.check_input_validity" + ) as validator, + mock.patch("matching.convert.utility_to_rank") as ranker, + ): + effects = (suitor_utility.argsort(), reviewer_utility.argsort()) + ranker.side_effect = list(effects) + game = StableMarriage.from_utilities(suitor_utility, reviewer_utility) + + assert isinstance(game, StableMarriage) + assert (game.suitor_ranks == effects[0]).all() + assert (game.reviewer_ranks == effects[1]).all() + + assert game.num_suitors == len(suitor_utility) + assert game.num_reviewers == len(reviewer_utility) + assert game.matching is None + assert game._preference_lookup is None + + assert ranker.call_count == 2 + for call, utility in zip(ranker.call_args_list, utilities): + arg, *_ = call.args + assert np.array_equal(arg, utility) + + validator.assert_called_once_with() + + +@given(st_preferences()) +def test_from_preferences(preferences): + """Test the preference list builder.""" + + suitor_prefs, reviewer_prefs = preferences + + with ( + mock.patch( + "matching.games.StableMarriage.check_input_validity" + ) as validator, + mock.patch("matching.convert.preference_to_rank") as ranker, + ): + effects = ( + np.array(list(suitor_prefs.values())), + np.array(list(reviewer_prefs.values())), + ) + ranker.side_effect = list(effects) + game = StableMarriage.from_preferences(suitor_prefs, reviewer_prefs) + + assert isinstance(game, StableMarriage) + assert (game.suitor_ranks == effects[0]).all() + assert (game.reviewer_ranks == effects[1]).all() + + assert game.num_suitors == len(suitor_prefs) + assert game.num_reviewers == len(reviewer_prefs) + assert game.matching is None + + assert isinstance(game._preference_lookup, dict) + assert game._preference_lookup == { + "suitors": sorted(suitor_prefs), + "reviewers": sorted(reviewer_prefs), + } + + assert ranker.call_count == 2 + for call, preference, others in zip( + ranker.call_args_list, + preferences, + (reviewer_prefs, suitor_prefs), + ): + assert call.args == (preference, sorted(others)) + + validator.assert_called_once_with() + + +@given(st_ranks()) +def test_check_number_of_players_no_warning(ranks): + """Test the number of players can be checked without warning.""" + + game = mocked_game(*ranks) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + game._check_number_of_players() + + +@given(st_ranks()) +def test_check_number_of_players_warning(ranks): + """Test for a warning when the player sets are not the same size.""" + + suitor_ranks, reviewer_ranks = ranks + suitor_ranks = np.vstack((suitor_ranks, suitor_ranks[-1][::-1])) + + game = mocked_game(suitor_ranks, reviewer_ranks) + + match = ( + r"^Number of suitors \(\d{1,2}\) " + r"and reviewers \(\d{1,2}\) do not match." + ) + with pytest.warns(UserWarning, match=match): + game._check_number_of_players() + + +@given(st_player_ranks()) +def test_check_player_ranks_no_warning(player_ranks): + """Test the rank checker runs without warning for a valid set.""" + + suitor_ranks, reviewer_ranks, player, ranks, side = player_ranks + game = mocked_game(suitor_ranks, reviewer_ranks) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + game._check_player_ranks(player, ranks, side) + + +@given(st_player_ranks()) +def test_check_player_ranks_warning(player_ranks): + """Test the rank checker gives a warning for an invalid set.""" + + suitor_ranks, reviewer_ranks, player, ranks, side = player_ranks + ranks[-1] = 1000 + + game = mocked_game(suitor_ranks, reviewer_ranks) + + match = f"{side.title()} {player} has not strictly ranked" + with pytest.warns(UserWarning, match=match): + game._check_player_ranks(player, ranks, side) + + +def _zip_enumerated_ranks_with_side(ranks, side): + """Attach the side to a list of enumerated rankings.""" + + return ((i, rank, side) for i, rank in enumerate(ranks)) + + +@given(st_ranks()) +def test_check_input_validity(ranks): + """Test the logic of the input validator.""" + + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(*ranks) + + with ( + mock.patch( + "matching.games.StableMarriage._check_number_of_players" + ) as check_num_players, + mock.patch( + "matching.games.StableMarriage._check_player_ranks" + ) as check_player_ranks, + ): + game.check_input_validity() + + check_num_players.assert_called_once_with() + + assert check_player_ranks.call_count == ( + len(suitor_ranks) + len(reviewer_ranks) + ) + + suitor_args = _zip_enumerated_ranks_with_side(suitor_ranks, "suitor") + reviewer_args = _zip_enumerated_ranks_with_side(reviewer_ranks, "reviewer") + for call, (player, rank, side) in zip( + check_player_ranks.call_args_list, [*suitor_args, *reviewer_args] + ): + call_player, call_rank, call_side = call.args + assert call_player == player + assert (call_rank == rank).all() + + assert call_side == side + + +@given(st_ranks()) +def test_invert_player_sets(ranks): + """Test that the player set attributes can be swapped.""" + + suitor_ranks, reviewer_ranks = ranks + game = mocked_game(*ranks) + + game._invert_player_sets() + + assert (game.suitor_ranks == reviewer_ranks).all() + assert (game.reviewer_ranks == suitor_ranks).all() + assert game.num_suitors == len(reviewer_ranks) + assert game.num_reviewers == len(suitor_ranks) + + +@given( + st_ranks(), + st.sampled_from(("suitor", "reviewer")), + st.dictionaries(st.integers(), st.integers()), +) +def test_solve_valid_optimal(ranks, optimal, solution): + """Test the solver runs as it should with valid inputs.""" + + game = mocked_game(*ranks) + + with ( + mock.patch( + "matching.games.StableMarriage._invert_player_sets" + ) as player_set_inverter, + mock.patch( + "matching.games.StableMarriage._stable_marriage" + ) as stable_marriage, + mock.patch( + "matching.matchings.SingleMatching.invert" + ) as matching_inverter, + ): + stable_marriage.return_value = solution + matching_inverter.return_value = "inverted_matching" + matching = game.solve(optimal) + + assert matching == game.matching + stable_marriage.assert_called_once_with() + + if optimal == "reviewer": + assert player_set_inverter.call_count == 2 + assert [call.args for call in player_set_inverter.call_args_list] == [ + (), + (), + ] + assert matching == "inverted_matching" + else: + assert isinstance(matching, SingleMatching) + assert dict(matching) == solution + + +@given(st_ranks(), st.text()) +def test_solve_invalid_optimal_raises(ranks, optimal): + """Test the solver raises an error with invalid optimal.""" + + game = mocked_game(*ranks) + + match = "^Invalid choice for `optimal`." + with ( + mock.patch( + "matching.games.StableMarriage._invert_player_sets" + ) as player_set_inverter, + mock.patch( + "matching.games.StableMarriage._stable_marriage" + ) as stable_marriage, + mock.patch( + "matching.matchings.SingleMatching.invert" + ) as matching_inverter, + pytest.raises(ValueError, match=match), + ): + game.solve(optimal) + + player_set_inverter.assert_not_called() + stable_marriage.assert_not_called() + matching_inverter.assert_not_called() + + +@given(st_preference_matchings()) +def test_convert_matching_to_preferences(preference_matchings): + """Test that a matching can use the terms from some preferences.""" + + suitor_prefs, reviewer_prefs, matching = preference_matchings + + # the arrays here aren't used anywhere internally, just placeholders + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + game = StableMarriage.from_preferences(suitor_prefs, reviewer_prefs) + + game.matching = SingleMatching(matching) + + game._convert_matching_to_preferences() + converted = game.matching + + assert isinstance(converted, SingleMatching) + assert converted.keys_ == "reviewers" + assert converted.values_ == "suitors" + assert converted.valid is None + assert converted.stable is None + + assert set(converted.keys()) == set(reviewer_prefs) + assert set(converted.values()) == set(suitor_prefs) diff --git a/tests/stable_marriage/test_solver.py b/tests/stable_marriage/test_solver.py deleted file mode 100644 index 358bb90..0000000 --- a/tests/stable_marriage/test_solver.py +++ /dev/null @@ -1,192 +0,0 @@ -"""Unit tests for the SM solver.""" - -import pytest - -from matching import Player, SingleMatching -from matching.exceptions import MatchingError -from matching.games import StableMarriage - -from .util import STABLE_MARRIAGE, make_players, make_prefs - - -@STABLE_MARRIAGE -def test_init(player_names, seed): - """Test for correct instantiation given a set of players.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - for player, game_player in zip( - suitors + reviewers, game.suitors + game.reviewers - ): - assert player.name == game_player.name - assert player._pref_names == game_player._pref_names - - assert all( - [player.matching is None for player in game.suitors + game.reviewers] - ) - assert game.matching is None - - -@STABLE_MARRIAGE -def test_create_from_dictionaries(player_names, seed): - """Test for correct instantiation given a set of dictionaries.""" - - suitor_prefs, reviewer_prefs = make_prefs(player_names, seed) - game = StableMarriage.create_from_dictionaries( - suitor_prefs, reviewer_prefs - ) - - for suitor in game.suitors: - assert suitor_prefs[suitor.name] == suitor._pref_names - assert suitor.matching is None - - for reviewer in game.reviewers: - assert reviewer_prefs[reviewer.name] == reviewer._pref_names - assert reviewer.matching is None - - assert game.matching is None - - -@STABLE_MARRIAGE -def test_inputs_num_players(player_names, seed): - """Test for error when the player sets are not the same size.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - assert game._check_num_players() - - suitors = suitors[:-1] - - with pytest.raises(ValueError): - StableMarriage(suitors, reviewers) - - -@STABLE_MARRIAGE -def test_inputs_player_ranks(player_names, seed): - """Test for error when a player has incomplete preferences.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - for player in game.suitors + game.reviewers: - assert game._check_player_ranks(player) - - suitors[0].prefs = suitors[0].prefs[:-1] - - with pytest.raises(ValueError): - StableMarriage(suitors, reviewers) - - -@STABLE_MARRIAGE -def test_solve(player_names, seed): - """Test that the class solves games correctly.""" - - for optimal in ["suitor", "reviewer"]: - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - matching = game.solve(optimal) - assert isinstance(matching, SingleMatching) - - suitors = sorted(suitors, key=lambda s: s.name) - reviewers = sorted(reviewers, key=lambda r: r.name) - - matching_keys = sorted(matching.keys(), key=lambda k: k.name) - matching_values = sorted(matching.values(), key=lambda v: v.name) - - for game_suitor, suitor in zip(matching_keys, suitors): - assert game_suitor.name == suitor.name - assert game_suitor._pref_names == suitor._pref_names - - for game_reviewer, reviewer in zip(matching_values, reviewers): - assert game_reviewer.name == reviewer.name - assert game_reviewer._pref_names == reviewer._pref_names - - -@STABLE_MARRIAGE -def test_check_validity(player_names, seed): - """Test for a valid matching when the game is solved.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - - game.solve() - assert game.check_validity() - - -@STABLE_MARRIAGE -def test_check_for_unmatched_players(player_names, seed): - """Test that all players must be matched to another player.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - game.solve() - - player = game.suitors[0] - player.matching = None - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.unmatched_players[0] - assert error.startswith(player.name) - - -@STABLE_MARRIAGE -def test_check_for_players_not_in_matching(player_names, seed): - """Test that all players must be matched in the matching.""" - - suitors, reviewers = make_players(player_names, seed) - game = StableMarriage(suitors, reviewers) - matching = game.solve() - - player = game.suitors[0] - matching[player] = None - - with pytest.raises(MatchingError) as e: - game.check_validity() - error = e.players[0] - assert error.startswith(player.name) - - -@STABLE_MARRIAGE -def test_matching_consistent(player_names, seed): - """Test that the game's matching must match the players' matches.""" - - suitors, reviewers = make_players(player_names, seed) - - game = StableMarriage(suitors, reviewers) - game.solve() - - game.suitors[0].matching = None - game.reviewers[0].matching = None - - with pytest.raises(Exception): - game._check_matching_consistent() - - -def test_check_stability(): - """Test checker for whether a matching is stable.""" - - suitors = [Player("A"), Player("B")] - reviewers = [Player("X"), Player("Y")] - - (a, b), (x, y) = suitors, reviewers - - a.set_prefs(reviewers) - b.set_prefs(reviewers[::-1]) - - x.set_prefs(suitors) - y.set_prefs(suitors[::-1]) - - game = StableMarriage(suitors, reviewers) - - matching = game.solve() - assert game.check_stability() - - (a, b), (x, y) = game.suitors, game.reviewers - matching[a] = y - matching[b] = x - - assert not game.check_stability() diff --git a/tests/stable_roommates/test_solver.py b/tests/stable_roommates/test_solver.py index 8d52268..fc2ccef 100644 --- a/tests/stable_roommates/test_solver.py +++ b/tests/stable_roommates/test_solver.py @@ -113,8 +113,17 @@ def test_stability(): matching[c] = a matching[d] = b + a.matching = c + b.matching = d + c.matching = a + d.matching = b + assert not game.check_stability() matching[a] = None matching[c] = None + + a.matching = None + c.matching = None + assert not game.check_stability() diff --git a/tests/student_allocation/test_algorithm.py b/tests/student_allocation/test_algorithm.py index d2a8514..f2ef7f0 100644 --- a/tests/student_allocation/test_algorithm.py +++ b/tests/student_allocation/test_algorithm.py @@ -83,7 +83,7 @@ def test_supervisor_optimal( ) for supervisor in supervisors: - old_idx = -np.infty + old_idx = -np.inf for student in supervisor.matching: idx = supervisor.prefs.index(student) assert idx >= old_idx diff --git a/tests/test_convert.py b/tests/test_convert.py index 295ea9d..caa9be0 100644 --- a/tests/test_convert.py +++ b/tests/test_convert.py @@ -1,9 +1,7 @@ """Tests for the `matching.convert` module.""" -import itertools - import numpy as np -from hypothesis import given, settings +from hypothesis import assume, given, settings from hypothesis import strategies as st from hypothesis.extra.numpy import arrays @@ -52,20 +50,33 @@ def test_utility_to_rank(utility): assert isinstance(rank, np.ndarray) assert rank.shape == utility.shape assert (np.sort(rank) == np.arange(utility.shape[1])).all() + assert (rank == (-utility).argsort().argsort()).all() @given(preferences()) def test_preference_to_rank(preference): """Check that a preference dictionary can be converted to ranks.""" - others = list(itertools.chain(*preference.values())) - rank = convert.preference_to_rank(preference, others) + others = sorted(set(o for prefs in preference.values() for o in prefs)) + ranks = convert.preference_to_rank(preference, others) - assert isinstance(rank, np.ndarray) - assert rank.shape == ( - len(preference.keys()), - len(list(preference.values())[0]), - ) + assert isinstance(ranks, np.ndarray) + assert ranks.shape == (len(preference), len(others)) + + sorted_preference = sorted(preference.items(), key=lambda x: x[0]) + for rank, (_, pref) in zip(ranks, sorted_preference): + assert [pref[idx] for idx in rank] == others + + +@given(preferences()) +def test_preference_to_rank_incomplete(preference): + """Check the preference list converter assigns incomplete lists.""" + + others = sorted(set(o for prefs in preference.values() for o in prefs)) + preference[1000] = others[:-1] + assume(len(others) > 1) + + ranks = convert.preference_to_rank(preference, others) + idx = sorted(preference.keys()).index(1000) - for row, pref in zip(rank, preference.values()): - assert [others[r] for r in row] == pref + assert ranks[idx, -1] == len(others) diff --git a/tests/test_matchings.py b/tests/test_matchings.py index e93f352..85bb654 100644 --- a/tests/test_matchings.py +++ b/tests/test_matchings.py @@ -9,24 +9,10 @@ text, ) -from matching import MultipleMatching, SingleMatching +from matching import MultipleMatching from matching.players import Hospital, Player -@composite -def singles(draw, names_from=text(), min_size=2, max_size=5): - """A strategy for generating single-match matchings from players.""" - - size = draw(integers(min_value=min_size, max_value=max_size)) - players = [Player(draw(names_from)) for _ in range(size)] - - midpoint = size // 2 - keys, values = players[:midpoint], players[midpoint:] - dictionary = dict(zip(keys, values)) - - return dictionary - - @composite def multiples( draw, @@ -55,32 +41,6 @@ def multiples( return dictionary -@given(dictionary=singles()) -def test_single_setitem_none(dictionary): - """Test that a player in a matching can have ``None`` as a match.""" - - matching = SingleMatching(dictionary) - key = list(dictionary.keys())[0] - - matching[key] = None - assert matching[key] is None - assert key.matching is None - - -@given(dictionary=singles()) -def test_single_setitem_player(dictionary): - """Test that a player in a matching instance can match a player.""" - - matching = SingleMatching(dictionary) - key = list(dictionary.keys())[0] - val = list(dictionary.values())[-1] - - matching[key] = val - assert matching[key] == val - assert key.matching == val - assert val.matching == key - - @given(dictionary=multiples()) def test_multiple_setitem(dictionary): """Test that a host player in a matching can have a list match.""" diff --git a/tex/stable_marriage.tex b/tex/stable_marriage.tex index 371c5e6..69603de 100644 --- a/tex/stable_marriage.tex +++ b/tex/stable_marriage.tex @@ -9,22 +9,22 @@ % Suitors \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=left: {\(A: (D, E, F)\)}] (A) at (0, 0) {}; - \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, - label=left: {\(B: (D, F, E)\)}] (B) at (0, -3) {}; - \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, + \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, + label=left: {\(B: (D, F, E)\)}] (B) at (0, -3) {}; + \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=left: {\(C: (F, D, E)\)}] (C) at (0, -6) {}; % Reviewers - \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, + \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=right: {\(D: (B, C, A)\)}] (D) at (6, 0) {}; - \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, + \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=right: {\(E: (A, C, B)\)}] (E) at (6, -3) {}; \node[draw, shape=circle, fill, inner sep=0, minimum size=0.25cm, label=right: {\(F: (C, B, A)\)}] (F) at (6, -6) {}; % Question mark node \node[draw, shape=circle] (q) at (3, -3) {?}; - + % Lines into (?) \foreach \x in {A, B, C, D, E, F} \draw (\x) -- (q);