From 4c231f62d21a5da1b6fdb0b83a70709d442fa0fc Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Tue, 13 Aug 2024 12:22:22 -0700 Subject: [PATCH 01/32] Wolfson bipolarization index and tests --- inequality/tests/test_wolfson.py | 38 ++++++++++++++ inequality/wolfson.py | 85 ++++++++++++++++++++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 inequality/tests/test_wolfson.py create mode 100644 inequality/wolfson.py diff --git a/inequality/tests/test_wolfson.py b/inequality/tests/test_wolfson.py new file mode 100644 index 00000000..a3948c3f --- /dev/null +++ b/inequality/tests/test_wolfson.py @@ -0,0 +1,38 @@ +import numpy as np +from inequality.wolfson import lorenz_curve, gini_coefficient, wolfson + + +def test_lorenz_curve(): + income = [1, 2, 3, 4, 5] + population, cumulative_income = lorenz_curve(income) + + # Expected cumulative income values (calculated manually) + expected_cumulative_income = np.array( + [0, 0.06666667, 0.2, 0.4, 0.66666667, 1]) + + # Test if the Lorenz curve is calculated correctly + np.testing.assert_almost_equal( + cumulative_income, expected_cumulative_income, decimal=6) + # Should include start and end points (0 and 1) + assert len(population) == 6 + + +def test_gini_coefficient(): + # Lorenz curve values (population, cumulative income) + population = np.array([0, 0.25, 0.5, 0.75, 1]) + cumulative_income = np.array([0, 0.1, 0.3, 0.6, 1]) + g = gini_coefficient((population, cumulative_income)) + expected_gini = 0.25 + assert np.isclose(g, expected_gini, atol=0.01) + + +def test_wolfson(): + # Test with a known income distribution + income = [6, 6, 8, 8, 10, 10, 12, 12] + wolfson_idx = wolfson(income) + expected_wolfson_idx = 1/12 + assert np.isclose(wolfson_idx, expected_wolfson_idx, atol=0.01) + income = [2, 4, 6, 8, 10, 12, 14, 16] + wolfson_idx = wolfson(income) + expected_wolfson_idx = 11/72 + assert np.isclose(wolfson_idx, expected_wolfson_idx, atol=0.01) diff --git a/inequality/wolfson.py b/inequality/wolfson.py new file mode 100644 index 00000000..9f828411 --- /dev/null +++ b/inequality/wolfson.py @@ -0,0 +1,85 @@ +""" +Wolfson Bipolarization Index Module + +This module provides functions to calculate the Lorenz curve, Gini coefficient, +and Wolfson Bipolarization Index for a given distribution of income or wealth. + +Author: +Serge Rey +""" + +import numpy as np + + +def lorenz_curve(y): + """ + Calculate the Lorenz curve for a given distribution. + + Parameters: + y (array-like): A list or array of income or wealth values. + + Returns: + tuple: Two numpy arrays representing the cumulative share of the population + and the cumulative share of the income/wealth. + """ + sorted_y = np.sort(y) + cumulative_y = np.cumsum(sorted_y) + # Add zero for the starting point + cumulative_y = np.insert(cumulative_y, 0, 0) + cumulative_y = cumulative_y / cumulative_y[-1] + cumulative_population = np.linspace(0, 1, len(y) + 1) + return cumulative_population, cumulative_y + + +def gini_coefficient(lorenz_curve): + """ + Calculate the Gini coefficient from the Lorenz curve. + + Parameters: + lorenz_curve (tuple): A tuple containing two numpy arrays representing the + cumulative share of the population and the cumulative + share of the income/wealth. + + Returns: + float: The Gini coefficient, a measure of inequality ranging from + 0 (perfect equality) to 1 (perfect inequality). + + """ + lorenz_area = np.trapezoid(lorenz_curve[1], lorenz_curve[0]) + return 1 - 2 * lorenz_area + + +def wolfson(y): + """ + Calculate the Wolfson Bipolarization Index for a given distribution. + The Wolfson Index is a measure of income polarization, which + considers both the spread and the skewness of the income + distribution, focusing on the middle class. + + + Parameters: + y (array-like): A list or array of income or wealth values. + + Returns: + float: The Wolfson Bipolarization Index. A higher value indicates + more significant polarization in the income distribution. + + Example: + -------- + >>> income_distribution = [20000, 25000, 27000, 30000, + 35000, 45000, 60000, 75000, 80000, 120000] + >>> wolfson_index = wolfson(income_distribution) + >>> print(f"Wolfson Bipolarization Index: {wolfson_index:.4f}") + Wolfson Bipolarization Index: 0.1213 + """ + y = np.array(y) + cumulative_population, cumulative_y = lorenz_curve(y) + g = gini_coefficient((cumulative_population, cumulative_y)) + + median_y = np.median(y) + mean_y = np.mean(y) + + median_lorenz = np.interp(0.5, cumulative_population, cumulative_y) + + d50 = 0.5 - median_lorenz + return (2 * d50 - g) * (mean_y / median_y) From aaa63ab757942743fa4c7c0d450cb887d31abf2f Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 22 Aug 2024 11:53:32 -0700 Subject: [PATCH 02/32] ENH: Wolfson bipolarization index --- docs/_static/references.bib | 17 +++++++++ docs/api.rst | 21 +++++++---- inequality/__init__.py | 2 +- inequality/tests/test_wolfson.py | 7 ++-- inequality/wolfson.py | 61 +++++++++++++++++--------------- 5 files changed, 68 insertions(+), 40 deletions(-) diff --git a/docs/_static/references.bib b/docs/_static/references.bib index 71c4e12b..9863f520 100644 --- a/docs/_static/references.bib +++ b/docs/_static/references.bib @@ -1,3 +1,20 @@ + +@article{wolfson1994WhenInequalities, + title = {When {{Inequalities Diverge}}}, + author = {Wolfson, Michael C.}, + year = {1994}, + journal = {The American Economic Review}, + volume = {84}, + number = {2}, + eprint = {2117858}, + eprinttype = {jstor}, + pages = {353--358}, + publisher = {American Economic Association}, + issn = {0002-8282}, + urldate = {2024-08-12}, + file = {/home/serge/Zotero/storage/8JYHLHTW/Wolfson - 1994 - When Inequalities Diverge.pdf} +} + @article{care_2012, author = {Care, David C. and Pinkerton, Ruth M. and Poot, Jacques and Coleman, Andrew}, title = {{Residential sorting across Auckland neighbourhoods}}, diff --git a/docs/api.rst b/docs/api.rst index f863a0c4..6338d4c8 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -7,6 +7,16 @@ API reference .. _inequality_api: + +Gini Inequality Measures +------------------------ + +.. autosummary:: + :toctree: generated/ + + inequality.gini.Gini + inequality.gini.Gini_Spatial + Theil Inequality Measures ------------------------- @@ -17,16 +27,13 @@ Theil Inequality Measures inequality.theil.TheilD inequality.theil.TheilDSim - -Gini Inequality Measures ------------------------- - +Wolfson Bipolarization +---------------------- .. autosummary:: :toctree: generated/ - inequality.gini.Gini - inequality.gini.Gini_Spatial - + inequality.wolfson.wolfson + Pengram ------- diff --git a/inequality/__init__.py b/inequality/__init__.py index 4bafd1e8..adc4c775 100644 --- a/inequality/__init__.py +++ b/inequality/__init__.py @@ -7,7 +7,7 @@ import contextlib from importlib.metadata import PackageNotFoundError, version -from . import gini, theil +from . import gini, theil, wolfson from ._indices import ( abundance, ellison_glaeser_egg, diff --git a/inequality/tests/test_wolfson.py b/inequality/tests/test_wolfson.py index a3948c3f..a3367097 100644 --- a/inequality/tests/test_wolfson.py +++ b/inequality/tests/test_wolfson.py @@ -1,5 +1,6 @@ import numpy as np -from inequality.wolfson import lorenz_curve, gini_coefficient, wolfson + +from inequality.wolfson import _gini_coefficient, lorenz_curve, wolfson def test_lorenz_curve(): @@ -17,11 +18,11 @@ def test_lorenz_curve(): assert len(population) == 6 -def test_gini_coefficient(): +def test__gini_coefficient(): # Lorenz curve values (population, cumulative income) population = np.array([0, 0.25, 0.5, 0.75, 1]) cumulative_income = np.array([0, 0.1, 0.3, 0.6, 1]) - g = gini_coefficient((population, cumulative_income)) + g = _gini_coefficient((population, cumulative_income)) expected_gini = 0.25 assert np.isclose(g, expected_gini, atol=0.01) diff --git a/inequality/wolfson.py b/inequality/wolfson.py index 9f828411..fd61fff1 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -10,6 +10,8 @@ import numpy as np +__all__ = ["wolfson", "lorenz_curve"] + def lorenz_curve(y): """ @@ -31,7 +33,7 @@ def lorenz_curve(y): return cumulative_population, cumulative_y -def gini_coefficient(lorenz_curve): +def _gini_coefficient(lorenz_curve): """ Calculate the Gini coefficient from the Lorenz curve. @@ -45,41 +47,42 @@ def gini_coefficient(lorenz_curve): 0 (perfect equality) to 1 (perfect inequality). """ - lorenz_area = np.trapezoid(lorenz_curve[1], lorenz_curve[0]) + lorenz_area = np.trapz(lorenz_curve[1], lorenz_curve[0]) return 1 - 2 * lorenz_area -def wolfson(y): +def wolfson(income_distribution): """ - Calculate the Wolfson Bipolarization Index for a given distribution. - The Wolfson Index is a measure of income polarization, which - considers both the spread and the skewness of the income - distribution, focusing on the middle class. - - - Parameters: - y (array-like): A list or array of income or wealth values. - - Returns: - float: The Wolfson Bipolarization Index. A higher value indicates - more significant polarization in the income distribution. - - Example: - -------- - >>> income_distribution = [20000, 25000, 27000, 30000, - 35000, 45000, 60000, 75000, 80000, 120000] + Calculate the Wolfson Bipolarization Index for a given income distribution. + + Parameters + ---------- + income_distribution : list of int or float + A list representing the income distribution. + + Returns + ------- + w: float + The Wolfson Bipolarization Index value. + + Example + ------- + >>> income_distribution = [20000, 25000, 27000, 30000, 35000, 45000, 60000, + ... 75000, 80000, 120000] >>> wolfson_index = wolfson(income_distribution) >>> print(f"Wolfson Bipolarization Index: {wolfson_index:.4f}") - Wolfson Bipolarization Index: 0.1213 + Wolfson Bipolarization Index: 0.2013 """ - y = np.array(y) - cumulative_population, cumulative_y = lorenz_curve(y) - g = gini_coefficient((cumulative_population, cumulative_y)) + income_distribution = np.sort(income_distribution) + n = len(income_distribution) + total_income = np.sum(income_distribution) + mean_income = total_income / n + cumulative_income = np.cumsum(income_distribution) - median_y = np.median(y) - mean_y = np.mean(y) + # Calculate the Gini coefficient + g = 1 - 2 * np.sum(cumulative_income) / (n * total_income) + (n + 1) / n - median_lorenz = np.interp(0.5, cumulative_population, cumulative_y) + # Calculate the Wolfson Bipolarization Index + w = 2 * mean_income * g / total_income - 1 - d50 = 0.5 - median_lorenz - return (2 * d50 - g) * (mean_y / median_y) + return w From 8e307c15970cd81c477e190902cdf5f10a007dab Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Fri, 23 Aug 2024 10:10:50 -0700 Subject: [PATCH 03/32] ENH: Wolfson bipolarization index --- inequality/tests/test_wolfson.py | 13 +-------- inequality/wolfson.py | 48 +++++++++++++------------------- 2 files changed, 20 insertions(+), 41 deletions(-) diff --git a/inequality/tests/test_wolfson.py b/inequality/tests/test_wolfson.py index a3367097..b5194057 100644 --- a/inequality/tests/test_wolfson.py +++ b/inequality/tests/test_wolfson.py @@ -1,6 +1,6 @@ import numpy as np -from inequality.wolfson import _gini_coefficient, lorenz_curve, wolfson +from inequality.wolfson import lorenz_curve, wolfson def test_lorenz_curve(): @@ -11,24 +11,13 @@ def test_lorenz_curve(): expected_cumulative_income = np.array( [0, 0.06666667, 0.2, 0.4, 0.66666667, 1]) - # Test if the Lorenz curve is calculated correctly np.testing.assert_almost_equal( cumulative_income, expected_cumulative_income, decimal=6) # Should include start and end points (0 and 1) assert len(population) == 6 -def test__gini_coefficient(): - # Lorenz curve values (population, cumulative income) - population = np.array([0, 0.25, 0.5, 0.75, 1]) - cumulative_income = np.array([0, 0.1, 0.3, 0.6, 1]) - g = _gini_coefficient((population, cumulative_income)) - expected_gini = 0.25 - assert np.isclose(g, expected_gini, atol=0.01) - - def test_wolfson(): - # Test with a known income distribution income = [6, 6, 8, 8, 10, 10, 12, 12] wolfson_idx = wolfson(income) expected_wolfson_idx = 1/12 diff --git a/inequality/wolfson.py b/inequality/wolfson.py index fd61fff1..76611bc8 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -10,6 +10,8 @@ import numpy as np +from .gini import Gini + __all__ = ["wolfson", "lorenz_curve"] @@ -33,24 +35,6 @@ def lorenz_curve(y): return cumulative_population, cumulative_y -def _gini_coefficient(lorenz_curve): - """ - Calculate the Gini coefficient from the Lorenz curve. - - Parameters: - lorenz_curve (tuple): A tuple containing two numpy arrays representing the - cumulative share of the population and the cumulative - share of the income/wealth. - - Returns: - float: The Gini coefficient, a measure of inequality ranging from - 0 (perfect equality) to 1 (perfect inequality). - - """ - lorenz_area = np.trapz(lorenz_curve[1], lorenz_curve[0]) - return 1 - 2 * lorenz_area - - def wolfson(income_distribution): """ Calculate the Wolfson Bipolarization Index for a given income distribution. @@ -72,17 +56,23 @@ def wolfson(income_distribution): >>> wolfson_index = wolfson(income_distribution) >>> print(f"Wolfson Bipolarization Index: {wolfson_index:.4f}") Wolfson Bipolarization Index: 0.2013 - """ - income_distribution = np.sort(income_distribution) - n = len(income_distribution) - total_income = np.sum(income_distribution) - mean_income = total_income / n - cumulative_income = np.cumsum(income_distribution) - - # Calculate the Gini coefficient - g = 1 - 2 * np.sum(cumulative_income) / (n * total_income) + (n + 1) / n + >>> income_distribution = [6, 6, 8, 8, 10, 10, 12, 12] + >>> wolfson_index = wolfson(income_distribution) + >>> print(f"Wolfson Bipolarization Index: {wolfson_index:.4f}") + Wolfson Bipolarization Index: 0.0833 + >>> income_distribution = [2, 4, 6, 8, 10, 12, 14, 16] + >>> wolfson_index = wolfson(income_distribution) + >>> print(f"Wolfson Bipolarization Index: {wolfson_index:.4f}") + Wolfson Bipolarization Index: 0.1528 - # Calculate the Wolfson Bipolarization Index - w = 2 * mean_income * g / total_income - 1 + """ + y = np.array(income_distribution) + y_med = np.median(y) + ordinate, lc = lorenz_curve(y) + l50 = np.interp(.5, ordinate, lc) + d50 = .5 - l50 + rat = y.mean() / y_med + g = Gini(y).g + w = (2 * d50 - g) * rat return w From 9ada1c45f446ca955d38a0dda8ab99ff5591f8ad Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 1 Sep 2024 09:18:52 -0700 Subject: [PATCH 04/32] add pen and pengram to tutorials --- docs/tutorials.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/tutorials.rst b/docs/tutorials.rst index 5a4e93bc..fab23d06 100644 --- a/docs/tutorials.rst +++ b/docs/tutorials.rst @@ -9,3 +9,4 @@ Tutorials :caption: Gini notebooks/gini.ipynb + notebooks/pengram.ipynb From ace0e1a648f584da4974e4f3b18b7a8cfa778f1c Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 1 Sep 2024 10:42:14 -0700 Subject: [PATCH 05/32] DOCS: change theme --- docs/conf.py | 21 +++++++++++---------- docs/index.rst | 15 ++++++++++----- 2 files changed, 21 insertions(+), 15 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 7a763981..504c920d 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -17,11 +17,11 @@ # documentation root, use os.path.abspath to make it absolute, like shown here. # -import sphinx_bootstrap_theme - +from datetime import datetime # import your package to obtain the version info to display on the docs website import inequality +import sphinx_bootstrap_theme # -- General configuration ------------------------------------------------ @@ -31,7 +31,7 @@ # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. -extensions = [ #'sphinx_gallery.gen_gallery', +extensions = [ # 'sphinx_gallery.gen_gallery', "sphinx.ext.autodoc", "sphinx.ext.autosummary", "sphinx.ext.viewcode", @@ -60,7 +60,7 @@ # General information about the project. project = "inequality" # string of your project name, for example, 'giddy' -copyright = "2018, pysal developers" +copyright = f"2018 - {datetime.now().year}, pysal developers (BSD License)" author = "pysal developers" # The version info for the project you're documenting, acts as replacement for @@ -95,7 +95,8 @@ # a list of builtin themes. # # html_theme = 'alabaster' -html_theme = "bootstrap" +# html_theme = "bootstrap" +html_theme = "pydata_sphinx_theme" html_theme_path = sphinx_bootstrap_theme.get_html_theme_path() html_title = "%s v%s Manual" % (project, version) @@ -117,12 +118,12 @@ # Render the next and previous page links in navbar. (Default: true) "navbar_sidebarrel": False, # Render the current pages TOC in the navbar. (Default: true) - #'navbar_pagenav': True, - #'navbar_pagenav': False, + # 'navbar_pagenav': True, + # 'navbar_pagenav': False, # No sidebar "nosidebar": True, # Tab name for the current pages TOC. (Default: "Page") - #'navbar_pagenav_name': "Page", + # 'navbar_pagenav_name': "Page", # Global TOC depth for "site" navbar tab. (Default: 1) # Switching to -1 shows all levels. "globaltoc_depth": 2, @@ -136,7 +137,7 @@ "globaltoc_includehidden": "true", # HTML navbar class (Default: "navbar") to attach to
element. # For black navbar, do "navbar navbar-inverse" - #'navbar_class': "navbar navbar-inverse", + # 'navbar_class': "navbar navbar-inverse", # Fix navigation bar to top of page? # Values: "true" (default) or "false" "navbar_fixed_top": "true", @@ -154,7 +155,7 @@ # Navigation bar menu "navbar_links": [ ("Installation", "installation"), - ("Tutorials", "tutorials"), + ("User Guide", "user-guide/intro"), ("API", "api"), ("References", "references"), ], diff --git a/docs/index.rst b/docs/index.rst index 222abc75..bb8fe8e1 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -108,14 +108,19 @@ software, terms & conditions for usage, and a DISCLAIMER OF ALL WARRANTIES. +inequality +========== + +Documentation contents +---------------------- + .. toctree:: - :hidden: - :maxdepth: 4 - :caption: Contents: + :maxdepth: 1 + Home Installation - Tutorials - API + API reference + user-guide/intro References .. _PySAL: https://github.com/pysal/pysal From c3ef50fe226156459a2c3ff7e63d6b9aaee194f0 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 4 Sep 2024 07:31:05 -0700 Subject: [PATCH 06/32] doc refactor --- docs/conf.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 504c920d..ddac4fa8 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -97,7 +97,7 @@ # html_theme = 'alabaster' # html_theme = "bootstrap" html_theme = "pydata_sphinx_theme" -html_theme_path = sphinx_bootstrap_theme.get_html_theme_path() +# html_theme_path = sphinx_bootstrap_theme.get_html_theme_path() html_title = "%s v%s Manual" % (project, version) # (Optional) Logo of your package. Should be small enough to fit the navbar (ideally 24x24). @@ -106,7 +106,8 @@ # (Optional) PySAL favicon html_favicon = "_static/images/pysal_favicon.ico" - +html_logo = '_static/images/pysal_logo.png' +icon_links_label = 'inequality' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the From 0cd0d8ff9a54af66415e2816aa33be9360084e05 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 4 Sep 2024 07:39:13 -0700 Subject: [PATCH 07/32] DEV: add seaborn for dev --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 4a4aff79..02f67aa4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -56,6 +56,7 @@ tests = [ ] pen = [ "matplotlib", + "seaborn", "pandas", ] [tool.setuptools.packages.find] From 0df9cfc62d4d47ff92264d5ad51539835884f4b3 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 4 Sep 2024 09:59:32 -0700 Subject: [PATCH 08/32] links for user guide --- docs/api.rst | 8 ++++++++ inequality/atkinson.py | 2 +- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/docs/api.rst b/docs/api.rst index cea22885..de9558f6 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -25,6 +25,14 @@ Gini Inequality Measures inequality.gini.Gini inequality.gini.Gini_Spatial +Schutz Inequality Measures +-------------------------- + +.. autosummary:: + :toctree: generated/ + + inequality.schutz.Schutz + Theil Inequality Measures ------------------------- diff --git a/inequality/atkinson.py b/inequality/atkinson.py index 37230d03..5c0802ab 100644 --- a/inequality/atkinson.py +++ b/inequality/atkinson.py @@ -66,7 +66,7 @@ class Atkinson: if equally distributed, would give the same level of social welfare as the actual distribution. - See: cite: `Atkinson_1970_Measurement`. + See: :cite:`Atkinson_1970_Measurement`. Parameters ---------- From 94d614faa34f4e99ff7c188afc34d2740d944b8f Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 3 Oct 2024 14:28:08 -0700 Subject: [PATCH 09/32] pyproject.toml update --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index b9721fe5..edf86bdd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -48,6 +48,7 @@ docs = [ "sphinxcontrib-bibtex", "sphinx-gallery", "sphinx_bootstrap_theme", + "pydata-sphinx-theme" ] tests = [ "codecov", From bd33f3391444bbac35800e19fb73d46533fa0908 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 3 Oct 2024 15:36:20 -0700 Subject: [PATCH 10/32] reorg docs --- docs/user-guide/intro.rst | 12 + docs/user-guide/measure/decompositions.ipynb | 4873 +++++++++++++++++ docs/user-guide/measure/gini.ipynb | 875 +++ docs/user-guide/measure/intro.rst | 14 + docs/user-guide/measure/theil.ipynb | 848 +++ docs/user-guide/measure/wolfson.ipynb | 145 + docs/user-guide/measure/wolfson_spatial.ipynb | 3079 +++++++++++ docs/user-guide/viz/intro.rst | 11 + docs/user-guide/viz/pengram.ipynb | 641 +++ docs/user-guide/viz/schutz.ipynb | 1037 ++++ docs/user-guide/viz/weighted.cpg | 1 + docs/user-guide/viz/weighted.dbf | Bin 0 -> 43746 bytes docs/user-guide/viz/weighted.shp | Bin 0 -> 51924 bytes docs/user-guide/viz/weighted.shx | Bin 0 -> 356 bytes 14 files changed, 11536 insertions(+) create mode 100644 docs/user-guide/intro.rst create mode 100644 docs/user-guide/measure/decompositions.ipynb create mode 100644 docs/user-guide/measure/gini.ipynb create mode 100644 docs/user-guide/measure/intro.rst create mode 100644 docs/user-guide/measure/theil.ipynb create mode 100644 docs/user-guide/measure/wolfson.ipynb create mode 100644 docs/user-guide/measure/wolfson_spatial.ipynb create mode 100644 docs/user-guide/viz/intro.rst create mode 100644 docs/user-guide/viz/pengram.ipynb create mode 100644 docs/user-guide/viz/schutz.ipynb create mode 100644 docs/user-guide/viz/weighted.cpg create mode 100644 docs/user-guide/viz/weighted.dbf create mode 100644 docs/user-guide/viz/weighted.shp create mode 100644 docs/user-guide/viz/weighted.shx diff --git a/docs/user-guide/intro.rst b/docs/user-guide/intro.rst new file mode 100644 index 00000000..fbff9238 --- /dev/null +++ b/docs/user-guide/intro.rst @@ -0,0 +1,12 @@ +========== +User Guide +========== + +This user guide covers essential features of pysal-inequality, mostly in the form of interactive Jupyter notebooks. Reading this guide, you will learn: + +- how to :ref:`visualize ` spatial inequality +- how to :ref:`measure ` spatial inequality + +Notebooks cover just a small selection of functions as an illustration of +principles. For a full overview of pysal-inequality capabilities, head to the `API <../api.rst>`_. + diff --git a/docs/user-guide/measure/decompositions.ipynb b/docs/user-guide/measure/decompositions.ipynb new file mode 100644 index 00000000..44544ec3 --- /dev/null +++ b/docs/user-guide/measure/decompositions.ipynb @@ -0,0 +1,4873 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Demonstrating the Gini Coefficient:\n", + "## Spatial Inequality in Mexico: 1940-2000\n", + "\n", + "1. Imports & Input Data\n", + "2. Classic Gini Coefficient\n", + "3. Spatial Gini Coefficient\n", + "\n", + "-------------------------\n", + "\n", + "### 1. Imports & Input Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:00:59.142457Z", + "start_time": "2023-01-17T02:00:59.104306Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last updated: 2024-08-14T11:03:02.242653-07:00\n", + "\n", + "Python implementation: CPython\n", + "Python version : 3.12.4\n", + "IPython version : 8.26.0\n", + "\n", + "Compiler : GCC 12.3.0\n", + "OS : Linux\n", + "Release : 6.5.0-45-generic\n", + "Machine : x86_64\n", + "Processor : x86_64\n", + "CPU cores : 16\n", + "Architecture: 64bit\n", + "\n" + ] + } + ], + "source": [ + "%config InlineBackend.figure_format = \"retina\"\n", + "%load_ext watermark\n", + "%watermark" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.756177Z", + "start_time": "2023-01-17T02:00:59.145113Z" + } + }, + "outputs": [], + "source": [ + "import geopandas\n", + "import libpysal\n", + "import matplotlib.pyplot as plt\n", + "import numpy\n", + "\n", + "import inequality" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.770545Z", + "start_time": "2023-01-17T02:01:01.761777Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Watermark: 2.4.3\n", + "\n", + "matplotlib: 3.9.1\n", + "inequality: 0.1.dev136+gcb7fee0\n", + "geopandas : 1.0.1\n", + "numpy : 2.0.1\n", + "libpysal : 4.12.0\n", + "\n" + ] + } + ], + "source": [ + "%watermark -w\n", + "%watermark -iv" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.776633Z", + "start_time": "2023-01-17T02:01:01.772340Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mexico\n", + "======\n", + "\n", + "Decennial per capita incomes of Mexican states 1940-2000\n", + "--------------------------------------------------------\n", + "\n", + "* mexico.csv: attribute data. (n=32, k=13)\n", + "* mexico.gal: spatial weights in GAL format.\n", + "* mexicojoin.shp: Polygon shapefile. (n=32)\n", + "\n", + "Data used in Rey, S.J. and M.L. Sastre Gutierrez. (2010) \"Interregional inequality dynamics in Mexico.\" Spatial Economic Analysis, 5: 277-298.\n", + "\n" + ] + } + ], + "source": [ + "libpysal.examples.explain(\"mexico\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.962407Z", + "start_time": "2023-01-17T02:01:01.779047Z" + } + }, + "outputs": [], + "source": [ + "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", + "gdf = geopandas.read_file(pth)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.103640Z", + "start_time": "2023-01-17T02:01:01.964971Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 316, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot()\n", + "ax.set_axis_off()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.138110Z", + "start_time": "2023-01-17T02:01:02.106331Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...GR9000LPCGDP40LPCGDP50LPCGDP60LPCGDP70LPCGDP80LPCGDP90LPCGDP00TESTgeometry
017.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...0.054.354.324.254.404.474.434.481.0MULTIPOLYGON (((-113.13972 29.01778, -113.2405...
127.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...0.003.984.204.224.394.464.414.422.0MULTIPOLYGON (((-111.20612 25.80278, -111.2302...
232.731957e+10MX18Nayarit1034770.3416.750785e+062731956.8594836.07515.07621.0...-0.053.683.883.884.044.134.114.063.0MULTIPOLYGON (((-106.62108 21.56531, -106.6475...
347.961008e+10MX14Jalisco2324727.4361.967200e+077961008.2855309.08232.09953.0...0.033.733.924.004.214.324.304.334.0POLYGON ((-101.5249 21.85664, -101.5883 21.772...
455.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...0.134.023.793.944.214.324.324.445.0POLYGON ((-101.8462 22.01176, -101.9653 21.883...
\n", + "

5 rows × 35 columns

\n", + "
" + ], + "text/plain": [ + " POLY_ID AREA CODE NAME PERIMETER \\\n", + "0 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", + "1 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", + "2 3 2.731957e+10 MX18 Nayarit 1034770.341 \n", + "3 4 7.961008e+10 MX14 Jalisco 2324727.436 \n", + "4 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", + "\n", + " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... GR9000 \\\n", + "0 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 0.05 \n", + "1 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 0.00 \n", + "2 6.750785e+06 2731956.859 4836.0 7515.0 7621.0 ... -0.05 \n", + "3 1.967200e+07 7961008.285 5309.0 8232.0 9953.0 ... 0.03 \n", + "4 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 0.13 \n", + "\n", + " LPCGDP40 LPCGDP50 LPCGDP60 LPCGDP70 LPCGDP80 LPCGDP90 LPCGDP00 TEST \\\n", + "0 4.35 4.32 4.25 4.40 4.47 4.43 4.48 1.0 \n", + "1 3.98 4.20 4.22 4.39 4.46 4.41 4.42 2.0 \n", + "2 3.68 3.88 3.88 4.04 4.13 4.11 4.06 3.0 \n", + "3 3.73 3.92 4.00 4.21 4.32 4.30 4.33 4.0 \n", + "4 4.02 3.79 3.94 4.21 4.32 4.32 4.44 5.0 \n", + "\n", + " geometry \n", + "0 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", + "1 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", + "2 MULTIPOLYGON (((-106.62108 21.56531, -106.6475... \n", + "3 POLYGON ((-101.5249 21.85664, -101.5883 21.772... \n", + "4 POLYGON ((-101.8462 22.01176, -101.9653 21.883... \n", + "\n", + "[5 rows x 35 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.975365Z", + "start_time": "2023-01-17T02:01:02.141021Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 337, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot(column=\"PCGDP1940\", k=5, scheme=\"Quantiles\", legend=True)\n", + "ax.set_axis_off()\n", + "ax.set_title(\"PC GDP 1940\");\n", + "# plt.savefig(\"1940.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "------------------------------------------------\n", + "\n", + "### 2. Classic Gini Coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.985182Z", + "start_time": "2023-01-17T02:01:02.978350Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.3537237117345285)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gini_1940 = inequality.gini.Gini(gdf[\"PCGDP1940\"])\n", + "gini_1940.g" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.993505Z", + "start_time": "2023-01-17T02:01:02.988524Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "range(1940, 2010, 10)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "decades = range(1940, 2010, 10)\n", + "decades" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.010083Z", + "start_time": "2023-01-17T02:01:02.996515Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[np.float64(0.3537237117345285),\n", + " np.float64(0.29644613439022827),\n", + " np.float64(0.2537183285655905),\n", + " np.float64(0.25513356494927303),\n", + " np.float64(0.24505338049421577),\n", + " np.float64(0.25181825879538217),\n", + " np.float64(0.2581130824882791)]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", + "ginis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------------------------------------\n", + "\n", + "### 3. Spatial Gini Coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.023820Z", + "start_time": "2023-01-17T02:01:03.017957Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "inequality.gini.Gini_Spatial" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inequality.gini.Gini_Spatial" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.029897Z", + "start_time": "2023-01-17T02:01:03.026482Z" + } + }, + "outputs": [], + "source": [ + "regimes = gdf[\"HANSON98\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.038550Z", + "start_time": "2023-01-17T02:01:03.032955Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w = libpysal.weights.block_weights(regimes, silence_warnings=True)\n", + "w" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.201808Z", + "start_time": "2023-01-17T02:01:03.041647Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 337, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot(column=\"HANSON98\", categorical=True)\n", + "ax.set_title(\"Regions\")\n", + "ax.set_axis_off()\n", + "# plt.savefig(\"regions.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.234210Z", + "start_time": "2023-01-17T02:01:03.204552Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.01)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.random.seed(12345)\n", + "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], w)\n", + "gs.p_sim" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.388274Z", + "start_time": "2023-01-17T02:01:03.237277Z" + } + }, + "outputs": [], + "source": [ + "gs_all = [\n", + " inequality.gini.Gini_Spatial(gdf[\"PCGDP%s\" % decade], w) for decade in decades\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.396504Z", + "start_time": "2023-01-17T02:01:03.391373Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[np.float64(0.04),\n", + " np.float64(0.01),\n", + " np.float64(0.01),\n", + " np.float64(0.01),\n", + " np.float64(0.02),\n", + " np.float64(0.01),\n", + " np.float64(0.01)]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_values = [gs.p_sim for gs in gs_all]\n", + "p_values" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.404200Z", + "start_time": "2023-01-17T02:01:03.399458Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[np.float64(0.2940179879590452),\n", + " np.float64(0.24885041274552472),\n", + " np.float64(0.21715641601961586),\n", + " np.float64(0.2212882581200239),\n", + " np.float64(0.20702733316567423),\n", + " np.float64(0.21270360014540865),\n", + " np.float64(0.2190953550725723)]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wgs = [gs.wcg_share for gs in gs_all]\n", + "wgs" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.412352Z", + "start_time": "2023-01-17T02:01:03.407034Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[np.float64(0.7059820120409548),\n", + " np.float64(0.7511495872544753),\n", + " np.float64(0.7828435839803841),\n", + " np.float64(0.778711741879976),\n", + " np.float64(0.7929726668343258),\n", + " np.float64(0.7872963998545913),\n", + " np.float64(0.7809046449274277)]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bgs = [1 - wg for wg in wgs]\n", + "bgs" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.419153Z", + "start_time": "2023-01-17T02:01:03.414765Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1940, 1950, 1960, 1970, 1980, 1990, 2000])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "years = numpy.array(decades)\n", + "years" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.733573Z", + "start_time": "2023-01-17T02:01:03.421484Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 469, + "width": 629 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots()\n", + "t = years\n", + "s1 = ginis\n", + "ax1.plot(t, s1, \"b-\")\n", + "ax1.set_xlabel(\"Year\")\n", + "# Make the y-axis label, ticks and tick labels match the line color.\n", + "ax1.set_ylabel(\"Gini\", color=\"b\")\n", + "ax1.tick_params(\"y\", colors=\"b\")\n", + "\n", + "ax2 = ax1.twinx()\n", + "s2 = bgs\n", + "ax2.plot(t, s2, \"r-.\")\n", + "ax2.set_ylabel(\"Spatial Inequality Share\", color=\"r\")\n", + "ax2.tick_params(\"y\", colors=\"r\")\n", + "\n", + "fig.tight_layout()\n", + "\n", + "# plt.savefig(\"share.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "-----------------------" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "\n", + "def cv_decomp(df, column, group):\n", + " y = df[column]\n", + " groups = df[group]\n", + " std = df[[column, group]].groupby(by=group).std(ddof=0)\n", + " ybar = df[[column, group]].groupby(by=group).mean()\n", + " n_g = df[[column, group]].groupby(by=group).count()\n", + " Y_bar = y.mean()\n", + " cv = y.std(ddof=0) / Y_bar\n", + "\n", + "\n", + " res = pd.concat([std, ybar, n_g], axis=1)\n", + " res.columns = ['s', 'ybar', 'n']\n", + " res['lam'] = res.n / res.n.sum()\n", + " res['b'] = res.ybar / df[column].mean()\n", + " res['omega'] = res.lam * res.b**2\n", + " res['y_dev'] = res.ybar - Y_bar\n", + " res['cv'] = res.s / res.ybar\n", + "\n", + " # Rosenbluth\n", + " V = cv\n", + " V2 = V * V\n", + " r_within = (res.cv * res.cv * res.ybar * res.ybar * res.n).sum()\n", + " r_between = (res.n * res.y_dev * res.y_dev).sum()\n", + " den = df.shape[0] * Y_bar * Y_bar\n", + " r_within /= den\n", + " r_between /= den\n", + " V2r = r_within + r_between\n", + " print(f'V2: {V2}, within: {r_within}, between: {r_between}, V2r: {V2r}')\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " return V*V, r_between, r_within, V2r" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "V2: 0.5020013737145368, within: 0.4286865118397805, between: 0.0733148618747563, V2r: 0.5020013737145368\n" + ] + }, + { + "data": { + "text/plain": [ + "(np.float64(0.5020013737145368),\n", + " np.float64(0.0733148618747563),\n", + " np.float64(0.4286865118397805),\n", + " np.float64(0.5020013737145368))" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cv_decomp(gdf, 'PCGDP1940', 'HANSON98')" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "y = gdf['PCGDP1940']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "def vol_decomp(df, column, group):\n", + " def gmean(values):\n", + " return np.prod(values)**(1/len(values))\n", + "\n", + " y = df[column]\n", + " n = df.shape[0]\n", + " df['ly'] = np.log(y)\n", + "\n", + "\n", + " Gmean = gmean(df.ly)\n", + "\n", + " grouped = df[['ly', group]].groupby(group)\n", + " Gmeans = grouped['ly'].apply(gmean)\n", + " diff = np.log(Gmeans) - np.log(Gmean)\n", + " diff2 = diff * diff\n", + " lam = df[['ly', group]].groupby(by=group).count() / n\n", + " between = (diff2.values * lam.values).sum()\n", + "\n", + "\n", + " group_var = df[['ly', group]].groupby(by=group).std(ddof=0)**2\n", + " within = (group_var.values * lam.values).sum()\n", + "\n", + "\n", + "\n", + " print(Gmean,Gmeans, diff2, lam, between, within, df['ly'].var(ddof=0))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8.66124720968162 HANSON98\n", + "1.0 9.145681\n", + "2.0 8.759428\n", + "3.0 8.530656\n", + "4.0 8.922624\n", + "5.0 8.282520\n", + "Name: ly, dtype: float64 HANSON98\n", + "1.0 0.002962\n", + "2.0 0.000127\n", + "3.0 0.000231\n", + "4.0 0.000884\n", + "5.0 0.001999\n", + "Name: ly, dtype: float64 ly\n", + "HANSON98 \n", + "1.0 0.18750\n", + "2.0 0.21875\n", + "3.0 0.31250\n", + "4.0 0.06250\n", + "5.0 0.21875 0.0062028008997258 0.3009515466471512 0.3845017425430747\n" + ] + } + ], + "source": [ + "vol_decomp(gdf, 'PCGDP1940', 'HANSON98')" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def pyatt_decomp(df, column, group):\n", + " df_short = df[[column, group]]\n", + " group_y = df_short.groupby(by=group).sum()\n", + " theta = group_y.values / group_y.values.sum()\n", + " M = df_short.groupby(by=group).mean()\n", + " group_n = df_short.groupby(by=group).count()\n", + " lam = group_n.values / df_short.shape[0]\n", + "\n", + " return group, theta, M, lam\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('HANSON98',\n", + " array([[0.26993176],\n", + " [0.21554001],\n", + " [0.23618164],\n", + " [0.09172908],\n", + " [0.18661751]]),\n", + " PCGDP1940\n", + " HANSON98 \n", + " 1.0 10409.333333\n", + " 2.0 7124.428571\n", + " 3.0 5464.700000\n", + " 4.0 10612.000000\n", + " 5.0 6168.428571,\n", + " array([[0.1875 ],\n", + " [0.21875],\n", + " [0.3125 ],\n", + " [0.0625 ],\n", + " [0.21875]]))" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pyatt_decomp(gdf, 'PCGDP1940', 'HANSON98')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "dfs = gdf[['PCGDP1940', 'HANSON98']]" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PCGDP1940
HANSON98
1.010409.333333
2.07124.428571
3.05464.700000
4.010612.000000
5.06168.428571
\n", + "
" + ], + "text/plain": [ + " PCGDP1940\n", + "HANSON98 \n", + "1.0 10409.333333\n", + "2.0 7124.428571\n", + "3.0 5464.700000\n", + "4.0 10612.000000\n", + "5.0 6168.428571" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs.groupby(by='HANSON98').mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PCGDP1940HANSON98
022361.01.0
19573.02.0
24836.02.0
35309.03.0
410384.02.0
54359.03.0
611016.03.0
74414.03.0
83327.03.0
93408.04.0
1017816.04.0
116909.03.0
126936.03.0
137990.05.0
143758.05.0
153569.03.0
1621965.05.0
173605.03.0
182181.05.0
191892.05.0
202459.05.0
212934.05.0
226399.01.0
238578.01.0
248537.01.0
254840.02.0
2612132.02.0
273734.02.0
284372.02.0
299073.01.0
307508.01.0
315203.03.0
\n", + "
" + ], + "text/plain": [ + " PCGDP1940 HANSON98\n", + "0 22361.0 1.0\n", + "1 9573.0 2.0\n", + "2 4836.0 2.0\n", + "3 5309.0 3.0\n", + "4 10384.0 2.0\n", + "5 4359.0 3.0\n", + "6 11016.0 3.0\n", + "7 4414.0 3.0\n", + "8 3327.0 3.0\n", + "9 3408.0 4.0\n", + "10 17816.0 4.0\n", + "11 6909.0 3.0\n", + "12 6936.0 3.0\n", + "13 7990.0 5.0\n", + "14 3758.0 5.0\n", + "15 3569.0 3.0\n", + "16 21965.0 5.0\n", + "17 3605.0 3.0\n", + "18 2181.0 5.0\n", + "19 1892.0 5.0\n", + "20 2459.0 5.0\n", + "21 2934.0 5.0\n", + "22 6399.0 1.0\n", + "23 8578.0 1.0\n", + "24 8537.0 1.0\n", + "25 4840.0 2.0\n", + "26 12132.0 2.0\n", + "27 3734.0 2.0\n", + "28 4372.0 2.0\n", + "29 9073.0 1.0\n", + "30 7508.0 1.0\n", + "31 5203.0 3.0" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "groups = dfs.HANSON98.unique()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 2., 3., 4., 5.])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "groups" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "y1 = dfs[dfs.HANSON98==1.0].PCGDP1940.values" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "y2 = dfs[dfs.HANSON98==2.0].PCGDP1940.values" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([22361., 6399., 8578., 8537., 9073., 7508.])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y1" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 9573., 4836., 10384., 4840., 12132., 3734., 4372.])" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y2" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([12788., 17525., 11977., 17521., 10229., 18627., 17989.])" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y1[0] - y2" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "d = y1[:, np.newaxis] - y2" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[12788., 17525., 11977., 17521., 10229., 18627., 17989.],\n", + " [ 0., 1563., 0., 1559., 0., 2665., 2027.],\n", + " [ 0., 3742., 0., 3738., 0., 4844., 4206.],\n", + " [ 0., 3701., 0., 3697., 0., 4803., 4165.],\n", + " [ 0., 4237., 0., 4233., 0., 5339., 4701.],\n", + " [ 0., 2672., 0., 2668., 0., 3774., 3136.]])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.where(d <0 ,0, d)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(3284.904761904762)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "d12 = y1[:, np.newaxis] - y2" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "d21 = y2[:, np.newaxis] - y1" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[12788., 17525., 11977., 17521., 10229., 18627., 17989.],\n", + " [-3174., 1563., -3985., 1559., -5733., 2665., 2027.],\n", + " [ -995., 3742., -1806., 3738., -3554., 4844., 4206.],\n", + " [-1036., 3701., -1847., 3697., -3595., 4803., 4165.],\n", + " [ -500., 4237., -1311., 4233., -3059., 5339., 4701.],\n", + " [-2065., 2672., -2876., 2668., -4624., 3774., 3136.]])" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d12\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-12788., 3174., 995., 1036., 500., 2065.],\n", + " [-17525., -1563., -3742., -3701., -4237., -2672.],\n", + " [-11977., 3985., 1806., 1847., 1311., 2876.],\n", + " [-17521., -1559., -3738., -3697., -4233., -2668.],\n", + " [-10229., 5733., 3554., 3595., 3059., 4624.],\n", + " [-18627., -2665., -4844., -4803., -5339., -3774.],\n", + " [-17989., -2027., -4206., -4165., -4701., -3136.]])" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d21" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(956.1904761904761)" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.where(d21 < 0, 0, d21).mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "import itertools\n", + "\n", + "\n", + "def E(df, column, group):\n", + " y = df[[column, group]]\n", + " groups = df[group].unique()\n", + " k = groups.shape[0]\n", + " E = np.zeros((k,k))\n", + " for pair in itertools.permutations(groups, 2):\n", + " row, col= (np.where(groups == c)[0] for c in pair)\n", + " i, j = pair\n", + "\n", + " yi = y[y[group]==i][column].values\n", + " yj = y[y[group]==j][column].values\n", + " dij = yi[:, np.newaxis] - yj\n", + " E[row, col] = np.where(dij < 0, 0, dij).mean()\n", + " dij *= -1\n", + " E[col, row] = np.where(dij < 0, 0, dij).mean()\n", + " for j in groups:\n", + " i = np.where(groups == j)[0]\n", + " yi = y[y[group]==j][column].values\n", + "\n", + " dii = yi[:, np.newaxis] - yi\n", + "\n", + " E[i, i] = np.where(dii < 0, 0, dii).mean()\n", + " return E\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "e = E(gdf, 'PCGDP1940', 'HANSON98')" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2348.5 , 4241.0952381 , 5211.83333333, 3879.41666667,\n", + " 5950.5 ],\n", + " [ 956.19047619, 1712.44897959, 2459.78571429, 1858.21428571,\n", + " 3365.91836735],\n", + " [ 267.2 , 800.05714286, 1129.29 , 1032.4 ,\n", + " 2068.48571429],\n", + " [4082.08333333, 5345.78571429, 6179.7 , 3602. ,\n", + " 6417.71428571],\n", + " [1709.5952381 , 2409.91836735, 2772.21428571, 1974.14285714,\n", + " 2985.14285714]])" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "e" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "y = np.array([10, 20, 30, 80])" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "d =y[:, np.newaxis] - y" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, -10, -20, -70],\n", + " [ 10, 0, -10, -60],\n", + " [ 20, 10, 0, -50],\n", + " [ 70, 60, 50, 0]])" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(13.75)" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.where(d < 0, 0, d).mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$G = (m'p)^{-1} p'Ep$" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "def pyatt_decomp(df, column, group):\n", + " y = df[[column, group]]\n", + " groups = df[group].unique()\n", + " k = groups.shape[0]\n", + " E = np.zeros((k,k))\n", + " for pair in itertools.permutations(groups, 2):\n", + " row, col= (np.where(groups == c)[0] for c in pair)\n", + " i, j = pair\n", + "\n", + " yi = y[y[group]==i][column].values\n", + " yj = y[y[group]==j][column].values\n", + " dij = yi[:, np.newaxis] - yj\n", + " E[row, col] = np.where(dij < 0, 0, dij).mean()\n", + " dij *= -1\n", + " E[col, row] = np.where(dij < 0, 0, dij).mean()\n", + " for j in groups:\n", + " i = np.where(groups == j)[0]\n", + " yi = y[y[group]==j][column].values\n", + "\n", + " dii = yi[:, np.newaxis] - yi\n", + "\n", + " E[i, i] = np.where(dii < 0, 0, dii).mean()\n", + "\n", + " p = y.groupby(by=group).count() / y.shape[0]\n", + " m = y.groupby(by=group).mean()\n", + " G = (p.values * m.values).sum()\n", + " res = {}\n", + " res['p'] = p.values\n", + " res['m'] = m.values\n", + " res['E'] = E\n", + " return res\n", + "\n", + "res = pyatt_decomp(gdf, 'PCGDP1940', 'HANSON98')" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "m = res['m']\n", + "p = res['p']\n", + "E = res['E']" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(7230.53125)" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(m*p).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.1875 ],\n", + " [0.21875],\n", + " [0.3125 ],\n", + " [0.0625 ],\n", + " [0.21875]])" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.1875 , 0.21875, 0.3125 , 0.0625 , 0.21875]])" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p.T\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.35372371]])" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.dot(np.dot(p.T, E), p)/ (m*p).sum() # Gini" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "from inequality.gini import Gini" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.3537237117345285)" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Gini(gdf.PCGDP1940).g" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'0.1.dev136+gcb7fee0'" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inequality.__version__" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "import libpysal" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'4.12.0'" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "libpysal.__version__" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overlap" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PCGDP1940HANSON98
022361.01.0
19573.02.0
24836.02.0
35309.03.0
410384.02.0
54359.03.0
611016.03.0
74414.03.0
83327.03.0
93408.04.0
1017816.04.0
116909.03.0
126936.03.0
137990.05.0
143758.05.0
153569.03.0
1621965.05.0
173605.03.0
182181.05.0
191892.05.0
202459.05.0
212934.05.0
226399.01.0
238578.01.0
248537.01.0
254840.02.0
2612132.02.0
273734.02.0
284372.02.0
299073.01.0
307508.01.0
315203.03.0
\n", + "
" + ], + "text/plain": [ + " PCGDP1940 HANSON98\n", + "0 22361.0 1.0\n", + "1 9573.0 2.0\n", + "2 4836.0 2.0\n", + "3 5309.0 3.0\n", + "4 10384.0 2.0\n", + "5 4359.0 3.0\n", + "6 11016.0 3.0\n", + "7 4414.0 3.0\n", + "8 3327.0 3.0\n", + "9 3408.0 4.0\n", + "10 17816.0 4.0\n", + "11 6909.0 3.0\n", + "12 6936.0 3.0\n", + "13 7990.0 5.0\n", + "14 3758.0 5.0\n", + "15 3569.0 3.0\n", + "16 21965.0 5.0\n", + "17 3605.0 3.0\n", + "18 2181.0 5.0\n", + "19 1892.0 5.0\n", + "20 2459.0 5.0\n", + "21 2934.0 5.0\n", + "22 6399.0 1.0\n", + "23 8578.0 1.0\n", + "24 8537.0 1.0\n", + "25 4840.0 2.0\n", + "26 12132.0 2.0\n", + "27 3734.0 2.0\n", + "28 4372.0 2.0\n", + "29 9073.0 1.0\n", + "30 7508.0 1.0\n", + "31 5203.0 3.0" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "def overlapping(dfs, column, group, group_a, group_b):\n", + " a = dfs[dfs[group] == group_a]\n", + " b = dfs[dfs[group] == group_b]\n", + " a_min = a[column].min()\n", + " a_max = a[column].max()\n", + " b_min = b[column].min()\n", + " b_max = b[column].max()\n", + " print(a_min, a_max)\n", + " print(b_min, b_max)\n", + "\n", + " if a_min > b_max:\n", + " return False\n", + " if b_min > a_max:\n", + " return False\n", + " if a_min >= b_min:\n", + " return True\n", + " if b_min >= a_min:\n", + " return True\n", + " return False\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6399.0 22361.0\n", + "3734.0 12132.0\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "overlapping(dfs, 'PCGDP1940', 'HANSON98', 1.0, 2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6399.0 22361.0\n", + "3734.0 12132.0\n", + "1 2 True\n", + "6399.0 22361.0\n", + "3327.0 11016.0\n", + "1 3 True\n", + "6399.0 22361.0\n", + "3408.0 17816.0\n", + "1 4 True\n", + "6399.0 22361.0\n", + "1892.0 21965.0\n", + "1 5 True\n", + "3734.0 12132.0\n", + "3327.0 11016.0\n", + "2 3 True\n", + "3734.0 12132.0\n", + "3408.0 17816.0\n", + "2 4 True\n", + "3734.0 12132.0\n", + "1892.0 21965.0\n", + "2 5 True\n", + "3327.0 11016.0\n", + "3408.0 17816.0\n", + "3 4 True\n", + "3327.0 11016.0\n", + "1892.0 21965.0\n", + "3 5 True\n", + "3408.0 17816.0\n", + "1892.0 21965.0\n", + "4 5 True\n" + ] + } + ], + "source": [ + "for i in range(1, 5):\n", + " for j in range(i+1, 6):\n", + " res = overlapping(dfs, 'PCGDP1940', 'HANSON98', i*1.0, j*1.0)\n", + " print(i,j, res)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ordering the groups" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PCGDP1940
HANSON98
1.06399.0
2.03734.0
3.03327.0
4.03408.0
5.01892.0
\n", + "
" + ], + "text/plain": [ + " PCGDP1940\n", + "HANSON98 \n", + "1.0 6399.0\n", + "2.0 3734.0\n", + "3.0 3327.0\n", + "4.0 3408.0\n", + "5.0 1892.0" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs.groupby(by='HANSON98').min()" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PCGDP1940
HANSON98
1.022361.0
2.012132.0
3.011016.0
4.017816.0
5.021965.0
\n", + "
" + ], + "text/plain": [ + " PCGDP1940\n", + "HANSON98 \n", + "1.0 22361.0\n", + "2.0 12132.0\n", + "3.0 11016.0\n", + "4.0 17816.0\n", + "5.0 21965.0" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs.groupby(by='HANSON98').max()" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PCGDP1940
HANSON98
1.08557.5
2.04840.0
3.04808.5
4.010612.0
5.02934.0
\n", + "
" + ], + "text/plain": [ + " PCGDP1940\n", + "HANSON98 \n", + "1.0 8557.5\n", + "2.0 4840.0\n", + "3.0 4808.5\n", + "4.0 10612.0\n", + "5.0 2934.0" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs.groupby(by='HANSON98').median()" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " region_pair abs_deviation\n", + "0 (A, A) 10000\n", + "1 (A, B) 40000\n", + "2 (A, C) 20000\n", + "3 (B, B) 15000\n", + "4 (B, C) 15000\n" + ] + } + ], + "source": [ + "# Example DataFrame\n", + "data = {\n", + " 'income': [50000, 60000, 55000, 70000, 65000],\n", + " 'region': ['A', 'A', 'B', 'B', 'C']\n", + "}\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Create all possible pairs of observations (including those within the same region)\n", + "pairs = list(itertools.combinations(df.index, 2))\n", + "\n", + "# Calculate the absolute deviations and region pairs\n", + "deviation_data = []\n", + "\n", + "for i, j in pairs:\n", + " income_i = df.loc[i, 'income']\n", + " income_j = df.loc[j, 'income']\n", + " region_i = df.loc[i, 'region']\n", + " region_j = df.loc[j, 'region']\n", + " abs_deviation = abs(income_i - income_j)\n", + " deviation_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + "# Create a DataFrame from the deviation data\n", + "deviation_df = pd.DataFrame(deviation_data)\n", + "\n", + "# Sum the absolute deviations grouped by region pairs (including own region pairs)\n", + "result = deviation_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "\n", + "\n", + "# Display the result\n", + "print(result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " region_pair abs_deviation\n", + "0 (A, A) 8000\n", + "1 (A, B) 29000\n", + "2 (A, C) 270000\n", + "3 (B, B) 8000\n", + "4 (B, C) 243000\n", + "5 (C, C) 8000\n" + ] + } + ], + "source": [ + "import itertools\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create a DataFrame with three regions and overlapping/non-overlapping income ranges\n", + "data = {\n", + " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", + " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", + "}\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Create all possible pairs of observations (including those within the same region)\n", + "pairs = list(itertools.combinations(df.index, 2))\n", + "\n", + "# Calculate the absolute deviations and region pairs\n", + "deviation_data = []\n", + "\n", + "for i, j in pairs:\n", + " income_i = df.loc[i, 'income']\n", + " income_j = df.loc[j, 'income']\n", + " region_i = df.loc[i, 'region']\n", + " region_j = df.loc[j, 'region']\n", + " abs_deviation = abs(income_i - income_j)\n", + " deviation_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + "# Create a DataFrame from the deviation data\n", + "deviation_df = pd.DataFrame(deviation_data)\n", + "\n", + "# Sum the absolute deviations grouped by region pairs (including own region pairs)\n", + "result = deviation_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "\n", + "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Sum of Absolute Deviations by Region Pairs (Including Own Region Pairs)\", dataframe=result)\n", + "\n", + "# Display the result\n", + "print(result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
income
region
A50000
B53000
C80000
\n", + "
" + ], + "text/plain": [ + " income\n", + "region \n", + "A 50000\n", + "B 53000\n", + "C 80000" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby('region').min()" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
minmax
region
A5000054000
B5300057000
C8000084000
\n", + "
" + ], + "text/plain": [ + " min max\n", + "region \n", + "A 50000 54000\n", + "B 53000 57000\n", + "C 80000 84000" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby('region')['income'].agg(['min', 'max'])" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All Absolute Deviations\n", + " region_pair abs_deviation\n", + "0 (A, B) 20000\n", + "1 (A, C) 270000\n", + "2 (B, C) 243000\n", + "Non-Overlapping Absolute Deviations:\n", + " region_pair abs_deviation\n", + "0 (A, B) 20000\n", + "1 (A, C) 270000\n", + "2 (B, C) 243000\n", + "\n", + "Overlapping Absolute Deviations:\n", + " region_pair abs_deviation\n", + "0 (A, A) 8000\n", + "1 (A, B) 9000\n", + "2 (B, B) 8000\n", + "3 (C, C) 8000\n" + ] + } + ], + "source": [ + "import itertools\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", + "data = {\n", + " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", + " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", + "}\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Calculate the range of incomes for each region\n", + "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", + "income_range['range'] = income_range['max'] - income_range['min']\n", + "\n", + "# Create all possible pairs of observations (including those within the same region)\n", + "pairs = list(itertools.combinations(df.index, 2))\n", + "\n", + "# Initialize accumulators\n", + "non_overlapping_data = []\n", + "overlapping_data = []\n", + "all_data = []\n", + "# Calculate the absolute deviations and classify them\n", + "for i, j in pairs:\n", + " income_i = df.loc[i, 'income']\n", + " income_j = df.loc[j, 'income']\n", + " region_i = df.loc[i, 'region']\n", + " region_j = df.loc[j, 'region']\n", + " abs_deviation = abs(income_i - income_j)\n", + "\n", + " range_i_min = income_range.loc[region_i, 'min']\n", + " range_i_max = income_range.loc[region_i, 'max']\n", + " range_j_min = income_range.loc[region_j, 'min']\n", + " range_j_max = income_range.loc[region_j, 'max']\n", + "\n", + " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", + " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + " else:\n", + " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + "# Create DataFrames from the deviation data\n", + "all_df = pd.DataFrame(all_data)\n", + "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", + "overlapping_df = pd.DataFrame(overlapping_data)\n", + "\n", + "# Sum the absolute deviations grouped by region pairs\n", + "all_data_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "\n", + "\n", + "# Display the results\n", + "print(\"All Absolute Deviations\")\n", + "print(all_data_result)\n", + "print(\"Non-Overlapping Absolute Deviations:\")\n", + "print(non_overlapping_result)\n", + "print(\"\\nOverlapping Absolute Deviations:\")\n", + "print(overlapping_result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " region_pair abs_deviation\n", + "0 (A, A) 8000\n", + "1 (A, B) 29000\n", + "2 (A, C) 270000\n", + "3 (B, B) 8000\n", + "4 (B, C) 243000\n", + "5 (C, C) 8000\n", + " region_pair abs_deviation\n", + "0 (A, B) 20000\n", + "1 (A, C) 270000\n", + "2 (B, C) 243000\n", + " region_pair abs_deviation\n", + "0 (A, A) 8000\n", + "1 (A, B) 9000\n", + "2 (B, B) 8000\n", + "3 (C, C) 8000\n" + ] + } + ], + "source": [ + "import itertools\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", + "data = {\n", + " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", + " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", + "}\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Calculate the range of incomes for each region\n", + "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", + "income_range['range'] = income_range['max'] - income_range['min']\n", + "\n", + "# Create all possible pairs of observations (including those within the same region)\n", + "pairs = list(itertools.combinations(df.index, 2))\n", + "\n", + "# Initialize accumulators\n", + "non_overlapping_data = []\n", + "overlapping_data = []\n", + "all_data = []\n", + "\n", + "# Calculate the absolute deviations and classify them\n", + "for i, j in pairs:\n", + " income_i = df.loc[i, 'income']\n", + " income_j = df.loc[j, 'income']\n", + " region_i = df.loc[i, 'region']\n", + " region_j = df.loc[j, 'region']\n", + " abs_deviation = abs(income_i - income_j)\n", + "\n", + " range_i_min = income_range.loc[region_i, 'min']\n", + " range_i_max = income_range.loc[region_i, 'max']\n", + " range_j_min = income_range.loc[region_j, 'min']\n", + " range_j_max = income_range.loc[region_j, 'max']\n", + "\n", + " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", + " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + " else:\n", + " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + "# Create DataFrames from the deviation data\n", + "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", + "overlapping_df = pd.DataFrame(overlapping_data)\n", + "all_data_df = pd.DataFrame(all_data)\n", + "\n", + "# Sum the absolute deviations grouped by region pairs\n", + "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "all_data_result = all_data_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "import itertools\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", + "data = {\n", + " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", + " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", + "}\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Calculate the range of incomes for each region\n", + "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", + "income_range['range'] = income_range['max'] - income_range['min']\n", + "\n", + "# Create all possible pairs of observations (including those within the same region)\n", + "pairs = list(itertools.combinations(df.index, 2))\n", + "\n", + "# Initialize accumulators\n", + "non_overlapping_data = []\n", + "overlapping_data = []\n", + "all_data = []\n", + "\n", + "# Calculate the absolute deviations and classify them\n", + "for i, j in pairs:\n", + " income_i = df.loc[i, 'income']\n", + " income_j = df.loc[j, 'income']\n", + " region_i = df.loc[i, 'region']\n", + " region_j = df.loc[j, 'region']\n", + " abs_deviation = abs(income_i - income_j)\n", + "\n", + " range_i_min = income_range.loc[region_i, 'min']\n", + " range_i_max = income_range.loc[region_i, 'max']\n", + " range_j_min = income_range.loc[region_j, 'min']\n", + " range_j_max = income_range.loc[region_j, 'max']\n", + "\n", + " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", + " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + " else:\n", + " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + "# Create DataFrames from the deviation data\n", + "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", + "overlapping_df = pd.DataFrame(overlapping_data)\n", + "all_data_df = pd.DataFrame(all_data)\n", + "\n", + "# Sum the absolute deviations grouped by region pairs\n", + "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "all_data_result = all_data_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", + "\n", + "print(all_data_result)\n", + "print(non_overlapping_result)\n", + "print(overlapping_result)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Non-Overlapping Absolute Deviations:\n", + " region_pair sum count\n", + "0 (A, B) 20000 4\n", + "1 (A, C) 270000 9\n", + "2 (B, C) 243000 9\n", + "\n", + "Overlapping Absolute Deviations:\n", + " region_pair sum count\n", + "0 (A, A) 8000 3\n", + "1 (A, B) 9000 5\n", + "2 (B, B) 8000 3\n", + "3 (C, C) 8000 3\n", + "\n", + "All Absolute Deviations:\n", + " region_pair sum count\n", + "0 (A, A) 8000 3\n", + "1 (A, B) 29000 9\n", + "2 (A, C) 270000 9\n", + "3 (B, B) 8000 3\n", + "4 (B, C) 243000 9\n", + "5 (C, C) 8000 3\n" + ] + } + ], + "source": [ + "import itertools\n", + "\n", + "import pandas as pd\n", + "\n", + "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", + "data = {\n", + " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", + " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", + "}\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Calculate the range of incomes for each region\n", + "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", + "income_range['range'] = income_range['max'] - income_range['min']\n", + "\n", + "# Create all possible pairs of observations (including those within the same region)\n", + "pairs = list(itertools.combinations(df.index, 2))\n", + "\n", + "# Initialize accumulators\n", + "non_overlapping_data = []\n", + "overlapping_data = []\n", + "all_data = []\n", + "\n", + "# Calculate the absolute deviations and classify them\n", + "for i, j in pairs:\n", + " income_i = df.loc[i, 'income']\n", + " income_j = df.loc[j, 'income']\n", + " region_i = df.loc[i, 'region']\n", + " region_j = df.loc[j, 'region']\n", + " abs_deviation = abs(income_i - income_j)\n", + "\n", + " range_i_min = income_range.loc[region_i, 'min']\n", + " range_i_max = income_range.loc[region_i, 'max']\n", + " range_j_min = income_range.loc[region_j, 'min']\n", + " range_j_max = income_range.loc[region_j, 'max']\n", + "\n", + " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", + " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + " else:\n", + " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + "# Create DataFrames from the deviation data\n", + "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", + "overlapping_df = pd.DataFrame(overlapping_data)\n", + "all_data_df = pd.DataFrame(all_data)\n", + "\n", + "# Sum the absolute deviations and count the number of pairs grouped by region pairs\n", + "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", + "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", + "all_data_result = all_data_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", + "\n", + "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Non-Overlapping Absolute Deviations by Region Pairs\", dataframe=non_overlapping_result)\n", + "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Overlapping Absolute Deviations by Region Pairs\", dataframe=overlapping_result)\n", + "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"All Absolute Deviations by Region Pairs\", dataframe=all_data_result)\n", + "\n", + "# Display the results\n", + "print(\"Non-Overlapping Absolute Deviations:\")\n", + "print(non_overlapping_result)\n", + "print(\"\\nOverlapping Absolute Deviations:\")\n", + "print(overlapping_result)\n", + "print(\"\\nAll Absolute Deviations:\")\n", + "print(all_data_result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3222.222222222222" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "29000/9 # MAD A,B" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3222.222222222222" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "5/9 * 9000/5 + 4/9 * 20000/4 # weight average MAD A,B overlapping and non overlapping" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1800.0, 5000.0)" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "9000/5, 20000/4 # MAD AB overlapping, MAD AB nonoverlapping" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.11091514795218499)" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inequality.gini.Gini(df.income).g" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(63000.0), 9)" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mu = df.income.mean()\n", + "n = df.shape[0]\n", + "mu,n" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
region_pairsumcount
0(A, A)80003
1(A, B)290009
2(A, C)2700009
3(B, B)80003
4(B, C)2430009
5(C, C)80003
\n", + "
" + ], + "text/plain": [ + " region_pair sum count\n", + "0 (A, A) 8000 3\n", + "1 (A, B) 29000 9\n", + "2 (A, C) 270000 9\n", + "3 (B, B) 8000 3\n", + "4 (B, C) 243000 9\n", + "5 (C, C) 8000 3" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_result" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.11091514795218499)" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_result['sum'].sum() / (mu *n**2) # gini" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(566000)" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_result['sum'].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(566000)" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "non_overlapping_result['sum'].sum() + overlapping_result['sum'].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Non-Overlapping Absolute Deviations:\n", + " region_pair sum count\n", + "0 (A, B) 20000 4\n", + "1 (A, C) 270000 9\n", + "2 (B, C) 243000 9\n", + "\n", + "Overlapping Absolute Deviations:\n", + " region_pair sum count\n", + "0 (A, A) 8000 3\n", + "1 (A, B) 9000 5\n", + "2 (B, B) 8000 3\n", + "3 (C, C) 8000 3\n", + "\n", + "All Absolute Deviations:\n", + " region_pair sum count\n", + "0 (A, A) 8000 3\n", + "1 (A, B) 29000 9\n", + "2 (A, C) 270000 9\n", + "3 (B, B) 8000 3\n", + "4 (B, C) 243000 9\n", + "5 (C, C) 8000 3\n", + "region_pair (A, A)\n", + "sum 8000\n", + "count 3\n", + "Name: 0, dtype: object\n", + "region_pair (A, B)\n", + "sum 9000\n", + "count 5\n", + "Name: 1, dtype: object\n", + "region_pair (B, B)\n", + "sum 8000\n", + "count 3\n", + "Name: 2, dtype: object\n", + "region_pair (C, C)\n", + "sum 8000\n", + "count 3\n", + "Name: 3, dtype: object\n", + "\n", + " AD Sum Matrix:\n", + "[[ 8000. 20000. 270000.]\n", + " [ 9000. 8000. 243000.]\n", + " [ 0. 0. 8000.]]\n", + "\n", + " AD Pairs Matrix:\n", + "[[3. 4. 9.]\n", + " [5. 3. 9.]\n", + " [0. 0. 3.]]\n" + ] + } + ], + "source": [ + "import itertools\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", + "data = {\n", + " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", + " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", + "}\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Calculate the range of incomes for each region\n", + "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", + "income_range['range'] = income_range['max'] - income_range['min']\n", + "\n", + "# Create all possible pairs of observations (including those within the same region)\n", + "pairs = list(itertools.combinations(df.index, 2))\n", + "\n", + "# Initialize accumulators\n", + "non_overlapping_data = []\n", + "overlapping_data = []\n", + "all_data = []\n", + "\n", + "# Calculate the absolute deviations and classify them\n", + "for i, j in pairs:\n", + " income_i = df.loc[i, 'income']\n", + " income_j = df.loc[j, 'income']\n", + " region_i = df.loc[i, 'region']\n", + " region_j = df.loc[j, 'region']\n", + " abs_deviation = abs(income_i - income_j)\n", + "\n", + " range_i_min = income_range.loc[region_i, 'min']\n", + " range_i_max = income_range.loc[region_i, 'max']\n", + " range_j_min = income_range.loc[region_j, 'min']\n", + " range_j_max = income_range.loc[region_j, 'max']\n", + "\n", + " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", + " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + " else:\n", + " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", + "\n", + "# Create DataFrames from the deviation data\n", + "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", + "overlapping_df = pd.DataFrame(overlapping_data)\n", + "all_data_df = pd.DataFrame(all_data)\n", + "\n", + "# Sum the absolute deviations and count the number of pairs grouped by region pairs\n", + "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", + "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", + "all_data_result = all_data_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", + "\n", + "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Non-Overlapping Absolute Deviations by Region Pairs\", dataframe=non_overlapping_result)\n", + "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Overlapping Absolute Deviations by Region Pairs\", dataframe=overlapping_result)\n", + "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"All Absolute Deviations by Region Pairs\", dataframe=all_data_result)\n", + "\n", + "# Display the results\n", + "print(\"Non-Overlapping Absolute Deviations:\")\n", + "print(non_overlapping_result)\n", + "print(\"\\nOverlapping Absolute Deviations:\")\n", + "print(overlapping_result)\n", + "print(\"\\nAll Absolute Deviations:\")\n", + "print(all_data_result)\n", + "\n", + "# Create a numpy matrix for overlapping deviations along the diagonal\n", + "regions = df['region'].unique()\n", + "num_regions = len(regions)\n", + "matrix = np.zeros((num_regions, num_regions))\n", + "count = np.zeros_like(matrix)\n", + "\n", + "region_to_index = {region: idx for idx, region in enumerate(regions)}\n", + "\n", + "for idx, row in overlapping_result.iterrows():\n", + " print(row)\n", + " region_pair = row['region_pair']\n", + " abs_deviation_sum = row['sum']\n", + " npair = row['count']\n", + " if region_pair[0] == region_pair[1]:\n", + " region_idx = region_to_index[region_pair[0]]\n", + " matrix[region_idx, region_idx] = abs_deviation_sum\n", + " count[region_idx, region_idx] = npair\n", + " else:\n", + " region_j = region_to_index[region_pair[1]]\n", + " region_i = region_to_index[region_pair[0]]\n", + " matrix[region_j, region_i] = abs_deviation_sum\n", + " count[region_j, region_i] = npair\n", + "\n", + "for idx, row in non_overlapping_result.iterrows():\n", + " region_pair = row['region_pair']\n", + " abs_deviation_sum = row['sum']\n", + " npair = row['count']\n", + "\n", + " region_j = region_to_index[region_pair[1]]\n", + " region_i = region_to_index[region_pair[0]]\n", + " matrix[region_i, region_j] = abs_deviation_sum\n", + " count[region_i, region_j] = npair\n", + "\n", + "print(\"\\n AD Sum Matrix:\")\n", + "print(matrix)\n", + "print(\"\\n AD Pairs Matrix:\")\n", + "print(count)" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(566000.0)" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix.sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(566000)" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_result['sum'].sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(24000.0)" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix.diagonal().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(533000.0)" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.triu(matrix, k=1).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(24000.0), np.float64(533000.0), np.float64(9000.0))" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "within_ad = matrix.diagonal().sum()\n", + "between_ad = np.triu(matrix, k=1).sum()\n", + "overlap_ad = np.triu(matrix.T, k=1).sum()\n", + "within_ad, between_ad, overlap_ad" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 8000., 20000., 270000.],\n", + " [ 9000., 8000., 243000.],\n", + " [ 0., 0., 8000.]])" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.True_" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix.sum() == within_ad + between_ad + overlap_ad" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(2+3+1)/7 == 2/7 + 3/7 + 1/7" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.857142857142857" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2/7 + 3/7 + 1/7" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8571428571428571" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(2+3+1)/7" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(36.0)" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "count.sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(9.0), np.float64(22.0), np.float64(5.0))" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "within_pairs = count.diagonal().sum()\n", + "between_pairs = np.triu(count, k=1).sum()\n", + "overlap_pairs = np.triu(count.T, k=1).sum()\n", + "within_pairs, between_pairs, overlap_pairs" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "ads = within_ad, between_ad ,overlap_ad\n", + "pairs = within_pairs, between_pairs, overlap_pairs" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[np.float64(2666.6666666666665),\n", + " np.float64(24227.272727272728),\n", + " np.float64(1800.0)]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[ad/c for ad,c in zip(ads,pairs, strict=False)] # MAD by type" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [], + "source": [ + "ads = np.array([within_ad, between_ad ,overlap_ad])" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 24000., 533000., 9000.])" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ads" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.11091514795218499)" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ads.sum() / (mu * n**2)" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [], + "source": [ + "den = mu * n**2" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.00470312, 0.10444836, 0.00176367])" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ads/den" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.11091514795218499)" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(ads/den).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.04240283, 0.94169611, 0.01590106])" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ads/den / (ads/den).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.9999999999999999)" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(ads/den / (ads/den).sum()).sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Extensions\n", + "\n", + "- put the regions on a map :->\n", + "- count of pairs that are neighbors versus non-neighbors\n", + "- is overlap more frequent for regions that are neighbors?\n", + "- i think there is another decomposition here." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bidecomposition of the Gini\n", + "\n", + "The Gini as \n", + "\n", + "$$\n", + "G = \\frac{\\sum_{i=1}^{n} \\sum_{j=1}^{n} |x_i - x_j|}{2n^2 \\mu}\n", + "$$\n", + "\n", + "with\n", + "\n", + "$$\n", + "\\mu = \\frac{1}{n} \\sum_{i=1}^{n} x_i.\n", + "$$\n", + "\n", + "\n", + "Focusing on the double summation of the absolute deviations, we can decompose this into two parts, deviations involving pairs of observations from the same region, and deviations involving pairs from different regions:\n", + "\n", + "$$\n", + "\\sum_{i=1}^{n} \\sum_{j=1}^{n} |x_i - x_j| = \\sum_i \\sum_i \\mathbb{I}_{i,j} |x_i - x_j| + \\overline{\\mathbb{I}}_{i,j} |x_i - x_j| \n", + "$$\n", + "\n", + "where\n", + "\n", + "$$\n", + "\\mathbb{I}_{i,j}\\{ \\text{region}(i) = \\text{region}(j) \\}\n", + "$$\n", + "and\n", + "\n", + "$$\n", + "\\overline{\\mathbb{I}}_{i,j}\\{ \\text{region}(i) \\ne \\text{region}(j) \\}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [], + "source": [ + "# Create data with overlap in incomes for group 2 and 3\n", + "data = {\n", + " 'Income': [50000, 55000, 60000, 45000, 46000, 47000, 45000, 46000, 47000, 48000],\n", + " 'Group': [1, 1, 1, 2, 2, 2, 3, 3, 3, 3]\n", + "}\n", + "\n", + "# Create DataFrame\n", + "df = pd.DataFrame(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_209447/1723929582.py:6: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.boxplot(x='Group', y='Income', data=df, palette='tab10')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 546, + "width": 868 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "# Set up the plot\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "# Create a boxplot to visualize income distribution by group\n", + "sns.boxplot(x='Group', y='Income', data=df, palette='tab10')\n", + "\n", + "# Add titles and labels\n", + "plt.title('Income Distribution by Group')\n", + "plt.xlabel('Group')\n", + "plt.ylabel('Income')\n", + "\n", + "# Show the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [], + "source": [ + "import itertools\n", + "\n", + "pairs = np.array(list(itertools.combinations(df.index.values, 2)))" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [], + "source": [ + "p_df = pd.DataFrame(data=pairs, columns=['i', 'j'])" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [], + "source": [ + "p_df['y_i'] = df.Income.values[p_df.i]\n", + "p_df['y_j'] = df.Income.values[p_df.j]\n", + "\n", + "p_df['region_i'] = df.Group.values[p_df.i]\n", + "p_df['region_j'] = df.Group.values[p_df.j]\n", + "p_df['adiff'] = np.abs(p_df.y_i - p_df.y_j)\n", + "p_df['within'] = p_df.region_i == p_df.region_j\n", + "\n", + "p_df['diff_within'] = p_df.adiff * p_df.within" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ijy_iy_jregion_iregion_jadiffwithindiff_within
0015000055000115000True5000
10250000600001110000True10000
2035000045000125000False0
3045000046000124000False0
4055000047000123000False0
\n", + "
" + ], + "text/plain": [ + " i j y_i y_j region_i region_j adiff within diff_within\n", + "0 0 1 50000 55000 1 1 5000 True 5000\n", + "1 0 2 50000 60000 1 1 10000 True 10000\n", + "2 0 3 50000 45000 1 2 5000 False 0\n", + "3 0 4 50000 46000 1 2 4000 False 0\n", + "4 0 5 50000 47000 1 2 3000 False 0" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "tad = p_df.adiff.sum()\n", + "wad = p_df.diff_within.sum()\n", + "bad = tad - wad" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.int64(231000), np.int64(34000), np.int64(197000))" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tad, wad, bad" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.04723926380368098)" + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inequality.gini.Gini(df.Income).g" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.04723926380368098)" + ] + }, + "execution_count": 121, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_df.adiff.sum() / (df.shape[0] * df.shape[0] * df.Income.mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Given the region cardinality what is the maximum between region ineq?" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [], + "source": [ + "def giniD2(y, group):\n", + " n = y.shape[0]\n", + " pairs = np.array(list(itertools.combinations(range(n), 2)))\n", + " p_df = pd.DataFrame(data = pairs, columns=['i', 'j'])\n", + " p_df['y_i'] = y[p_df.i]\n", + " p_df['y_j'] = y[p_df.j]\n", + "\n", + " p_df['region_i'] = group[p_df.i]\n", + " p_df['region_j'] = group[p_df.j]\n", + " p_df['adiff'] = np.abs(p_df.y_i - p_df.y_j)\n", + " p_df['within'] = p_df.region_i == p_df.region_j\n", + "\n", + " p_df['diff_within'] = p_df.adiff * p_df.within\n", + " tad = p_df.adiff.sum()\n", + " wad = p_df.diff_within.sum()\n", + " print(tad, wad)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "231000 34000\n" + ] + } + ], + "source": [ + "giniD2(df.Income.values, df.Group.values)" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [], + "source": [ + "y = df.Income.values" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([50000, 55000, 60000, 45000, 46000, 47000, 45000, 46000, 47000,\n", + " 48000])" + ] + }, + "execution_count": 125, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IncomeGroup
0500001
1550001
2600001
3450002
4460002
5470002
6450003
7460003
8470003
9480003
\n", + "
" + ], + "text/plain": [ + " Income Group\n", + "0 50000 1\n", + "1 55000 1\n", + "2 60000 1\n", + "3 45000 2\n", + "4 46000 2\n", + "5 47000 2\n", + "6 45000 3\n", + "7 46000 3\n", + "8 47000 3\n", + "9 48000 3" + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [], + "source": [ + "df['Income_sorted'] = np.sort(df.Income)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IncomeGroupIncome_sorted
050000145000
155000145000
260000146000
345000246000
446000247000
\n", + "
" + ], + "text/plain": [ + " Income Group Income_sorted\n", + "0 50000 1 45000\n", + "1 55000 1 45000\n", + "2 60000 1 46000\n", + "3 45000 2 46000\n", + "4 46000 2 47000" + ] + }, + "execution_count": 128, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "231000 45000\n" + ] + } + ], + "source": [ + "giniD2(df.Income_sorted.values, df.Group.values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So the within component increases now if we sort the incomes from low to high but keep groups as they are.\n", + "\n", + "What about moving the groups around?" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [], + "source": [ + "df['Group_sorted'] = np.sort(df.Group)[::-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IncomeGroupIncome_sortedGroup_sorted
0500001450003
1550001450003
2600001460003
3450002460003
4460002470002
\n", + "
" + ], + "text/plain": [ + " Income Group Income_sorted Group_sorted\n", + "0 50000 1 45000 3\n", + "1 55000 1 45000 3\n", + "2 60000 1 46000 3\n", + "3 45000 2 46000 3\n", + "4 46000 2 47000 2" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "231000 26000\n" + ] + } + ], + "source": [ + "giniD2(df.Income_sorted.values, df.Group_sorted.values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This changes things, so we have to consider all permutations of the groups. In other words [1,1,1, 2,2,2, 3,3,3,3] which is [A,B,C] \n", + "means we have to consider [A,B,C], [A,C,B], [B,A,C], [B, C, A], [C, A, B], [C, B, A]\n", + "\n", + "but the number of regions is vastly smaller than the number of units so this should be feasible for modest number of regions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Basic idea:\n", + "\n", + "1. Calculate observed statistic\n", + "2. Sort incomes from low to high\n", + "3. Permute the set of groups\n", + "4. recalculate statistic\n", + "5. repeat steps 2-4 for all permutations of the sets\n", + "\n", + "We keep the incomes fixed from low to high. \n", + "On a given permutation of the groups (e.g., [C, A , B]\n", + "since C has four members, A has 3 and B has 3,\n", + "C gets the four lowest values, A gets the next three highest, and B gets the three highest.\n", + "\n", + "Lets say incomes are 1,2,3,4,5,6,7,8,9, 10\n", + "\n", + "Then [C,A,B]\n", + "gives: C: [1,2,3,4]\n", + "A: [5, 6 7]\n", + "B: [8,9 10]\n", + "\n", + "But [A, C, B] gives\n", + "A: [1,2,3]\n", + "C: [4,5,6,7]\n", + "B: [8,9, 10]\n", + "\n", + "and so on\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/user-guide/measure/gini.ipynb b/docs/user-guide/measure/gini.ipynb new file mode 100644 index 00000000..71c63b2f --- /dev/null +++ b/docs/user-guide/measure/gini.ipynb @@ -0,0 +1,875 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Demonstrating the Gini Coefficient:\n", + "## Spatial Inequality in Mexico: 1940-2000\n", + "\n", + "1. Imports & Input Data\n", + "2. Classic Gini Coefficient\n", + "3. Spatial Gini Coefficient\n", + "\n", + "-------------------------\n", + "\n", + "### 1. Imports & Input Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:00:59.142457Z", + "start_time": "2023-01-17T02:00:59.104306Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last updated: 2023-01-16T21:00:59.129990-05:00\n", + "\n", + "Python implementation: CPython\n", + "Python version : 3.10.8\n", + "IPython version : 8.8.0\n", + "\n", + "Compiler : Clang 14.0.6 \n", + "OS : Darwin\n", + "Release : 22.2.0\n", + "Machine : x86_64\n", + "Processor : i386\n", + "CPU cores : 8\n", + "Architecture: 64bit\n", + "\n" + ] + } + ], + "source": [ + "%config InlineBackend.figure_format = \"retina\"\n", + "%load_ext watermark\n", + "%watermark" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.756177Z", + "start_time": "2023-01-17T02:00:59.145113Z" + } + }, + "outputs": [], + "source": [ + "import geopandas\n", + "import inequality\n", + "import libpysal\n", + "import matplotlib.pyplot as plt\n", + "import numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.770545Z", + "start_time": "2023-01-17T02:01:01.761777Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Watermark: 2.3.1\n", + "\n", + "libpysal : 4.7.0\n", + "inequality: 1.0.0+28.g078a825.dirty\n", + "matplotlib: 3.6.2\n", + "numpy : 1.24.1\n", + "json : 2.0.9\n", + "geopandas : 0.12.2\n", + "\n" + ] + } + ], + "source": [ + "%watermark -w\n", + "%watermark -iv" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.776633Z", + "start_time": "2023-01-17T02:01:01.772340Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mexico\n", + "======\n", + "\n", + "Decennial per capita incomes of Mexican states 1940-2000\n", + "--------------------------------------------------------\n", + "\n", + "* mexico.csv: attribute data. (n=32, k=13)\n", + "* mexico.gal: spatial weights in GAL format.\n", + "* mexicojoin.shp: Polygon shapefile. (n=32)\n", + "\n", + "Data used in Rey, S.J. and M.L. Sastre Gutierrez. (2010) \"Interregional inequality dynamics in Mexico.\" Spatial Economic Analysis, 5: 277-298.\n", + "\n" + ] + } + ], + "source": [ + "libpysal.examples.explain(\"mexico\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.962407Z", + "start_time": "2023-01-17T02:01:01.779047Z" + } + }, + "outputs": [], + "source": [ + "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", + "gdf = geopandas.read_file(pth)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.103640Z", + "start_time": "2023-01-17T02:01:01.964971Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 316, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot()\n", + "ax.set_axis_off()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.138110Z", + "start_time": "2023-01-17T02:01:02.106331Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...GR9000LPCGDP40LPCGDP50LPCGDP60LPCGDP70LPCGDP80LPCGDP90LPCGDP00TESTgeometry
017.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...0.054.354.324.254.404.474.434.481.0MULTIPOLYGON (((-113.13972 29.01778, -113.2405...
127.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...0.003.984.204.224.394.464.414.422.0MULTIPOLYGON (((-111.20612 25.80278, -111.2302...
232.731957e+10MX18Nayarit1034770.3416.750785e+062731956.8594836.07515.07621.0...-0.053.683.883.884.044.134.114.063.0MULTIPOLYGON (((-106.62108 21.56531, -106.6475...
347.961008e+10MX14Jalisco2324727.4361.967200e+077961008.2855309.08232.09953.0...0.033.733.924.004.214.324.304.334.0POLYGON ((-101.52490 21.85664, -101.58830 21.7...
455.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...0.134.023.793.944.214.324.324.445.0POLYGON ((-101.84620 22.01176, -101.96530 21.8...
\n", + "

5 rows × 35 columns

\n", + "
" + ], + "text/plain": [ + " POLY_ID AREA CODE NAME PERIMETER \\\n", + "0 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", + "1 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", + "2 3 2.731957e+10 MX18 Nayarit 1034770.341 \n", + "3 4 7.961008e+10 MX14 Jalisco 2324727.436 \n", + "4 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", + "\n", + " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... GR9000 \\\n", + "0 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 0.05 \n", + "1 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 0.00 \n", + "2 6.750785e+06 2731956.859 4836.0 7515.0 7621.0 ... -0.05 \n", + "3 1.967200e+07 7961008.285 5309.0 8232.0 9953.0 ... 0.03 \n", + "4 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 0.13 \n", + "\n", + " LPCGDP40 LPCGDP50 LPCGDP60 LPCGDP70 LPCGDP80 LPCGDP90 LPCGDP00 TEST \\\n", + "0 4.35 4.32 4.25 4.40 4.47 4.43 4.48 1.0 \n", + "1 3.98 4.20 4.22 4.39 4.46 4.41 4.42 2.0 \n", + "2 3.68 3.88 3.88 4.04 4.13 4.11 4.06 3.0 \n", + "3 3.73 3.92 4.00 4.21 4.32 4.30 4.33 4.0 \n", + "4 4.02 3.79 3.94 4.21 4.32 4.32 4.44 5.0 \n", + "\n", + " geometry \n", + "0 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", + "1 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", + "2 MULTIPOLYGON (((-106.62108 21.56531, -106.6475... \n", + "3 POLYGON ((-101.52490 21.85664, -101.58830 21.7... \n", + "4 POLYGON ((-101.84620 22.01176, -101.96530 21.8... \n", + "\n", + "[5 rows x 35 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.975365Z", + "start_time": "2023-01-17T02:01:02.141021Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABAcAAAKjCAYAAABhmWaAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd1xT1/sH8M9NIOw9VVTEiQv3HuDeirNqVWxdrdpax7eOWrXD0dZa9Vf33gpurVtxD5y4BVRQkCF7hoz7+yPlNkhCQgi5AZ7368vrm3DPPfdJck25zz3nOQzLsiwIIYQQQgghhBBSbgn4DoAQQgghhBBCCCH8ouQAIYQQQgghhBBSzlFygBBCCCGEEEIIKecoOUAIIYQQQgghhJRzlBwghBBCCCGEEELKOUoOEEIIIYQQQggh5RwlBwghhBBCCCGEkHKOkgOEEEIIIYQQQkg5R8kBQgghhBBCCCGknKPkACGEEEIIIYQQUs5RcoAQQgghhBBCCCnnKDlACCGEEEIIIYSUc5QcIIQQQgghhBBCyjlKDhBCCCGEEEIIIeUcJQcIIYQQQgghhJByjpIDhBBCCCGEEEJIOUfJAUIIIYQQQgghpJyj5AAhhBBCCCGEEFLOUXKAEEIIIYQQQggp5yg5QAghhBBCCCGElHOUHCCEEFIifH19wTCM2h8bGxt4enqif//+WL16NVJTU4t8jJycHBw9ehRTpkxB06ZNUblyZVhYWMDKygoeHh7o0KEDZsyYgXPnzkEul5fAq1TIysrC4cOHMWXKFDRv3hxVqlSBlZUVzM3N4e7uDh8fH4wePRqrV69GVFSUVn16enqqfe8sLS1RoUIF1K5dG35+fpgxYwb27NmD+Pj4IsX99u3bQj8jExMTODk5oWHDhhg3bhzOnDkDlmV1eYvUiomJwdGjR/HDDz+gR48ecHJyyhfD27dvdeo3JycH69evR9++fVG5cmWYm5vD0dERDRo0wLRp0/DgwQO9vYaBAwfmi9nX17dI+7Msi8OHD2Pw4MGoXr06LCws4OLigmbNmmHRokVanzOEEEJIsbCEEEJICejYsSMLQOsfW1tbdvv27Vr1LZFI2DVr1rAVK1bUuv9KlSqx//d//8dKJBK9vcasrCz2999/Z11dXYv0Wtu0acOeOHGi0L6rVq1apD4BsKampuyQIUPYGzduaBX/mzdvinyM5s2bs69evdLH28dWqFBB4/HevHlT5H4vXbqk8dxgGIb99ttvWbFYXKzXEBQUVKDvjh07ar1/dHQ026lTp0Jjtba2Zrdu3VqsOAkhhBBNGJbV8y0AQgghBIqRA5cvXwYANG/eHC1atOC2sSyLlJQUhISEICwsLN9+69atw8SJE9X2m5ycjEGDBuHSpUv5fu/m5oamTZvCxcUFAoEAsbGxePbsGSIjI/O1++qrr7BmzZrivjy8e/cOAwYMwP379/P93sXFBU2aNIGzszMsLS3x8eNHREdH4/79+5BKpfna/vnnn/juu+9U9u/p6cnF3rlzZ9SpU4fbJpPJkJKSguTkZISGhuLDhw/59hUIBPjuu+/w66+/wszMTO1rePv2LapVq8Y9Hz16NGxsbLjnUqkU0dHRuHr1ar6RHe7u7rh16xaqVq2qtm9tMAyjsc2bN2/g6empdZ8nTpyAv78/916bmJigdevWqFWrFsRiMUJCQvDy5Uuu/WeffYY9e/ZoFcunUlJS4O3tjdjY2Hy/79ixI4KDgzXun5aWhrZt2+LJkyfc71q0aIF69eohNTUVFy9eREpKCrdt+/btGD16dJHjJIQQQrTCc3KCEEJIGaU8cmDBggVq2x0+fJi1t7fn2pqZmbHv3r1T2TY5OZmtU6dOvruqPXv2ZG/dusXK5XKV+4SGhrLffvsta2ZmxgJgx4wZU+zX9ubNG9bd3T3fXeghQ4awd+/eVRtHWloae/jwYbZz587cfj///LPaYyiPHNB01/j169fsvHnzWCcnp3zvTa9evViZTFbo61Bur+4ufXp6OjtlypQCfRcXANbc3Jxt1aoVO3XqVHbHjh3smTNndB45EB0dzdra2nL7Nm3aVOUoh6CgINbGxoZr99dff+kU/5dffsmN2Bg8eHCRRw6MGjWK28fR0ZG9ePFivu3p6ensiBEjuDYikYgNCwvTKVZCCCFEE0oOEEIIKRHaJgdYlmVPnDiR74Jwzpw5Ktv169ePayMQCNi///5b63giIyPZDh06FDs5kJ2dzTZt2pSLw9LSkj1y5EiR+rhz5w7boEEDvSUH8sTGxrK+vr753ssZM2aoba9tciDPkCFD8rV/8eKFVnGpc//+/QLTPIoak7Jvvvkm3zSSxMREtW1PnjzJtXVycmJTUlKKFPuFCxe4/efNm8cuWLCgSMmBx48fswKBgNvn9OnTKtvJZDK2TZs2XLvhw4cXKU5CCCFEW1SQkBBCCO969+6NRo0acc/Pnz9foM2uXbtw7Ngx7vmSJUvw9ddfa32MKlWq4MKFCxgzZkyxYv39999x79497vnu3bvRv3//IvXRvHlz3L17F/7+/sWK5VNubm44ffo0mjRpwv3ur7/+QkREhF76nzdvXr7nFy5cKFZ/jRs3homJSbH6UBYYGMg9njlzJhwdHdW27dWrF9q3bw8ASExMxO7du7U+TnZ2NiZMmAAAqFGjBn744Ycix7p27VquSGbXrl3RvXt3le0EAgF+++037vmBAweQkJBQ5OMRQgghmlBygBBCiFFo3bo19/j169f5trEsi2XLlnHPmzVrhpkzZxb5GCYmJvDz89M5xqysLKxcuZJ7Pnz4cAwYMECnvkQiEerVq6dzLOqYmZlhz549EAgU/4mXyWRYunSpXvpu2LAhrKysuOeffk58ioyMzFd7oWfPnhr36dWrF/f44MGDWh9rwYIFXMJl7dq1MDc3L0KkivNZOdE1duzYQtu3bdsWNWvWBKD4PI8fP16k4xFCCCHaoOQAIYQQo+Dg4MA9TktLy7ft2rVr+Yq2TZs2jbv4NaTAwEAkJiZyz9UVE+Rb7dq10bt3b+55UFCQXpZyZBgGdnZ23PNPPyc+xcXF5XuuTbFE5TZXrlyBRCLRuM+9e/fw559/AgA+//xzdOnSpYiRAmFhYXj//j33XJulD5XbXLx4scjHJIQQQjSh5AAhhBCjkJyczD1WvgAF8l8MiUQiDBo0yGBxKVNeIaFatWpo3rw5L3FoY8iQIdzjlJQUPH78uNh9sv+uMpHn08+JT2wxF1+SSqV49eqVxjbjxo2DTCaDo6MjlyQoqufPn3OP3d3dUaFCBY37KE8VUd6fEEII0RdKDhBCCDEK169f5x4rL68HAFevXuUe+/j4FHkYt74ox9GyZUteYtDWp/Hdvn272H0+fPgQWVlZ3PNPPyc+ubi45Hv+6RKWqnzaRtNF9x9//IGHDx8CUNSe+PSY2lJeSlHb5SCrVKnCPX7x4oVOxyWEEEIKQ8kBQgghvDt58iRCQ0O55507d863/e3bt9zjkpinr62oqCjusbe3N29xaKNmzZr5pl58OuxeF4sXL873/NPPiU/VqlWDk5MT9/zUqVMa9/nnn3/yPU9KSlLbNiwsDIsWLQIAdOzYUWOdgMIoT01xc3PTah93d3fucVZWFsRisc7HJ4QQQlTRX4lgQgghRAdHjx5FQEAA91wkEhVYhUD5os3e3t5AkeWXlpYGqVRapDj++eefAhegn/rpp58KraqvK4ZhYGNjg9TUVAD5p20UVUZGBubMmYOgoCDudz179kTt2rWLHae+MAyDPn36YPv27QAUd/lHjx6t9r39559/8o0EAYD09HSVbVmWxfjx45GTkwORSIR169aBYRidY83IyOAeW1hYaLXPp+0yMjJgZmamcwyEEELIpyg5QAghpMT9888/+PjxY77fpaSkICQkpMA87xUrVqBy5cr5fqd80WZtbV1ygRbi0wtH5ar96ty5cwd///13oW00LblXHNbW1lxyQN2Fr7IFCxbAxsaGey6VShETE4MrV65w/QCAq6urxtfFh++//x579uyBRCJBdHQ0unXrhr1793KV/vMcPnxY5ZKW2dnZKvvduHEjLl++DACYM2cO6tSpU6w4c3JyuMcikUirfT5NBKiLlRBCCNEVJQcIIYSUuJCQEISEhBTaxsbGBitXrlQ5XNvGxoa7861819WQlC+aASAzM5OXOIpCOSFga2ursf2OHTs0tmnatCl2795tVPUG8nh7e2PFihWYMmUKAMXKAnXr1kWbNm1Qq1YtiMVihISEcHP286Ze5NUA+PQzBoCYmBj873//AwDUqlULc+bMKXacyjUzcnNztdrn02kE2o44IIQQQrRFyQFCCCG8sLa2hpOTExo2bIguXbpg9OjRaofqOzo6cskB5Wr5hmRrawsTExNuaoE2cSxcuBALFy7M97u3b98a5MJaLpfnSw7oMjpBKBTC1tYWHh4eaN68OQYPHowePXoUa0h9SZs8eTIsLS0xdepUZGZmQiqV4sqVK7hy5Uq+dk2aNEFQUBD8/Py436k6/yZPnsyNmli/fr1ehvIrj37RdgTAp+34GkFDCCGk7KLkACGEkBK3YMGCAhfJReHp6YmIiAgAwLNnz/QUVdFVqVIFr1+/BmD8y8m9evUq3/J+ygXt1Hnz5g08PT1LMCrDGDt2LPr27Yv169fj7NmzeP78OVJSUuDo6Ih69ephxIgRGD16NFiWxYcPH7j9PDw88vVz9OhRHDlyBAAQEBAAX19fvcSnXDhR20KRsbGx3GNLS0uqN0AIIUTvKDlACCHE6LVr1w4XLlwAADx69AhisZiXi6P27dtzyYE7d+4Y/PhF8enSha1ateIpEn44Oztj3rx5mDdvnto2ISEh3LB+hmHQrFmzfNsfPHjAPb5z506h7+H79++5x/fv38/Xds2aNWjSpAn3XLmQozZLLgL5V8oobs0DQgghRBVKDhBCCDF6nTp14paRE4vFOHjwIEaMGGHwOPz8/Lhq+K9fv8bdu3cLXFAaiwMHDnCPnZycULduXR6jMU6XLl3iHtetWxd2dnZq2xZlxEp6enq+5ExaWlq+7crLYMbGxiI2NlbjyI779++r3J8QQgjRF4HmJoQQQgi/2rdvj/r163PP//rrL8jlcoPHMXjw4HxDwlesWGHwGLTx/PlznDp1ins+dOhQo64TwBflAoyjRo0y2HFr1qyZbwpDcHCwxn3yVksAFMkyQgghRN8oOUAIIcToMQzDVYwHFMPBdbkwl0ql+e4WF5WVlRWmTp3KPd+zZw+OHTumc38lQSwWY+TIkVy9ARMTk3zvHVHYu3cvnj59CkCxTKCqVTIWLlwIlmW1+lmwYAG3X8eOHfNt+7RWAcMw6NevH/d827ZthcZ68+ZNbslPgUCAvn376viqCSGEEPUoOUAIIaRU+Pzzz9GnTx/u+ffff48NGzZovX9kZCQ6d+7MTQvQ1ffff4/GjRtzz0eMGIETJ04Uq099iY+PR48ePfLNlf/+++/LRJFBfXrx4gW+/fZb7vkPP/wAV1dXg8YwadIkCASKP8POnDmDc+fOqWwnl8vzJXeGDh0KFxcXg8RICCGkfKHkACGEkFKBYRhs374dNWvWBADIZDJMnDgRffv2RUhISL7K/MqePHmCadOmoVatWgWWs9OFubk5Dh48yF1MZmZmon///hgxYkS+i/JPyeVyBAcHY8KECcWO4VNv377Fjz/+iLp16+Ybou7v74+ff/5Z78czZvPnz8e+ffuQlZVVYJtMJsPu3bvRoUMHJCQkAACaN2+O77//3tBhokGDBhg5ciT3fPjw4QWmF2RmZmLMmDG4du0aAEAkEpW7z5MQQojhUEFCQgghpYajoyNu3ryJQYMGcXOwT5w4gRMnTsDd3R1NmzaFi4sLBAIBYmNj8fTp0wLV4G1sbIodR7Vq1XDnzh30798fjx49glwux969e7F37164urqiadOmcHZ2hpWVFTIzM/H+/XuEhoYiMTExXz9+fn75ahios2vXLty9e5d7LpPJkJqaiuTkZISGhiImJiZfe4FAgP/973/46aefjLrWwLp167Bu3bp8v8tbPSBPr169IBKJ8v1u0qRJmDRpkso+Q0JC8Msvv8DCwgJNmjRB9erVYWZmhri4ONy4cQMfP37k2jZu3BinT5+Gqampnl5R0fzf//0f7t+/j6dPnyIxMRF+fn5o1aoV6tati9TUVFy8eBHJyclc+w0bNqBGjRq8xEoIIaTso+QAIYSQUsXJyQnnzp3DunXrsGTJEm6d+tjYWJw8eVLtftWrV8fcuXMREBCglziqVq2KGzduYNWqVVi+fDl30RkfH5+vGOCnGIZBu3btMGPGDPTv31+rY124cIFbyrEwIpEI/v7+mD59Olq0aKHdC+FRbGwsHj16VGib58+fq9xPk+zsbFy/fh3Xr18vsE0gEGDSpElYsmQJbG1ttQ9Yz2xtbXH27FmMGjUKFy9eBADcunULt27dytfO2toaq1atwpgxY/gIkxBCSDlByQFCCCGljqmpKaZOnYpx48bh9OnTOHfuHG7duoX4+Hh8/PgRQqEQDg4OqFGjBlq2bInevXujffv2er+LbmlpidmzZ2Pq1Kk4ffo0Lly4gNu3byM+Ph6JiYmQy+Wwt7eHi4sLGjVqhObNm6NPnz7w8vIq1nHNzMxgZ2cHOzs7VKpUCU2aNEHTpk3RrVs3ODs76+nVlU5r1qzBmTNncPHiRTx79gxxcXFIS0uDs7MzKleujB49emD48OGoU6cO36ECACpWrIjz58/j8OHD2L17N+7fv48PHz7A2toaVapUQd++ffHll1+iSpUqfIdKCCGkjGNYdZM0CSGEEEIIIYQQUi5QQUJCCCGEEEIIIaSco+QAIYQQQgghhBBSzlFygBBCCCGEEEIIKecoOUAIIYQQQgghhJRzlBwghBBCCCGEEELKOUoOEEIIIYQQQggh5RwlBwghhBBCCCGEkHKOkgOEEEIIIYQQQkg5R8kBQgghhBBCCCGknKPkACGEEEIIIYQQUs5RcoAQQgghhBBCCCnnKDlACCGEEEIIIYSUc5QcIIQQQgghhBBCyjlKDhBCCCGEEEIIIeUcJQcIIYQQQgghhJByjpIDhBBCCCGEEEJIOUfJAUIIIYQQQgghpJyj5AAhhBBCCCGEEFLOUXKAEEIIIYQQQggp5yg5QAghhBBCCCGElHOUHCCEEEIIIYQQQso5Sg4QQgghhBBCCCHlHCUHCCGEEEIIIYSQco6SA4QQQgghhBBCSDlHyQFCCCGEEEIIIaSco+QAIYQQQgghhBBSzlFygBBCCCGEEEIIKecoOUAIIYQQQgghhJRzJnwHQAghhBBCdMOyLDIzM5GWloacnBzIZDK+QyKEEKIFoVAIc3Nz2NrawsrKCgzD8B0SGJZlWb6DIIQQQgghRSOXyxEVFYXs7Gy+QyGEEFIMFhYWqFKlCgQCfgf2U3KAEEIIIaSUYVkWkZGR+RIDDMNAKBTyGBUhhBBtyWQyKF+KW1hYoGrVqryOIKBpBYQQQgghpUxmZiaXGBAKhXB3d4e1tTXvd50IIYRoRy6XIyMjA7GxsZDJZMjOzkZmZiasra15i4n+C0IIIYQQUsqkpaVxj93d3WFra0uJAUIIKUUEAgFsbW3h7u7O/S49PZ3HiCg5QAghhBBS6uTk5ABQTCXg8y4TIYSQ4rG2tuamEvBdQ4aSA4QQQgghpUzeqgRCoZBGDBBCSCkmEAi4ejF8rzhD/zUhhBBCCCGEEELKOUoOEEIIIYQQQggh5RwlBwghhBBCCCGEkHKOljIkhBBCCCHFJs4WI+JRJD5ExEEilsDUzBQVqruhuk9VmFmY8R0eIYQQDSg5QAghhBBCdJKVno1zOy7jzLZLeP0oEjJpwWJaQhMhqjfyRPcAP3QZ1QGWNhY8REoIIUQThmVZlu8gCCGEEEKI9sLCwiCVSmFiYoKaNWsa/PgymQwHfjuGvUsOITsjR+v9LKzNMXzOQAz9Xz+uOjchhJR3fH+n56GaA6QAlpWBlSeDlb4BK8/gOxxCCCGEGJF3L6PxTet52DJvT5ESAwCQnZGDLfP24Ns28/DuZXQJRUgIIUQXlBwow1iWBSvPACt9D1byFKz4OtjsE2Azd4HN+BvytF8hT5kJedI4yBOHQJ7QFfK45mDj6oKNbwk2bQHA0BxBQgghhCi8uheBae3m49XdiGL18zJE0U/Y/dd6isw4vHv3DgcPHsTs2bPRqVMn2NragmEYMAyDhQsXFqmvZ8+eYerUqWjQoAFsbW0hEong4uICPz8/rFixAunp6Rr7kMlk2L17N3r37g13d3eIRCK4u7vDz88PGzZsgFQqLXR/qVSKc+fOYdasWWjfvj1cXFxgamoKe3t7NGnSBDNnzkRERPHOhU9lZWXh999/R4sWLeDo6Ahra2t4e3tj5syZiIqK0rqfp0+fYtKkSahRowYsLCzg4uKCDh06YP369Rpft6GIxWIcPnwYc+bMQZcuXVCrVi04OjrC1NQUTk5OaNOmDX788Ue8f/++0H6Cg4O580zTj7rzcNu2bVr3kfcTEBCg8TV+/PgRv/32G9q2bQt3d3eYmZmhYsWKaNmyJWbNmoWbN2/q8M4ppKWlYd++fRg/fjyaNGkCe3t77t+Jr68v/vjjD6SkpGjdX2JiIhYsWAAfHx/Y2dnB1tYWPj4+WLBgARITE3WOszShaQWlBMvmAvIUxQ+bAsiTAXkqIE8By6b8t43brtgGSHQ7oLAqGKcDYAQO+gifEEIIIXrExxDUdy+jMa3dfKQlar4o1Zatkw3+uvYzKteupLc++RIZGQlPT0+12xcsWKB1gmD58uWYPXt2oRexVatWxbFjx9CwYUOV2z98+ICBAwfi1q1bavto1qwZTpw4ATc3twLbEhIS4O3trfGiSCQS4bfffsO3335baDttREREoHfv3nj58qXK7XZ2dtizZw969epVaD+bN2/G5MmTIRaLVW5v1aoVTpw4AScnp2LHXBzh4eFa/fu1srLCmjVrMHr0aJXbg4OD4efnp9Ux1Z2H27Ztw9ixY7XqI8/ixYsxZ84ctdsDAwPx1VdfFXoO9e/fH0eOHCnScQHg1KlT8Pf3V/sZ53Fzc8PevXs1vj8hISHo378/Pnz4oHJ7xYoVcfToUTRr1qzIsWrDWKYVUEFCA2NZFmAzAHnSvxf4yf9ezKeAzbugZ5P/vdBP/e9in80yXJCMNRiHdZQYIIQQQggAxR3opaNW6zUxAABpielYNno1Vt74tdTXIFC+38YwDKpXr46KFSviypUrRernwIEDmDlzJgDFhffkyZPRpUsXODs7IyIiAmvWrMG1a9cQGRmJHj164Pnz57Czs8vXR3Z2Nnr37o0HDx4AALp06YJJkyahWrVqSExMRFBQEDZt2oS7d++iT58+uHbtGszM8o8WFYvF3EVdo0aN0L9/f7Rs2RJubm5ITU3FqVOnsHr1auTk5GDatGmwsLDAhAkTivy+5cnIyECfPn24xMD48ePx2WefwcLCApcuXcKSJUuQmpqKIUOG4ObNm2qTImfOnMGECRMgl8vh5uaGefPmoWXLlkhKSsLGjRtx6NAh3Lp1CwMHDsSlS5cgEPA7kNrV1RV+fn5o3rw5qlatigoVKsDU1BTR0dE4efIkdu/ejczMTAQEBMDFxQU9e/YstL8tW7agefPmhR5PlQEDBmh14Ttw4ECEhYVBIBDg888/V9tux44dGDt2LORyOVxdXfHVV1+hXbt2cHR0RGxsLCIiInD8+HGYmppqPKYqiYmJEIvFEAgE6Nq1K3r06AEfHx/Y29vj/fv32L17N/bv34+4uDj06dMH169fR6NGjVT2FR0djb59+yIuLg4mJiaYPn06+vTpAwA4ceIE/vzzT8TExKBPnz64d+8eKlUq/clMdWjkQDEpLvbT/r3Yz//DFvhdoiIZoOvdfEMx84PAYT3fURBCCCFEDUPfZdq75DC2zNtTYv1/uXgEPpvtX2L9G0JiYiLWrVuH5s2bo3nz5nBwcMh3R1fbkQMNGjTAkydPACguTHr37l2gzaBBg3Do0CEAilEG06dPz7f9jz/+wKxZswAAY8eOxebNm8EwTL42W7duxRdffKG2j+joaIwdOxY//fQTWrVqpTLW27dvw8/PD9nZ2bCzs8O7d+9gY2Oj8TWqsnDhQixatAgA8Ntvv3Hx57l58yY6dOgAqVQKPz8/XLx4sUAfUqkU3t7eCA8Ph62tLe7fv4/q1avnazN58mSsWbMGALB9+3a1d+MNQS6Xc0P01blz5w7atWsHiUSCJk2a4N69ewXaKJ9nly5dgq+vb4nE++LFC3h7ewMAOnfujPPnz6ts9/z5czRu3BhisRjt27fH8ePHCySw8uTm5kIkEhU5lv379+PSpUuYO3cuqlSporLN6tWr8c033wAAOnXqhAsXLqhsFxAQgO3btwNQJOeGDBmSb3tgYCCGDh0KQPHvacuWLUWOVxNjGTlAyYFPsKz834v9RKWL+uR/L/YTP7nYTy4dF/tFZTEEArtf+Y6CEEIIIWoY8g/JrPRsfFZpQpGLDxaFpY0F9r5fX+aWOSxqciAtLY27iFJ3IQgAoaGh8PHxAaBIFAQFBeXbnpdgsLKyQnR0tNoLs3bt2uH69etwc3NDTEyMTnfRZ86cieXLlwMADh06BH//oid5JBIJXF1dkZKSAm9vbzx58kRlLJMmTcL69YobWHfv3kXTpk3zbVe+iFuyZAlmz55doI+srCx4eHggOTkZ9evXx+PHj4scr6H17NkTp0+fBgCkp6fD2to633ZDJQfmzJmDpUuXAig8sdKlSxdcuHABzs7OeP78OZydnUskHm00b94cd+/ehUAgQHx8fIGpJHFxcahUqRJkMhm6d+/Ovc+f6tGjB86cOQOhUIjo6GiVU3GKw1iSA1SQEIA8eQrkH/tAHt8GbFw9sPEtwH7sCTZpJNiUqWDTfgSb8ReQtRPIOQnk3gSkLwF5PMpcYgAABKqHGxFCCCGk/Dm343KJJgYARQLi/M6iDb8vi3Jzc7nHXl5eatsp3w3/dM51dnY2N/KgdevWahMDgOKCB1BcIF29elWnmJXncutanDA4OJgrHDdmzBi1SQrlAnh5IyeUKc9dV1csz9LSkksgPHnyBGFhYTrFbEhWVlbcY01z7EuKXC7H7t27uXgGDRqkst2LFy+4O/RTpkzhNTEAgEuUyOVyvHnzpsD2Y8eOQSaTAUChNRfyzieZTIZjx47pPU5jQckBAJDcA6SvAPlHADK+o+FFjtQCVz92w7LnU7HntQ+kcjnfIRFCCCHECJzZdqlMHceYOTs7w9HREQDw+rX6lRyUL8Jr1aqVb1tycjL3WNPdTeXtly9fLlKseZQvVnWdv6+cmOjYsaPads2aNeMulK9du6a2n9q1a8Pd3V1tP8rHUNWPMYmPj+emUDg7O/NWRPHSpUt49+4dAMVoFeWEhbLAwEDusfLw/OTkZISFhRm86r+m81Pbc680nTPFQckBAIA53wHwKjKrFpocHYuxF6th4+Nc/Hj5HpptXINvT5/E0ZfPkZKTzXeIhBBCCOGBOFuMiIdvDXKsiIdvkZuTq7lhGZdX1O/+/fs4deqUyjY///wzAEAoFGLcuHH5tilftKWmphZ6LOXtz5490yle5aRCnTp1dOrj+fPnWvVhYmLCjZpQ3gdQFDTMW/JPUxzK2z/txxiIxWK8efMGGzduRJs2bbiEjzYrQsydOxceHh4QiURwcHBA48aN8d133+HVq1fFimnHjh3c4zFjxqhtl7c6hp2dHby9vbF79274+PjA0dERtWrVgrOzM7y8vLBo0SJkZGQUKyZt5J2fJiYmqFGjRoHteZ+/nZ1doQmlChUqwNbWNt8+ZRElBwAw1pP4DoFXNz62RK4s/4iJNLEYx1+9wHdn/kGzjWsxLGgf1t+7g/CkRFCZCkIIIaR8iHgUCbnMMKMJZVIZIh5FGuRYxmzevHno0qULAMDf3x8zZ87EqVOnEBISgv3798PX1xdBQUEQCoVYtWoVVyAuj52dHSpUqABAcaGmPFXhU8orKURFRRU51g8fPmDr1q0AFHe1tV1O71N5d6StrKxgb29faNvKlSsDUCy1qHxX+P3799zfqB4eHlr1oXxsvgUHB3PFCc3NzeHl5YUJEyZwo0RGjhxZoEijKjdv3kR0dDQkEglSUlLw8OFD/PXXX/D29sbChQt1+js+MzOTm8ZRuXLlQmsa5CWZPD09MXXqVHz++ecIDQ3N1+bNmzdYuHAhWrdujZiYmCLHo62TJ09yx+7evTt3ca8s7/PXdM4A/503xnLOlARKDgCAxRDAtDHfUfDmRlzhQ87kLIuQmGgsu34V3XZtg9/2zfjp8kVcjXoLcSHr7xJCCCGkdPsQEWfg48Ua9HjGyNraGqdOncLGjRvh4eGB5cuXo1evXmjRogU+++wzXL58GQMHDsT169fx9ddfq+yjf//+AICPHz9yxQI/de3aNZw8eZJ7np5etGUqWZbFpEmTuP3mz58PCwvdCkrm9fFpoT1VlEdGKN95Vo5fUz/q+jBGnp6eOH36NHbt2lVguUllFSpUwOTJk7F3717cvn0b9+7dw+HDh/HFF1/A1NQUcrkcixYtwrx584ocw6FDh7j3adSoUYVOH0lKSgKgqD3w999/w97eHuvWrUN8fDxycnIQEhLCLcf45MkTDBkyBPISmM6clJSEyZMnA1CMsMkbbfMpXc49Yz9nisOE7wCMAcMIANuFYBMHorzVHIjNqYKr74tWZCgqLRXbHj3AtkcPYGVqinZVPNGpmhd8PavBxVL1/CNCCCGElD4SsWELL+eK6aYDoKjEv3fvXrV1B86fPw83Nzd4e3urvBs6e/Zs7NmzB2lpaZg3bx7i4+Px9ddfw9PTE4mJiTh48CDmzJkDlmVhYmICqVSK7OyiTSNdvHgxV5jNz88PU6ZMKfoL/VdOjuJvUW2WtFO+QFaOOa8PbfpR1wefmjdvzq2cIBaLERUVhWPHjmHnzp0YO3Ysfv75Z3z55Zdq942MjISpqWm+3zdp0gQDBgzAxIkT0a1bN6SmpmLp0qUYOnQoGjVqpHVsO3fu5B5rWvoxMzOTew1CoRCnTp3KtxRms2bNcOLECfTp0wenTp3CjRs3cOjQIQwePFjreDSRyWQYOXIkIiMVI5F++OEHNG6s+kawLueesZwzJYFGDvyLMfUGLEfxHYZBsSww98EwZEh0/w9/pkSCMxFh+P78GbTctA7++3dj9Z2beBofR9MPCCGEkFLO1MxUcyM9EpnRfaugoCD4+vri4sWLaNCgAQ4fPozExETk5uYiIiICixcvhkQiwdq1a9GmTRvExhYcbVG1alUEBgbCxsYGLMvir7/+Qq1atSASiVChQgVMmTIF6enpWLp0KczNFbW3bGxstI5x9+7dmD9/PgDFne09e/boXIwQABdDYVMg8ihPJVAeqZDXhzb9qOuDT1ZWVqhfvz7q16+Ppk2bwt/fH1u3bsWZM2eQlJSEcePG4aefflK776eJAWUtWrTA33//DUAx4iPvsTZiYmK41QdatmyJ2rVrF9pe+XMYMmRIvsRAHoFAgN9//517vnfvXq3j0cbXX3/NLUnYu3dv7lxVRZdzz1jOmZJAyQEljPW3gHl/vsMwmP3vR+LKuzS99vkoLhYrbt1A33270HbLBsy7eA4XXkcguxgJCEIIIYTwo0J1/a7lrfl46guClQdxcXEICAiAWCxGvXr1cOPGDQwYMACOjo4wNTWFl5cX5syZg+PHj4NhGDx9+hRTp05V2Ve3bt3w8OFDfPnllwUq3Ldq1Qr//PMPJk+ezA2RdnBw0CrGkydPYuzYsWBZFm5ubjh37lyhhdy0kZeY0Ga4dt6daSD/UHDl5IamftT1YYw6d+7MFSJctGgRXrx4oVM/w4YN45a1LMrKFLt27eKG/WsaNQDk/xzypg+oUq9ePVSqVAkAEBISonU8msyZMwcbNmwAALRr1w6BgYEQCoVq2+ty7hn7OVMclBxQwgisILD/HYzjLkBYXfMOpViG1BZL7mr3HwFdxWZmYO+TUIw/cQRNNqzBl8cOY/fjR4hJ129CghBCCCElo7pPVQiEhvlzUWgiRHWfqgY5lrHat28fdwEyd+5ctcvFde7cGZ07dwagmA+uvHyhMi8vL2zatAkJCQmIiYnBy5cvkZqaips3b6Jnz5549OgR17Zu3boa4wsODsbgwYMhkUjg4OCAs2fPqqwAX1R5xeAyMzORkpJSaNu8YnAuLi75pgcoF5TLW7VAUx9A/uKExiqvhoRcLucKAxaViYkJt+xldHS01vvlTSkQiUT47LPPNLZXfj+1LQwZHx+vdTyFWbZsGZYuXQpAMaXixIkTGu/y58Wo6ZwB/jtvSsM5oytKDqjAiFqAcT4KmPXgO5QSYyVMg7uV+qIm+iaWSXHp7WvMv3Qe7bZuRO89O7D85jU8+BADWQkUISGEEEJI8ZlZmKF6I0+DHKt6I0+IzDXP+y3LlJdIa9KkSaFtmzZtCkBxwahpmTqGYVChQgXUqlUrX40C5fXaW7ZsWWgfd+7cQd++fZGTk8MVTWzYsGGh+2hLOTFR2J1xqVTKVe//dJUGa2tr7qJN09115e2f9mOMXFxcuMd58+h1UdQpv/fv38eTJ08AAH369IGjo6PGferVq8c9lskKr+WWt93EpPjTidasWYPZs2cDUHymZ86c4UZKFCbv3EtNTVU5RSfPhw8fkJaWxvVfVlFyQA2GEYGx6MN3GCWGYYB+1firtPn8YwL+DrmNQYF70WrzOsw6dxr/hL1CutIcMEIIIYTwr3uAbsvTGetxjJnyRZJUw4pQEqUpm7peXO3ZsweAYg5137591bYLDQ1Fjx49kJGRAXNzcxw/flxjMqEo2rVrxz0ubMj73bt3uZEVbdu2VdvPy5cvC73QUz6Gqn6MjfKdfl2HtEulUi6JVLFiRa322bFjB/dYmykFANChQwfucV4iR528gpt50wt0tXPnTq4gppeXF86fPw9nZ2et9tX23Ctt54yuKDlQGFFLlOW3qK/HRb5DAAAkZmfj4POnmHLqOJptXIPPDwdi68P7iNQwrIwQQgghJa/r6I6wsDbX3LAYLG0s0GVUB80Ny7hq1apxj69evVpo2ytXrgBQjArw9PQs8rECAwO5aQUjRoyAvb29ynavXr1Ct27dkJycDFNTUxw8eLDQde514evry93l3b59u9o73Nu2beMe+/v7F9g+YMAAlW2VZWVl4cCBAwAUd43zhtobs8DAQO5xgwYNdOpj37593J3vjh07amwvlUq5QoHOzs7o1auXVsfp168fVxyxsCkQly9fRmJiIgCgffv2WvWtyqFDh7gaGB4eHrhw4YLWyY+8ePOKaW7dulVtu7zzSSAQoF+/fjrHa+zK7pWvHjACO8BE8/yr0qqKRRhszYxr+J5ELseNd1H4+col+O3YjK47t2LJtcu4/f4dJBqGJhFCCCFE/yxtLDB8zsASPcbwOf6wtCm7FcC11bt3bzAMAwD49ddf1c4N37BhA+7evQtAUVzw04KDABAVFaX2OLdv38a4ceMAAI6Ojli8eLHKdlFRUejSpQvi4uIgFAqxZ88erS8SlQUEBIBhGDAMg+Dg4ALbRSIRvvnmGwCKqRV//PFHgTY3b97E5s2bASgubps3b16gjb+/P6pXV9QNW7Jkico717NmzeJqNMyaNUtlvMHBwVy8AQEBWr1GXezduxepqamFtjlw4ADWr18PALCzsytwYZqcnKzyPVV2584drnAlwzCYNGmSxthOnz7N1QIYPnx4oashKHNycuLOrXPnzmHfvn0F2qSnp2PatGnc84kTJxZos23bNu4zWLhwocpjnT17FsOHD4dMJoOrqyvOnz9f5ESZu7s7Ro4cCQA4c+YMgoKCCrQJDAzEmTNnAACjRo0qdgFOY0brxWhi1gaQPuE7ihKRI7VAmljzsh18ikhOQkRyEjbevwtbMzN0qOqJTp7V0bGqJxzK8DIihBBCiDEZ+r9+uHb4Nl7dLXyYsC5qN6+OIbPKxp2406dP5xvOrjy3/eHDh/nuZltbWxdY271OnToYO3YstmzZgujoaDRu3BjTpk1D+/btYWNjg3fv3mHfvn3cdAChUKj2wr53796wsbHBiBEj4OPjAysrK0RHR+PYsWPYtm0bpFIpzMzMsGfPHri6uhbYPzExEV26dOGKsM2YMQN16tTh5qCr4uDgoPMQ8VmzZmH//v149eoV/ve//yE8PByfffYZLCwscOnSJSxevBhSqRQWFhb466+/VPZhamqKVatWoW/fvkhLS0Pbtm3xww8/oEWLFkhOTsbGjRtx8OBBAIrh5KNG8buM+fr16zFhwgQMGDAAHTp0QO3atWFnZ4fMzEy8fPkSQUFB+OeffwAoLupXrlxZYN5/amoq/Pz80LBhQwwYMABNmzZFhQoVIBQKERUVhePHj2Pnzp3cNJSZM2eiWbNmGmNTnlIwZsyYIr2uRYsW4eTJk4iKisKoUaNw/fp1DBw4ELa2tnj8+DGWLVvG/dv46quvVCZ6NLl16xb8/f2Rm5sLU1NTrFixAhKJpNDz08PDQ+UImV9//RWnT59GQkIChg8fjrt376JPH8X08hMnTmD58uUAFLUffvnllyLHWpowLC1GXyhWfB1s8li+wygR77Jrwu94J77D0ImAYdCkQkV08vRCp2peqOnoxGXaCSGEkLIuLCwMUqkUJiYmqFmzpkGO+e5lNKa1m4+0xHS99WnrZIO/rv2MyrWLN+fYWPj6+mq9TFzVqlXx9u3bAr8Xi8UYM2YM9u/fX+j+VlZW2LBhA0aMGKFye/369fH06VO1+3t4eGDbtm3cqgefCg4Ohp9f0epAjBkzRuVw/oCAAGzfvh0AcOnSJbXTEsLDw9GrVy+EhYWp3G5ra4vdu3dzF27qbNy4EVOmTFG7dn2LFi1w8uRJtfPST506xY2QmD59OndxqG/ani8ODg5YvXo1d4db2du3b/NNR1FHKBRi/vz5+PHHHzX+zZyamgp3d3fk5OSgbt26hZ5H6jx//hz9+vVDeHi42jZffPEF1q1bp3JUwrZt2zB2rOIabMGCBQVGDyxcuBCLFi0qUkxbt25VOxLk9u3bGDBggNpaFe7u7jhy5Ihea20o4+M7XRUaOaCJqCkAEQDjvsOui/icCnyHoDM5y+JuTDTuxkTjtxtXUdXOHt2q10AXr+po4l4RQgHNmCGEEEL0qXLtSlh65gfM7v6LXhIEtk42WHrmhzKTGNAXMzMz7Nu3DxMnTsS2bdtw69YtREdHQywWw9bWFrVr10aXLl0wYcKEQpeK++OPP3D8+HFcv34dMTExSElJgZOTE+rUqQN/f3988cUXRrdee40aNfDgwQP8/fffCAwMRHh4OHJzc1G5cmX06tUL3377LapW1bzc5fjx49G6dWusWrUKFy5cQExMDKysrODt7Y2RI0di3LhxhRZxvHnzJgBFoce8QnclYffu3Th//jwuXbqE0NBQxMXFISEhASKRCM7OzmjQoAF69OiBESNGwMFB9RLkFStWRGBgIG7evIk7d+4gOjoaHz9+RE5ODuzs7FC7dm34+vpi3LhxWg+5P3DgAHJycgBoX4jwU97e3nj48CHWrl2LoKAghIWFISMjA66urmjbti0mTpxY5ORTSWrZsiUeP36MlStX4siRI1zirlq1aujfvz+mTZumcvpOWUMjB7TA5pwHK7kPZAUBbArf4ejNP7H++OZKwWFkpZ2ThQU6V6uOrtVroF3lqjDTw/IohBBCiDHh8y7Tu5fRWDZ6NV6G6D7FoHbz6pi98xt41NK+cBghhpJ3Rz9vigchJc1YRg5QcqAI2KxDYNNm8x2G3hyOnYlZV/Q3NNAYWZqaomPVaujqVQN+ntVgZ16y1ZYJIYQQQ+D7D0mZTIYDvx3DvqWHkZWerfV+iuKG/hgyqx+EQmEJRkiIbsRiMezt7SGRSPDixQvUqFGD75BIOcD3d3oeuqVaFBYDAPFZQGwcSwAW18AaEjjbD8SS61fwKvEj3+GUiCyJBKfCX+FU+CuYCARoUckD3bwU0w8q2tjyHR4hhBBSKgmFQgyf44/+U3rg/M4rOLPtEiIevoVMWnBlIaGJENUbeaLHWD90/rwDrUpAjNqdO3eQk5ODUaNGUWKAlDs0cqCIWJYFxMFgM5YD0ld8h1N8jD2kom44+H4I/rx1A4nZWXxHZDD1Xd3QzasGulavgVpU0JAQQkgpYix3mZTl5uQi4lEkPkTEIlcshcjMBBWqu6O6T1WIzI1r6WRCCDEmxvKdTskBHbGsDMg+AjZjBSCP5zuc4rMciyzzGVh/7w423b8HsUzKd0QGVdXOHl29FHUKqKAhIYQQY2csf0gSQggpPmP5TqfkQDHJU/4H5BzhOwy9YGzmAZaj8SEjHX/cuIYjL5/zHRIvqKAhIYQQY2csf0gSQggpPmP5TqfkQDHJE7oBsrd8h6E/jD0Y24VgLHohNC4Wi69exp2Y93xHxRtLU1N0qOKJbtVrwM/TiwoalkPJucm4knAt3+/ypqAwyD8VJe85819Dndux+Per+d+vaPbT3yvRpq2jyAGN7RvB0sSywP6EkNLHWP6QJIQQUnzG8p1Ot0SLiGVZQHIXYKwARlS2EgMAwKaAzfkHjEUvNHRzx95BQxGfmYn0XDHSxGJEJCfhz5vXEZeZwXekBpElkeB0RBhOR4RRQcNyKik3GYeij/Adhl6YMCZoYFcfLRybo7GDDyyEVBSMEEIIIYQo0MgBHbC5d8AmjQOQw3coJYOxAuN6GwyjunhQuliMFbeuY0foQ8jL8elDBQ3Lh1fpYfj1+VK+w9A7c4E5fmmwEC5mLnyHQgjRgbHcZSKEEFJ8xvKdTlXXdMCIWoBxWAugjFbeZTOB3PtqN9uYmeHHjp1weNhINHB1M2BgxuVJfBz+vHUdPXdvR6cdW7D4ajBCYt5DJpfzHRrRIzlbNj/PHHkONr/eVmZfHyGEEEIIKRpKDuiIMWsLWI3nO4wSw+be0NimgasbDg0dgYUdO8HatGiJEjcra5iXoUJ/kakp2PTgHoYF7Uerzesw+/wZXHgTgRyphO/QSDHJ2IJrdpcVz9Nf4FJ8MN9hEEIIIYQQI1B2rs54wDBCFaXBygIBGPOeWrUUCgQY7dMY3avXxC9XL+Fk2Cut9mtbuQpSxTl4lZiIzNxcJOVkFydgo5KYnY0Dz57gwLMnVNCwDCjLyQEA2P8uCA3tG9D0AkIIIYSQco6SAzpi2Vywkid8h1EyLEeDMfUu0i5u1tZY3bMvBnu/wYLgC4hKSy20fR1nF3zRuCkEDAOxVIrDL55h04O7eJ2cXJzIjY5yQUMhw6ClR2UqaFjKlPVh92K5GJtfb8P/6syAgKHBZIQQQggh5RUVJNQRm7kDbPovfIehfwJXMM6nwQisde4iRyrB3yG3seFeCCRq5t9Xs3dA4JDP4Gjx37JqcpbFpTevsfH+3XKxfCIVNCwd7iXfx6qwv/kOo8SNrvo5Orv58R0GIURLxlK8ihBCSPEZy3c6jRzQleXngPQVkH2A70j0irH8rFiJAQAwNzHFjNbt0K+WNxZduYh7MTEQy6Tc9jaVq2BJp275EgMAIGAYdPaqjs5e1fEw9gM23b+L0xFhZXZFhCfxcVxRw6p29ujqVR1dq9dAE/eKEAroDq6xKOvTCvLsfxeIhvb1aXoBIYQQQkg5RSMHioFl5WDTfgCyg/gORW8Y25/BWA7Ta58syyI9NxcfszLBMAyq2Ttove+GeyFYev2KXuMxdk4WFuhcTZEoaFu5CsxNTPkOqVy7mXgb6yI28B2GQdS2qYWvq0+Evcie71AIIRoYy10mQgghxWcs3+k0cqAYGEYA2P4KWAwEm7kZEF8ESnuJQoGj3rtkGAa2ZmawNTMr8r71y+FSiVTQ0LjIy8nIAQB4mf4K3z2chUYOPujo0h4N7RpQHQJCCCGEkHKCkgPFxDAMIGoGRtQMrOQZ2KSRAJvJd1i6K4HkQHF4O5fvIc6fFjRs5VEZ3avXRPfqNeFiZcV3eOWCrIwXJPyUHHLcT36A+8kP4GDqgA4u7dDepR1czJz5Do0QYuTEYgnCIhMQE5uCXIkMIlMhKrrbo2ZVF5iZ0Sg4QggxdpQc0CPGtC5g+wvY1O/4DkV3Au2H/BuCg4UF3K2sEZuZwXcovJOxLK6/i8L1d1FYEHwBTSpURI8atdC9eg142NrxHV6ZVV5qDqiSLEnG0ZjjOBZzAt3du+KzykOpcCYhJJ+s7FycCn6Kfy49QfjbBMhkBROqQqEANT1d0KtTffToWA+WFiIeIiWEEKIJ1RwoAfLUH4HsfXyHoRPG9Q4YgT3fYXCyJBLMPn8Gp8JfQUanqlr1XVzRvUYtdPGqDrt/p2+wLMCCVUx0+fetY8H+9/t//z9vc95XAff/UKwgkbeN/bdT5eeFb/vkWIVs//d/hWxj870eOat4Xtg0Hif7LEAgVbs97x3R5EnqU1z5eE1ju/Kgs6sfPq86gqYaEGIE+J6fKpPJsedoCHYcvIXsHInW+1mYm2L0oFYY0b85hEL6LiGEEID/7/Q8lBwoASybAzZxCCB9yXcoRSQE4/ZUUUvByKSJxbjxLgqXI9/gSuQbfMigkQREvUp2ItTwDoUc5WtKgCF0dOmAAM9RlCAghGd8/iEZFZ2En1aexIuIOJ378K7hjvnf9EKVSsY1nZEQQvhgLMkB+uuuBDCMORj7lQBjqbmxMRHYG2ViAABszczQo0ZNLOncDdfGTsCpkWMwp10HtPaoAtN/l/2r4eCIyc1bggY9k7beoMRACbmccAWb32yFvJzVYiCEKLyIiMVX8/YWKzEAAM/DFf28fF28foxJfHw8tm/fjilTpqBNmzaoVq0abGxsYGZmhgoVKqB79+5Yu3YtMjMLr021cOFCMAyj1U9wcLDKPgICArTuI+9n27ZtGl/j8+fPMWvWLDRs2BAODg6wsLCAp6cnunTpgsWLF+Pt27dFf+P+FRUVhbVr12LYsGGoXbs2rKysYG5uDg8PD/Tv3x979+6FVKppROB/nj59ikmTJqFGjRqwsLCAi4sLOnTogPXr1xepH76sWbNG688nODhY68954cKFGo9969YtfPnll6hduzasra25c7hHjx7YtGkTcnNzC93//v37WLx4MXr27InKlSvDzMwM1tbWqFWrFgICAnD16tUivhuFe/bsGaZOnYoGDRrA1tYWIpEILi4u8PPzw4oVK5Cenq5VP4mJiViwYAF8fHxgZ2cHW1tb+Pj4YMGCBUhMTNRrzMaKRg6UIDb7GNjUmXyHoT2TmhA4n+Q7iiLLzM3FzfdRuBsTjU7VqiM1JwffnjmJHKkUAoaBnE7xckUkBDq1ikKmjEaXlKTWTi0x3utLCBkh36EQUi7xcZcpKjoJX83bi9T0bL31aWdjgbW/Di8TIwg2bdqE8ePHa2xXtWpVHDx4EE2bNlW5feHChVi0aJFWx7x06RJ8fX0L/D4gIADbt2/Xqo88N27cQOvWrVVuY1kW8+fPx7Jlywq9sF6xYgWmTZtWpOMCwI8//ohffvkFmi5LmjVrhoMHD6JKlSqFttu8eTMmT54MsViscnurVq1w4sQJODk5FTlWQ4iJiYG3tzfS0tK4323duhUBAQEq2wcHB8PPz0+rvhcsWKA2QcCyLKZPn46//vqr0D4aNGiAf/75Bx4eHgW2dezYEVeuaF6GfNSoUdi0aRNEouLVIFm+fDlmz55d6HlZtWpVHDt2DA0bNlTbJiQkBP3798eHDx9Ubq9YsSKOHj2KZs2aFStedYxl5AAVJCxBjEU/sOILQM4pvkPRjpGtVKAtK5EIXbxqoItXDe53ewcNw/4nofi6eUuMOhyEyNQU/gIkBtWpriWXGBBCABmNICgRNxNvQ8rKMMlrPEwE9J8SQso6mUyOn1ae1GtiAABS07Px86p/sG7xiFJfg4BhGNSsWRO+vr5o3LgxKlWqhAoVKiAnJweRkZHYtWsXzpw5g8jISHTt2hVPnz5FhQoVCu3z8ePHhW6vVq2ayt//+uuvmDmz8BtUycnJ8PX1hVwuR82aNdUmBgBgwoQJ2LRpEwDAx8cHX375JXx8fGBhYYF3797h2bNnCAoK0rlobUxMDFiWhZWVFfz9/dG5c2fUrFkT5ubmeP78OVatWoWQkBDcvXsXXbp0wf3792Ftba2yrzNnzmDChAmQy+Vwc3PDvHnz0LJlSyQlJWHjxo04dOgQbt26hYEDB+LSpUsQCIzvvJsyZQrS0tLg6uqK+Pj4Iu27ZcsWNG/eXO12V1dXtdt+//13LjFgY2OD6dOno23btrC2tsbLly+xfPlyPHnyBI8fP0bv3r1x7949mJjk/xsgOjoagOJiesiQIWjfvj2qVKkCmUyGmzdvYvny5YiOjsbOnTshlUqxZ8+eIr0+ZQcOHODOc5FIhMmTJ6NLly5wdnZGREQE1qxZg2vXriEyMhI9evTA8+fPYWdXsIh3dHQ0+vbti7i4OJiYmGD69Ono06cPAODEiRP4888/ERMTgz59+uDevXuoVKmSzjEbOxo5UMLYnDNgU6byHYZ2zHpA4LCK7yj0LjotDb327EB6rursMSlbmla1gEeVSFjIKkJqkoi43Gi+QyrTmjg0xkSvcTAXmvMdCiHliqHvMu08dBvrd+t3KLCyiSPbY9TAliXWvyHkfR6F+euvv/Ddd4pVraZPn47ly5cXaKM8cqAk/0xfu3Ytvv76awDAzz//jB9++EFluy1btuDLL78EAEybNg3Lly9Xe0Gdm5ur053g77//Hk5OTvjqq69gY2NTYLtMJsOIESNw4MABAMBPP/2E+fPnF2gnlUrh7e2N8PBw2Nra4v79+6hevXq+NpMnT8aaNWsAANu3b8fo0aOLHG9JOnr0KAYMGAAXFxfMnj0bM2bMAKD9yAF1o0k0kUgkcHNzQ3JyMkQiEW7fvo1GjRrlayOVStGuXTvcvn0bAHDw4EEMHDgwX5s+ffpg9OjRGDRoEITCgqMLP378iLZt2+LVq1cAgCtXrqB9+/ZFjhdQjGB48uQJAMVFfO/evQu0GTRoEA4dOgRAMcpg+vTpBdooj7Q5cOAAhgwZkm97YGAghg4dCgAYO3YstmzZolO8hTGWkQPGlyora0RtUGoGaMg/gC2D84gr2thwVflJ2XcvMhunb7gh6JYUpqwV3+GUefeTH2Dmo9n458NpiGWUgCOkLMrKzsWOg7dK9Bg7D91GVnbh85iNnabEAKC4I5x3x1ubodclaceOHQAUIx5GjRqlsk16ejp3Z9bX1xcrVqwo9E67rkPEly1bhv/9738qEwMAIBQKsWbNGq7/oKAgle0OHz6M8PBwAMCcOXMKJAYAxd1xBwcH7rExSU9Px5QpUwAAf/zxBxwdDTeq9/nz50hOTgaguMD/NDEAKM7xuXPncs9v3LhRoM2JEycwdOhQlYkBAHB2ds6XFFP3WWqSlpbGJQaaNGmiMjEAKKZRFBZvXFwcdu3aBQDo3r17gcQAAAwZMgTdu3cHoPh3ExdXdmqlfIqSAyWMEdgApo35DkM7kkdA1m6+o9C7j9lZyNBQOIWULWIZC6kcYGVmfIdSLqRL07H/XSBmhc7G6dizyJXTvzdCypJTwU+LtFyhLrKyc3H68tMSPYYxMDExgdm/Sw7n5OTwFkdYWBhu3VIkfDp27IiqVauqbLd7927uglGbQnYlycnJiZszHhERobLNkSNHuMfq7rJbWlpyd4GfPHmCsLAwvcZZHHPmzMH79+/h6+tr8BENykUGvby81LZTTrioq+mgifLIBnWfpSb6ivfYsWOQyWQAFKMC1Mk7n2QyGY4dO1bUcEsNSg4YgrAi3xFojc34A6w0iu8w9CKvEOGbf/+jRsqf3FxTvkMoV1IladgbtR+zHs1GUi79uyOkrPjn0hPDHOeiYY7Dp3PnznFVz+vUqcNbHHmjBgAUehEaGBgIQDFPvWPHjgAUUx1iY2MRERGBDAMvLZ13cadu9EJeFfzatWvD3d1dbT95rwUArl27pscIdXf79m2sXbsWIpEIa9euNfjxa9asydWMeP36tdp2yhfztWrV0ulYyhf2utZ8cHZ25kZWFCde5ZUTlM+LTxnjOVMSKDlgCJLCi8kYFTYbyC045KY0YlkWl9++wZsUukgprzJy6CuODymSVBx+f4TvMAgheiAWSxD+pmgF0XQV9jYB4lzjX2KuqNLT0/Hs2TMsXLgQgwYN4n7/zTffaNy3a9eucHJygkgkgqurK3x9fbF06VLubr4uWJblhlFbWlpi8ODBKtvJ5XKEhIQAUFT3z83NxaJFi7hCizVq1ICtrS2aNWuGnTt3lmh9BECxVOTz588BqE6sZGRk4P3792q3K1PentcnnyQSCcaPHw+5XI5Zs2YVK3E0d+5ceHh4QCQSwcHBAY0bN8Z3333HzfFXx87ODsOGDQOgmBoQGhpaoI1UKsWSJUsAALa2thg+fLhOMV6+fJl7XJzXOmHCBACKpRNPnVJdAP7nn38GoJiaMm7cuALb8z5/Ozu7QhNKFSpUgK2tbb59yiL6y7mEsfI0QKY+m2WUTPjLZOuTUCDAjfdROBsRzncohCcphS8lTUrQ1Y/XEZlZNkYhEVKehUUmQCY3TN0emUyO8LcJBjlWSVu4cCG3rrytrS3q1auHRYsWIT09HUKhEH/99ZdWRdjOnz+PpKQkSCQSJCQk4PLly5gzZw68vLxw9OhRnWK7cuUK3r59CwDw9/dXO8//3bt33Prwrq6u6NChAxYuXJhvqTeWZXHv3j2MHj0an332WaHLyRXX77//zvWfNy1A2fv377kEhaol9pRVrlyZe/zu3Ts9Rqmb33//HY8fP4aXlxfmzZtXrL5u3ryJ6OhoSCQSpKSk4OHDh/jrr7/g7e2NhQsXFprEWbFiBRo1aoTc3Fy0b98eP/30E86fP49bt25h+/btaNasGW7dugULCwts27YNzs7ORY5PLpdj6dKl3HNVn6W25s2bhy5dugBQnMszZ87EqVOnEBISgv3798PX1xdBQUEQCoVYtWoVvL29C/SR9/lrOmeA/84bYzhnSgolB0qaPB4wqQVAt6Vd+MCmLQSbG8J3GHrRydMLl96WsuQM0Zu41LJ3B6q0YMFi2Yvfce3jjRK/m0QIKTkxsSkGPV50nGGPZ2idO3dGaGgovv3220LbNWjQAPPnz8fx48dx79497uKsW7duAICUlBQMGjRI7d3SwihPKRgzZozadklJSdzjnTt34vbt2/D29saJEyeQnp6O9PR0HD9+HLVr1wagqPKubsWD4rp9+za3xJ6Hhwe3yoKyvEQGALXLHOaxsvqvYLGhp0Z8Kjw8nLu7/ffff8PCwkKnfipUqIDJkydj7969uH37Nu7du4fDhw/jiy++gKmpKeRyORYtWlRo8sHd3R3Xrl3Dn3/+CQsLCyxYsABdu3ZF69atERAQgNDQUHz55Ze4e/cu/P39dYpzxYoVuHPnDgDFBX2zZs106gdQfM6nTp3Cxo0b4eHhgeXLl6NXr15o0aIFPvvsM1y+fBkDBw7E9evXVZ4zwH/njaZzBvjvvOH7nClJpaSMfunFmNQA43wCrCwBbOJQQF4KllWTPgObNBKsWXcwNrPAmFThOyKdNXBTPzyIlH0xqbkovWdv6Zcpy8LG15txJ/EOAqqNhqPIcFWXCSH6kSuRGfR4EknZSOp+/fXX3HD9zMxMPH/+HDt27MCFCxcwfPhwbNiwAS1bql66cdq0aSqL/7Vs2RKjR4/G+vXrMWnSJMhkMowbNw7h4eFaX1Dm5ORw1eErVaqEzp07q22bmfnf8DuxWIzKlSvj2rVr+Sro9+nTB61atYKPjw9iYmKwYsUKTJ06Va/rwMfFxWHw4MGQSqVgGAbbt2+HpaWlyteWR9OqCXlFIQEgOztbb7HqYtKkScjJycGQIUPQo0cPnfpo3rw5IiMjYWqav9ZSkyZNMGDAAEycOBHdunVDamoqli5diqFDh6pcjQBQLIu4b98+lRX5WZbF8ePH4erqioULFxZ5dYrLly9j9uzZABSjUfRRW+Hu3bvYu3ev2roD58+fh5ubG7y9vblpAcryzhttXkveecP3OVOSaOSAgTBCFzAOqwCUogJp4jNgkyfyHUWx3PtQCpIxpMRIZICNierhksRwHqU+xtzHP+LGx5JdCo0Qon8iU9XLkZUUU9Oycd/K1dUV9evXR/369dGyZUsEBATg4sWL+OWXXxAaGgpfX1+cPXtW5b729vaF9j1x4kRu7nRMTAy3hrs2jhw5grS0NADA559/XmgxOHNz83zP582bp3JpPWdnZ255u9zc3CLFo0l6ejp69+7N1RJYvHgxOnXqpDHeXA2rVClXrdf1Tr0+bNu2DRcuXICtrS03MkIXVlZWBRIDylq0aIG///4bgOICP+/xp1auXIl+/frhzp076NChA86dO4fU1FSIxWI8e/YMM2fORGJiIpYsWYKuXbvmSyBp8vTpU/j7+0MqlcLMzAwHDhyAm5tb0V7oJ4KCguDr64uLFy+iQYMGOHz4MBITE5Gbm4uIiAgsXrwYEokEa9euRZs2bRAbG1ugj7zzRtM5A/x33vB5zpQ0Sg4YEGPaAIzjntI1p5/N4juCYrkWFcl3CIRnlgJKDhiDbFk2tr/dgRwZf0t3EUKKrqK7vUGPV8nNsMcztHnz5qFly5bIycnB+PHjdZ6jP3HifzdvlIu7aaLtKgUACtQi6Nmzp9q2eWvAA+CKGBZXTk4O+vfvj3v37gEApk+fzt11VkU5Xk3DvpUvarUZTl4SEhISMHPmTACKonkVK5bs6mbDhg2DnZ0dANXnzKNHjzB9+nTI5XJ06dIFFy9eRJcuXWBrawuRSARvb2/8/vvv2LBhAwBF7Qptl7d88+YNunXrhuTkZAiFQuzdu7fQlQG0ERcXh4CAAIjFYtSrVw83btzAgAED4OjoCFNTU3h5eWHOnDk4fvw4GIbB06dPMXXq1AL95J032kwVyDtv+DpnDIGSAwbGiHzAOB0CYzMbYAoOiTI6bOkeNkPJAWLKWmluRAwiRy7GmvD1eJup+HeZKy/ZddMJIcVXs6oLhALD1E0SCgWo4elikGPxqV+/fgCAqKgobu51UdWtW5d7HB2t3SjJuLg4brRC06ZN8/WhioeHB7e0HYBCpwooF/iLjy/+6hZSqRRDhw7FpUuXAADjxo3D8uXLC91HuaBc3kgDdZQLyinHbkibNm1CYmIi7O3t4eTkhH379hX4uX37Ntf+9u3b3O91eY9NTEy4pfxUnTPbtm2DXC4HACxatAhCoepRQ1988QVq1qwJANiyZYvGukIxMTHo0qULYmJiwDAMtmzZonO9AmX79u3jLtbnzp2br46Ess6dO3PTZw4dOlRgpY+880bTOQP8d97wdc4YQtkYu1XKMIwJYPUFYN4TbNpCQHyJ75DUK8XJATnL0jKGBJCZa25DDOZRaigepYaikkVFMGAwospniMn5gE6uvhAyhh2+TAjRzMzMFDWqueJlRMH5x/pW09MFZqKy/6epi8t/CZDIyEi0adOmyH3oUuh19+7dkMkUNSQKK0SYx8rKClWrVuVWNpDL5WovGPP6BRQXocUhl8sxatQoHD9+HIDijvf69es17mdtbY3KlSvj3bt3ePHiRaFtlberqmBvCHlD1FNSUvD5559rbL9u3TqsW7cOAHDp0iW4uroW+ZiFnTfKy/M1adKk0H6aNGmCsLAwJCUlIT4+Xu30gI8fP6Jr165cPYDVq1drHLGiraLE27RpU5w/fx5yuRyvXr3KV++jbt26uHfvHlJTUxEbG6t2OcMPHz5wU3L4OmcMgUYO8IgRVgBj/R3fYWggBsvK+Q5CJwKGQRsPKkdX3oklpajORzkSnR2D99nR+O3lcuyK3IM/Xq5AhqTsVv8lpDTr5VffMMfpZJjj8E35rq2uw5OfPXvGPdZ2OHrelAJTU1Ot16fv0KED9zgiIkJtO+VtxS1GOHHiROzbtw+AouDhzp07C62NoKxdu3YAgJcvX6qcX55HeVh927ZtixFt6SGVSvHq1SsAqs8Z5aSOpukuEsl/I//UJYNSU1PRvXt37lxdunQpJk+eXOS41dFXvHnnDFD4FJ3ycs5QcoBvTCkY8lyKRw909arOdwiEZ5k59DVXGjxLe46Fz35GVFbZXTuYkNKqp289WJiXbKLV0kKEHh3rlegxjIFcLsfBgwe55/Xr65YQUb6Trs3c7cePH+PRo0cAgF69emm9Pv2gQYO4x4UVGlTe1r59e636VmX69OnYtGkTAMVw8KCgoEIL7X1qwIAB3ONt27apbJOVlYUDBw4AUNw1zhtqb2gLFy4Ey7KF/mzdupVrv3XrVu73vr6+RT7evn37uDvfqs6ZatWqcY+vXr2qth+JRIKbN28CAOzs7FQWqczKykLv3r1x//59AIpaG99//32RYy6MtvECivoIAMAwDDw9PfNt69evH5d8Un6/P5V3PgkEAm5qUFlEfzXzTUDJgZLUyas6hIxh5koS45ScUfShl4QfCeKP+PnZYoQk3eU7FEKIEksLEUYPalWixxg1sCUsLYq2LJqx2bhxY77h9Z+Sy+WYMWMGnjx5AkBxx1L5AgdQXMSHh4cXepz169dj8+bNABTr0mszf3v79u3c46IM6+7Tpw+XwFi2bBlevnxZoM3z58/xxx9/AFBMmRg4cGCBNgEBAWAYBgzDIDg4WOWxFi5ciBUrVgAA2rRpg6NHj+ZbclAb/v7+qF5dcWNoyZIlKkc7zJo1i5t3PmvWLJX9BAcHc/EGBAQUKQZDS05OVvue5rlz5w5XjI9hGEyaNKlAm759+3KPZ8+ezSUSPrVgwQJ8+PABgCLRxHzyd3Zubi78/f1x/fp1AMC3336LX375RevXk2fbtm3cZ6Cq8GHv3r25Y//6669qa29s2LABd+8q/q5o1aoVnJyc8m13d3fHyJEjAQBnzpzhlvpUFhgYiDNnzgAARo0apXbqQVlQ9id2GTumFFS7LMXJARdLK8xp1xG/XA3mOxTCk4Q0OTyKt1IOMaBceS7+L3wt3MxcYWVihbne38NUQFNDCOHbiP7NcfnWK7wogdoD3jXcMaJ/c733a2gTJkzAokWLMHjwYLRq1QpVq1aFpaUlkpOT8eDBA2zbtg2hoaEAAFtbW6xZs6ZAH/fu3cO4cePg5+eHnj17okGDBnBycoJUKsWLFy+wa9cunDt3DgAgFAqxfv16tYXY8shkMuzZswcA4OjoiD59+mj9mgQCAdauXYvOnTsjLS0Nbdq0wffff4+OHTuCZVlcvnwZy5Yt4yq9r169GpaWRS+4vXr1aixatAiAYlrCb7/9hjdv3hS6T+3atQuMKjA1NcWqVavQt29fpKWloW3btvjhhx/QokULJCcnY+PGjdzIjXbt2mHUqFFFjtXYpKamws/PDw0bNsSAAQPQtGlTVKhQAUKhEFFRUTh+/Dh27tzJDa2fOXMmmjVrVqCfbt26oVOnTrh48SJCQ0PRqFEjfPvtt2jRogXMzc0RHh6OLVu24PTp0wAUNSkWLFhQoJ/hw4dzhS87deqEL7/8kkuIqSISiXQavVGnTh2MHTsWW7ZsQXR0NBo3boxp06ahffv2sLGxwbt377Bv3z7u3BcKhVi8eLHKvn799VecPn0aCQkJGD58OO7evcv9Ozlx4gRXDNPFxUWnREdpQskBnjGMCCxMARhx1W5pOGBSeqtyjm3UBA/jPuDEq4LZblL2RaeI4cmYQMrqtlwU4UecOB4QA7cSb6O9SzvNOxBCSpRQKMCP3/bGV/P2IjVdfzcN7GwsMP+bXhAKy8Zg1ujoaKxcuRIrV65U28bb2xu7du1CgwYNVG6XyWQ4f/48zp8/r7YPJycnbN68WavhzefOnePu9H722WcQiYo2QqNdu3bYs2cPxo4di6SkJJXDw/MuyocNG1akvvMoT7WIjo7ONw9cnTdv3hQYIg4o7mavW7cOU6ZMQVxcnMrl61q0aIHDhw+rLbCYnf3fOf7pnWZjFRoayiWfVBEKhZg/fz5+/PFHtW2CgoIwaNAgXLp0CW/evMG0adNUtnNxccGePXtQu3btAtuUp5hcvHgRDRs2LDRu5aKXRbVmzRpkZmZi//79SEhIwLx581S2s7KywoYNG9ROx6hcuTKOHz+OAQMGIDY2FsuWLcOyZcvytXF3d8eRI0fyrYpRFlFywBgwlgCbyncUarHZe8CY+/Edhs4YhsHSzt3xKjERrxI/8h0OMbBcGSD92Agmzg8pQVAKbXqzFZFZURhaeQhENIKAEF5VqeSIP38cjOk/BeklQWBnY4E/fxyMKpUKzlkujUJDQ3Hx4kUEBwcjLCwMcXFxSElJgaWlJSpWrIgmTZrA398f/fv3VzuPvlevXti8eTNu3ryJBw8eIC4uDomJiWBZFo6OjvDx8UGPHj0QEBAAW1tbreLauXMn91jXSvGDBg1C8+bNsXr1apw8eRLv3r2DXC5H5cqV0aVLF0ybNg01atTQqe+SMH78eLRu3RqrVq3ChQsXEBMTAysrK3h7e2PkyJEYN25coasq5M2pNzExwZQpUwwVtk4qVqyIwMBA3Lx5E3fu3EF0dDQ+fvyInJwc2NnZoXbt2vD19cW4ceNUJlOUOTg44MKFCzh27Bj27NmDkJAQxMbGQiqVwt7eHvXq1UPPnj0xbtw4lbUGDM3MzAz79u3DxIkTsW3bNty6dQvR0dEQi8WwtbVF7dq10aVLF0yYMEHjRX3Lli3x+PFjrFy5EkeOHOESFtWqVUP//v0xbdq0UpMoKg6G1WUtFKJX8nhfQB7DdxiFYMA4nwVjUpXvQIrlTUoy+u/bhYzcXL5DITzo2cASGVY0l720qmJZGXPq/A+WJkUfrkpIWRQWFgapVAoTExNuzXFDiYpOws+r/sHzcPXV4DXxruGO+d/2QpWK/F9gEPIpX19fXL58mRu2TkhJ4/M7XVnZGMNV2hl9UUIWbNZuvoMotmr2DljRrRffYRCe3H1DSaHSLCrrHcIy1C+jRQgxnCqVHLFu8QhMHNm+yEUELS1EmDiyPdYtHkGJAWKUxGIxbt++DaFQiLlz5/IdDiEGRckBY8AtZ2jEVfWzg8DKM/mOotg6e1XHlOYlW3GZGKeEDCnsTRz4DoMUw+vM13yHQAj5l1AowKiBLXFk4yRMH98Zdaq7qa0bIBQKUKe6G2aM74IjGydh1MCWZabGACl77ty5g5ycHIwYMcKopkoQYghUc8AY5CUHLAYC2UcAqF8GhzdsBiCLAQT8DXPRl29btkZoXCyuRL3lOxRiYNaMC1KQzHcYREdvMgqvXE0IMTxLCxEG9miMgT0aQ5wrRfjbBETHpUAikcLU1ASV3OxRw9MFZiL6k5OUDu3btwfNuiblFX1TGwMTL8C0ERizDmBl0UDuLb4jUk1Yke8I9EIoEOCvHr3Qe88OfPh36R1SPohzrAHVhYlJKfA68w1Yli2wpjIhxDiYiUxQr1YF1KtVge9QCCGE6IDGdBkBxvobMGZtFCsWSCNhlNMLGHswRl8bQXv25hYY5F2f7zCIgcUmUWagNEuXZiiWOCSEEEIIIXpHyQEjwAjsANMGYMx8IXC9DMYtFIyN+jVIeVFGRg0o61Gj9E+RIEXzNEZ/a3MTfsx/shBXEq7xHQYhhBBCSJlDyQEjwTDmSo/NwFh9DpgP4C+gTwkr8R2B3tVycoZISHeSy5PUbDkcTZ35DoMUQ648F3eSQiCRS/gOhRBCCCGkTKHkgBFjzHvyHcJ/ymByIDQuFrkyIyz+SEqUJevCdwikmB6nPsHqsDWUICCEEEII0SNKDhgz07p8R8BhyuC0Andra/zdqy/crKz5DoUYUHa2Jd8hED14lBqK/wtfSwkCQgghhBA9oeSAMRO4AgIjGQJdBpMDFW1s0bNGLWwbMAi2ZmZ8h0MMJDrRCAt+Ep08THmE7W938h0GIYQQQkiZQMkBI8YwDGDizXcYCgIHviMoMbWdnPFDe1++wyAG8jQmB4wxrghCdHI7KQRimZjvMAghhBBCSj1KDhg703p8RwAAYDN38B1CiXKxLDvLNJLCZeXK4WzqyncYRE9y5bl4mvaM7zAIIYQQQko9Sg4YOcZY6g6Iz4AV3+I7ihJjKTLlOwRiQGasE98hED1Kzk3hOwRCCCGEkFKPkgPGTlCB7wg4bPqvYFkp32GUCEsTSg6UJxmZVJSwLKllU5PvEAghhBBCSj1KDhg7WRTfEfxH+hLIDuQ7ihJhKRLxHQIxoHcfWb5DIHpiKbRAJYuyVzCVEEIIIcTQKDlg5FhpGN8h5MOmrwArT+U7DL2jkQPly7OYbAgZId9hED2QsjIqMEkIIYQQogcmfAdANJCG8x1BfmwK2LQFgO1iMIKyMzTb0pSSA+VJrgxwMnVDfG4M36GQYsqV5yJZkgJHUdldUYWQ0iJHKsHzhAREpqYiVyaFSGiCqnZ28HZxgTkl4QkhxOhRcsDYySL5jqCgnH/A5j4EbH8EY96J72j0gpID5RFNLSgr4nLiKDlACE8ycnNx6PlTBD1/ihcfEyCVywu0MREI4O3sgsF168O/Tl1Y01Q+QggxSpQcMHKM4wEg9xrYzO2A5C7f4fxHHgM2ZRJYs65gbOeDEbrzHVGxCAUCiIRC5MpkfIdCDCRbnsF3CERPPuTEwtu2Dt9hEFKuyORyrL8XgrV3byNTIim0rVQux+P4ODyOj8Nv16/gq2YtMbFpcwgFNLuVEEKMCX0rGzlGYAXGvDsY++UAzPgOpyDxObDpS/mOQi+uBIzDhj790bGqJ9+hkBImYIAMKSUHyoobH28iV57LdxiElBuvk5Mw8MAe/HHzmsbEwKcyJRL8cfMaBgXuxevkpBKK0PgMHToUDMNwP2/fvlXbduHChfnaFvYTHBxc6HFZlkVgYCAGDBiAypUrw9zcHJaWlvDy8sJnn32GM2fOFLq/VCrFuXPnMGvWLLRv3x4uLi4wNTWFvb09mjRpgpkzZyIiIkKHd0S9s2fPYvjw4fDy8oKlpSXMzc1RuXJlDBgwAAcOHADLajfy7+nTp5g0aRJq1KgBCwsLuLi4oEOHDli/fj2kUuNcfSszMxN///03OnfujEqVKsHMzAxubm5o0qQJpk6dirNnzxa6f1xcHH744Qc0bdoU9vb2sLCwgJeXFwICAnDrluYlyRMSErB161aMHj0a9evXh42NDUQiEdzd3dGjRw+sX78e2dnZGvvR9vz19fXV9q1RKS0tDfv27cP48ePRpEkT2NvbQyQSwcXFBb6+vvjjjz+QkpKidX+JiYlYsGABfHx8YGdnB1tbW/j4+GDBggVITEwsVqylBcNq+y+M8E6eOh/I3s93GAUxNmBcb4FhysbQ/Lcpyei8YwsNOi/D3G1NUbPuI77DIHrkY9cA39ScAhMBDYgDgAfJD3E85iSaOzZDa6eWsBfZ8x0S0bOwsDBIpVKYmJigZk3DLef5OD4OAUeCkJyTU+y+HMzNsX3AYNR3ddNDZMbr5MmT6NOnT77fvXnzBp6enirbL1y4EIsWLdKq70uXLqm9wEpNTcWAAQM0JhCGDRuGHTt2QPTJdI+EhAR4e3trvCgSiUT47bff8O2332oVszq5ubkYNWoUDhw4UGg7X19fHDlyBHZ2dmrbbN68GZMnT4ZYLFa5vVWrVjhx4gScnJyKFbM+Xbp0CWPHjkVkpPopxT4+Pnj48KHKbceOHcOoUaOQlpamcrtAIMCcOXPwyy+/qNy+ceNGfPXVV5BpGEVbs2ZNBAUFoWHDhmrbMIx2hYI7duyo8fxU59SpU/D391f7Gedxc3PD3r174efnV2i7kJAQ9O/fHx8+fFC5vWLFijh69CiaNWumU7ya8PWd/in6K6o0Eaj/EuQVmw7k3gXMWvMdiV542jugR41aOBX+iu9QSAlxsaaVCsqaR6mPsS5iA76qMbHcr0SRlJuEv8JWAwAiMl9j/7tA1Lerh7bObdDEvhHMhPlHoclYWbl/z4h2Xicn6S0xAADJOTkYcyQIgUOGw8vBUS99GpuMjAx8/fXXAABXV1fEx8cXaf/Hjx8Xur1atWpqtw0fPpy78KpWrRpmzZqFBg0aQCKR4N69e1i2bBk+fvyI/fv3w8nJCX///Xe+/cViMZcYaNSoEfr374+WLVvCzc0NqampOHXqFFavXo2cnBxMmzYNFhYWmDBhQpFen7Jp06ZxiQFXV1f873//Q5MmTWBqaorHjx9j2bJliIyMRHBwMEaMGIGTJ0+q7OfMmTOYMGEC5HI53NzcMG/ePLRs2RJJSUnYuHEjDh06hFu3bmHgwIG4dOkSBEYwveX8+fPo27cvcnJyYGNjgwkTJqBz585wc3NDQkIC3r59i1OnTiEuLk7l/levXsXgwYMhkUhgZmaGqVOnonfv3rCxscGLFy+wYsUK3Lt3D7/++iscHR0xffr0An3ExcVBJpNBJBKhT58+6NatG7y9vWFjY4OIiAhs3LgRZ8+eRVhYGLp06YL79+/Dw8Oj0Nf11Vdfcee/KlZWVkV7o5QkJiZCLBZDIBCga9eu6NGjB3x8fGBvb4/3799j9+7d2L9/P+Li4tCnTx9cv34djRo1UtlXdHQ0+vbti7i4OJiYmGD69OlcQu/EiRP4888/ERMTgz59+uDevXuoVKmSznEbOxo5UIrI05cDmev5DkM1s65g7JaBEViDZWUABFpnDY3Ro9gP8D+wh+8wSAnpUMsSrKMR1fAgejOs8hD0qtCD7zAMSs7KIWNlMBUoRm/dSQrB3+HrVLY1F5ijuWNTtHVuAzkrx9WP13A/+SHaO7dFQ/uGCEsPw4v0l2jt1BKtnFpCyAhhLjTP10eOLAcv08PgY98AmdJMWJno/scd0Z2h7zLJ5HIMPLAHj+NVX5wUR0M3dxwcMrxM1iCYNm0aVq5cic6dO8PDwwPbt28HoP3IAV3/TL937x53h9PLywsPHz6EjY1NvjZRUVHw8fFBSkoKBAIBYmNj4eLiwm2Pjo7G2LFj8dNPP6FVq1Yqj3P79m34+fkhOzsbdnZ2ePfuXYHjaCM+Ph4VKlSAXC6Hg4MDQkNDC1x4pqWlwcfHh5uSce/ePTRp0iRfG6lUCm9vb4SHh8PW1hb3799H9erV87WZPHky1qxZAwDYvn07Ro8eXeR49Ul5hIa3tzfOnj2r9qI7Nze3wAgPlmXh4+ODx48fQygU4syZM+jcuXOB/fr06YNz587BwsICYWFhBS5wV6xYgbi4OMyYMSPfeaBsxowZ+PPPPwEAX3zxBTZv3qyyXd41wIIFC7Bw4UKN74Eu9u/fj0uXLmHu3LmoUqWKyjarV6/GN998AwDo1KkTLly4oLJdQEAA92/zwIEDGDJkSL7tgYGBGDp0KABg7Nix2LJli75eBsdYRg5QcqAUYXMugU2dqbhTb4wYBzBWAWBzzgGQgLGeAsa8O99R6Wz4wf24Hf2e7zBICejV0BLplpQcKIuqWlbFT/V/5DuMEpcpzcLuyL1o49wKx2JO4FV6GJzNnOBu7o40STois4q30g0DBixYCCBANStPeNvWQXVrL2RIM3Az8TbEMsUwznfZ7+FfqT/XhhiOof+QXBNyG3/cvFZi/c9q0w5fNWtZYv3z4e7du2jVqhVMTEwQGhqKxYsXGyw5sGrVKm6Y/6pVqzB16lSV7aZPn44VK1YAAI4fP15g+oM2Zs6cieXLlwMADh06BH9//yL3cezYMfTv35+LKa+/Tym/rtWrV2PKlCn5titfxC1ZsgSzZ88u0EdWVhY8PDyQnJyM+vXraxydUdLGjRuHzZs3w8zMDI8ePULt2rWLtL9yImjkyJHYtWuXynZhYWGoVasWAMVn9vvvvxc51tzcXHh6euLDhw+wt7dHUlKSypuBhkgOaKt58+a4e/cuBAIB4uPjC0wliYuLQ6VKlSCTydC9e3ecPn1aZT89evTAmTNnIBQKER0dDTc3/U6HMpbkQNlL0ZZhjLkfGOezgMVgvkNRjU0Gm7ECkD4BpC/BpkwFm3WQ76h0Nr5Jc75DICXEwqzgUlukbIjMikR8TgLfYZSYywlX8X/ha7Hg6SJcT7yB31/+iZfpr8CCRYL4Ix6nPil2YgAA2H+rrsghR0Tma5z48A9Whv0fNr/ZhmdpzxGR+RoRma+RK8/F/neBiMp6V+xjEuOVkZuLtXdvl+gx1obcQUZu2SksKpVKMX78eMhkMsyePZu7KDOUXKX30svLS2075bvqmuZuq6M8l1vX4oT6ivfIkSPc44CAAJV9WFpacgmEJ0+eICwsrIjR6k9KSgr27FGMVB0+fHiREwOAYq58np49e6ptV7NmTe79CwoKKvJxAEV9ibZt2wJQxF4aivTl1eSQy+V48+ZNge3Hjh3j6iyMHTtWbT9555NMJsOxY8f0HqexoORAKcMInSCwWwzGMRAQuPIdjkZs2rx/RxKUPn6e1TC0bn2+wyAlwNTUOKsUE/0ISS6bo0LSJOnYF3UAIUl3kSD+yHc4+RyPOYFsmeYK1qR0OvT8aZFXJSiqDEkuDr94VqLHMKQ///wTDx8+RM2aNTFnzhyDH185GfH69Wu17ZQv5nVNYChfpOs6f19f8V69ehUAULt2bbi7q19mu2PHjtzja9dKbkSMJsePH+eq/ysPZU9PT0dYWJhWNSqSkv5b9UPT3ey87W/fvkVUVJQuIevl8zYkTfHmnTNA/vPiU8ZyzpQ04/9EiUqMyAeMXWlYQlAONuU7sOKSveNQEhiGwa+duqJ3TcNm+0nJY4S63R0hpcOJmH/wNLXsXGTkCXwXhCxZFt9hqJQuzcD+qECEpYcjTWKkU9+IzoKePzXMcZ49MchxStqbN2+4aQFr1qyBmZnuS1F37doVTk5OEIlEcHV1ha+vL5YuXYrk5ORC9+vevTs3bWHlypXIzMws0Ob9+/fYtm0bAKB169Zo0KCBTjFevnyZe1ynjm7Tixo2bIjWrRWFrbdt24aYmJgCbdLT0/HXX38BADw9PdGtW7d82zMyMvD+/Xut4lDe/vz5c51i1gfl5QVbt26N06dPo23btrC1tUWtWrXg5uaGihUrYvr06fj4UXVSWLmoX2pqaqHHU97+7FnR/zspkUhw8+ZNAIqikY6OhRcSDQwMRO3atWFhYQEbGxvUrFkTY8aMwaVLl4p8bF3lnZ8mJiaoUaNGge15n7+dnV2hCaUKFSrA1tY23z5lESUHSjHGrB0Ymx8Bi6GACX9zUzTLBZsyCazEMH9c6JNQIMDybr3Qsar6asCk9JEz+qm0TYxTliwLv7/8E2djz+k8X9fYhKeH48pH475TcSnhMn55vgTXPl5HUm5SmXnvy7scqQTPE4pWYV9Xzz8mQGyk688XxaRJk5CVlYXhw4ejS5cuxerr/PnzSEpKgkQiQUJCAi5fvow5c+bAy8sLR48eVbufmZkZdu/eDUdHR0RERMDHxwfr16/H9evXERwcjOXLl6Np06ZITk6Gp6cntm7dqlN8Hz584PZ1dnbWuFxcYbZs2YKqVasiKSkJTZo0wZ9//ong4GBcu3YN69atg4+PD968eQMnJyfs3r27QNLl/fv33PeOpir6lStX5h6/e8fftKi8C3Q7Ozts2rQJPXv2xI0bN/K1+fDhA1asWIHGjRurvKD39vbmHisnaj4VHx+PFy9ecM91GTmwYcMGLknxadE+VZ49e4ZXr14hJycHGRkZCA8Px44dO9CpUyf4+/trTGYU18mTJxEaGgpAkTDLu7hXlvf5azpngP/OGz7PmZJGyYFSjrH6HAK7X8A4HQVjuxBg7PkOSTU2E2zyl2AlRb8rwLIsWJa/OeIioRBre/dFy0qavzRI6SBmjfPuK9EfFix2R+3D5jdbIZGX7HDokiZn5dgRuZvvMLQWnxOP31+uKNUr1pD/PE9IgMxAiR6pXI7nH0t3zZBdu3bh7NmzsLOz46q666JBgwaYP38+jh8/jnv37uHWrVvYvn07d7c8JSUFgwYNwqlTp9T20aZNGzx48AAzZsxAVFQUJk2ahHbt2sHPzw8zZ85EVlYWFi1ahJCQEJ3murMsi0mTJiE9XTFaaP78+bCwsNDtBUNxN//u3btYtGgRMjMzMWPGDPj5+aF9+/b46quv8P79e8yYMQP3799HmzZtCuyfFwcAWFtbF3os5bvtGRkZOsdcXHlTArKzs/H999/DzMwMS5cuxfv37yEWi/HkyRNuNYX379+jf//+BeJt3749dwd/69atamsozJ8/n5tbD+R/v7Tx+vVrzJs3D4Di/Z07d67atpaWlvjss8+wceNGXL16FQ8ePMDZs2cxb948riDgkSNH0L9/f0hKaMpSUlISJk+eDAAQCoX4+eefVbbLex80nTPAf+cNn+dMSaPkQBnBMCZgLEeAcTkLWI4CYIRrVsuTwCYOA5u5tcgX+2zyl2DFNzQ3LCHmJqbY0GcAGrqpH25ESo9MGQ17Li+ufryOpS9+R1Ju4UNwjdml+GBEZuk2N5QPlxIuI1dGU3fKisgSvrNX8HgpBj2ePiUlJXHrxy9evLjQIcqFmTZtGkJDQ/HTTz+hT58+aNKkCVq2bInRo0fjzJkzWLdOsVSpTCbDuHHjuDnrn2JZFkFBQQgKClJ5AZaRkYF9+/bh5MmTOsW5ePFirjCbn59fgZUDdPHPP/9g//79Ki++JBIJgoKCEBgYqHJkUk7Of6MCP13u71PKow7UvX+GkDfdIzc3FyzLYufOnfj+++9RqVIliEQi1KtXD9u3b8eECRMAAOHh4dznn8fCwgI//PADAMVn2rFjR+zcuROJiYnIzc1FaGgoPv/8c2zYsCHf+1KU152VlYWBAwdyd/pXr16NihUrqm0fHR2NvXv3Yty4cWjXrh0aNWqErl274pdffsHTp0/RuHFjAIqRDmvXrtU6Dm3JZDKMHDkSkZGKAr0//PADd8xP5Z03ms4Z4L/zhs9zpqRRcqCMYQT2ENjOB+N0DBAVzKryTwI2fQnY5AlgZdpVOFXcfZKDTQ6APGkcWMmrkg1RDRszM2ztNxC1HJ00NyZGy8JUgBw5TSsoT8IzIjDz0fdYHfY3HqWEQs7jSKSiksqlCHp/mO8wikzGyhGeHg4ZK9PcmBi1XJlhh/nnykrvOTN9+nQkJCSgefPmmDRpks792NvbF7p94sSJGDduHAAgJiYGhw4dKtBGLpdj2LBhmDFjBiIjI/Hll1/i/v37yM7ORkZGBq5du4Z+/frh+fPnCAgIwIwZM4oU4+7duzF//nwAivn/e/bsKXZxupkzZ2LMmDF49uwZBgwYgOvXryMjIwPZ2dm4f/8+xo4di8jISMycORPDhg2DXJ7/u9zc3Jx7nKth5QvlInXFGe1QXMoxt2rVSu1Q/cWLF3MXpnv37i2w/bvvvuPOuQ8fPmD06NFwdnaGmZkZfHx8sHv3bjg5OXGfGQDY2NhoFaNUKsWQIUPw6NEjAIrzT91KEHkKO4fd3NwQFBTEXYyvXr1aqziK4uuvv+aWJOzdu3e+1/2pvM9A0zkD/Hfe8HnOlDRKDpRRjGlNMA5bwdivBQTOfIdTUO4VsIn9wIqva7kDk28/eepcsDLDDz10sLDAsq49DH5coj9utiZ8h0B4IGNluJt8H3++WonpD/+HoHeHkChO0rwjzxLEH422CGFhkiXJ+Pn5Eky5/y1Wh/2NS/HBZXqJybJMJDTsd6ZIaIQjH7Vw8eJFbN++HUKhEOvXry/xKu4TJ07kHquaZ75mzRoEBgYCABYuXIhNmzahcePGMDc3h5WVFdq2bYujR49i1KhRABSrK2g7guDkyZMYO3YsWJaFm5sbzp07p/MoiTwnTpzA8uXLASiWjDt8+DDatGkDKysrmJubo3HjxtiyZQt3kRcYGFjgjrPyxa6mYd/KBRq1GU5eUpRjLmwZQicnJzRr1gwA8OjRI5UjQdauXYsjR46gQ4cOMDH579+tpaUlRo8ejcePH+e7aHdwcNAYH8uyCAgIwD///ANAUWdgzZo1GvfTxMvLC127dgWgGA2hqgClrubMmYMNGzYAANq1a4fAwEAIC/leyfsMtJkqkHfe8HnOlDT6K7kMYxgGMO8MMNZgk0cDMLLiUPIEsMlfgLUaB8Z6GhjGVGUzVvoeyL2pvCOQHQRWFg/GcZNhYlXyND7O4Mck+uNkTV975V2yJBnHP5zE8/SX+MF7tlHPjY/NieU7hGLJkmXjbvJ93E2+DwBoYFcfM2pNM+r3nORX1c7OwMezN+jx9GXZsmUAgGbNmuHly5d4+fJlgTbKa6wfP34cLi4uAIDPPvusyMerW7cu9zg6OrrA9s2bNwNQXPjMnj1bbT+LFy/Gzp07AQCbNm1C7969Cz1ucHAwBg8eDIlEAgcHB5w9e1ZlBfiiyosXAH755Re17ebOnYsVK1YgIyMDmzZt4uaUA/kLyuWtWqCOckE55eKEhla5cmVuxQJtiyjKZDIkJiaqTMj0798f/fv3R3Z2NmJjYyEQCFCxYkWYmir+xs4rzgfkP4fUmTx5MnbvVtS86dmzJ3bv3q23xFfdunW5hFR0dHSh0xS0tWzZMixdqljNrUmTJjhx4oTGu/weHh6Ii4vTeM4A/503fJ4zJY3+Si4HGLOWgO1isDknAEkowBrTfGsWyNwINvc2YPcnGJMqKppkQDHI5ZOhhrlXwOY+ACNSPYeopFyNijTo8Yh+2Vsw0DxwjJQH4RnheJH+Et62ui29ZQhxOWUrGfk49QnuJIWgpVMLvkMhWvJ2cYGQYQxSlNBEIIC3s0uJH6ck5A03vn37NoYPH66x/TfffMM91iU5oGk1kLyl1urWrVvoUooeHh5wc3NDXFxcvkr2qty5cwd9+/ZFTk4OrK2tcerUKTRs2LDIsRcWr5ubGypVqqS2nbm5OerVq4fbt28XiNfa2hqVK1fGu3fvNL4W5e3K1f4NrV69etwID5mGKTXK25VHBqhiYWGBatUKrrR17Zpi1Rtzc3P4+PgU2sf333/Pjc7o0KEDDh48yCUZ9EHfK9qsWbOGS4R5e3vjzJkzsNMiuVm3bl3cu3cPqampiI2NVTsK5sOHD0hLS+P6L6toWkE5wVgOgsBxKxjXEDDOp8HY/QZYfg6YNgCgv3/oOpOEgk3sDzb7RIFNjGkdwOoLlbux4gslHVk+UrkcN96VnsJgRMHd1gTD20swvL0E9q6aM8Ok/NgZuRtRWca5JFFM9gecij3Ldxh6t+9dIMRUsLDUMDcxhbeLq0GO5e3sAjMNFz1EQXlJO1V3XPMuHqVaLA2ZN0S9sAvO0NBQ9OjRAxkZGTA3N8fx48fRsmXLooatlr7ibdeuHQDg5cuXiI1VP/JKeSpG27ZtixSrPnXo0IF7HBERUWjbvO0WFhbc6gRF8fDhQy4JM2DAgEIv9H/55Rf89ttvAIDmzZtrdQe+qDSdw0Wxc+dOriCml5cXzp8/D2dn7aZV550zQOFLQRrLOVPSKDlQzjCMAIyJFxiLARDY/giB00EwLsGASX2+Q1Msd5g6XVFP4JMiVoz1VEDoWWAXxsSwd/yEDAPHMlyEpKxKzZbjvSQM7yVhiM/9wHc4xIhEZ8dgwZOfsDdqP7JlxlN9+EN2LBY/X4YUSQrfoehdUm4S/ny1Eh+yS/eUifJksHc9wxynrhH8LaKj4ODgf5deVv8zZswYrv2bN2+43+ti/fr13OOOHTsW2J531/jJkydISUlR28+TJ0+45fRU3WkGgFevXqFbt25ITk6GqakpDh48CF9fX53iVifv2ImJidwFrCpJSUl48uSJ2ngHDBjAPd62bZvKPrKysnDgwAEAirvGtWrV0jHq4uvQoQM3veTIkSNqz4c3b97g4cOHABRLVOoytD9vGUJAUbBPnZUrV3K1HRo0aIDTp09rXbxQW69fv8a5c+cAKC7mCxstosmhQ4e4GhgeHh64cOFCkZIN/fr1497PrVu3qm2Xdz4JBAL069dP53iNHSUHCBihCxjHXYBZZ75DUcgOApuRf21ghjEHY/erisYsWFlckZdG1BXDMJjWqg1EAiECfBrjr+690KN6TQho/qxRy5bIYWNiy3cYxEjJIcfp2LOYEzof/3w4jYiM15DKDVuh/VMX44ORLjWmKWD69SL9JX54sgCH3h9Brrxk1rgm+jPQux6s9DicWBVrUxH862ieA13WPX78GOHh4YW2Wb9+PTdH393dHf7+/gXa9O3bF4BiusP06dPVLv2nPL2hT58+BdpERUWhS5cuiIuLg1AoxJ49e9CrV68ivSZAUWSQYRgwDIPg4GC18QKKpRxVVY6Xy+X49ttvuW2q4vX390f16tUBAEuWLFF5N37WrFlITk7mHqsSHBzMxaupMn9xCIVCzJw5E4BitENe7QplEokEX3/9Nbc6g6qVMNLS0tQmgViWxdy5c7migp9//jnat2+vsu3WrVvx3XffAQBq1aqFc+fOFXmUwvHjxwsdARIXF8fVrQCQr26Esm3btnGfwcKFC1W2OXv2LIYPHw6ZTAZXV1ecP38enp6eRYrX3d0dI0eOBACcOXMGQUFBBdoEBgbizJkzAIBRo0YVuwCnMaOxWwQAwAgsAfv/A5u+FMjaznc4ijoEJnXAWPz3HwtG1Bxw2ApWfBnIDvx3pEHe0jtmYIWVAKEHYOIFge3cEgutf21v1HJyRjV7e5ibmKJfbW/cev8OIw4dKLFjkuKzFtgjHWl8h0GMWLIkGfvfKeZ+igQiVLfyQi2bmqhlUxPVrb1gIbSAnJVDwJRsXp1lWTxMeVSixzAGUlaKozHHcSvxNkZ7fo76doa5O02KzlokwlfNWuKPm9dK7BhfNW8Bay3WGS/r7t27h3HjxsHPzw89e/ZEgwYN4OTkBKlUihcvXmDXrl3cHde8lRGsrKwK9DN9+nRs3rwZ8fHx2Lp1K8LCwjBp0iTUqVMHMpkMDx48wKpVq7ih3d7e3gUughMTE9GlSxeuCNuMGTNQp04d7s69Kg4ODjrdBQ4ICMCKFSvw4sULnD17Fs2aNcPUqVPh4+MDoVCIZ8+eYe3atbh5U1Gg2s3NDdOnTy/Qj6mpKVatWoW+ffsiLS0Nbdu2xQ8//IAWLVogOTkZGzduxMGDBwEohpPnrdbAp2+++Qb79+/H/fv3MWfOHDx9+hSff/45XFxcEB4ejj///BO3b98GAPTq1QuDBg0q0MerV6/QoUMHDB06FL169YKXlxekUimePn2KTZs2cUUPGzdurHbpwCNHjmD8+PFgWRa2trZYuXIlEhISkJCgfqWZatWqFTj/pk6dColEgkGDBqF169bw9PSEhYUFPn78iODgYKxbtw6JiYrlzNu1a6c2OaDJrVu34O/vj9zcXJiammLFihWQSCSFnp8eHh4ql1n89ddfcfr0aSQkJGD48OG4e/cul3xSXknDxcWl0IKZZQElBwiHYYRgbOeBFVYGm/4r+F7dgE2dC5h1BCP4744vY9YWjFlbsObdwCZ/CbB5w4DFgOy14kfyCCjB5AAArmDSx6wsWJmalup1mcsLobzgH0+EqJMrz8Xz9Bd4nq4oWsWAQWVLD4yp+jlq2BS/Mndh5JDDSeSIeHF8iR7HWMSJ4/H7yz/RyrElhlcZBnuRYavjE+1MbNocZyLC8LgEVuxp6OaOCU2a673f0komk+H8+fM4f/682jZOTk7YvHmz2uHNzs7OOHPmDAYOHIg3b97g2rVrXDG6TzVq1AhHjhzh1p3P8/jxY4SFhXHPf/vtN24eujpjxoxRO5y/MCKRCKdPn0b//v3x6NEjPH78GBMmTFDZtlq1ajh06JDaOeW9evXCunXrMGXKFMTFxWHq1KkF2rRo0QKHDx9Wu8RddvZ/08ycnJyK/HqKwtzcHCdOnEDfvn1x79497Nq1C7t27SrQrlevXti3b5/a1V6ys7Oxfft2bN+u+iZfnz59sH37dpUXx4AiOZBX9DAtLa3QpRXzXLp0SeUUk5iYGKxevVptIgIABg0ahE2bNhVaMLMwp0+fRlaWYqlfiUTC3f0vzNatW1WOBKlcuTKOHz+OAQMGIDY2FsuWLSswisPd3R1HjhzRuKpEaUfJAVIAYzUaEFYCmzpd6eKbD2JAzfKGjKgZYL8WbPIE4NPa84xuXzLayszNxdmIcBx79RzXoiJxcsRoxGaU3eG/ZYVUYg7Q7A+iIxYsorLe4UL8JUhYaYmucJAtzUYLp+Z4lREGGVt+Eo+3km4jMTcRP9Sdw3coRAWhQIAV3XthSOBeJOfk6K1fB3Nz/NmtJ4R6Wh6ttOvVqxc2b96Mmzdv4sGDB4iLi0NiYiJYloWjoyN8fHzQo0cPBAQEwNa28OlyjRo1wuPHj7F9+3YcPXoUoaGhSEpKAsMwcHV1RePGjTFkyBAMGzZMr1XodVW1alWEhIRg3759CAoKwv3795GQkMC99oYNG2LAgAEYPXq0ytESysaPH4/WrVtj1apVuHDhAmJiYmBlZQVvb2+MHDkS48aNK7QAY94IBRMTE67QXUmqUKECbt26hc2bN2Pv3r149uwZUlJS4OTkhBYtWiAgIEDl9JE8tWvXxv/93//h/PnzePLkCeLi4iCTyeDu7o42bdrg888/R/fu3Uv8dQDA9u3bcfnyZdy8eROvX7/Gx48fkZaWxq0m0aZNG4wZMwatW7c2SDzaatmyJR4/foyVK1fiyJEjePv2LQBFMqp///6YNm1aiSeKjAHD6nsdCVJmsOIbYJMD+A3CahIY6+/UZklZcTDY5MkAlOasCqtA4KI+266rJ/Fx2HA/BOdfRyBHaS7V4aEjEBITjcXX1Fc4Jfzr2cASGVZ3+Q6DlAEeFpUwpPIg1LCuDmsTa731ez/5Ac7EnsPL9FdgeR65xaffGi6Gm7kb32EYvbCwMEilUpiYmKBmzZoGO+6T+DiMORKklwSBg7k5tg8YjPqu9HkT4+Lr64vLly9j7Nix2LJlC9/hkHKAr+/0T1GalqjFmLUBzPz4DSJzHdi0BQVWL8jDmPmCsf8TgFD5lyUSym/Xr+LEq5f5EgMAkCmRYIxPYwyuS/NljdlHGtxB9OR9djRWvFqFyfe/xezQH7D59VZcTriKBLH6eZmaRGS8xv+Fr8WL9JflOjEAAHujDlCRQiNW39UNgUOGo6Fb8QpyNXRzR+CQ4ZQYIEZHLBbj9u3bEAqFmDu3ZKepEmJsKDlACsXY/gzG+jtAWJW/ILL3gU2dDpYtWLkWABjz7mDsloEbMy59CzZXv8W8krOzcfN9lMptN99HwVQoxLLO3eHl4KDX4xL9eZdEFxtE/z7kfMCVj9ew5c02LHjyE5Jyk4vcR5okHf8XvqZcTSEozIOUh1j24g+kSyijZ6y8HBxxcMhwzGzdDtamRSsiaG0qwqw27XBwyHB4ORR9rXZCStqdO3eQk5ODESNGoEaNkq0xQ4ixoeQAKRQjdAVj/dW/F988yjkFSCPVbmYs+oGxzaseKgGbMhWsLFFvhz/7OhwyNTNwDj57CplcDoZhYCakMh7GKjYtF6ZqalgQog+Zsixser0F8iIsrSpn5VgXsUGnpEJZFp4Rjp+fLUZ8ju6jMUjJEgoE+Lp5S9z4ciIW+XZGA1c3mKipG2AiEKCBqxt+8u2MG19OxFfNWlKNAWK02rdvD5ZlsWPHDr5DIcTg6EqGaMe0MSD0BGRveQyi8LtqjOUQQOgCNn0lIH0KNmMFGDv9LDfyKPaD2m2xmRm4FhWJjp7VIFRTG4EYAwZ2Jg74KCkfFeAJP56mPcPPzxajk6svWjg2B8MIkC3Lgp2p6gr8h94fwdO0ZwaOsnSIE8fjVtJt9KtYcC1zYjysRSKMatgIoxo2glgqxfOPCYhMTUGuTAaRUIiqdvbwdnaBWSHF3wghhBgH+qYmWmEYBrAaCzZtAY9RaL4bx5j5AqKOgDgYYPS3XrKTpWWh2wOfPUFHz2pqCycS42AOWwCUHCAl63XmG7x+8wZ7ovbDhDGBhdACP9adCysTq3zfEfeTH+D4h5M8Rmr84nPo32tpYmZigkbuFdDIvQLfoRBCCNEBJQeI1hjL4QBjATZ1HvKtDmAw2s3HZRgGMNdvIUVXq8Irkp97HY50sRgCSg4YNVZWeJKHEH3KkinWX06TpmHvu/14kfYSHpYeqGNTGxUtKmDD6808R2j84otR5JEQQgghRUPJAVIkjMUAsLn3gOz9hj+47CNgCkVhwuxDAJsJWH5hkLv1sRmFF8Zyt7aBlUiELf0G4sXHBCwIvoDw5KQSj4sUTU6OKaC/ASWEaMXJ1Ak3E29DxsrwMTcRD1P0WzC1LKOaA4QQQojhUDUYUmSM9WQwzv+AcdwFmBiuiiub8YciMSB5BjbtR7Dpywpd5lBf9j0Jxdq7dwptM9C7LgQMAwcLC7SuXAX7Bg8r9jJPRP+SM+krjxietak1rUSgo2RJMp6nvQCrpiAsIYQQQvSH/lImRcYI3cGY1AAjagHG6QhgNd4wB5aGgU2ZAjb7wH+/y94HyONK7JAX37zGvIvnNLYbWKdevueOFpbY5T8EbSpXKanQiA7iUugCjRhWNStPRGapX2mFaLb0xe9YFfZ/fIdBCCGElHmUHCDFwjAiMFZfGu6A4mAgOyj/79isEjtch6qe+KtHb9R3cVXbpmUlD1S2K1iJ3Fokwua+/uhRvWaJxUeKJjIpl+8QSDliAiFSJal8h1Em3E95iKisd3yHQQghhJRplBwgxcYIHAGLYfwFwGaBlUWDzdwBecq3YHMu6a1rE4EAfWvVwdHPPsdu/yHoWLVagTb9a3ur3d/MxASre/bB+t798Vm9BnDTUNiQlKxsiRw2JrZ8h0HKieo21ZGUm8x3GGVGcPwVvkMghBBCyjQqSEj0grH9CazAGcj82+DHZpOnAvIP/z2XPAWj59UKGIZB68pV0LpyFbxM/IhN9+/i2MvnkMjliEot/M6gUCBA1+o1UN3REbPbdcCMs6dw4c1rvcZHtGctsEc60vgOg5RxdqZ2eJ3xhu8wypSbiTcxrPJgmAnN+A6FEEIIKZMoOUD0gmEYMDbfghW6g01bAEBuuIMrJQYAALIosLJYMMKSKQhY28kZv3ftgZmt2+FJfBz8qnlp3CcpOwvDDx6Ak6UlsiV8LANJAKBeRQskSykxQ0qes8gJETSlQK+yZNkISb6Hds5t+A6FEEIIKZNoWgHRK8ZyGBh7w48eKCA3pMQP4WZtjc5e1SHQYilFRwtL7Bk4BKk52YhMTSnx2EhBlR1MUdUrDDnyHL5DIWVcZQsPRGRSEqokXKapBYQQQkiJoeQA0T+zNoBZd8C0ASBw4iUENrfwpQf5UN3RCfsHf4aqdvZ8h1Iuta4NpEtpOgEpWQwYiOVU+LKkvMoIQ0x2DN9hEEIIIWUSJQeI3jGMBQQOqyFwOgjG5QbAOBg+CCNMDgCAh60d9g8ehlpOznyHUu68TzDlOwRSDtSyqYF4cTzfYZRpuyL3IkOawXcYhBBCSJlDyQFSohiGAUTNDH9g2Ruwso+GP64WXK2ssXfgUDR0K5maCES1O2+yYCGw4DsMUoZZCS0RlfWe7zDKvKdpz7DgyU+IyKCpG4QQQog+UXKAlDjGaizA2Bj+wJKSrzugKwcLC+zyH4KajvxMuyiPpHLASViV7zBIGVbRoiKyZdl8h1EufMxNxK/PlyJBnMB3KERJrjwX4RkRuPHxFq4kXMWNj7cQnhGBXJpqQwghpQKtVkBKHCNqBjgdAJs8AZC9M9hx2dw7YMx7Gux4RWUtEmFOu4744tghvkMpNxKTbAAe8lSk7KtoXgFhGeF8h1GumAvM4WDKw7Q1kk+2LBvXP97E1YRreJf9HjJWVqCNkBGiimVltHduizbOrWEhpFFchBBijGjkADEIxqQ6GLslhj2oAVYsKK6OVT3R2qMK32GUG7dfZ0NIX3uElAmZskz8+HQRnqe94DuUcknOynE85iSmPZiBnZG78TYrUmViAABkrAxvMt9iR+RuTHswA8djTkLOGnDJY0IIIVqhv5KJ4eQ+MOzxpK/ASp4a9phFxDAM5rTrwHcY5UZqthxuIkrGEP2qaV0DMTkf+A6jXIrOjkFsTizfYZQ7H7Jj8dOzXxH0/hBy5OIi7ZsjFyPo/SH89GwxPmSX7c8uKioKCxYsQLNmzeDi4gJzc3NUrlwZ7du3x48//ognT54Uun9oaCgmTJiAWrVqwcrKCra2tqhXrx7+97//ISoqSuPxX758iRUrVmDAgAGoVq0aLCwsYGlpiWrVqmHYsGE4efIkWJYttI/g4GAwDKPVz8KFC4vy9hQQFRWFtWvXYtiwYahduzasrKxgbm4ODw8P9O/fH3v37oVUKtW6v6dPn2LSpEmoUaMGLCws4OLigg4dOmD9+vVF6scQZDIZdu/ejd69e8Pd3R0ikQju7u7w8/PDhg0bdI5XLpejdevW+T4ndbZt26b1Z533ExAQUKCftLQ07Nu3DzNmzEDHjh1Ro0YN2NnZQSQSwdXVFb6+vvjtt9+QmJio02tSZ9++fejevTsqVKgA8/9n777Do6yyB45/7/TJpFcCCaGF3hSkCyjYEEUELLiu6NrL6lrXsra1915+WLB3xV5WRBRpCoIgLfSWSnqZfn9/xAwJ6cnMvDPJ/TwPj8nMO/eeZMbJvOe99xyLhR49enDuueeyYsWKFo9x8OBB7rjjDoYNG0ZMTAzR0dEMGzaMO+64w+/xhiohm3tXUBQ/8RbOA+ey4E9smoCwXQDGgYAJhAkwNvkGGWzrcrL5MmsLX2/LYn+ZarcXSKcdaeWgabXWYSgdhFmYMeqNqnq+hv6V+U+Gxw3TOoygy8rKwu12YzAYyMzMDNq8Oyt28ciWx/3ymo80RHJDv2vpYet49WCefvppbr75ZioqKho95uqrr+aJJ55o8L477riD//73v42evEdHR7NgwQJmzpzZ4P3nnXcer7/+erNxnnDCCbz77rvExsY2eP+PP/7IMccc0+w4NTG3NUFw++23c8899zSbrBg5ciQfffQR3bs3neh/+eWXueKKK3A4Gk5ejRkzhi+++IKEBO1rP2VnZ3P66ac3eRI7cuRIvvjiC1JSUlo19jPPPMNVV11V57bGfscLFizg/PPPb9X49913HzfffHOd277//nuOO+64Zh+bmJjIm2++yQknnNCqOQ9nt9uZM2cOX3zxRYP363Q67rzzTv7zn/80Oc6vv/7KjBkzyM5uONnftWtXPv30U0aODEyhda3e0w+nkgNKUEhpR+aOBEKnKJGIvB4RebHWYdQhpeSPvFy+3raVr7O2sre0ROuQOpweCSbSM9dqHYbSQfSLzGRLeZbWYXRqk5MmcX7Pv2sdRtBp8UEyuyqHezbd79dkWKQhktsG3EyqteN08Lnnnnt8JyK9evXi4osvZvTo0URFRbF//362bt3KJ598wujRo3nsscfqPf6BBx7wnXClpqZyww03MG7cOACWLVvGQw89RE5ODmazmR9++MF3X21Tp05l0aJFxMfHM3v2bCZPnkyPHj0wGAz8/vvvPPbYY2zZsgWACRMmsGTJEnS6+guKaycHXnnlFY466qhGf+7k5GSSk5Nb+duqduGFF/Lyyy9js9mYOXMmU6ZMITMzE4vFwqZNm3jqqaf49dfq7aKZmZmsWbOGyMjIBsf69ttvmTZtGl6vl5SUFG699VZGjx5NYWEh8+fP5+OPq2s9TZw4kcWLFzf4cwdLVVUV48eP5/ffq1fXTp06lUsvvZSePXty8OBBPvzwQ1566SW8Xi8jR45k6dKlmM3mFo29f/9+Bg4cSFlZGQkJCRQUVHfxauzUr7i4mH37mu+4c/rpp5OVlYVOp2PXrl2kp6fXuf/777/nggsu4JhjjmHEiBGkp6eTmpqK1+tl3759fPjhh3z88cd4PB5MJhO//vorQ4cObdHP1JBzzjmHt99+G4BjjjmGq6++mq5du7J+/Xruu+8+tm/fDsD8+fO58MILGxxj//79jBgxgtzcXAwGA9deey3Tp08H4IsvvuCxxx7D7XaTkpLC6tWr6datW5vjbYxKDihBIaUH0Gl+lVxWvIEs+6+mMRxORN+JiJirdRiNklLyZ34eb69fx7t/rtc6nA7l9KMPku/K1ToMJcwlmRI56CzEi9o7raUIfQR3D76DJHOi1qEEVbA/SHqll7s33svOil1+H7unrSe3D7wFnQj/3a4//PADU6ZMAWD27Nm8+eabjZ7MOZ1OTCZTndv2799P7969cTgcdO3alV9//ZWuXbvWO2bUqFEcOHCAYcOGsWbNmnonuPPmzWPcuHGcd955Dc5fWVnJCSecwNKlSwF4/fXXOffcc+sdVzs5sHjxYiZPntyyX0Qr3XTTTSQkJHDZZZcRFVW/crDH42Hu3Lm8//77ANx9990NXgl2u90MGDCAbdu2ER0dzZo1a+jdu3edY6644gqee+45AF577TX+/nftkouPPPIIN9xwAwDnn38+L7/8cr3P7K+++ioXXHABAI8++ijXXntti8aeOXMmCxcu5IILLmD79u0sWbIEaDw50BKbN29mwIABAEyZMoXvv/++3jEejwe9Xt/kOAsXLvStejn99NP56KOP2hTPkiVLfK/JU045hU8++aTO3AUFBYwYMYI9e/YQFxfHjh07GlwlM2/ePF577TUA3n//febMmVPn/g8++IAzzjgDqH6eXnnllTbF25RQSQ6E/7uw0iRZ/jSy/OF2vRG0OwZPLrK8fmZcc1q0V2wFIQSDk1NItjWcGVfazuBK1ToEpQOwGiJUYiAEVHoqeSrrGRye1u19V1rny+yvA5IYANhZsZOvsr8JyNjB5PV6ufTSSwHo169fk4kBoF5iAKr3Tdcshb/rrrvqJQYAunXrxl133QXAunXr+Prrr+sds2DBAi6++OJG54+IiOD555/3ff/hhx828ZMF3oMPPsiNN97YYGIAQK/X89xzz/l+Z43F+8knn7BtW3XnmJtvvrleYgDg4YcfJi4uzve1lmpOSG02G48//niDF/POP/98xo8fD8BDDz2E19v8352PP/6YhQsXkpiYyEMPPeT3eIFGkyrNJQYATjvtNPr37w/ATz/91OZ4an62mtfH4XMnJiby4IMPAlBUVMTLL79cb4zc3FzefPNNoHqbzeGJAYA5c+b4tj+8/vrr5OZ23AtMKjnQgUn3Pqh4HipeQpY/oV0cZfeBbHzPnWZ0oZ0cqKHXhU5thFAVZdaREW8iyqwDmk+EbTvQ/B8uRWlKL1tP9lQ2XxBMCY49lXv5PneR1mF0WFWeKr448GVA5/j8wJdUeaoCOkegfffdd2RlVW8zuvnmm1u8/Lu2mqXzACed1Hg75hNPPNH3dVtP7AcPHkxiYvWKm5ql16EsISHBt/y8sXgXLlzo+7qhYnlQnRipuQq8YcMG33MWbFVVVb6ilGPHjiUmJqbRY2ue79zcXH7++ecmxy0tLeWf//wnUJ388FddBa/Xy1tvvQVUJzNmzZrVrvFsNhtQXTOgLcrLy1m0qPp9/7jjjiMtLa3B404//XSio6MBfFtKavvss8/weKo7rTRVc6Hm9eTxePjss8/aFHM4UMmBjkyfCrqk6q8rX0dKV9BDkI4lYK+f0Q4NBq0DaJErjhrDlJ69tA4j5ESYdJw5sZLTR1o4+qg9dO+7luFHbODYsds4+2gPE/pEIBpJFJgMKuGitJ0BA4XOIq3DUA5z0FnYaCs9pX1+KVje6q4ErWX32llWsDygcwTaBx98AFRfxTz99NN9txcUFLBt2zZKSpqvI1RYWOj7uqnic7Xvq1ku3hZOZ3UtKC333bdGzaqKxuKtOXHu168fXbo0Xsdi0qRJvq9rtlYEW1HRob8jzRUabM3z/e9//5v9+/czceLERhMkbbF48WL27t0LwKxZs3wn922xadMm1q5dC+BbQdBaq1at8r0eaj+fhzOZTIwZM8b3GJer7vlQ7WRLU+OEwmsmGMLjnUBpEyH0YJlW/Y2sANfG4AfhLQv+nC0kS25FundrHUazdELw6PHT6PXXEjil2oyjJAecu8g3rKHMfajDg0u62Ofagkj8jWkTDnDGGBO9kw5dvTl+UATWlLUaRKx0FL2jelHsKtY6DOUwi/IWc+v6O1hf0nR7OKX1fs4Pzgfhnwt+Cco8gVJTbX7QoEHYbDaeeuop+vTpQ1JSEpmZmcTGxjJo0CCeeuqpeicoNWqfcDWVTKh9365du6isrGx1vL///julpdV/P1tygnbLLbeQlpaGyWQiLi6OI444gn/9619s3bq11XO3RV5eHps2bQIajre8vNxXUK+5n6f2/TVjBltLn+vD79+4sfHP88uXL+fFF1/EaDTW2TbiD7W7X5x33nmtfnxlZSVZWVk89thjHHPMMb6r9VdffXWb4qn9vLX0+Xa73fVWitSMExMT02RCKTU11bcCQavXTDCo5EAHJqUE76EMNM6W9/n0F2GdDrYrgj5vi3izkYXnIN2hv5Qu2mzm/6afRmQD+xM7o+MHRbDP82ezx5W6S8hmLV17/84ZE8s5a5yeqqjfcMvQ6m+shI84Yxzby3doHYbSiGx7Nh/s/VjTOjsdjdPrZE/l3qDMtadyL05v8Fc5+oPX62Xz5s0AdO/endNPP52rr7663vL3jRs3cvXVV3PcccdRVlb/AkpNsTdo+gpx7X3aUsoWVZk/3H333ef7umaZfVOWL1/O/v37cblcFBcXs3btWp544gkGDBjAnXfeGfD/7x5++GHcbnej8e7bt88XQ2NLzGvUrrBfczU82GJiYkhNra6BtGLFCt8qjobUfr737Gl4S5vL5eLiiy/G6/Vy/fXXM3DgQL/FWlFR4VuSn56e3uLClAsWLEAIgRACm81G3759ue6663x79q+//nrOOeecNsVU+3lrz/Nd831zY9QeR6vXTDCo5EBHVvUB2A/tiZGudZqEISL/CabxmszdLG8esvRuraNokV5x8Tx+wjQ6+4L4WKseGdP6K4PZzj3s96quD0r7xJpiVXIpxO2u3M2/19/KN9nfUu7yX8u9zmpP5d6gFd70SA97g5SI8LeSkhJfobj//e9/fPrpp6SlpfHOO+9QVFREZWUlP/74I6NHjwaqT/wvuuiieuPMmDHD9/Xdd9/d4H5su93O3XfX/ezSUKKhKR999JGvVsGIESOa3D+emprKFVdcwTvvvMPKlStZvXo1n3zyCRdccAFGoxGv18tdd93Frbfe2qoYWmPlypU88cQTQPVJ3OWXX17vmNq/g8baHNaofdW+vFy794ma57ugoIBHH320wWOWLl3Kl18eqvnR2HP94IMPsmHDBnr27NlgJ4f2+Pjjj32/p3PPPbfd21CGDx/OihUrePjhh9vcUc1fz3fNOM2NUXscLV8zgaaSAx2UdG2sf9Krz9AkFiFEaHcG8Da/BzBUTOnZm2vG1O9n3JkUV7lJMNSv3qwogZYR0Z2dFTu1DkNpgRx7Lu/sfZ9r1l7HNznfaR1OWMuz5wd5vrygzucvFRWHCi87HA6ioqJYsmQJZ511FrGxsVitViZNmsTixYsZNmwYAO+9916dAoQAo0eP5tRTTwWqOxFMmjSJRYsWUVlZSWVlJYsWLWLSpEmsW7euTreDqqqWF3PcvHmzr/Ca1Wrl9ddfb/QE7aijjmL37t0888wznHXWWYwaNYojjzyS0047jZdffpmlS5f6Cuk98MADvn3k/pSbm8vs2bNxu90IIXjttdeIiIiod1ztREpDnSBqq10ssjW/O3/797//7Vuqfuutt/Kvf/2LrKwsXC4XOTk5PPvss0ybNg0pJQaDodF4s7KyuPfeewF45plnsFqtfo3zjTfe8H3dmtaPp512GuvXr2f9+vWsWrWKd955h5kzZ7J27VrOOeccvvjiizbH5K/nu2ac5saoPY6Wr5lAU8mBDkh6S5HF/wTqLk8SpuGaxAOAN4Rbfsjwyv5dcdQYju/dR+swNCT4dVMMeqE6DijBo0NHpaf1e3oVbbmkm/f3fhiwFnydgTvIxYxdYboyx2Kx1Pn+iiuuoFev+sWErVar7yQOqlsXHu61116rU0Bt6tSp2Gw2bDYbU6dOZdWqVRx11FF1lmM31gLwcAcOHOCkk06irKwMIQQvv/xyk8vPbTYbRqOx0ftHjRrFs88+C1Rvb6j52l/Kyso4+eSTfdsm7rvvPo499tgGj639HDS1RB8OFTYE/H4i3RoZGRl88MEHREVFIaXkiSeeoG/fvphMJlJTU7nyyispKyvjgQce8P18DT3Xl1xyCXa7nVmzZjFt2jS/xnjgwAFfV4DRo0fTr1+/Fj82NjaWwYMHM3jwYI466ijOOussPv74Y15//XV27NjBjBkzWLBgQZvi8tfzXTNOc2PUHkfL10ygqeRAhyQRCQsR8e+C4dDeNYzDtAvJk6Pd3M0Js+SATggeOe4kMuP905omHG3Pd5Ash2gdhtKJZEb1Id9RoHUYSht4pIf/2/4STm/zH/yU+gyi8RPDQDCK8OgkdLjDT9iaakM4ZcoU31Xgw1cOQPUJ1ZIlS3j88cfrnbh36dKF//znP/z888++YoIAcS0oWlxYWMjxxx/Prl27AHjyySc5++yzm31cc84880zf6oH2dE44nN1uZ8aMGaxevRqAa6+9ln//+9+NHl/7OWhu2XftlR4tWU4eSMcffzxr167lH//4R722g2PGjOGrr77iiiuu8P1Mhz/Xr7zyCosXLyYqKoonn3zS7/G9+eabvi0zrVk10JRzzz2XOXPm4PV6ufLKK+t0bmgpfz3fNeO0ZKtAzThav2YCKTzfgZUmCd1ffVJNR0LCx1D1LrLyHYS+8QqcgSLd25C6FPCG8DJBb3glBwAiTSZePnUmf1/4EbuKO2dLtS/WuDl2VCwl7mKtQ1E6uChDJLsqQr+zidK4A/ZsPtr3CWd3P1PrUMJOsiUpyPMlB3U+fzGbzSQlJZGfX70No6niZhaLhcTERHJycsjLa/jzkclk4pprruGaa66hpKSEvLw8IiMj6dKli28LwB9//AFUn9w0V0ytrKyME088kT//rC7m+9///perrrqq1T9nQwwGA3379uXXX39l//79fhnT7XZzxhlnsHjxYgAuvPDCRvfk16j9O2iuQGPtgnK1i9VppVevXrz00kvMnz+fnJwcysrK6NKli2/LwbJly3zHHp4wevDBB4HqVnu12/LVVvt1VrNaxWazccoppzQbW82WApPJxFlnndWKn6ppM2bM4P3336eiooKvv/6auXPnturxhz/fI0eObPTYpp7vtLQ0cnNzW1TUs2acUHjNBIpKDnRwQugh4hywzgn63NK+CFlyPcQ+AyKxoSMaeyQ0WHavqeNbc3t93qIrwHYhOtMRLX6M1tKiY/hwzllc8sWnrM4+oHU4QVfp9OIozITo+lddFMWfUiwpbCsP/a4mStO+zfkf/aP6MTx2WJsLYHVG3SPS0aELSlFCvdCTHhG+H7oHDRrEjz/+COBr09aYmvtrVhA0JSYmxndlvkZubi7btm0DqusCNFUgrqqqilNOOcW3SuGGG27gtttua3be1vBnpwKv18u5557L559/DlSvTHjxxRebfVxkZCTp6ens3bvX1zmiMbXvr90hQmtCCFJTU31dDGosXXqonWhNUcsaNUvdv/jiixbt4a9ZLZKRkdFscmDNmjVs2FBdBHr69OnEx8c3/0O0UFLSocTj7t2tT8DXTpK09Pk2GAz06VN3a+7AgQNZvXo1JSUl5OTkNNrOMDs727daJ5ReM/6mthV0EkIErwWelF5k+bPI4stAVkD5MyBzG/iX18i//CZub+hfQSP/Drb8n+N/YP8qaL8jf4m3RvDGzNmc2Duzzu2Wwz5sCGBsWvcgRhYc/9tYTldTD63DUDqwbpauKjHQQUgkT2Q9zQ1//Jtyd/itGNOKSWeie5BO2LtHpGPSBXcbgz9NnDjR9/XhLQxrKy0tpaCgeptSt27d2jTXO++84zshb6oNocvlYtasWb7l/pdeeikPPfRQm+ZsjNvtZuvWrQB07dr+gsGXXHKJ7+r29OnTeeONN1pcHX/ChAkAbNmyhZycxre01t7+MH58iHbUquXtt98Gqve6t+Rqv7+8/vrrvq/9taWgRu1VJm1Zpn/UUUf5igg2tZ3F6XSyYsWKeo+pUfOaaW6ccHvNtJVKDih+J0tvR5bX2vPkWq1dMK0gDP21DqFNLAYjz0w7hUtHjGLukGG8fOpM1lx8OVeNGuM75rjefXj6pJNJ6HAFVARrt8SjV29lSoB4gtTCTQmefEcBvxaGx9+lUHF00oTmD/LHPInh/YG7djvAmp7wDfnkk098J/ZHH310q+cpLS31LSWPjY1tdDm2x+Nh7ty5fP3110D1Pu/nnnuu1fM159133/VdUZ00aVK7xrr22mt56aWXgOraDB9++GGTBREPd9ppp/m+bqzQXWVlJe+//z5QfdW4b9++bY43GD744APWratuRz537lxiY2Pr3L9r1y6klE3+q/281NxWU3uiMW63m3feeQeAxMREvxc6/OCDD3xfDxnS+jpSUVFRTJkyBYDvv/++0W0BH3/8se/1OXPmzHr3n3rqqb7k06uvvtrofDWvJ51O5+so0hGpT9SKX0lvOVR9onUYbWMMz+QAVBcpvHH80dxzzFSO6dELi8HINaPHMWvAIAAuOnIkXgnXjBnP3ZOnMLlHTwzt7FEbKrbk2ukiVHFCxf8yI/uQYw/hYqpKm604uFLrEMLK+MSxWHTm5g9sB4vOwrjEsQGdI9CGDh3qK0T46quv1lkKXiM7O9u3pN9kMvlaCh5+jMvVcJeIsrIyZs2a5bsq/sgjjzRYvV5KyUUXXcSHH34IVCcuXn311VZtqSkqKvJtk2jMqlWrfLULhBBceumlDR43b948hBAIIRod88477+Txxx8HYNy4cXz66ad1WtC1xMyZM+nduzcA999/f4MrOG644QZfAbwbbrihwXF+/PFHX7zz5s1rVQyttWfPnkbvW7lyJRdeeCEA8fHx3HfffQGNpbZvvvnGV6vg7LPPbnGSZsGCBXXaDDbk8ccf56uvqlfs9ujRo87V+9rj1DwHd955Z4PjXH/99UB1IuOKK66ot52noKCAm266CahOpNX8Lmvr0qWLr/PHt99+6/t/prYPPviAb7/9FqhOsjW29aAjUDUHOikppV/3XErpBPcO8OwGgtv2yD/0YOhY7QGFENx77HHklJdx15LFfHbW3zhnSHXHir8NHU5RVRVfb9vK51s30zM2jl5x8azJPsDSPbspd4VXVe8v13iYcFQU5e4yrUNROggDBg5UZWsdhhIgm8u2cNBRSILZf/tnOzKr3sr0rifz4b7Gr4a31yldT8aqD//VbU888QTLly+nuLiYE044gX/961+ceOKJmM1mVq1axf333+9bTv3f//63wW0Fb731Fo888gjnnXcekyZNIjU1ldLSUlasWMFzzz3nO5k8//zz+cc//tFgHNdff73vKujgwYO55ZZb2LRpU5OxDx48uM73JSUlHHPMMQwdOpTTTjuNESNGkJqail6vZ8+ePXz++ee88cYbvkTG9ddf32RRuKY8/fTT3HXXXUD1VouHHnqInTt3NvmYfv361TthNRqNPPXUU5xyyimUlpYyfvx4brvtNkaNGkVRURHz58/no48+AqqXk5977rltitefTj75ZKKiopg7dy7Dhg3DZrOxf/9+PvvsMxYsWIDb7cZsNvP222+TnBy8gp21txScd955LX7cnXfeyXXXXcesWbOYMGECvXv3JjIykrKyMtavX89bb73FL7/8AlQnyObPn9+i2hsNOfbYYznrrLN49913+eyzzzjuuOO45ppr6Nq1K+vXr+fee+/1/f/ywAMPNNrV49577+Wbb74hPz+fs88+m99++43p06cD1bUcaophJiUlcc8997Qp1nChkgOdVeUreD05iIi/A06Qjup/wgyG/gjR8qvK0pWFLLkWjEMR0XcjYp9FVvwfuNYFLn5/06cC4bvPsTEmvZ7npp3K8n31s9JxVitzhwxj7pBhSCkpcdgZkJTEpoJ8ykvCKzlQ5vAiS/qB7TetQ1E6CDduLCKwV0oVba0oXMnJqY23m1PqOjn1JFYXrWFnxS6/j93T1pNpqSf6fVwt9O3bl88//5zZs2eTm5vLvffey7333lvnGCEEt956KzfeeGOj4+Tm5vLQQw81WB/AYDBw3XXXNXkVueYEGGDDhg2MGDGi2dgbKyr4xx9/+DojNESv1/Of//yH22+/vdk5GlM73v379zd4JflwO3fupEePHvVunzZtGi+88AJXXnklubm5DXZlGDVqFJ988gl6vb7BsauqqnxfH95e0N+klCxfvpzly5c3eH9aWhoLFizwLaEPhpKSEl9ByIEDB7bo9VNbYWEh8+fPZ/78+Y0ek5aWxiuvvMLUqVPbFesrr7xCaWkpX331FYsXL/Z1uKih0+n4z3/+wyWXXNLoGOnp6Xz++eecdtpp5OTk8OCDD/q27tTo0qULCxcubLYzSLhTyYHOSlih8jVk5WsN3BeHNB+NME8E8wSEruErK1JKqHwDWfYw4AARVd0dwXIc6DOQB6cH9mfwJ88+ZOFciH0KoQ/PNkqNiTKbOf6wgoWHe3jZUl5YvSpIEQXGN+srOGNid7KdjS/PU5TWSLGkUF6+Q+swlABZVrCCE7scj140fHKg1KUTOi7pdRH3bLrfrwUdIw2RXNLrQnStuCgR6iZMmMCff/7J008/zcKFC9m5cydOp5PU1FQmT57MVVddxRFHNN4d6fTTT8dut/PDDz+wfft28vLyMJvNpKWlcfzxx/OPf/yDQYMGBfzn6Nq1Kx988AHLly9n1apV7N+/n4KCAux2OzExMfTr14/Jkydz4YUXNniSrqWLLrqIsWPH8tRTT7Fo0SIOHDiAzWZjwIABnHPOOVx44YVNXq2uOVE3GAxceeWVAY31kUce4fPPP+eXX37hwIEDFBcXk5CQQP/+/Zk5cyYXXHBBmwr2tcf777/v2xrQ2kKEixYt4vvvv2fx4sVs2rSJ3NxcDh48iMViISUlheHDhzN9+nTOOOMMIiIi2h2r1Wrlyy+/5O2332bBggWsW7eO4uJiUlJSOProo7nyyisZO7b5LUujR49m/fr1PPnkkyxcuNBXk6Fnz57MmDGDa665JuCJolAgpD97jyhhQ0oHMn8KeBvur3uIAOMQME1EmMdQfXXdDdKJrHgVnD/VOtSGSPgIYeiFlC5k3hiQhy3z1vcET9PLxLQkIq9CRPqn7284efbXlTy6vP7eyHDTK8HE8EE55DvVPnGl/TIj+5BVvk3rMJRWSjIlYtabsRlsbCnb2uSxNn0EYxPHcFb6GRjDrEp+VlYWbrcbg8FAZmbTCWB/2lWxm4e3POaXBEGkIZIb+l1LD1uGHyJTFP+ZPHkyS5Ys4fzzz+eVV17ROhylE9DqPf1wKjnQicmK15Bl9zZ/YGuIOETc8wjTkUj3NmTR5eDZD5aTEBHnIkzDkFVfIEtvBVnV/HjBpk9DJH7fqm0VHUHWwYO8/sfvvP/nelze8K7ObtLDzFFGsuUfSNTbm9J2McYYSlwlWoehtJBA0Dcqk23l2/HI6qJUGREZFDgKqPBUNPiYZHMSLq+bgdEDuKjXBX6txRNoWn6QzK7K4cUdL7Gzou3J/p62nlza60K6WDtuYS8lPDkcDmJjY3G5XGzevJk+fTpWTSolNIVKcqBznQEpdUWcjUj8BhH7PH7bby+LkIVn4S04Few/IGKfRMS/hbCcCM6fkeXPgHkyGI/yz3z+5tmHLJyDrHhZ60iCSq8TfLzpz7BPDAA4PfDechf64tbtj1OUw5W4Skg0dfwlhB2BSZhIsSSzpWyrLzEAsLtyNwadgW7W+r3Xe0b0oMRVQpGriF8OLuOzA18EM+Swlmrtwu0Db2F22ulYdJZWPdaiszAnbRa3D7xFJQaUkLRq1Srsdjtz585ViQGl01ErBxQApP070CUiK54Hx5LATiYiQFYGdg4/EPFvIUwhmsTwIykln27ZxO2LF4Vdl4KmSaZPyKbEXax1IEoY6xuZydbyLK3DUJrR3BYQHToyo/r4thn0i+rb4JaDy3pfwpiEUQGL059C5SpTlaeKZQXL+bngF/ZU7q2TnKmhF3q6R6RzdOIExiWO6RBdCRRFUfwpVN7TVUFCBQBhOb76C88pSNemFtQiaIcwSAwAyJJbIe4l0EWCiKkuttgBbcjP49rvvtY6jAAQRHnTKaFY60CUMOaWbq1DUFqgytN0T20vXraUbaWnrSc6RIOJgczITF7a8QqfHvic4bFDGR47jD6RvVXBwmZY9VampBzLlJRjcXpd7K3cS549D5d0YxQGki3JpEekYwqzmg6KoiidkVo5oNQjpRtZfAU4Fjd/cGeh74mIugHMU8JqT2pLnfPxBw22Owx3o3paMaes1joMJYxZdBYcXoeqXxHC4o3xFLoK2/x4q85KqrULOxrYP2/TR3BS6omc0vXk9oQYEKFylUlRFEVpv1B5T1c1B5R6hDAgou8DXaLWoYQOz05k8eXIwrlI51qto/G7K44arXUIAbFqZxWO3JHEGdW+caVt7F47XS2pWoehNCHJ3Pa/VWnWbpj1pgYTAwAVnkqWFvzS5vEVRVEUJZyo5IDSIKFPQMQ8BCJW61BCi2s1svAMvMXX0pEW3YxNS2doSscsDLVqZyX/W5FKN91QBB1v1YcSeJHG4PaXVlonx5Hbpsf1i+rL/qoDFDfTkSLHnkuFOzy2wymKoihKe6jkgNIoYZ6ASF6KiH0OzCcCJq1DCh32L8CzV+so/EYIwYjU+tW8O4oql5d3l7npZlRVh5XWq3A33AZP0V5GRPc2tZuMN8WzpWxri7eL/FLwC26vqj+hKIqidGwqOaA0SQgTwjIVXdxTiOSfwHS01iGFDucyrSPwq4yYWK1DCDi3qNI6BCUMHajKxqRTydFQZGxjkbtCZyHxprgWH//WnnfZU9lxEsKKoiiK0hCVHFBaTOjiEXH/B7YrtA4lJEjnCq1D8KsesS3/oByuqrzlWoeghCEvXlV3IARZdRZ2Vexu8+MNwkiyOYkInZWeth6Ym0gAxRpj6WHLaPNciqIoihIOVCtDpVWE0COirkYKHbL8aa3D0ZZzBVJ6EaJj5Ng6w8oBh7fpdmeK0hizzqx1CJ2aAQPx5ngMQo9eGNALHWadmS3l9VsStlSe41DL3p0Vu+hp68HOil0NHntE3HB0HeS9XlEURVEao/7SKW1j6pjV7VvFWwjutn8wDTXdoqO5+MiRvHLq6R02UZCo76F1CEqYKnIVaR1Cp5Vm7Ua0KZo8Rx4H7NnsrdrLrsrd7UoMNCSnqvHChkfGDvfrXIqiKIoSilRyQGkbw0BQld+R9s+0DsFvDDod/54wick9enLHpGO1Dicg9udGaR2CEqbyHPlEGdTrJ5gMGHwdBQqdhQGfr8pbRVwDdQgsOgsDovsHfH5FURRF0ZpKDihtInSRoO+ldRjaq3gJWdVxEgQA+0pLWLFvDxZDx9t1tO+gS+sQlDCWYknWOoROo5ulK7GmmFZ1FPCHOGNsvds80sOi3B/wSE/Q4lAURVEULajkgNJ2xsFaRxASZMnNSOcqrcPwm7ToGM4ZMpzLRo4izmLROhy/ykjqeAkPJXiEVKulAs2Ann5RfTlgz6bAeTDo8xtF/e4HLuninb3vc+ef/21T20RFURRFCRcqOaC0mYj4G1hnax1GCHAhK99FyuBd3Qq09JgYrho1ltdOm02kseO0cEuIVlf+lLbLdTS+J11pvwhdBHHmuKCvFqjN4XU0et+eyr0syf85iNEoiqIoSnCp5IDSZsI0DF3MfWCaoHUo2tPFAR1vyfrg5BRenD4Dk06vdSh+YTRXaR2CEsZK3WUkmZO0DqPD8uIl31GgaQwHm1mt8EvBsiBFoiiKoijBp5IDSruJ2McQ0feB+Rjgr6vMxhGg60T7cyvfQOZNwFtyJ9K5pkOtIhib3p0nTzoZvQj/JdV2Al/UTOnY4hvYk674h91rJ0IfoWkMZe7yJgtPdqC39oCQ0o50rkVWfYas/LD6v861SKnayCqKooQDtQFXaTehi4WI2YiI2UhvBXj2IYz9qk+QPTuQZY+C43utwww8WQxVbyOr3gZ9GtJyKsJ6CsLQW+vI2u2E3pmsvvhy1mRn8+uBffx2YD/rcnNwesJrmb6FaCCv2eMUpTFO2fFWCIWSGGMMlZ5KTWNoqvBgnCk2eIGECekth6qFyKqPwb0ZcDdwlAFp6I+ImAWWGdVFjRVFUZSQI2RHusSphCxpX4QsuQVkJ+wVbhiMiLoOYR6vdSR+5XC7WZ+Xy68H9rEuNwerwUiyzUZhVRUfbfpT6/AaNKCLhaQev2u2n1kJf2ZhwiXdePFqHUqH1NvWi+0VOzSb36qzUOVt/Cr32ITRXNr74iBG1LisrCzcbjcGg4HMzMygzy+lByrmIyteBFnR8gcKG8J2CdguQoiOsWVNURSlvbR+T6+hthUoQSEsUxCxjwPhvzS91YQROuDJqNlgYGTXblw2cjQvnDyDx0+Yxs0TJnHPMVNJjQzNfvCbcux0Mwxo8hgpIcKTis7bcQoxKv7jkE66WlO1DqPDMoi6CxrTrWmkWdOCNn9MM9tG4oxxwQkkxEn3DuTBOcjyx1qXGACQFcjyx5CFZyDd2iWCAqm0tJQHH3yQ8ePHEx8fj9lspnv37syZM4dvvvmmzeNmZ2cTGxuLEAIhBJMnT2702Hnz5vmOa+m/BQsW1Btn9+7dzJ8/n4suuohRo0aRkZFBREQEVquV9PR0Tj31VN544w1cLv+tqqqsrOThhx9m1KhRxMfHExkZyYABA7j++uvZs2dPi8f5888/ufTSS+nTpw9Wq5WkpCQmTpzIiy++iNvd0AoX/9uzZw/PP/88Z555Jv369cNms2GxWEhLS2PGjBm88847zcYipWTp0qXcfvvtTJkyhdTUVEwmE9HR0QwaNIjLL7+cdevWNRvLb7/9xqOPPspZZ53F0KFDSU1NxWw2ExUVRb9+/TjvvPNYvHhxq36+iooKnn32WaZMmUK3bt0wm82kpKRw5JFHctVVV/Hdd981+tht27bxzjvv8K9//Yvx48cTERHR5GuxvTrS6yqQ1MoBJahk+bPI8ie1DiN4TBPQxb+idRRB9/q637lzyQ9ah9GgbjEmxg7LJ9e5v87tVk8yruJ+bMlxcKCsHJvRyKQBJsoiftUoUiVU9Yvqy5ayrVqH0SH1iMhA/9fV5FxHHl6vl0pvJfGmeJLMiQH/vTe3cuHUrtOZlTYzoDG0lFZXmaRrA7LwguqtdO0lYhHxryKMg9o/VohYvnw5s2bNIjs7u9Fj5s2bx0svvYRe37qVE7Nnz+ajjz7yfT9p0iR+/PHHRud47bXXWjX+smXLGDt2bJ3bbrvtNu69995mHztkyBA+/fRTevbs2ao5D7d9+3ZOPvlktmzZ0uD9MTExvP3220ybNq3JcV5++WWuuOIKHI6GO5CMGTOGL774goSEhHbF25Tbb7+de+65p9k6VCNHjuSjjz6ie/fuDd6fkZHR7MmrEIIbbriBBx54ANFIjagJEybwyy+/NBv3nDlzeP3117E008568eLFnH/++ezevbvRY4YNG8batWvr3b5kyZImk1uvvvoq8+bNazbWlgqH11WorBxQNQeU4LJdBs7V4FoPxgGg6wLOn8Eb/H7WwSCsp2kdgibOHDSE535bSV5FK68oBcH+Eicf/hTNtCGpELOVMncpFm8Sazd2J6/i0OuwwuXi121G+g/WgU4tIVcOKXeXax1Ch7Wr8tCHTJveRqW3uv5AobOQQmchOnQB3dJx+MqFw3124At2V+zh/J5/J87U+VYRSPcO/yUGAGQxsvB8SHgXYejlnzE1tGXLFk466SRKSkrQ6XRceOGFzJ49m4SEBHbu3Mnzzz/PokWLWLBgAVFRUTz11FMtHvvzzz/no48+Ijk5mby85mvn3HvvvVx//fVNHlNUVMTkyZPxer1kZmbWSwwA6HQ6hg0bxoQJExg+fDipqamkpKRQVlbG9u3befXVV1m2bBnr16/nuOOO448//iAiom2FRcvLy5k+fbrvBO6iiy7irLPOwmq1snjxYu6//35KSkqYM2cOy5cvZ+jQoQ2O8+2333LxxRfj9XpJSUnh1ltvZfTo0RQWFjJ//nw+/vhjVqxYwemnn87ixYvR6QKzkPrAgQNIKbHZbMycOZMpU6aQmZmJxWJh06ZNPPXUU/z666/89ttvTJ06lTVr1hAZWb8ex/791Rcz+vTpw6xZsxg/fjxdu3alqqqKxYsX8/jjj1NUVMRDDz2EXq/nvvvuazAes9nMpEmTGDduHAMGDKBLly4kJCSQn5/PunXreOGFF9i5cycffPABOp2Od999t9Gf7fvvv+eUU07BbrcTFRXFxRdfzJQpU0hJSSE/P59du3bx9ddfk5vbcAvg2gkTnU7HgAEDsNlsrFq1qjW/4hbpaK+rQFMrB5Sgk9IFGHyZTSndYP8aWXID+OtDn/UMcK0Ft8ZX93QpiISPEPpO1LkB+HDjBrYXFfLi6tC+6h5p1nHSMDPLNunZX9bwCd+Y7onERrnQmyrwGIqp0uXiFY33Qlc6PoHArDNjb2JvuhIYscYYil0lARs/M7IPWeXbmj3uX5n/ZHjcsIDF0RLBvsokpQd5cA64N/h/cOMQRPz7YV+DYPr06Xz55ZdAw1c+pZRccMEFLFiwACEEv/76KyNGjGh23PLycgYOHMjevXt5/fXX+fvf/w40vXKgJZ5//nkuv/xyAP773/9y22231Tum5jXWlGuuuYYnn6xeFfrUU09x1VVXtSmeO++8k7vuuguAhx56iBtuuKHO/cuXL2fixIm43W6OOeYYfvih/gpFt9vNgAED2LZtG9HR0axZs4bevesWhr7iiit47rnnAHjttdd8v09/u+mmm0hISOCyyy4jKqr+dkuPx8PcuXN5//33Abj77rv5z3/+U++4cePGcccdd3D88cc3uCpg+/btjB07lvz8fAwGA1u2bKFXr/rJtuaey6qqKqZMmcLy5csB+OOPPxgyZEi94/Lz8xkwYAAHDx5kwIABfPfdd6SlNbz9y+l0YjLV36aZlZXFp59+ylFHHcWIESOIjIxkwYIFnH/++YB/Vw6Ey+sqVFYOhGdKQwlrQhjrvLkJYaiu6h95tf/miLoREXGB38ZrM28usvgKpOxcJ5NHdU3j3Q3rtQ6jWeUOL79nWRtNDACs2FPAN3+W8OXvbr75NZIlK3uTkzUuiFEqoUYiSbV20TqMTilCbwvo+HZPyxI+P+QtbvGxHUbF/MAkBqB6NWHFS4EZO0gKCgr46quvABg/fnyDJzZCCB5//HFsNhtSSh544IEWjX3LLbewd+9ejjnmGM4991y/xfz666/74mps3OYSAwA333yz7+uffvqpTbG4XC5fgmHAgAFcd9119Y4ZO3Ys//jHP4DqJe2rV6+ud8wnn3zCtm3bfHEdfgIH8PDDDxMXF+f7OlAefPBBbrzxxgYTAwB6vZ7nnnvOd/L84YcfNnjcsmXLOOGEExrdLtC7d29uv/12oPok9tNPP23wuOaeS6vVytVXH/os3thzefPNN3Pw4EHMZjOffPJJo4kBoMHEAEBmZibXX389kyZNanC1hL90xNdVoKnkgBI6bJeAeZIfBtKBiAyd2oeudciS231LqKTzN6S3TOOgAisjNpY5A8NjD6lZ3/rdVVkHizF7O9+SYuUQozBqHUKnZNGbAzp+lcdOL1tP+kX1JcXc+IqvdSXruXfTAxQ6CwMaT6iQ3vLqrgSBnKPiheq2iGHqt99+8/2dP+mkkxo9LjY2ljFjxgDw1VdfUVnZdOvOVatW8eyzz2IymXj++ef9Fm9WVhYrVqwAqlcgZGRktHksm+1Q0s5ub1vS7Mcff6S4uBiA8847r9El2bWTLh9//HG9+xcuXNjgsbVFRERwxhlnALBhwwaysrLaFLM/JCQk+Jaxb9++vc3jHHPMMb6v2zNOc89lcXExb7/9NgBnn302/fr1a/NcwdBZX1ftoZIDSsgQQoeIeRh03do3kPkYkHZk1UK/xOUX9k+gsrowoSy5EVlwIrLqy2aL1ISzK0eNIa6ZYjahwGRo2zJWs7OHfwNRwkqhsxO2ZQ0BOhHYjy0FzgJ2VOxkS9lW8h0F9Ivqi2gk07ynci93/Xkveyr3BjSmkFC1sPVdCVpLVoC94Sue4aCw8FCiKCUlpclja+6vrKzkt99+a/Q4t9vt2+N80003+fVErGbVANDuZfXvvPOO7+v+/fu3aYyff/7Z9/WkSY1fKBo5cqTvBHbp0qWNjtOvXz+6dGl8hVftORoaJ5hqitu1Z4967QJ57Rmnuefy888/p6qqCqguXFijrKyMrKysFtXDCKbO/LpqK5UcUEKK0MUi4p4FXRN79EUMIvI6EA1cuTWOQETfjiy6EJwrAhdoG8iyh5HeUjBPAW8+suRfyKILke6Wt08JJ9FmC1ePDu3l9zrA08YETVlpaLZr9D/JRV0iidCFylKc0FDgLCDGGKN1GJ1Orj14Hzy9eDlQdaDJY4pdxby9u/GiXR2FrKp/JS0g81R+1PxBIar2FdeSkqbrYtS+f+PGjY0e98gjj7Bu3Tp69+7NLbfc0v4g/yKl5M033wSqr3bOnj271WMUFRXx+++/c+2113LFFVcA1UvIL7300jbFtGnTJt/XTSUYDAaDb0l37cdAdW2Gffv2NTvG4fcfPk4w5eXl+eZva2IFqqv/12jNOF6vl9zcXH744QdmzpzpWxXQr18/TjjhhHrH16w2gerl+N988w3jx48nOjqavn37kpKSQteuXbn22mspKCho88/jL531ddUeKjmghBxhHIhI+BRMExq404aIewkizkVEXQ+GwXXvNw5FFl8JrsYz8ZrRxYKIQlhPP3Sb82dkwcnI8ueQ0qlZaIFy9uCh9IoLzeX3SdYIMhMS+SM3p02PX76rkCiXdgVjguVvydGMM33Nk913cnRM4PYFhqNkc5LWIXQq3SPSKXMHd0tWqiUVSdMJxE1lm9lbuS9IEQWflHZwB+lDrntz2NboGTBggO/r2idqh3M6naxcudL3fWMt6nbs2MHdd98NwHPPPddsW7nW+Omnn9i1axcAM2fObHRP/OHmzZvn60MfHx/PkUceyeOPP47L5cJqtfLmm282uBe7JfburV6BY7PZiI2NbfLY9PR0oLowXu0r5vv27fOtyGxqH3ztMWrPrYWHH34Yt9sN4FuS3lqVlZU88cQTQHWCZsaMGc0+pkePHggh0Ov1dOnShSlTpviWzmdkZPDRRx81WKOgJpkVExPDSy+9xEknncSyZcvqHJOdnc3jjz/OEUcc0WTyKxg66+uqPVRyQAlJQp+AiHsJEfkvDr1MLYi4/0OYhiF0EYiIOegSP0YkfALWM0FEgDBXFzYKRYaB1X9UjQPAMLDWHQ5k+RPIglORjpWNPjwcGfV6bh7ffB2JQUnB7eYwODkZp9fLloNtz2q7vF6WbogkwpPqx8hCQ7LRyLnJUSQYDBxjrb5KYPDu5fyYb7kt3YSlkaJI4cYiBENtESQbjYhmTgAb0txJo+I/3SPScXs9QZ+30tP0fvAa/8v9PsCRaMi1GQjW797913zhp2/fvr4EwZdfftloP/lHH320zhXVsrKGE16XXHIJVVVVnHnmmRx//PF+jbX2loLzzjuv3eOdeeaZbNq0qc4y89aq+T20pDhd7VUa5eWH6lTU/l02N05jYwTTypUrfSf1aWlpvs4RrXXTTTf5kkxXXHEF3bq1bXuuwWDg7rvv5o8//mDQoIbrRtVsn6mqquKmm27CbDbzwAMPsG/fPhwOBxs2bPBtU9m3bx8zZszQ7PcLnfN11V6tr8SlKEEihA4iLwPzePCWgaE3Ql9/n48wDkLE/BcZdRPYvwjdj+uyEild1d0arKcjyw7Lpnp2IIvORVpOQ0TfidC1rU9wqDm2Zy8uPnIkr6xdg9tbv1Xl9L79eOKEk7nw809YsmtnQJ8/HTCyWxqr9vvnKl+pw8Efm9MZOKASpy5w7dWC7awkI0cYvmJiWjo676F9tAIvvcUinsrIYEHhAJaVBngPcgDpgPu6VxEnq6sxS3QgonGLGFxE4pARVEkLFV4TZV4j2+06vi8qx1lrG0pOVcP9mxX/6hPZh20taC/obzGGGPZV7W/RscsKVnBG2mwijR1wdY0nyFvfPHsAbdtEttW9997L6aefjtfrZdq0adx3333MmjWLhIQEdu3axXPPPceTTz6JyWTC6axeLVizf7u2119/ne+//57o6Ggef/xxv8Zot9t9VfG7devGlClTWvzYe++9l+uvvx6A0tJS/vjjD+bPn897773H/v37eeWVV9rcgq2m+F1j1e1rM5sPFSat/furXUCvuXEaGyNYcnNzmT17Nm63GyEEr732GhERrf/c99Zbb/HMM88A1atX7r333hY97rvvvsPpdOL1ejl48CC//PILzz//PPfccw9ZWVk899xzDZ4IV1RU/92vef2+8cYbdZJCgwYN4rXXXsNisfB///d/bNu2jRdeeMH3ugm2zva68ge1ckAJecI4FGEe32BioM5xukiwnICIugWMQ/+6tfk3g6BxrUGW3lG9NMk6E4zDGz7OvhC8Te9zDSdCCP49YRLfnHMeU3tWLzccltKFG8cdzfnDj6SoqooPN27g5VNmcs+xx2FsRyGdpiT+tY3AX4mBGtll5ezdMQi9DGwV9WCKN1T/0Td4G14SZ/Tu5sLY/3FLuhlzWK4ikNzVXRAnf/XdIvAiZDFG724ivH8SJ3+lKz+TqVvEkYZvmBP5FS90X8NDGW7mJEUTqddT7ilvsqK90joG9PSL7EuCMcF3W5Qhkv0tPEH3txRL00XlanNJFz/mt62FW8gL9pa3MN5iN3PmTO677z6EEJSWlnLllVeSmpqKyWSib9++PPHEE1gsFu6//37fYw5f0l9QUOBrt3bvvfeSmurf1WkLFy6ktLQUgL/97W+tKl7XrVs3Bg8ezODBgxk3bhyXXnopq1at4pJLLmHp0qWMHj2adevWtSmumm0TNSedTam95NtqtdYboyXjNDZGMJSVlXHyySf79rHfd999HHvssa0e58cff/S14IuLi+PDDz9s8c/St29fBg8ezNChQznmmGO47bbb2LBhA8OGDeONN95g/PjxDa5qqf07HjNmTKOrRe677z7fiXLtIofB1pleV/6ikgNKhyJ0cQjbPHQJHyISv0dE36Z1SHVVfYgsfxqhi0LEvw7mRpYKSldw4wqCXnHx/N8pp7HyH5fyyZnncOnIUfxn4jG8MXMOZwwaghCCQUnJJNv8f+VtUFIybtm+bQRN2VpQTNm+0SDD8US5vhjR/FI4gYdM8T1PZ+zl5PgoToiL4sykKP6REkmkvm0dIILlum4RpNH6Ezkhy0mSy5lm/ZKnui3n8YwqpsaqP6P+EGOMIcmSxJbyrVR4Kuhp6wFAsjmZKo82V18kXvpF9iUzso+vvaFZ13jCeVHeD3hk8Lc+BJwIcpI92PP52c0338yPP/7ISSedVOekwmg0MnPmTH7//Xf69u3ruz3usLo8NYXcRo4c2eZl5k3xZ5cCAL1ez1NPPUV6ejpFRUVcdtllbRqnJknSkqXYNVevoe4y79qJlubGaWyMQLPb7cyYMYPVq1cD1c/3v//971aP89tvv3HqqaficDiw2Wx89dVXDBw4sPkHNiEuLo7XXnsNgD/++KNOEqtG7d9xUy07ExISGDlyJADr1q3D5dLmc21neV35k9pWoHRYwtAdKcur9/e7tS2IUkfFM0h9CiLiTIh9Cln2IFS+ethBHS85UCOp1n6sww1N6cLnZ/+Na7/7mh937Wz3XAI4yo/bCJqyen8BJyceSal1dcDnCjSrKKKl+zuM3p3Mjqz7XPXoNon/hGgTjnkpUQzWf9XucQQOYuVvTDX/RlLXE3jiQAU00vJOaVq6NY1CZxHZrurioHavnZ0Vu+ht68X2ih2axZXVwFYGm95Gui2dbRX1+4gXOotYXbSGUfFHBSO84NF379jzBcDEiROZOHEiTqeT7OxsPB4P3bp1811J/eijQ10Zap/QHThwgDfeeAOAY489lvfff7/JefLy8nj33epuGT179mT06NFNHp+bm8t3330HwIgRI9p9MlnDZDJx4oknMn/+fJYvX86BAwfo2rVrq8ZIS0tj5cqVVFRUUFxc3GTxuJpCb0lJSXWWcdcuFldzVb65MaBuEblAcrvdnHHGGSxevBiACy+8kEcffbTV4/z555+ceOKJlJWVYTabWbhwIWPGjPFLjAMGDCAzM5OsrCw+/PBD7rvvvjr3p6en+zoWtLQ4n8fj4eDBg022AAyUzvC68jd1yUPp0Ko7H3yIiPo3iNBZ3iNL70TaFyOEDhF142EFCgnrZZXtFWux8tIpM7lu7Ph2nWolWK30DcA2gqbYq8K/ToRAYpL57RojjSWclhB6rR5PSYhiovlbv487zPAtd6Yb2lTUsLPrF9WXfVX7qfDUr1+hZWKgMRWeCkpcjdcX+V/OoiBGEyTG/kCwVgMZ/pqvYzCZTGRkZNCrV686Jxu1+5/XPqGvvWT5oYce4uyzz27wX41Nmzb5bnv++eebjeett97C46le3eKPQoS1JSUd6t6ye/fuVj++dqJi8+bGi1K63W62b69OztXuEAHVV2prTsiaGuPw+w8fJxC8Xi/nnnsun3/+OVBdxPHFF19s9Tjbt2/nuOOO4+DBgxgMBt577z2mTp3q11hrnsuGnsfahQprXkuNqX1/Q50PgqGjv64CQSUHlA5PCAPCdgEi8SswT9Y6nL94kCXXICs/QJb+t97KBun4CeltWZXsjkgnBFccNYbXTptNQhv2bA1KSsYjZcC2ETSmtCr8rxxPiYtGyPYXV5xh+4rHe1QyOqrxlSLBNC7axkzbD4gAVV3PED/ycIYrTGswBJ9RGOlj682Wsq1h1/Uh31lArDGmwft2Vbb+pCjUCWEBQ5A+5Br6I0THqd/SkPz8fL7/vrq7xZgxY4J6dbFmS4HRaKyTZPCH/fsP1QZpy3LqCRMOta9uqhXkb7/95lu6PX78+EbH2bJlCzk5jbcqrj1HQ+P42yWXXOJb5TF9+nTeeOONVtV7gOqr1lOmTCE7OxudTsdrr73WoraFrVXzXDb0PE6cONH3dc3JdGNq7rdarcTHx/sxwpbr6K+rQFDJAaXTEPpuiNgXEbFPgS4EiojJKmTprVD1dv37Kl5A5k/GW/YY0pMX/NhCxITuGXx61t+wtjDjLIDR3dL4Mz+P4lrVZYOloDz8V3wcF13st7Fivau5NO4bnuhRyZgmkwSSk+OjeDTDQd8AFPAZEBHBP+JWIgjsayJBruTRjCJiQ7zmgtbiTXHEm+IaXJofLpLMSQ3e7vQ6+Tr7W19P7I5CWE8PzjwRs4Iyj5buvPNO3/7rK664os59PXr0QErZ7L8akyZN8t22YMGCJuddv369r1jgtGnTSExM9NvPVFFRwddffw1Unwj27t271WNMnjyZmJjqpNtrr73W6P9DtX/OmTNn1rv/tNNOa/DY2iorK31bNgYOHFinBkQgXHvttbz00ksATJkyhQ8//BCj0diqMfLy8pg6darvav4LL7zA3Llz/R7rr7/+6ptjyJAh9e6fOHGib2XBwoULG32edu7cydq1awEYN25cqxMh/tKRX1eBopIDSqcihEBYTkQkfg0RcwnpPcKyGCpegKqPtY5EU12jojmlb/PLTBOsVvolJLIyiNsIDnegtIJwPieI1etJkmv8Pm6MdzWXxH3Dkz0qGBd9KEkQoRNc1CWS/+uxl9mRXxEvV/HvpB+5Nd1U7wRbD4yItDEhpnVXpLqaTFyXvB6dLPLHj9Ism3c9D6bvJd0c3kXVAiUjojtVHju5jvBNetr0NsrdjRelenfv+7y1R7vq3AFhPQ1EgFcBCRtY/H8VNJhcLleTVxVfeOEFnnvuOQCOPvpozjnnnGCF5is0By0vRFhQUFCnPkJD7HY7F1xwAXl51f9Pz5o1q8GWfPPmzav+DCYEP/74Y737TSYT//znP4Hq7RKPPPJIvWOWL1/Oyy+/DFQnRo46qn59j5kzZ/qSE/fff3+DV7dvuOEGioqKfF835Mcff/TFO2/evAaPaYk777zT145y3LhxfPrpp3W2mLREcXExJ5xwAlu2bAHg8ccf56KLLmrVGKtWrWLNmqb/vu/fv7/OdpNzzz233jF6vd7XlnDLli08+OCD9Y5xuVxcfvnleP9qX33ppZe2KtbWCLfXVThQBQmVTknoohDRdyItM5Clt4N7i9YhNUIPQbpiE8rmDhnG+xs3NHr/oMRk9peXsjnI2wgO5/B4sMoE7OKgpnG01aykiIBeXY/2ruGiWDgz/gjyPHH01q2u3sLgPXSMwEkfsYjH0mLZ7D6KSL2TJF0OZu8uBA4kRiRT+aWknAidwO6VtR9eR5Rex+1d96APcmtQk3c7d6RW8njeEP6sDM8+x4HQL6ovW8uywm4bQW0xhhj0Oh3Z9sZPAAHWlzT+fhWOhC4SbJcgyx8L3By2S6vnCWMlJSWkp6czY8YMZsyYQb9+/QDIysrijTfe4Ntvq2ueZGRk8MYbbyCCtA3J4/Hw9tvVqxTj4+OZPn16ix5XXl7O7Nmz6dOnD7NmzWLUqFG+wooFBQWsWrWKl19+mR07quuDdOvWrcGTxZa64YYbeO+999i6dSs33ngj27Zt46yzzsJqtbJ48WLuu+8+3G43VquVJ554osExjEYjTz31FKeccgqlpaWMHz+e2267jVGjRlFUVMT8+fN9CY8JEyY0eALsL08//TR33XUXUP27eeihh9i5s+liy/369auzqsDhcHDyySf7rsKfc845TJ06lQ0bGn+Psdls9OzZs85tGzdu5Pzzz2fcuHGccsopDB8+3LcCYP/+/SxevJhXX32VkpLqbYVTp07l/PPPb3D8f/7zn7z33nusWbOGm2++mT///JO//e1vJCUlsW3bNh577DFWrlwJVK9SmTWr4RVBH374YZ3q/7VrcdT+GqBLly6ceOKJjf7MTelor6tAE7KjrX1TlFaS0onMm1B9pT7UmCaii39J6yg0V+50MvSFp+vdLoBR3dI0XS1wuJNHeCg1hmqyqSmS53sUYPE2XWwnFHhFIg6RjMW7lTLdEO7aF0uh213nGCPwaI8yorxrNYkRQIpYXikey9KS5lsodWQmYSItohs7KtrfgURrBgxEGSMpchU3eVyaNY0b+v2LGGNMwE4As7KycLvdGAwGMjMzAzJHbVJ6kAfngDsAiQ/jEET8+wgR3ltyCgoK6hTma8jYsWN5++236dGjR5vnqXlNTZo0qcGrpYf75ptvfG3nLr/8cp599tkWzbNr1656J5mNGTt2LG+++Sa9evVq8P558+b5Vi8sXryYyZMnN3jctm3bmDZtGllZWQ3eHx0dzVtvvdVsgmP+/PlceeWVjfalHzVqFF9++WWj2yu+/vprpk2bBlRvC2hLV4HJkyc3uc+9ITt37qzz2mjNc1CjodfFggULGj3ZP9y8efN49tlnG1wBUiM7O5tTTjnF15KxIdOmTePdd9+t0wqwth49erS4eGVjr/Vwe101Jdjv6Y1RKwcUBSMi8lJk2SOAu9mjg8q5Emn/AWE5VutINFXqqH81O95iJTkyMqQSAwDSFV19ZhomLEIwN9nGGOtmjN7wOHnTyQKssnqVSLT3dx5MS+OZ/EGsq6gp4im5J8OraWIAQMhiLohZTKz+WL4oLNM0Fq0kGBPQ6XQdIjEA4MZNrCm22eTAvqp9XL32Oiw6M8mWZFIsKXSPSGd66jR0Ijx3dAqhh9hHkAfP8m8yXcQiYh4O+8QAQGxsLC+99BKLFi1izZo15OTkYLfbSUlJYeTIkZx11lnMnj07aCsGatS0R4SWbykA6N69OytXrmTx4sUsWbKEnTt3kpubS1lZGZGRkXTv3p2RI0cyZ84cTjjhBL/8XH369OH333/n2Wef5YMPPmDbtm04nU7S09OZNm0aV199NRkZGc2Oc9FFFzF27FieeuopFi1axIEDB7DZbAwYMIBzzjmHCy+8sMkK+suXLweqq+xfeeWV7f65tHbmmWfStWtXfvjhB5YtW8b+/fvJy8vD6XQSHR1NZmYm48eP59xzz2Xo0KHNjpeamsqKFSt4+eWXeeedd9i4cSPFxcUkJCQwatQo5s2b1+Defa2EyusqHKiVA4ryF+n8HVl8DXiztQ7lMHpEzP0I62laB6KZzQX5zPngHf42dDiRJjNfb9tCdlkZRRoUHWzO1L4JOOJ/1jqMRkXpdTyWvgMvZpxEECH3Bm0/fiBJEcEyxyS2VMHkaAe9xA9ah+TjFYlctmcgzk7457Z3ZC+2l4deS8L26hvZF4kXr/S2quXiyLgRRBki2W8/QLI5ifN7nIdB17YPklpdZZKuP5GF5/snQSBiEfGvIoyDmj9WUYKo5qr/+eefzyuvvKJ1OEonECorB1RyQFFqkd4iqHwXKR2AC6QLqj4EqfGyYF0SuuRftI1BQ8X2Kn7ctZNl+/ZwwbARzPnwXSpcodkZYFR6IuZuP2kdRpMezXAQL1dpHUan8oN9Gm/kdb7VA2ZhJtoURb5D23oggdQvsi9byre26bHDYoZyZeZlmHStL2Cp5QdJ6d6BLLkBXOvbPohxCCLmEYShdUumFSXQHA4HsbGxuFwuNm/eTJ8+fbQOSekEQiU5EJ5r2xQlQIQuDhF5Gbqoa9BF3YAu+hYwH/3XnXFgPEKbwGSFNvOGiMKqKj7c9CcfbvyTH3btYP4ppzEkOUXrsBpUUO7SOoRmLatoek+s4n/jIsK3bV97OKQDj/QSoW9872q421K+lX6RfcmM7EP3iNb1rF9X8gePbHmcKk94Fa4Uhl7VNQIir219FwNhQ0ReV/14lRhQQtCqVauw2+3MnTtXJQaUTie8N0UoShDoYp9Euq8FfSpghMrXkWX3BjcIWYmUng6xJ7O1ftq9iwNlpSzfuweAHrGxjElLZ3rffqzPy9U4uvoOlFXQVUKQt5S2yucHyzjZFlPdKUAJCg+dt7VhobOQdGsa9io73kZ7S4S3mpUDNn3r2/1tKdvKA5se5rp+11DsKmF7+Q4GRQ8k2RLaSTwh9BB5KUT8DeyfIis/AvdmGq7dYwBDf0TEbLCcGvZdCZSO7eijj0YtrFY6K5UcUJQWEIZDRUpkxLlQ/mTwtxq4/gCTRisXNOJwu7lryQ+MT+/ua352zbdfkV1eztI9LatwG2x2txurjMMuQncfv1NKDshhdCO0tz90JNudXYHKZo/rqPZW7aNvZCZbyxuuFN1RVHgq6GrpygF769pn7qrczT9/v9bX5lEv9ExOmsSpXadj1ptwep3EGGMCEXK7CV0kRJyDiDinekueazN49oB0gjCBvjsY+yNE63q7K4qiKMGnkgOK0kpC6JDGIeBcHtR5Zdl9EP8eIkwrXbfFq2vXUOZ08OPuQ5XO3V4v9/78o2YxtUTRgSEkxToRloNU6vfgEQ6tQ6rnf6WRzIvWOorO45eyzvP/bWO2lmd1igRBlDES2lArVXLoSqVHeliU9wM/FyzFrDNj0Zu5sd/1YbCawAymYcAwrUNRFEVR2kAlBxSlLTRIDuBaB/bPoJN0LcguK+OZX1cgpaSgMryuuP62rwD2ARjRiT5kxEbTLdZIdKQDzPmU6/cihba1CZYUl3JubCr6kOvO0fF4RTy/lpUBIbzXJEiyyreREZHB7srQXPnjDyUu/23XcXqdOL1Oytxl3LvpAaanTqN/dD/SI9L8NoeiKIqi1FDJAUVpA2Eciha70WTZI2A+DqFr/b7WcHP/0iVUukK/uF9zvFKys6iEnb5dBhYMun70iI2ma6yBSJsdj2UvlfrgnqRnmM3ovIVBnbOzOkg/pEoMANVXx3dX7ibdmo5RZ2BHxc7mHxRmcuy5xBhj/JokACh2FfPmnrcZHjuMAVH9SPV0wdSJa1koiqIo/qeSA4rSFsZhYD0dHL+AN4hF8bx54D0IHTw5sHzvHr7I2qJ1GAHj9nrZVljMtr/OzVMj0+g9KDuIRQwll6Q4EYTedoeO6E97HND52hg2ZW/VXqB9bQBDWRdLClGGSCL0EQgE++0HKHf7p07N2uJ1rC1ex6URF2HUGf0ypqIoiqKASg4oSpsIfQoi5gGkew+y8O/gbV3xqTbTd0cYute5SXpLwP4/pP0rRMw9CH3X4MQSIC6PhzuX/KB1GEGVXV7Bke4BlBo3BXgmybT4GKZH78DqDfRcSo19TlX1ujE7KnZi1VvDrpVfc7aU1U14JJoS0Bt1lLhKARAI+kT2BsAtPbi8LpxeB1UeO5WeCjyy+a4OB+wH8Bo9xOnjKXYW45EePNJLjDGaKk/tzhA1rz+BURgw6kyYdEZ0nah+jaIoitIyKjmgKO0gDN0h4S3kwb+Bd3/gJzRNqPOtlG5k/mSQFdW9pnVdAh9DgL21fh1ZhQe1DiPoDhYkYUwN3Al7X6uVa1L2YvUupYN2kwtZ5lDua6kxl3RhouNf/S5wHiTOGEe8KQ6n10WcMY6s8m2NHt8vqm+9BENDvFLili6KXMW+2yo9lXWKGzbGIAwYdUZMwkiMMQa9rvO1ylUURVHqUmljRWknoe+GiLo+OHOZx9e9wbOrOjEQcX51r2l34x82w8XukmKtQ9DE6r2FGL2B6/19ZKRBrRbQiEX9pW2SoZMsjS9yFeH2utGh822raMzuij0YRMuu3xyeBmhJYgDALd1UeaoocZfWSS4oiqIonZf6yKIo/mA5EfQ9Az+PcWDd710bARAR56CLug4MfQIfQ4AlWCO0DkETLq8XU+XggI1vU+/2mjHr1MqBJklItYT/qqeWKHWXUeoubfY4u9febHLAJV148SI9Eult39aVMncZhY5CvM1sZzjoKCTfUUChs5ASZwke6WnXvIqiKAp4vV48nur3U71e21Vc6uOioviBEHqE7eLAT+RYWedb6doEhv6+OgSiA+whTYzonMkBgF+22rF5ugVk7Ai92kugFbNQNQeaUuIuId9eQI+IDK1DCSlu6W7y/oMU4vA4AIm7qv2dXcrcZVS6K5Gy7utVSkmJs4ScqhzK3KWUu8spcZVS6CrC41XJAUVRlPYqLy/3vfdarVZNYwn/MwlFCRXWU0EX2GKA0vFt3RvcGxGW4wI6Z7B11pUDAGVOJ79v6orZG+f3sa1CfYjXikklB5rlxo1Jp9ry1dZccmCP3IdbunF4nFQdrMJV4WzXCgIvknxnAdn2HOweu+92j/RQ6Cqiymtv8xYGRVEUpT6v10tpaSk5OTm+26KiojSMSBUkVBS/EcIItguRZXcHbhLHUqQnH6FPqs4wujZB1C2Bm08Dnb12W255BbZt/cno8ztunb35B7SQVdf0iYYSOCadOoFqCbdaou6jQ1er20DDcsmlQBagcwriiEfmS0Ag9IL2vI2WAQXkoxd6DMKAROL0Ohs8dpfOoboeKIqitJHH46mzWstqtWKzaduuXCUHFMWfImZDxXPgLQjQBC5k/tGQsg4wgnkyGPoGaC5tfL51i9YhaG5HYQlRe48ipvsypJ+u+JuFSg5oxahWDrSIW7Z/aXxHYRQGHLLhE/IaEskSuZRJTMDrlBiEAbPejM4loF3pgZaLMcZg1KmPkoqiKO1ltVrp3r07QuOrZOodXVH8SAgL2C5Alj0UwEmsgKG6vkDMA5q/ifiTlNIvbQwjjSacXg9OT/heiVyXfZDx5vGIlJ/avZoiQieI0+WpFoYaMapffIs0dnW6MzLojDg8zf8+3Lj5QS4hRSaTLtJI9CZgFMHr/hBljsJgUB8lFUVR2kKv12O1WomKisJms4XEZ3r1jq4o/mYcHtjxZQWy+GqIfRQhzIGdK8iEELw5czbHv7GAmQMG8uraNXhl66+6nty3H+/9uT4AEQbXL7sKmJaYSZkhq81j9DRbuCl1F2Zv28dQ2segU8mBlqh0V2kdQsjQi5ZXq5ZIcsglR+bW3BA0N3e7kczozOBNqCiKogSU2iimKH4nQQR4v5DjO2Th+UjpCOw8Goi3RjBn0GBuPXoyC888h/6JSa16/Cl9+1Pp6jjLk0sKUtv82MmxUdzWZbVKDGhIiljezdf+SkA4KHWX0i+yY22TaiuDTttWVi3VXF0ERVEUJbyo5ICiBIL1zMDP4foNqj4N/DwamDt4GACDk1MYn94dm7Fly2RP6J3JdWPH8+22jnMy/NveIoyy9cmmi7tE8vfo79DJwgBEpbSERMd7pePYYe94SbxA2VK+VbU0BHSEfnLArDOToZ4rRVGUDkVtK1AUv5MgzFTn3gJ7VUVWvALW2dX1BzoQk17PV1lb2FxQwBdbtyAQvHzqTNbl5PDC6lX1agkk22zcNXkKY9O6c8VXn+HsQL23HR4P5orBuCJXtuh4sxDcni7pytcBjkxpzjr3cXxbVKZ1GGEnuyqHJHMS+Y58rUPRTDisHJiYNAGbofO2nlUURemIVHJAUfxNSsBFMJIDeHaAYwlYjgnsPEGWEhnJiX36MqF7BrMHDiKvooLX//ide46ZSqnDzoJ1v/uOPXvwUG4afzRlTidnfPAOW/1Q0DDUbN4vGDXERJRBT5ROR6RBR5ReEKGDCJ3EqvNi0UksOg/p+r1YvKrjg9YKxSiePFBBsKrGdyQO6cAj3XSzdsPpdVLoLMTTydoc6kJ8YadAcFzKVK3DUBRFUfxMJQcUJRCki2CdFMiKF8E0GqHrWFdwdEIQbbYQbbbQPSaWQUnJfLt9GxePOIrdJSVkxMQwODmFyT16YtYbOP79BeRVVGgddkB4PSXc22VRCw8ObCxK81y6DO7ca0U9GW1X6CwCigDIiOjO7so92gYUZLoQXw12RNxwUizJWoehKIqi+JlKDiiK30mEaRyy8p3gTOdag8wfizRPRVhPAdN4RBBbWQWL1WhkRr/+VLndvHzqTBbt2M7lX32Gy+vlpD59fYmBS0eMIsZiZmdREbuKi1l1YJ/GkbffEUmd66ppOJNYeTKvH2UeVXnfX0w6E5EGG+Xujpn8a0hruhVo4cQux2sdgqIoihIAKjmgKP5mHILQ2ZDBXBYqq8D+OdL+OYg4iH8DYex4Vb+FEEQYjXilZP6a33B5q6/Mfr1tq++Yg1WV3Dj+aABcHg/9nn1Ci1D9amCc6v8eLty6LvxZqRID/qBHT5IlEZ3QYdKZSTRZKXAWaB1WUJS7Kuht60WBs4ASV6nW4dTRIyKDvpGqfaGiKEpHpJIDiuJnQvdXZXkhgtpv2kcWgezYRdB0QvDaabO4edF3VLpdXD1qLBL4+ycfckrf/r7jShwdo0p8r5hKrUNQlKCLMERg0VnYWtZxuo+01EHXQQ66quunxBpjMOss5DpyNY6q2oldjkcIVUtDURSlI1LJAUUJGC33jIb2klR/MBsMPHr8SZQ5HUSbLQB8fva5pEZF+Y4ptlcRbTZTGuZJgrSIEq1DUFrI4D3AhJj+LC0p1zqUsFfmLqPMXUa8KY4kcxLby3fglm6twwq6YlcJvW0J5IbA21icMY6j4kdqHYaiKIoSIKFd8UZRwpqGV1a8naO3vfiraGGN2okBgB6xcSw570KiTOZgh+ZXCebO8Xx2BAIHF8QuY1CEVetQOoxCZxFbyraSZE4iyhDV/AM6GIvOQpXHrnUYAJzW7RQMOnVdSVEUpaNSyQFFCRjt/veSZQ8gZWh8mNSSXgh2FRdx5ajRPHXiyTx2/DSizeGXKIjU52kdgtIKQpbwz+TtWofR4WTbs9Gho4slRetQgqaLpQsRBisH7Ae0DoU+kb2ZmHS01mEoiqIoAaSSA4oSMBquHPDsQpY9rt38IUIIwbAuqcweMBiz3kBhVSXzhh2JSRc+2y70wotB5mgdhtJKJVK1eQuEEncJBx2F9LL11DqUgOsbmUmBo+Cvto7a0qHjvB7nhnyLRUVRFKV91NowRQkYjQs2VS5AWqYhTMO0jSMExFmtHNe7DwfKSvnfjm2M6NqVVfv34ZFaVIxsncEJIOh8+6zDWaVuEE9nRwCqy0QguKSLHRU7SbWkohc6BDqEEJh1JkpcpeQ5wnuljUmYSLelsbU8dAoxHt9lKt0j0rUOQ1EURQkwlRxQFD+T0oMIiR7VEmn/VCUHaukaFc15w47kvGFHUlRVxaKd2/lu+zZ+3rMbhyc0T8DjLc0fo4SOAxzN7bvAoxIDAZdtz27w9u4R6ZS7y0PiintrJZuT8Uov28t3aB2KT7wpjpndZmgdhqIoihIEan2YoviR9OQBXqTjR5DFGkcDOFdoHUHIirNamT1wMP93ymmsuvBS+iYkEmex8PSJ0+keHaN1eD5/HlQtw8JJkm4fUfpQSA52TnHGWEpcJWGZGMiM7EORs4gCZ4HWodRxTve5WPQqS6koitIZqOSAoviTZzcAsvR+jQP5i3sb0pOvdRQhL8ps5tmTpnNin76c0CeTqb36aB2ST16VQIrOV6E9XBm9O7krvaQTNBMNPAMGUs1dyIzsQ9/IvnSPSKerJZU+kb3pF9mXZHP9ug5Or4sUSwpGYdQg4rYxCiOZkX3IKt+GS7q0DqeOYTFDGRF3hNZhKIqiKEEipAyDTbeKEiZk1ULwliDL7tU6FB8R8zDCqpaEtsSyvXv4dMsmNuXnkV1ehkGnp9Rhp8qt7ZaDDWd8jwVV/T6c7GEyd+zxaB1GWNKhIzOyD9sqtuGR3kaPM+lMdLV0ZVflLnpEZKAXenZV7sYjPeiFrsnHhopEUyI6oQvJOgkmnYn7htxNkjlJ61AURVGUIFHJAUXxEyldUPEK0rUeHN9pHc4h+u6IxM8RQvVdb4qUkgqXi0iTqc7t63JzOOvD9zStSbDktI10M/2s2fxK22z2TuWRfQ4CnSKQEizOKCyOaEz2KHRVVqgy46kw4CoXCD2YehZTmLIVt8ER4Gjar3tEOnsq97boWIEgyhBFqbs0wFH5Xx9bb/ZW7cXhDc36FLPTTueUridrHYaiKIoSRCo5oCh+Ip2/gmcf0vEL2D/TOpy6Iuahi75F6yjCht3twunxEm02A/Dt9iy2FxYikby4+lfKncH9MD+9h5snRr0c1DkV/3DoMvm/gl6sKa/025gJv06gIl9QUeqmrMxJcYkdj6f5q+Qmo57MAXHE9rNT0jWLKkux32LylzRrGvuq9mkdht9kRvbhQFU2FZ4K32169PSO7BVS3QgOZ9PbeOqIxzDoVN1qRVGUzkQlBxTFT7xljyLMU5FV70PVB1qHcxiBiPo3RPzd10lButaDazNYZyCEqZnHdy4/79nFvT/9yP+dchrdY2Lr3FdYVck/PvuEdbk5QY1p6cz1dDEuC+qcin9IDGz2HMMTBxw42/kn1wgUvTKS3PyKZo9tihDQq1ccyf0ljow9FEfuR4RA7ctetp7sqNipdRh+0cfWm20V20k2J2MzRCDQAZJKTxU59uC+f7TW+IRxXNz7H1qHoSiKogSZKkioKP7i+BkMvUG270N7YEhk2f3Ig3OQro3VNzl+Rpbeisw/FlnxMtIbinFr4+juPXjj9Dm8tX6db5XAy7+vptThIN4aweMnTCPCGNyCZ3f8OhBJCJy9Ka0mcDNA/z9uSmv/Vdh/pxu54JSGW/i1hpSwfXsRy78sZs1z0VS+NoqEVRNILOgLXm1eZ1GGKHZW7NJkbn/KiOhOv6i+7KqsLlCb58hjZ8UudlTsYEfFzpBPDAAcEada4CqKonRGKjmgKH4gPfngPQhCX50kMIZodWf3BuTBWciqL8ByKmAGbx6y7EGofEvr6EJKUoSNm8ZP5JPNG/FKSXp0NOd+8gGvrl3DhrxcTu3bP6jxLNqnZ59jYlDnVPwrXt++ffGnJUTRS/zAiUe+y+hh0X6KqlpObhmrFh9k5ct6Sl4ZgcUe/HaeZe4yMiP7oAvzjyYmnYktZVtxS20LmbaVQRgYEjNY6zAURVEUDYT3X2BFCRXOpWDoBY4lYBqFsJ6mdURN8CDLHwN9Mtgu9N0qHd9rGFNo0gnB+PTu3LLoOypdLtbn5fLfnxazt7SEEkfwC7vdvLIvUjXJC1sRHGzzY/tYLZwauRSo3hJw/RkfYbUEZvVKwcEKPN8N0WQFwdbyLNIj0rDoLEGf2188Mry7VAyMHoBFH76/f0VRFKXtVHJAUfxAOn4GQy9k1ReIiL8BId5Cy7MPqhYiIi8GXWr1ba61SE/otdPSWq+4eFIiI7n2u699t9mMJp45aTqRxuDWaliRo2OH/Zigzqn4j1HmAq2vOWASgutTdiPkoZUHKbE7uXxO4Cr0b950kOQN4wI2flN2V+4hyhBJnDFWk/nbw6a3sfuv7QTh6oi44VqHoCiKomhEJQcUpZ2kt6x6K4GuG3gLwDgAWfak1mE1S1a8AFgQiZ9WFyvUZ4DjB63DCkmXjRxF9+hDy6zLnE5yysspdwW/BdmNy3oiCW69A8U/hKykt6X1LUVvTddh9m6td/spo97giIH+3V5Q24pvCknZMxzhCe5HhSRzEnGmOMrd4VcHJS2iGx4Z4snhZgyPVfUGFEVROiuVHFCUdpJlD4EsAUN/RPw7UPkOyOJDB4jg791tEc8+8OxF6GIRtgsQid+C+WitowpJFoOROydP8X1f5nSQVdj2JeLtsa5Ax+aKKc0fqISkW1J+Z3p8VIuPPzMpiu782OB9Oh3cePZnmE2BaTcnJSx7x8GBZ4cQuWgiXXYdidnR8tjbItGUSL4jn63lWbikK6BzBUKZq0zrENqlp60H8aY4rcNQFEVRNKKSA4rSDtKxEqreA0DoExBCgOUEQICwVR9knqBdgM1xbfB9KYQOoe+mYTChbXKPnpzQOxOASqeTHUWFmsVy7S/dkSKwJ2lKYOhkAbMiv+LhDBfnJkfR09z03u7REflN3t8tfisXzbL7M8R6KqucrPstn1/eqyLr2QyMrsDtR4802AI2djBEGiK1DqFdjogdrnUIiqIoioZUckBR2sO1CvQ9AJCVrwEgDH3AMh0MA6uP0aeCIVOjAJsm3RuaP0jxuffYqXx/7vncMelYJvXoiUGnzVtoVrHgjrVzkAS35oHiP4lyBcdavuL2lP/xUo9tPJDh5fyUKHpb6p54l8nmT5YnDV4UqDDr6TsgDpexfjJCeHQkrxtPbEk6ABFV8STm9231+EZd+L2mLToLSaZEAJze4G818idVb0BRFKVzU8kBRWkHEXkVuqTvEMmrEKYJSFdW9e22S8E4oHr1gGs9IvIqjSNtmAjRpEWoirdG0CsunnW5OXSPjmFm/4GaxfL2FiMvbjuLKjLxiljN4lDaT+/NJkX+wkTzV9ya/APXdbP6/jgXu83NPt7tDV5leY9L1utiEF3eBc9HY1j+TSE73k3C+s3R/PlMF1a+oidl8+hWja8j+B0S2iLWGEPfyEwyIrrjkk7ynQXEGmMw6sK3HkisMZZ0a5rWYSiKoigaElLK1pdOVhSlHiklsvxxdFHXIt17QZ8C0g2yCnRxyKJ54FyhdZiH6Lohkr5DiPD9MKuVF1ev4o0/1lLpclFsD+yS7pbQCy+LT9tEV+NSrUNR/KRCN4SHs5M5OsbCFMuXTR67K28wf78reJ0FuqREIQTY7W6qqlzYHe4mjx89NYH8I5ciWnDenxmZSVZ5lp8i9b8oQxTxpjh2V+7ROhS/Oyp+JFf2uUzrMBRFURQNqZUDiuInQgiQdqQnB2FIRwgTQhfxVy0CHSL2BTAepXWYPsL2D5UYaKNzhx6Bw+0JicQAgEfqOO7TAeS7W3eVVgldNu967ujyGz3NVc0e6/YEdyl+Tm4Z2TllFBVXNZsYAFj5/UFilkxE59U3e6wrhJfl94jIQOLtkIkBgD6RvbUOQVEURdGYSg4oip9IbznYvwJdfIP3C10EIm5+aCQIRCREzNY6irAVYTRy2chRWodRh8Or47jPhlHkPVLrUBQ/EbKEXqL59qKuICcH2uL3lfkYvhqLoZlihpWeyiBF1HI6dPSL6suuyt1h2V6xpTIj+2gdgqIoiqIxlRxQFH8RFjAeCe76/ch9h9QkCPQ9gxhYA/RdESJ4+5Q7orlDhjKmWzo6ITDrA9NKrrXK3YLjPx9JmRyidShKEAV75UBbbfrzII6Pj8Bib7y9a2kItQJMNCXQ29aLLpYubClr/H29IzAKAxkR3bUOQ1EURdGYSg4oip8IYUDE3I8svQdZ8TqNlfMQuggwaXx1V6f6WLeXxWDkzdPncMekY5nRrz93TjqWoSldtA6LIofghC/GUkk/rUNRgsTlCY3kVEvs2lXMwXf7EVWRgpRgdkQRU5aGrSoBszBh94bGVp2ullSqPHa2V+zggP2A1uEEXA9bDwy68HkdKYqiKIGh/hIoih8JnQ1in0YWnokwTwZDw1dihD4DiQGo3q8r4l5GVr4NjmC1JAuPK42hTicE5w4dzt6SEhbt3M47p5/Biv17ufCzT9Cy0mtelWDaV5P438kVGOU+DSNRgsHtDq/aITm5ZRx8MQnpTcTt8QIQYY1n7N/17Ir9XePoqmsLHLBnh31bwtZQ9QYURVEUUCsHFMXvhD6peuuAeyvSW450rkLaFyOrvkRWvo+seA2p7w6W4xCJ3yPiXkKYj0ZEXhO8IN1/NrqyQWm99JgY/j7sCHaVFDM+PYOrRo3VOiT2lQs+23e01mEoQeDyhFdyAMDl8vgSAwB2h5vsH2NI0/XQLiigj603e6v2dqrEAEAfVW9AURRFQSUHFCUghKE3mCeBsIF7N7LkOmTJv5CltyHL7gV9CsL2D9CnI8wTqx9j7AemMcEJ0FsInl3BmauT0AnBgMQkdEIgBExIz6BnbByxluraDia9nmdOms53f5tHjDk49R7uWRWFV6gtJB1dOG0raIhOQP/eKWzcksvq5yNJMiRrFovda8coqldWGUR4/15bQ60cUBRFUUAlBxQlYIQwIoRARMxBJH4FpomH7iz9L4jY6vaHtR8TcV7wAnRqv3y3I9ILQWZ8IoVVlVxx1GgW//0fZMTEMj49g34JifSJT2Bm/wFBiaXMJfitSK0eCAU5Rb147ftL+GjZPBb9cTqrt09hR+5wispT8Xhb9qfY6234dren+RaBoUoIGJCZysasHADKiz3seiuVKH2UJvHsq9pPrDGWNGs3MiIyNIkh2JLMicSaGi8SqSiKonQeQqq1xYoSFFJKsH+CLL0PZCmIKETMQwjLlMOO+QxZeg/IksAGZJ2DLubewM7RiZU7nTyxYhlbDxZw/bgJdYoVbirI5+S3Xw9KHJmxkq+OfxWBKyjzKXXZnRG89eN5vPM1OJ2eBo8RAqIjLcRGG4iL1hMXJYmNchEb5SA2spK4yDLWbO3Owh+qMBp0GI16TEY9JqMOk0mHw+Ehv7AqyD+Zfwzum8qGrdn1bs8cYcVw3AacUtvl/amWLmTbczSNIdDGJozm0t4Xax2GoiiKEgJUckBRgkx6cpGld4Djr/7ltosQkf9C1FrCKj15fx0TwAKFhj7oEr8K3PgKABvz8/jvT4sZ3S2dy0aOwmyofp5Pe+8t/sgNzknH9zO20sO8OChzKdWkhB/+OJ3nP+pO3sFKrcMJSUP6dWX9lsY7AYw4wUbJ8NVIDct7do9IZ0/lXs3mD4ZzM85hasqxWoehKIqihAC1rUBRgkzoUxCxzyNiHgERCxXzQVYedkwyIvY5RMyj1ccEgnsb0vVHQIaWUiKlulINMDApmbdOP4OUyEjmfvw+7234g22FB8mvqAhaDI+sbXo/sVukcu+G81lXNi1IEXVsWw+M4J/PXM9d/5eoEgONGNq/W5OJAYDV31aQuk/btq97KveSZu2maQyBpuoNKIqiKDXUygFF0ZD05CMrXkYX/e+G75decG9Glj8Dju/9H4AuFZH4CUIX3+yh0r0DWfUpuDYgrKcgrKc1fbxjJcI82k+BdgwFlZU8+MtPfL51M05Pw0vMA2X17JXE6NbWu32/cwJn/W8g2RXV9S8uGezgukGfo5MHgxpfR1BcnsJL35zN5z9Wov6yNi4hzkZVlZNKe8sSiFOuMLIrMjCJzJaIMkRR5i7TbP5AMulMvDDiGfQifOtWKIqiKP6jVg4oioaEPqnRxACAEDrQd0GYRoEuyf8BeLORxdcgpbv5Yz3ZUPE8OH9Glt6JdO9s+njXKqS33C9hdhSJERE8fNyJvH7abDLjE4I695MbjqDEOxyPSAFAYuW9vecwaeGhxADAixvMnPT1LA56jgpqfOHM7THw/tLzmXvXHD5brBIDzUmItbU4MQCw6FknGd6+AYyocT0iMjpsYgAgxZysEgOKoiiKj1o5oChhQnpykOUvQNX7QAtO5lvDNAER/R+EoWfj83tLkXkjD91gGIxIeBfxV9uvesdXfQmeHYjIq/wbawfh9Hh45ffVPLVqOXa3n5/PZkQZJTFm2FcumjhK8sykYk5I+UQVM2zGhY9cz9adpVqHERaGDujGH5v2t/pxPQZZ0E8PfoeVPrbebKvYHvR5g2VAVH/+PeAGrcNQFEVRQoRaOaAoYULou6CLuROR+C1YT8ev//s6lyILpuMte7jRq/1CFw36WskD9wZk0eVITyP7hk1HISteQXrU8vSGmPR6Lh05io/PmItONHWS7n9lLtFMYgBAcOWSOK5aeR5OegQjrLDlcDTSY1CpIzE+kq078tr02L1b7BhqFW0NBrMwsbtyT1DnDDabwaZ1CIqiKEoIUckBRQkzwpCOLuYBROKXYPFnATkXVMxH5o3FWzADb/G1yPLnkPZvke5t1QUGjUPqPsT5E7JgGrLi1XpbE4Q+GXRJyIrn/Bhjx9M/MYlzhw7XOoxGfbNbz9iFx+Og8VUlnV1qkvpT2hJx0VbsjratQvG4ISEQW6uakGhJxNXBC6tGGiK1DkFRFEUJIeoTjaKEKWHojS72CUTCp2D2ZxsqB7g3gf0LZMUCpPN3ZNmT4PwFnEvrHy4rkWX3Iw/OQbrrLr8VsY+CczXS3bGvvrXX7ROP4f4px2MxBPfKaEuVOAU/195SogBQ6Yjmw1/msXV3xz6B9IehA7qRtSu/XWNY7bH+CaaFPLLjrwiJVCsHFEVRlFpUckBRwpwwDkAX9wIi/gMwjfPv4LIYhBVhnY4sugq8hY0f6/4TWf7sYbENQSS8D1Ltx26KEIIzBw3h0zP/Rt+ERK3DadCjv8ciUYXLAA4UZvL0Z1cx69ZzeeptE4XFVVqHFNKSEiLZsiO33eN4y8x+iKblPN7g1gLRglo5oCiKotQWmpepFEVpNWEahohfgLQvRpb8C6Sf+qtXvIDEC7Sgdqn9f0hvGUIXdSguYQLjYP/E0sFlJiSw8My53PPzEt5ev07rcOrIKtFxwDmObqaftQ5FE1LCup3H8MGSESxdXYqUDq1DCguRNjNWi4n8g+3vXCJig5uEcXbwLQWgag4oiqIodamVA4rSwQjLMYi410DE+mlEDy1KDADgAPs3fpq3c7IYjNxzzFSeOekUokzBvVLanJO+GMAu+zFahxF0lY4oLnzkOv75aCY//1aqWhW2UGy0lZgoK3v2N7HiqBWKje1ffdAa5a5yukd0D+qcwaZWDiiKoii1qeSAonRAoswFQgAAky1JREFU1asI3gRdctDnlhUvIB2/IB1L8ZbejTf/OKQz+C3Iwt20zL58OfdcjuiSqnUoPpVuwd++z9Q6jKDLKe5N1q6O2+s+EBLjIzGZDOzPKfbLeEnpJko8/hmrpTx42FO5h36RfdGLjvlxSdUcUBRFUWrrmH/tFEVBGPsi4t8GfVpwJ/bsRRadjyy6ACrfBM9ucP0Z3Bg6iLToGN6ddSaXjhildSg+OZUgO9mOtNzi0EnQhIPUpBi8Xklegf8SKj2GGf02VmttKd9KijmFWGOMZjEEikoOKIqiKLWp5ICidGDC0B0R/w4Y+mgbiPlobecPY0a9nhvHH81rM2aRYI3QOhxAIEW01kEEVV5RaBaJDEXdu8ZRXuWgsLjCr+NGpWlbHPCAPZskc3BbKQaD2lagKIqi1KaSA4rSwQl9CiL+LTAO0SYAfXeEIUObuTuQozN68NXcvzMhXfvfpVt2ruRAblHn+nnbqlf3RAqKKigrt/t97PVfSmL02l6531m+C6veqmkM/qYKEiqKoii1qeSAonQCQhdXXaTQNCb4k3uLkM7QqrwfrpJsNhacNosbxk1AL4RmcThkVPMHdSC5hRatQwh5/XunsD+nmMoqZ0DGz9/rpOSLXph12hXpTLV2IcUc/DougRKht6IXqj2poiiKcohKDihKJyF0kYi4+WCeEtyJZRmy6DykY0Vw5+2gdEJw2cjRvDPrTIw6bd7CKz2daylyfpF2iZhQZ9DrGD4wjc3bc3E4A7v0f/sfdkyrhqDT4KNLv6i+7K3ax67K3UGfO1DUqgFFURTlcCo5oCidiBBmROzTYJkR3IllJbLoQqR9cXDn7cBGdu3G2YOHajJ3hTsUah8ET0znyoW0WGpSDKnJMazduC9oc65dVEHK7iOCNh9AmjWNrWVZQZ0zGFS9AUVRFOVwKjmgKJ2MEAZEzIMQ8bcgz+xEFl+BdPwS5Hk7ritGjcFqCH7ngFJX51pm3zXJ/3vow93Q/t0oLKlgb3ZR0Ode+m4lGaXDgjKXTR9BqasUiQzKfMGgQ0eUIZKulq5ah6IoiqKEGJUcUJROSAgdIuo/YLsiyDO7kc7fgjxnx5UUYeP84SOCPm9eVedaOdA1sVjrEEKGLcLEwMwu/LF5f8C3ETTlh+cdZHj6+XVMszARa4yhiyWF7hHp9LL1IsGcQKm71K/zaC3FksxxKVO5uPc/tA5FURRFCTEqOaAonZQQAl3U1YjoO0AEce+ptzB4c3UCF48YSYw5uFfy7/k1Dq+IC+qcWhrSYz0Gg/pz2TsjEbPJyMasHK1DAQQl69tfGLOLJYVIQyR6ocMhnRS7Ssix57Knci87Knawp3KvH2INLdn2HJYWLKPYWax1KIqiKEqIUZ92FKWTExHnIJJ+ANvFIILQpkslB/wq2mzh0pFHBXXOAxWCD/acFNQ5tdQrZR3XzC3TOgxNDR+Yxo49BRQWV2gdik/M0PY/JyadmXJ3OR7p9UNE4cMj3R2quKKiKIriHyo5oCgKQheHLup6ROIiiDgPMAZuMs9upLdzn2j529+HHkGyLbiVx29bHkmZHBzUObVid0bg8eoxm4Jf3yEU9OmRxNqN+5AhtO0+Kl7Pfv32do2REZHBnso9fooovLi87g65KkJRFEVpH5UcUBTFR+gT0UXfikj6HqxnAQE4GXJvRuZPwFtyK9K1wf/jd0JWo5Hnp51KvCUIKz/+IhHcvGoMsgP/GXG4LCz4/lLm3P4PHn/Toukee63oBFRVObUOo57hJ5pxy/Y9H3ZPlZ+iCT+l7lJNWkIqiqIooU39ZVAUpR6hT0UXczci8RuwnIbf3ypkFVR9gDx4Ot6C05GV7yO9lf6do5M5IrUrH5xxNhkxsUGb85vdejZVHB+0+YLtl03TeOUTLyVlDq1D0UTvHon06ZHM/twSrUOpx5TYvoRFZmQfch15foomPMUYo7UOQVEURQkxKjmgKEqjhKE7utiHEIlfgC45MJO4NyBLb0PmT0C627dMuLPrGRvHB3POZlhKl6DNefEP3fGKhKDNFyzFFcm89W0vrcMIOiFgYGYqGd3i2b6rgK07Q/ME2p5tavNjDejJc+T7MZrwFGuM1ToERVEUJcSo5ICiKM0Shj6IiPMCO4ksR5behQyljc1hKDEigrdOP4MpPYNzYptTJfh8/3FBmStYDhRmcvnjfyNrV8dqYdcci9lAn4wkNmZls3t/aBcOzdnS9veJDFsPSlyhtxoi2GJMMVqHoCiKooQYlRxQFKVlIs4AEeD+9s4VYP8isHN0AhFGI8+fPINzhgwLyny3LIvCSfegzBVoW/YfxWWPnMS+7HKtQwmqSJuZLkkxZO0KjyvqO/+swijaVjg1uyobg+icxSVrizWq5ICiKIpSl0oOKIrSIkIXA9bZAZ9Hlt2P9IZOu7RwZdDpuHvyFG4YNyHgczm8Or7JHhfweQJt5dYT+OejR1FUYtc6lKCKjbESE2lh176DWofSYl4PJOnatn2m0ltJT1sP/wYUZnToiDREah2GoiiKEmJUckBRlBYTEX8n4G8b3gJAbS3wByEEl40czeMnTMOoC+zz9vOB4LZSDITnPhpMlaNzdSRITojEqNeHZNHB5pjKYtv82DJ3526nGm2MRifUR0BFURSlLvWXQVGUFhOG7oiofwd2El0CQqeuaPnTjH4DePyEkwM6xw979UhEQOcItNKKjp0Y6NYllrjYQ1uD0rrE4nR5yC8Mzy0UUrb89WbAQI+IDDIj+9Db1otSZxlp1rQARhfaYtSWAkVRFKUBatOdoiitImzzkJ4DULkgMBPoMwIzbid3Up9MMuMTyCoMzNLxEqfALbphlPsCMn6gSQmlHbxlocfjpai4Ep1OEBcTwcHiCqrsLq3DajN3VDF4W3Zsj8gMtpUf6oYiEBQ6Q7voYiCpegOKoihKQ9TKAUVRWk1E/RtMAdpjru8Yhe1CjRCC84cfGdA5Cl3pAR0/kOyuKFzuFp5phqFIm5myiupaCl6v5GBReCcGhE5SQG6Lj/ce1gVFIqn0VPo7rLChOhUoiqIoDVHJAUVRWk0IHcIyPTBjG1RyIFBO6z+AeIs1YONvKk4N2NiBVlqZoHUIAZXWJZaKSqfWYfhNxgArDm/LV3qUOMOvpkIgRegD9z6gKIqihC+VHFAUpW3MgVo5oLYVBIrFYOScoYFrb3jhD4ksPHAWEnPA5giU0qp4rUMImGED09i8veVX2cNBVVn9VR4WnQWzzoy+gY82sepKeR12T8feQqMoiqK0jao5oChKmwh9V6S+J3h2+nFUIxgDd/KqwN+GDOfF337F6fUEYHTB9Utj2Db4bK4b+BaC8Fm2XloZp3UIAdG9axzrN+/XOgy/y93jpJ8ug/3e3QgE6YXDWTy/Cv4qiil0EpNFj8ksMFl0cJYEk7Yxh5LOvKVCURRFaZxaOaAoStv5efWAiLpWbSsIsCSbjTMHD6FXXBw6EZjuAi9sMPPc1rnIMMk/Swm/Z/XTOoyAyDtYRpekaK3DCIifH7RiWzGCiBVHsni+HWp1y5BegaPSS1mRh4PZLkoj8rQLNARVuCu0DkFRFEUJQeHxyU1RlJAkTOOQlW/5ZzDzsRAxzz9jKU26a/IUABbt2M7V335Jpcv/V/gfX2vBoj+bC3q/CxhAGEC6ENj9Pld7lFQk8dD75/Hzb6VahxIQdocbt9tDpM1MeUXHWkouvYI/ljR/BTyhq5F8d8faVtFelZ4qrUNQFEVRQpCQ8rASvoqiKC0kvWXIvKNocT+xhujTEFE3gfl4RICuZCuN+zMvlws/X0huReB73T92dDGnpr4X8Hla45ZXrmfp6o6ZGKitT48kduwuqFe1vzPod5SVtPEOpNHNbt0WrcMJCSnmFB4adp/WYSiKoighRm0rUBSlzYQuCoxD2/hgGyLyOkTi1wjLCSoxoJFBySl8cuZcBiUlB3yuVbm2gM/RGgVlaSz/vUzrMIKiotLZKRMDAFt+rWLRE15+eFjQwz5Y63BCgqo5oCiKojREJQcURWkfUxvqDphPRCR+i4i8BCHCr7J9R9MlMop3Z53JsT16BWyOZJuNA/Z0lhXNxCXSAjZPayxZPwWPt3OcMCfFR2odQggQLHrSTYa7v9aBaK7SU4laOKooiqIcTm0rUBSlXaTzV2ThOS1/gL47IvFLlRQIQU6Ph3kLP2LF/r1+HTfKZMbuduHy1mw/kZzUw4vNIClzCcqcArsHLhxYzLEpSzHIbL/O35jnv7ySd75yBmUuLcVEWamscuJyB6JDRfjRG2DitS72iG1ah6Kp/xvxHGa9eh9WFEVRDlErBxRFaR/jMBAtrIYubIjoe1RiIESZ9HqeP/lUesX5t61fv8TEWokBAMHXu/R8uM3At7v1LMvWsSZPx+U/xjPkg1N4ecffqZAD/BpDQ4pKO0dvu7gYq0oM1OJxw+5vOmYHh9aoUFsLFEVRlMOo5ICiKO0ihKm6oGBzTOMQiV8gzGMCH5TSZjEWC6+cejoJVqvfxmzNAjWXV3D/b1aGfTCRW9deQI5rHJLA1KMoLO0cfwJ37Sukf+8UrcMIKT2PdmsdguYq3So5oCiKotTVOT4ZKYoSWNbZYJrQ8H26JET0fxFxryL03YIbl9Im3WNieXH6aZj0er+Mtzr7AAMTk1r9uPe2GpnwyRD+tuRCSmUbC182oai08+yqK6twoGp+Vus93EpedOfeUmDSmVRRQkVRFKUelRxQFKXdhBCI2EcgYi5gAPRgPhYR+zwiaQki4kzVjSDMHJnalceOP8kvY6XYInHLtre7XJmr49v9/q8yX1jSea4e788pZlDfrlqHoblRp9ownrieSm/nPjE+MvYIbIbQ6h6iKIqiaE8lBxRF8Quhi0cXfSci8RtE0o/o4l5AWKYghEHr0JQ2mpbZjxvHHQ1ApKlt+/NHpHal3OFg68GD7Yrl4+3+PZHxeqG4xO7XMUNdbkEpen1n/bMvOfZSMwcH/IZLurQORnPHd5lKV0uq1mEoiqIoIaazfkpQFCVAhKE7Qq/2N3cUl4w4ivdnn8W49O6tfuyI1K6szj5Ahbv9J2O/5go8wn+vq9Kq5E7TxrBG/sFyBnfS1QNmqw5XXPsSVB1FmjWN3pG91GouRVEUpR6VHFAURVEaJYRgZNdu3Hb0ZPrGJ7TqsaV2hz8jocid4bfRisq7+G2scPLn1gMM6tv5rhg7qiS/PR1F6u4RpOrTtA5HU0fGDdc6BEVRFCVECdmaMtKKoihKp1XqcPDPr7/gpz27mj02xmyh0uU8rIVhW0kWTM1nQvwnfhir2urtU/jXY70bvG/gUd2QRoGnyEXu/lJKSqv8Nm+oGDagG+s27dc6DM30HGyh12Q3eVHbO039AaMwMC31JE5OPQmzXrWTVRRFUepTyQFFURSlxdxeL//9aTFv/LG22WN7xMTi8nrZX1ba5vmMOsnnJ++gj/X7No/RkO/XzeLu/2t4JUT/CWn8oP/rxFlKuuhtZIgoTHu9bM/K82scWho+MI21G/dpHYamDGY48ngb1kEH2S93IWn4I1EXfTdyPOGdTBkSM5h/9f0neuGfLiSKoihKx6O2FSiKoigtZtDpuGvyFO6YdAy6ZvYs7yopprCqimEpbVvCb9VLfp65tsHEgEQgaXuxy8Ky6Ebv01XVOkEUghxvJSs9uRR398cqiNCxduM+hvbv1qlbHLodsOrzCpY8YKH8vaF0LxpOjD623nEbX44nw93f971RGIMYpX/k2HMRdOInW1EURWmWSg4oiqIorXbesCO5f8rxzR5X5XZhd7etZWB6NCTqV9W7vcAziiuW/4NzfzqfA66j2zR2UWlE43c2sp5uvauApMSoNs0Xqv7YvJ8BvbtgNKiryTm7nCz+Pwe/P9CFqN9GkuHt57vKbjDp+OFR6F5wJPH6BMo/GkSiPknjiFvn2OTJlLvLtQ5DURRFCWEqOaAoiqK0yen9B9IzNq7Z4/aWlvhlvnI5mNvXXcCYj47gu716VuTomPjJQG5c/Q8krTu5LSprvDXj3rj6NQb0Eo6RaZSXd7z2hxu35dAzvXXFJg16HT3TExiYmUpifGSAItOG9ArWLqrgh4d15L08kLScI5FeCQgWv1zF2kdT2JfloOzH1nfw0IpRGJiQOJ7VRWu0DkVRFEUJYSo5oCiKorSJXqfjkhFHNXtcpctF18i2X3F30Iunt57H8A/G8faW+su5P95uoMQ7pFVjFpY2nExITY1hi6uwzm2DDAkMz4pmy8/7qLK7iI+zERcbgcUcfkvLG7N1Zx4D+jS//UMnBEP6V7dD3Ln3IBuzsikoLCcuNoJhA7s1u9Uk3BTnu1nyWhUF+w+143Q5qpeWbFxWSQ/HIK1CaxWXdPPW7ndwS4/WoSiKoighTCUHFEVRlDY7rf9AUiObvnIcZTJjMzZ+pb4xZU54Z89chn4whSfXWqCJ/dLL8vq2auyiRmokZmeXMGF/Emn6Qz9TjNdEdnb16gez2UDWUAd/DqsiZyykp8e3at5QVl7ZdOtJnRD079OF9ZsP4PbUrb9QVFzJuo376d87pVNtUVj1miBKHx5bTVYUriTR1LoVIoqiKErnopIDiqIoSpuZ9HrePv1MTuidWef2GLOZkaldGZyUTKXLSVbRwVaPnV0h+M+KKDyy+T9V//dnbKvGLippvA7Cju35GJdWMYnqK+SrvDnExlgB6JmZhIPqq6+V0k1u345zJXbvgaJGVw/odNWJgY1Z2U2OsXFbDv1bsAKhoygr8mD+s5/WYbRYtLHxQpyKoiiKopIDiqIoSrtkxMYyNi2dtKhoRnbtxsCkJMocDn7LPsCG/Dw8QeiYu+GgoEIOaNGxUkJRSdO1AxxON+RWJxCihZnYuOoChvbDatAlSWujY3RJiSZuSiLJyeFxZRkgv7Cc4QPTGJiZStJftQR0OkH/3s0nBmrodR1ra0FzVn5aTjq9NZlbSsDb8o9yOyp2Bi4YRVEUJeyp5ICiKIrSbkd1S2NfWSm/HdjPxvx8tGj6d/LXR7Om9BQkdU/YJdWJA5foBkC5PR6Xu/kIDXFGkJL4lR527TqI0ahnrSyoc0xMZePtFM0DbfzpPsjWgXYGHtmtDT9R2yXEWbnp/DKG9GvdleKCwnLWbtzHxqxs8gvLibSZSUmMbnFiABpt9tCBCTa/F0mCPtH/I0sjQtavbRHl6svKX4ewdOVAfl7Vn8iKUS0ab0PJn/4OUVEURelA2t4kWlEURVH+MiAxiRGpXVmdfUCzGPaVC874piu9o8/lkQl7iTba+fFAGq9tsrKnXPDqlHyOTviY3fktW2FQZnGDV+D5a399z8wkdsvcOsfY8xvfp1+qc4G3evvB91EHGHNMKoWrCimvaHpvf3slJ0TwxNVfk5awhbyiS1m/pe1jlVc4WhXv0P7d+GPTvrZPGKZydjnJuS+J9H7p9BorkKkHyfbuxdvCNFmyPhVrUTIALp2VnaUmckqc7CstQy8EmYkxdI0TmG1FVBp34ShLxuk5VDjz6/XlnDR4DOWRK5qcZ3PpZtxeNwad+vinKIqi1Kf+OiiKoih+cc6QYZomB2psLxXM/Kp+m7mvdsdxdAK89b+xQCMVCWvZQxkAVqsRh9ONO1lX57K4XsK+PYWNPBpSSy38GXHo+xXeHLqMiqDP3mh2bMtv8c/TGqlJNh7/5+d0jd8GQLfEQiAWvU7g8Qb2mn50pIU/Nu8P6Byhbu8WO3u3AEQQFT+QgRMt2PqUk2fcTZW3botMozDSzZnJ/qVWlq+qAJwASJz0mdSNAmMJXinxSsnGvCI25lU/TpCBUV+/PejXG0qZ0m8Cupgt2HUNv77sXgfbyrfTPzp86iQoiqIowSOkDMJmUEVRFKXDc7jdjHvlRYrsTe/n14pZ5+W90Vlc/sChzgZCQEZGAtZYM0TocJglJToHubKSPHclCMERm6MoKCinZKKRUq/T99gBhnhKFjVeaDE2xsrmYXa8h23BH6lP5sAPuQ0/qB3Suth4/KqFpMQe2ldeUJZGSWUiMREF3P3aWazd1HxSpK10AgKcfwhbegMMGBdB8lAXrqhixP5Efv/CSVlh4wUt47tF4h5hYXNJ64t59oyLpneyAVNUDmX67SAOPTHTU6cxJ31Wm34ORVEUpWNTyQFFURTFb+5fuoT5a37TOoxGnXAwkfUb8omKtJA+OJGNEcUc8FQ0+ZgxO+MwWQz8lFr3auwxshtbfmp8CX1sjJXdR7ipkHU7I0yt6sbmX/fj/f/27js8jur6G/h3thftqndZzUWSbbk3MLbpNXQCvAmQQkJISCe/NCAFQkJCIJBAQiAJ1fRebAzuvTf1avVeV6vtu/P+IWyQrbKSZnd2pe/neXiwdmfuPbJVZs7ce44Ev35jovRYtUjA6vlFWJi1BSrl8F0YPF4lvvvYT1BWHbgEQaRJh96+0EwOhSNBISD7kjTstjeOu7BnlE6LhfPL4REGvs4zDBm4f+5vpAyTiIgmCW4rICIiyVwxMydkkwNmaGDtF5F9bir2+1pQJjQCfnQiVGtVQPKZReGE7pFP1i02o9/bdsbrG/WNUK8WkKYyI17UQ1PrRXXV2LYZ3HSpFqvnH8WctB1Q+FlaWKX04vKz2wAkoPyEBYF4NGA26ZkckJDoE1G1vh4Lc2PQMt2LBuvYEztqhfJUYgAAam21sLj7YFaHTxcNIiIKDiYHiIhoSpiVFIddaBqoGzCGbnsqjRLHFV04vbZce+PwN2qzl6Vho3f4/fduiDjhsaBdsCOlZWyt/xbNNuOuK/86pnNOuvasF3DtWUCfPQZHT6zEH/4zDXbn8KsNxsqo10g2Fn2uqbQL6holzro4FXt6x1bXod1mw9L+Zegz7keENwNdrRmoybBiXiKTA0RENBhbGRIRkWRsbrfcIQyryzm+J9qeeAU6fYPPTVYa0Nk19HaEtLRobNP7V5hxhTNhzN0LLlkx8W4AJn0XpieVSJoYAACNms8cAsXt8KL+o0YkG8d+U7+uwIqOqpVYf8CIfXUdUCuUAYiQiIjCHZMDREQkmX63a/SDZJAVFYXq7uE7C4zkEM7cGpAlmoc8VqtRoX2WD26MvmY/WqHFiSNjK0yo06qwZu66MZ0znAPlZ0kyzhcpFGNbBUFjk31+Kpr7+8Z1bkl796k/q5gcICKiITA5QEREkgnVlQNxBuO4z7WJZz5d1zuGvrlKPysRJ7z+7Qtf4ImD3TG2v6/VS/QwaKUpKHi8Kl6Scb5IiiKLNLSIGB0Oi9K0wGztt0oyDhERTS5MDhARkWRCMTmgVihQ2tEh6Zhl+l5EmvWnPk5KNCPv7DRsE/3fD35E1QGzSTemeS9ZdnxMx4/k3q88ijce3IgH72rGVy7XSPLU3+X2o8IjjUvMqlhYJVqZ88KxI5KMQ0REkws3BxIRkWRCMTmQExuHwvYztwZMRIPXitjFOuR703BC1YfDXguAPoyl0mGPz4kFaQmwlPhXCyE73YRF2ZvGF/AQBAFIjKpGYlQ1Vs0GkmJvxaMv6kc/cQQ+r2/0g2jMknJisK/HvzoW/tjX2ICanm5kRkVLNiYREYU/rhwgIiLJ2EKw5kBhexuWpqRKPm6nz4GtQiNq/dxGcLqzFckoL/Gv5kBCrAF/ufMNKBWBu/m+ZsWL+OoVZ7Zs9Fe0WY+unqGLNNL4iQD6cxR+VLHwX15cPF4plG4VChERTQ5MDhARkWT6XaG3cgAADjQ1YllKmtxhnJKoMKB9X6dfx5qMGvz1rk1IiKwLcFTAty99EpddGofZy9MQHxfh93k6rQoRRh06upkckNqMNSko6/Xva8VfBW0tMGt1sIyzgwcREU1O3FZARESSSY+MlDuEYe1vasDSlFQcaBpbn/iJilZosdAdBwDwKkW4FT4oGzyoso1eXE6jUeKh7x9FZmJBoMMEANS5zsN/7R2AToBmtgKrfGk4caAVDufwSR+FAKSnxKD8hLRbN6aytHnxUGkVEJQCjqg7AYlzbnaPB0pBQHF7O1akTZN2cCIiCluCKLK0MBERSUMURXznw/ew8USV3KEMa3FyCg43N0m6THsosQodFtpiUXW0BU7nmR0PRqNQCPjD9xpxTt6HAYjuTK2es3Duu/lw+wbXTYhX6DGvOxolR4dOquTnpqCgVLr98ARMPzcVbWan5CsGvijVZMYr198IUQSmhXBSj4iIgofbCoiISDKCIODPF16C5Aj/l6QH26HmJsxPTIZaEbhfgUoRyC7Tonhfw7gSAwCQk2UKWmKg17cAl7x/ZmIAANp9dmyKbELkBbHIzIwd9N6C2WlMDARA1dZGxGJsnSzGqrHPAofHg8Y+C5ye8X2NEhHR5MLkABERSSpar8ffLrkCCmHirfEC5WhrM3Ji46BVKgMy/hpfKhqbeiY0hskoTSwjERGBcttFuOyjZbB6Rv73KvF0YXd6J7LOS0FMtBH5uak4WtwQ+CCnIIVKQJW7J+DzlHd2YmFSMp4+fCDgcxERUehjcoCIiCS3LDUNP15+ttxhjKiwvQ2ZUdEwqsdfoX8oC5TxOLG/ZcLjmAyB3fhQYL0MS979Ci7/MBttdj8TOYKAXb5maBYY4fF4MX92GrLT45A7PRELZqdhWnIUFsxOQwjnhcKCzyMirUqNFZEpSI0wBWyeiq4OaFUqlHd2YFd9bcDmISKi8MCChEREFBDfXbIMexrqsach8FX2x6usswPZUdHotNvRO8HK7bEKHRZ0RaPkmDTL7MtqfGjtyUBilPQ3bSKM+O6Waeh1jf0uPlahg+OwFSW9tiHfr2/uwaysBDS19cLa75xoqFNWc3k3UN6NrBVJaNT2BWSO8s6BmgYXZE3H/33yMdZ99TZE6fQBmYuIiEIfVw4QEVFAKBUK/O2SyxCh0cgdyoiqe7oxIyZmYoOIImZU6iVLDABAQ0s/7nr0WpxonSfZmCcd71uDFn9XC5wmv8WMnmESAyeVn2iDXqdGdnoc9DppV2ZMNZ2VvYhQB+Z7qKKzAwBwUfYMxBuN+OXGT+Dx+QIyFxERhT4mB4iIKGASjBG4clau3GEEniDAOksheZ2Ftk4b7npkNQpqV8EjJGFH53W44tNv44WaW+BC+pjHE6HEjq7rcOPHqeOOSWXwb9Fhe6cV1XUdsDvc0GqUSIwzITs9DrNnJWN+Xhryc8cfw1SRlBODziVKWN2ugIxf09sDl9cLo0aDF665AU3WPnznw/dgc0vcO5GIiMICWxkSEU1S1d1d+KiiDLPjE3BeZrZsBQIPNDXgpjdfk2VufwgATFotLM6JL4GfeUCNfpv0N3LZ2bHYk94Br/h5Tl8p+HDvMjtuytgODUbfuuERUnDvocvwZuXEdhTmqmJg2SRNi705s5JRWdMOp4vV8r/InGBA3xIVOhw2OL3egM61/qtfQ05sHACg1+HAre++CQHAf666FvGGIFTFJCKikMHkABHRJOQTRSx46olTTxyvysnFY5dcIUssoiji3Of/i3pLryzzjyYvLh4lHe2SjJWxSwG3R/qbudlnTcNGzdCdAdQKEbfmupEX40B6hBWJul5EqTuhV7RBKQ58XvXONbjpkxz/Cw+ORBSxtCoKjY09Ex8LwLSUaNjtLnR090syXriLuToBrU4b2u3B+ft49OLLcE3u7FMfn0wQ9DocePbq65AdPcEtN0REFDaYHCAimqS+8tbr2NtYf+rj1264CUtT0mSJ5W97d+Ef+/fKMvdolqak4kBT48QHEkWkbJ/4MEOJvyAexzwdYz4vQiViRpSIox3S7SJUQ8CCSrNkyQEAMEfoEB9rQlWtf0kahUJAfk4KPN6B/fGCIEClVKCipi0gKzdGo9EosXyeEXuOWuHxjH/PfmSiASW5dgkjG93suHi8//9uHbSyqNfhwK3vvIHGPguevvIaLE7mFhAioqmANQeIiCapeYmJgz5+9shhmSIBbsibi0RjhGzzj6S2p0eScbRC4BoAxTq00Ihj/5Vt9QiSJgYAYI0jRdLEAABYrA6cqO/A/Dz/bkLnzErGsZJGFJU3o6i8GYVlTTha3AClQoH8nBRJYxtNhEGDtb9dhwe/8VcsnjOxtoNRaSYEe/NPcUc73iktHvRapE6HF669AakmM255+01sqKoIclRENFmIoohiSwl2d+zFga6DONx9FMd7ClDeVwG7N3DJUNHXD9H2Onydt8DX9xeIntDtnBRKuHKAiGiS2lBVge9+9P6pj3+5cjXuWLxUtnjsbjf+d/Qw/n1wf8AKrI2FAsD8pGQcaWme+GCiiAudaSjeN/TSfynExUbAnG/GLl8TRJnqRyxUxqN1c1tA58jPTUVVTRtsjqGL4i2Yk4ajRSP/PWemxSDCoEVpVeup1QWBoNWo8NNbOnHZ4oGaGu/tuwWPvGCY0Jhp+XFomOZCU39g2hcOJckYgU23fRN69eDOEj0OO259500Ut7fht2vOx23zFwYtJiIKfaIootXZBpvHBpPaBLPKBK1Se+r9FnsL3mv6AOV9lbB7bbB7HfDh85/JAgSkG6ZhZsQMzDTNwMyImYjVjm0rkyi6gP7/Aco0QD0H8Fkg2t8AnJsB0QmIJ3+WCoBmFYSoRyAoIqX49CclJgeIiCaxA00N+Me+vdhZX4tPbvk6ZsTEyh0SOmw2/GP/HrxSeFzWtmlzExJQ1tEJt2+CNQJEERfa01B8IHCJgS+amZuIbYmBvUEfSoSgRvoR1ahtDKWg06qQk52E5vZetHV8fpM8NycFhWX+t4s0R+iQnR6HhuZuv2oaLJxtxuqF7fj7y1qMdHWUkRKBf/70OUTouvDFPE1nXwqu+9WXRjzXHxq9EskXJWNPrwTbXfz00xUr8f1lK854vcdhx5WvvIR4gxFv3/SVoMVDRKGpyd6E4z0FqLBWoryvEhaPZdD7WoUWZrUJKkGFNmc7vKJ/v2MNSj0WRM3HvMh8JOgSkKCNR4QqAj74oBSUQ54jig6I3XcBykQIqtkQnVsBTyUEw5cBw1cAIQJi+4WA7wsPAfQ3QhH5h/F++pMekwNERFNAQVsrZsXE4j9HDkGnUsGs1SJKq8OF2dMhyPQUur2/H512G14uOIaXCo7JEsM0cyR0KhUquvyvvj9XGYMGsR89PudAYsCaiuLDwbuJm704FRsj/L9BlopOUCJxpxiQgosjyZ2eCK1WDdEnoqiiCV7v2C9bBAHInZ4Er8+H8uqhEysr5pvx52//FYIAvLLtdvzr9aEvRgHgV9+w4LIlrw753vce+xkKKyxDvjdWfRfp0OeaeBcNfxjUamy57XbEGwd3KPCJIpY98y+sSJuGJy6/MiixEFFo2tq2DS/UrvX7hn88knVJWB2/CvHagS4qezv3o8vVhRR9MmZEzMCa6BQIqukQBAVEnw1wvA/obxryWkYU7RBbFwAY/HtDiH4RgnZ5wD6HcBa4DZJERBQy8hMS8fi+3Xh8355Br7947Q1YOS1DlpjijUbEG434v7NXYX1lBTrtgX8ifbqTHRSWpaThWGuzX23jdIIKSQeAvCVJMHQLKD4avMQAAPRGeoHg3p8DAByiF9My41BdKU1nB3+VVrVOeAxRBEoqWwAAiXEmJCWYUVXTAavt8xvvr168/9QqgJtX/xd1rT/BR9vOXG2QGGfAhQueG3auVQu7UVgxfGJhLMxqTdCSAza3G1e/+hISIiIwMyYWD190KURRxMeVFehy2JFmNgclDiIKPR6fB2vrXsHmtq0Bn6vZ0YLX6t844/Xq/hPY2bEbq30HIET8AKLxFggKA2C4echxRE8lxL7HcHpiAABEy31A3PsQBJ3E0Yc/JgeIiKYAURSRFGHCxdNnYHd9HSAC9605D2enpcsdGkxaLRYlJ+PT6irZYtjf1ICUCBPMOh1KR2lrWOrtRqTVBcsWCWoVjJFarUSBb+xdC6SiSdQClbJNL4nWjj60dvRBrVYiPzcVvX12mA0ezMv4vNWEIAA/ve5JNLf/EI1tHsyZocScrC7MySjFzORDUKuGr5lxzpxd+BdWSxKrQaUe/SAJtfRb0dJvRY/djrdKivD0oQOnVtVclZMX1FiISF4+0YcGeyNKLaXY3bkPJ/pPyB3SZ0SI1ocB68MQhShAmQgokwBFEgRlEqBIhOjaCzg+wFCJAQCAt2YgcWC8FRB9gDIJghDcn7ehiskBIqIpQBAE3DQnHzfNyYfH54PV5USUTi93WACAoy3NsiYGTmqy9qHJ2oelKakobGuD3TN0QTyr6Mbs1Gg0NHQHOUIgMzsOtWLw6w2c1KQLbpu9QHK7vSgoHVj18ehPO3H6ilS1yoVHvvsolIqx1cWYFleKrLQrcKJh4gUFjQp5LlZdXi8ONTWeSgyclZaO2fEJssRCRIEliiKsHivanO1odbShzdmGBlsDSvvK0Oexyh3eEL5wwy/2AJ4ewFN2+jujs/0Pou1/AAAh9n1AnStVgGGNyQEioilGpVCETGJAFEX8YfsWucMY5EBTIxKMRqgUimGXdCsUwa/TMDM3Ea2pbsAT9KlPKXN3YqZRC2t/cJa6B0uXZeib8LEmBk5avciOExOoT6nXqTE9Ix6tx/qhz1YPm6gKFKvLhStn5eLVogIAwLcWLQ7q/EQkLZ/oQ7erB23Ots8SAO1oc7ahzTHw/0C2FJReAMrlicHrDhPqmBwgIiLZVHd34bAUrQQl1mN3wCMOfWOYoTSjrq4rYHMLAmDQa9Bvc8Fo0CIjPx5lxl5s87bJmhgAAFEQkJoVg7LC0Ps3m4iGVu3oB43BOXMP4Pn3x9f2LzUxEi6391RXhnnzUrGvJ7gFKK1uF+osvUg3R0KjVGJNRlZQ5yeisfP4POhwdqDV2Y62z1YAtH3253ZnO9yizL9AQpmPyYGTmBwgIiLZpEdGQatUwekNrYuW9KhIVHYNnQCYYTOhBL2SzpczJxlNtd0ARBiWR+KIpx0GQY0O0YMKNMpSgHAo05WRaKoJ/naKQDtWoYZ4qQICpGmtOSvlABLjVqK14/MimwpBgM+PBlFxsSYcK/582YFLkKfd55MH9uLqnDykmsxQyNTRhIgGc3gdp274W7/w5L/N0Y5OVyfEQDxVDzlcORBITA4QEZFs1Eol5iYk4FBz8FvzDUerVEKrHPrXoyCKaC2T9uY4KzsOW+JaIMSKiFBo0ecZKIhoC7GnPFlKM9QHHLBYHXKHIrkjpQrsLr0OK3PflGQ8QQAe+u42vLblEjR36dHdY4PT5UF7lxU+38gXtuJp7/f7grul4KQGiwUKQcA1uSxESCQXn+hDsaUEm9u2otJaiV63NG1S6TQ+/r2epJA7ACIimtrmJSbJHcIpRrUamVHRKGofuujfYlUiurr7oRAE5MxJQkK8acJz+jIG9ruLgoA+cfgq+LIRRSxXJkJ/yAVL3+RLDJz0wDPRcIvSde+YnnQEqxcU4lhxI+qautHa0Yc5M5NHPc/hHJwM0ApntkWM0uqgDMLT/LdKiqAQeKlIFGz9nn583PIJfnn8Xjxc9igOdR9mYiCQxFAsvCgPrhwgIiJZub3yrplPjohAgjECWpUKLdY+lHUO3yrwhNiH+eekoUTdgy2+VmQnmmHcq4ExQgufV0RH59guMGKijdjvbQFCcdW2KGKpKgmKChfq61vkjkYSEQYR15znxrFyFQoqBJz8i798lQc/vWkz1EKdpPNFGnsBpJz6uLaxCwtmp6Gzpx/1Td1QKRVIjDMj0qyHWq2E1+tDVe3gVprOHb1IXmFCc//ny17n9kdBUCmwA4FdcdPU14c3igvx1fz5AZ2HiAbU9NdiU9sW7O3cB5cvBJPFIUH6bQWizxKSv4blwOQAERHJaqSb8UBJjohAhEaLBosFzVYrmq3+3dR3+uzYrGzEya3p1V4LhCUiRMENiCKmq6OQ4YyAs8mB2hOdo+4xj4zWwyvYRjwm6EQRi9WJ0FR6UFs7OZICAJCZ4sNz97wJBXqAywEfImF1ZsPmjECieScECS84W3sy8NbOq2DQuYEv1DGwWB04+lk9AXOEDn39DjS29qCxtWfYsaxdDsQVatCfo4XF5USq0YQTH7cg/UupkLj0xZD+eWAvbsibA62Kl4xEUnP5XCjqLUZhbxEKeovQ6myVO6QwEICaA451EFVpgO4aCAqj9OOHEf6kJyIi2YiiiPLOzuDPC5zq4T7hsU4u7xYEVHl6UaXsBaYB5gwN5iIG+i4B9ZWdQ7b/a6zvhmqaAE8IFZFaLaSiclOj3GFI7uKzXAOJgc8o0Auz9gjME2hUYHdG4F8f3o7rV29ERnwRypsW47Ut52Lzvn54vSO3exxL7YbOOgui25RIMmjh9Thg94lQuYHlvXEQfUBBfG/A2h02W614ragAt80fX/cFIjqTKIo42H0Ir9S9hk5X4LrfTEYBecLva4Zo+T3gOgoh6uFAzBA2mBwgIiLZtPZb0esM/j72bnvgezpbfC7sRgsQBSgWA3PUcUjs16G3zorGph4AgMvtxUxVLEo8oXNxqOoOnUSFlBbmSJeEcrp12Fd+MQ6UZuO9zTa8t2UlstIuRXV9H4DAVL12O7xwOz7fglO1/vOOBvnz4j5LEASmiOW/Du7HTXPyuXqASAINtkasrXsZxZZSuUMJU4H7HSXorwjY2OGCP+WJiEg2B5vkeULt9HqhV6kD9rT1dD4BKPB0okALYCaQnBOBHF8UxFY3RI8KJUGJYnQrFEkoPR46nSOk8v2bbZidukmy8TQqB97YPAvHSgcKhIkiPksMyKPheAeWXJSGHQjM91NrvxWvFB7H1xcsCsj4RFNBv8eGdxvfw8bWzfBJ1DZ1agpQckARD2jOCczYYYTJASIiCro+pxN/27cbLxw7IlsMUTod7FZ52sQ1+/rRjH4gEQN3liHQRz5LZUb7ruDXfwi0i1Z4ceOqlyQdUxCAVQs7caxULem446WNUKPX4AYCWL/sXwf34+a5+dCpQuNzJgoXoihie8dOvFH/Fvo88iURJ4dArRoQIBi+BkHgrTH/BoiIKKisLheufX0tqru7x3X+ouRktFr7IQBIjIjAoebxPemO0GjGdZ7kQiAxYBRUiC4CWhzyJEsCaeWCwLSo2nk0FoD8rcVi0kyoynHgRM/Q7Tel0m7rx9qC47h94eKAzkM02RRbSvC/E8/JHcak8NUEc0DGFWJehaBhXRUAYPNaIiIKGlEUcc/mT8eVGMhPSERmVDQONzejsc+Chj4LDjU3YVlK6rhiCdaWgpAniljWHoeWliCUvpfBrDTpb5rbLemnthTITVysD1itgdM9dXA/bG5+3xD5SxRFvN34ntxhTAompQLn6w9IP7AyE1AvkH7cMMWVA0REFDSvFB7HB+UjF2GK1etPLV0WBMCk0cEn+lDQNnSLp/1NjViWkoqitjb0+3nDvzg5ZdwrDiab831pKC1qGP3AELJ0jg/fvKoFRr0d/347C2W1Ajq6gaHqWMdH1kk+/+ZjF2KULpXBIQDFPe1Bm67TbsPagqP49qKlQZuTKJwVWYpRb6uXO4xJ4YcpSijEAPy8054PIQRW8IUKJgeIiCgoitpacf/2LSMekxUVhWarFZ2DugmM/oR2/2eFDdUKJVLNZnTabOhzDd1KTqtUora3x9+wJ7UFqniUbw+vtoVxUcDD33sbCgx0ePjTtwdeF6GBD7FweaNgd5rRZ49Aj9UAjeKEpPPXtc/GaxtMAALf8WI0xkgdRIzcMlFqTx86gK/MnQ9jqGzLIQphW9q2YZZpJgp6C+UOJazlGfSYLmwOyNiC7oKAjBuuuK2AiIgCrs/pxPfXfwiX1zvsMVFaHWxuDxwTWCLt9nlR09ON9MjIYY+Zn5iMDptt3HNMFslKAxz7LfCFxCNw/z14V+OpxMAXCXBBiWbolSWIMexDRuwmzM/4AIKEVcGrWhfgB3+7EB3d8iQGtEYVVOrPL90Mkdqgx9Bpt+PF40eDPi9RuLF5bNApdeh1T84tW8F0Z0I7BARg+5QQBahZa+CLmBwgIqKAEkURv978yYhP6xUAkkwmtPZLUzyuqL0Ny1LShnzP6Q3O/uxQphEVyKjUwtLnkDuUMVk824fclA2yzF3asBw/enQVunvl+TtTaRVQnh+JpnME6K+MQfpVaYjIN8kSyzOHD8DqCmBrBKJJoNhSguXaVajjtoIJuSbWBLMvQJ2N9NeyQ8Fp+LdBREQB4fZ6sa6yHP85fBBF7SMXhVuckooDTdIub9/f1IC8uHh0O+xosX6edHCOsHphqjjHm4zSuvCqMwAA936jIDBPj/xw/7Nnw2Ltl2VuQSEg6dJk7O8ZqJNRZelGFcZW1HOFKgaafi88BiUcGgGNsKPVPr4VNN0OB9ZVlOHGOfnjOp9oKkjUJOKZFw4BZ8sdSfjSCQKuMB2DhAvAPqc5C4LpZwEYOLwxOUBERAGTGRmFK2flItEYgeL2NiRGRCAzKhpVXZ0o/CxhsCRZ+sTASSUd7dCr1FiSkoqDn81hZ7V1+HrCb/XE/7vUhVjDPlnmbunORkNL8BMDMakmRC6MRIm761RiYLyUn9Sg8f3iUx/PfORStCrHv73mWGsLkwNEI3jj1VIcK2pEFJMD43ZXig4qXwCuD5RZEKL+DkFQSz92mGNygIiIAkKtVGJ+UjLmJyXjjsWDq5s39llw2drnkRJhwrHW5oDGYfe4cbCpEbPj4tFht6HfzeXQJxLtUJUq4PEG4nGM9NQqEbdfsU22+Y9ULZNl3pgcM7b3SXNh7GwYvO/Zq1EAE1hEc7QlsN+3ROHsg43H8fb6o4iPM8odStjK0GoxR7ld+oGFKAjRT0NQDF+baCpjzQEiIgq6VJMZ9597ATrsNrh9wblBLe5oh9XlQrdd/irzcqv1WjBzWYrcYfjtJ7dYJe86MBZpCfJswajZ3YLcEj3OQfKExlmkj4GldPDWHvcEH5iVd3bAxlU4REPasrscAKBU8lZrvL6fZIUAqWu8qCFEPwlBlSHxuJMHv2KJiEgWV+fkYXFycG9QbW43vGFWnT9QdmiakZhgljsMv/z7zQg09qyRbf7clP3ITAt+8T+Pwwuv24dCrX/1BRINEYjXD35SuaYU6P3OOnhtg2/knRO8AvSKIl4uODaxQYgmqdrGTgCAQiHIHEl4ui7OhDhxr+TjCpEPQNAsHf3AKYzJASIikoUgCPja/EVyhzFlueCDOFcndxh+6bUK+H/3zMKGIzdDhCZo8/bZY7B267dx0+++i5qGvqDN+0VRq2PQ4xz96Vm2ORqR+9xQfWzFKlXqqdebnjs45PHKRw/iXGsEUg0R447tjzu34bWignGfTzQZ2ewutHYM/LxgcmBsUjUa/CXDgysN66Qf3PgdCPrrpB93kmHNASIikk2PI7xa6U02R73tOG9OEsqKWuQOxQ8CHvyPGd5vXo/LF78S0JmaumbgzR2X46NtHtidHgDybEXJXJaE3T2j7+3PiYyFe0svrH1uCAB8/R5AC0RqtPA5hi4+2Vfahr57N0ILYOU1c+C9MAP7vd3wjXFlza83fQK9SoWrcvLGdB7RZFXf/PlKH4WSyQF/KAF8J9mIJZqdEERpWhp/Tg3BdDdg+PqoR4qiE4KglXj+8MLkABERyaKutwevFHJZspymKyNRX90ldxhjsuOwEZcvDszYxfUr8Nrmldh20AqfT97Elc6kRkVM36h5iblR8bB+0gmX/fPqgkqzCnAC0erRL3IFAC3vFgHvFiHp6QvRZBvbhbkI4O5P1kOvUuOi6TPGdC7RZFTb+PnPVJ9XhNmaBEFUQeFTQvApIQpedEfVyhhhaFkVGYFbosuh8VUN/ECRkioHQuRfIahzznhL9JwAvPWAZgUgugDbC4AiFjDcJHEQ4YXJASIiCiqL04l/HtiL544egcs3gXLpNCEJSj0MR93otIdX94b9hQJEaCBAmrh9PmBX6ZV4bWMOjpdZAMizfeB0CecloLp35PaFC6OS0LmuFR734KKeHh0AJ2AWVRhLA0aTML7LQq8o4gfrP8QzV16DVRmZ4xqDaLKo/0JyoKGxFw1PRg96f8GSOOACJgcS1Cr8ONmDZKwHJK9LLADGb0GI+BEE4cytaKLrAMSubwBwAYIJgBJQpkCIfVPqQMIOkwNERCQ5r8+HA02NaLD0osVqRbO1D83WPrRYrajr7WGVc5kZBRUyy7Vo6PKv0F0ocXsEOLxZ0CvLJBnv/f234tEX9QAskownBUOkFgcsI28nWBqVjOYPm+HzDn7UptIq0OC1Yqk2Fo4/7BrTvDpx/KWoXD4vvvPRe3ju6uuxLDVt3OMQhTuzST/i+4YUNywiIHxhx4EoAnpnJBy63uFPnCQEiPhmkhkrtbsgiIH4fBUQov8NQTt0EVtR9EG0/Ak4mWAW+wbOifwfhHEmSCcT/g0QEZGkdtXX4sEd21Da0S53KDSMZR1xKGsI3z717b1pSI+RJjlgc4be/lJbrxNLI9Owt6dxyPdXRKag7v3GIZfgTj8vBd5dtWh8duhChCeZZsUj8rb56P7vYfSf6ELKzQuwyz6xZJHD48G33n8HL173ZcxPTJrQWEThavbMkVuP7n6/Fwl7liIjTwdVZhc64ysQV7EILYUKKK7bC1EZnPa+clhmMuIbsTXQ+XZKv4XgJOMdwyYGAACOjwBP4eDXDF+HoJ4boIDCC5MDREQkiU6bDb/YuAGba6rlDoVGoBOUqCpplTuMCalsjEN6jDRjOZwqBGBN64R17eiAcZEa/Z+tsllpSoXY6oagUqD6/UYMVeZsTpQejfd+DGf7yJsJ4s+fgYPXJMDjsyL+Fwsw54gNh+dr4XM5Jxy31e3C1999Cy9ffyPy4uInPB5RuJmRGQ+VSgGPZ/ifK23tVrS1W4HtgFo9C1W+Pni9Pqw4fhbaF45txU84iFIq8ZNUEdPwCQRfAH/equZCiPj+sG+LohNi36ODX1SmQYj4YeBiCjNsZUhERJJo6LMwMRAGFtlMmK1VYYlKgSUud1heCBwpNUo2lsMVms9JrF0OLFYmAACmRZhRt6ERNQdacWJP85CJAZ1CQM+GY6MmBgBAoVHC89kFervDhq15gEWCxMBJvU4HbnvnTVR3h1exSyIpaDUqpCVFj37gZ9xuL7zege/HfZ92Ia79zOJ54UvErQkmPJJ2HOnYBiGgiVgdhKiHh6wxcIr9TcA3eEWWYL4fgsIQwLjCSzheExARUQhKN0ciVj/yXkuSiShiaacWF73VhdZffYyKtTtQ9MYeFH10GPN1amQZRriYCkGf7lWiqXeEZaNj4AzR5AAAVG9qxCohGUm1anjdI6/Bzff50NXk37YAjy3wRSg77Tbc8vYbqO+d/HuoiU5nsY6v/akoAhXvREDrNEkcUfDNNxrwRGYPztetg0IMfKJQMP8Kgmr6KEed9vNedw0E7TkBiykche5vRCIiCivRej3+etFl+Mb7b8sdypRj9iiw8qAT7rpe+NxeiB4fvB4vfB4ffC4vnP0OdLX0YqjLs7p1h5G1ZjZOKJWjzhOhViJRo4JRFKF2eyE43TiiEOAd8ll24NgcAm7+dQ7+/vNILMh4f0JjOVyh+5zE5xFRtXX4jgVKiEjQaRCnEFD6+m7/x+0PTkHQln4rbn3nDbx6w01Iigj/mx0if7jcHnT12MZ9fle3DSlbF0C8eMegooXhwqRU4EcpSmQLmyD4PMGZVHsuoL959OPUcz7/s+5yCJF/CFhI4YrJASIiksyazCzcsXgpnj50QO5QpgZRxLmNGvQ+dxTlHeNrwWfrtcHe1A1Mixt1rrTSRtQeH9yCK++rq1AYhCfRQ4mKGP8F+ElOVxhefX9mocuDonf2o2eM53ltwesWUmfpxa3vvIlXr78JsQYu3aXJr73TOuExCo92YGX2MrTM3C9BRMEi4svxZlxiOASlGMS6NooYCOY/QvAnk6KaBUANGG6CYLoXghC6yWG58G+EiIgkdfeKlViYNHK1Zpq4GTYNzn+lHfV/3QHLOBMDJ7WUNw2sZx3BHKPujMQAAAjV8hU3/N5DWShvuWzM5/V2xWDv1rPx7CNXwVNgCduLIXfv+JYuO7tsfq31mGuIwWqHGbON/u+fHkpVdxdue/dN9DocExqHKBy0dU7s5/FJ+z+wIcoSHm1Bcww6PJ7Zj8v164KbGAAgmP8EQTlKcvvksYIGQuRfIJjuY2JgGIIojnI1QERENEYNll5cvvYFWN3yPFGerGLcCszsUSGm0orKN4/C55WuuFPkV85Bi33oJ8oCRGQX1aOp/Mz2h4IgwHDT2ehwBmn56BBuusSFO69aDyVGvyjdvekc/P7WwRfv2Uunoz4rERa3N1AhBsQiqwMlnx4b17lpD16Ebcbhb2JWbulDy3tFAAY6jqVcn4/uS9NQ1D/+docLEpPxwrU3IEITXjUuiMZiw7ZiPPD3dZKMlZYaCcPNh+BVBW+1z1joBAE/StUgR7EdAmT4fa+/GYrI+4M/7yTG5AAREQXE9z56Hx9XVcgdRlhLcaqQ2wRoKnrRXdSMjtqOgM2Vnp8OU04K+qta0VHThpjUWBgSIqGMMgAeL4rePzjsuXOuW46DMl9NLEhS4yc3fYqsWeUjHvf2c5fh378+cx9/bGoMVOfOQY1MWyTGy6BSIFmjQrTVgaL3/N/OIwpAxL8vx3HbmZUoso2RwLc3DLm6IPnauei5fBoKx5kkWJ6ahv9ddR30avW4zicKdS++vQ//XrtDsvGWropD19nSjSeVK2NNuMp0DKrTqv8HjwAhfgeEz7q6kDRYc4CIiAJiUXIKkwPjkOxUYUGxC5a99Wgpa8aZC/kDo66gDiioO/WxtXv0lngnebv7gSjp2guOh1DajftvT8PfP2yFKXL4CvmdLUPflHY2dkH95l4svG45jjhC8yndUGweH6o8LqiUCsTEmtDn55JmQQQcP/4US+enQDctCi0XJaOivwcAkFHnRt0w5zW/Uwi8U4iVV8+B5YoMFAyRXBjJvsYGfG/dB3jmymugUnBZL00+re0WScc7sKMDZ2fkozW1QNJxxytbp8X3E3sRLe5AQDsTjkazjImBAOBPZSIiCohFySlyhxBWZvdpcOkn/Yj49W6UP78fLWVnLuEPVaoInazzJ+rUKN9WjKaqTjz0o9XweofeUe/zAWWHh9864Ha6UfrKTmQdr0Ha/grEbDyGWRXNiNaE/rMUjwhkrMod0zlemxtde2rR9PoxGB8+hBitHimGCHS+eGTUc1veK0L/d9YhWjv2f/tttSfw1z07x3weUTiQqubAFxW8q4TBHiP5uGOhEQT8JMWAexN2IlqUv+iwoLtC7hAmJSYHiIgoIObEJ0CjGL093lQ3y6rB+Wtb4bxvOyrWFUhaRyBYRN3wS8SNSgXSDBqoAtgUIK2nHz7fwL6Gg5/U4cXHrxzyuBceuwoFOxtGHa+lqhWdjV2w9zlQX1gHw45ipOlDf5+8qB5/EqOvvB0Jv9oL3R0b0V/j35aB9DuWo9s5viKDTx86gA1cWUSTUMcYVl35q8/qhHNDHuCTp7vKRdEmPJFRi3mqDRAQIoVFtWvkjmBSYnKAiIgCQqtSYW4Cl/yNRO8VEPtsKWoPnJA7lAlp2V2G5NMSBHqlgCUKAbpPj6Fz7Q5o392PjCMnML+9F0t9PswxaKCWoIl3nFaFis2Fg157/bEGdLYlDnpt0/vn45W/jm+TRldTN2JCvONhnFaFyo8OT2gMd4/dry4GABCzPB378yeWMPm/Tz/GiZ7xFzgkCkWL5k4LyLjlZV1IKDorIGMPZ5pWg79kePAV0zqofcHa5OYnb4vcEUxKTA4QEVHArMrIlDuEkLamwIe2qja5w5iwzsYueDccxcJeG5YCWCIApi1FKHprL2y9NgCAzyeiraYN5TtLUfjeAVSv3QHTp0cRO4El+0alAuZD1XA7B9cI8Hq8WP/6slMfFx+dj7/9cPg6BP6oHUMnA51CwAKDGnPqO7Cwtx/x2gBvSxBFpDZ0wmlzBnaez6ij9Gi7PRc2z8RqM1hdLnzvo/dhd4dPjQei0Vxz8fyAjb3v4x7Edk4P2PgnKQHclWzE75P2IV7cE/D5xsVdJHcEkxKTA0REFDB3Ll6GWbH+9R+eirpTtUhfnAlBgifocuvrsqJ0cwEK39mHorf3+VUYz97nQJJ66K0nRpVixL3+akFARnUrmiuGrs2w7rleeNxKtDam4vdfN8HtGn+rxdScFPSOlhwQRcw0arHY5oT+4yMoW7sT1QerULq5EM539mN+ALcl5Bt1KN9ZGrDxv0gEYPrTeai1SVN0rayzA/du2Qg2z6LJIi05GssXZgZkbJ9PxIl3o6FxB64A7KrICPwzswlL1B9DEK0Bm2eiRE+x3CFMSkwOEBFRwGhVKjx+6RXQKkO/oJsc9sW7sOXWJCTnJgMABEGAKdYkc1TBpf/CU3+NAOQbNJjfYYHi3f1wvbEb8zssmGPUDr5gEUXM6erDicPVw47b2dSLbevX4LffmIOetokVCIvMHH17zAKDFg0vbUfxhqNw9A9+gu92uhGoW1+9UoGOjccCNPqZMu45DwecY+tQMJp3SovxSuFxScckkovb7UWPxR6w8ds7+qHZvghS59MS1Gr8MV3ENyPXQ+OrknbwQODKgYAQRKZqiYgowF48fhS/3bpJ7jBC1mXbHHA196HhS6lwKEXMOWpDx+4adNZ3yh1awGkNWkyblwF1hBY1+ypg7xu62FVUYiTSzs5FrVaN9H47ij44NOrYCelx8Hq86Gya2L52QRAw+9plOCSKEIfalS+KyC6sQ3Pl8HtgNTeePfrqg3FY4nKjaIK1BvyVdOVs7LsoCh6f9EUzNQolXvvyzZifmCT52ETB9I/ntuA1P34+TdTZNxrQmjXxeQSI+GaSGSu1uyCIE9t+FTSKBECzAkLkHyEIoV8sNpwwOUBERAEniiLu+PBdbDox/JPeqSzGrUCXygt8cXuBKGK6TYOUXsBwuBOVG7mEcjyiEyOhNWjRcmLitR2yl05HbVYirKfd5M81aFG1dvuw56XmpaIyN23C858Rj0GDlpd3Bm1JvveZi1HTL20P9y9KMZnwwc23IlqvD9gcRIG0+1AVfv7Hd4Iyl06rQt7tHbCYxt/2dpnJiG/E1kDnC862JCkJUY8DqpkQVDPkDmVS4bYCIiIKOEEQ8NAFlyDeELh9kuGsS+0bnBgAAEFAldGNHSlufHq5GTqjVp7gwphCqUDarBRYOqTpO159oAq5pz/9F0W4j9eMeJ4hJuLUn6PUSqTrNYjTqmBQKTDutcGiCMWh6qDu1TchsNuDmvr68LttmwM6B1EgiKKI1z88hF//5b2gzelwetD1USYE79i/L6OUSvw+XYk7oz8Jy8QAFEmA6BpYQUCSYnKAiIiCItZgwF8vvlTuMMJWTAYLO46F3qRDfFosCnaUwNYn3f7fuu3Fn7dgFEUsMGhQV1A34jm1h09AoxAQrVHCtKcM7S/vQP+ruyC+sQeG9w4gdnMBFg9TmHFYggBTSvQ4P4vxibQGPhHxaXUluxdQWOnrd+Deh9/H35/dAo9H+i03I6mt7UHM4RVjOEPErQkmPJJ2HOnYCgHBjVcaOgjmeyG69kFQmOUOZtJhcoCIiIJmVXomvr1oidxhhJV5vRqs/G89moob5Q4lrKTNSkFrbbvk4/Z19mGeSoHFGiUyjtag7OWdo57jsrtg3HAUyo+PouO0OhKiKMLWa0Px67ux1OMd00qCqjgzzHHBK2CpbrYFfA6Hx4OddSHWT51oGGXVrbj9/17Etn0VssWwf3Mn4ltmj3rcfKMBT2b24HzdOihEaYuKBoX2AgjR/4UQ9wGgXQVBf5PcEU1KrDlARERB5fJ6ccPrL6OwfeJ7wCe7S4+KqHhun9xhhKV5q2fj+Pbwq9OQc+4cFMdEwOXn1Vm+QYPKtTsCG9Rnkm+Yh53nGAI+z/V5c/DwRVxlRKGtsqYd3/7FS3B7pC80OlZRZj3SvlENu67njPdMSgV+nKJElrAdAsbf0lVeAoS49RBU2XIHMulx5QAREQWVRqnEY5deAb2K7Q1HI3QFrh3WZGft7Zc7hHGp3FmKKO3o3xtKpQCtRokCmwu5580JQmSAal5w9vduPlEVkI4IRFIqKm8KicQAAPRY7PBumnvawiMRN8ab8FhaCbKFzWGcGACgvZiJgSBhcoCIiIIuOzoGv11zvtxhhLyeOVFyhxCWBIWAhvLxV/CWU+7F89DmGP0ifs6sFEAQMDcnBd7F02GKNUFQKaGLNMCUEg19bMSoY4yJQkB10hBtHAOg2+HAoSZuo6HQdiLEWs2WFHYiqXSg/kCuQY+/Z1pxmX4dFGKYrtITDIAiDhDMECK+LXc0UwYf2xARkSxunJOPpAgTfrFxA1r7rXKHE5L2JDhx3qIM1B3mHuyxSJuVgvrS8Lu5VGvVqDYbAOdAckCtUsAnivB6B+8xyM9NwfGSgc+vsKwJACCsmQ1RBE5WBVgUbUTJ/6Sr/D/tdxdgq02arg/++KS6EsvTpgVtPqKxOlHfIXcIZ9j/UR8ePisOi8wfQfC55A5nQoSY1yGoZ0F0boWgnid3OFMGVw4QEZFsVmdk4uOvfg1X5+TJHUpoEgR0X5UhdxRhJ1zLKc26eD66nB7MzEpAfm4K1Col9DoN5uelIiM1BgAQbdaj4sSZhRZP/5R9Bg3y7rx4wh0NBJWAtDtXYGdU4IsRftGn1ZVh++9IU0MoJgc8Xh9mamsgILwTAwAAX+vA/zVnD/m2KHohuguDGNDUwOQAERHJKlKnw98uuRxPXHYlonU6ucMJOUejXJi2kAmCsWisaIZaq5Y7DL9FTovFjKuWwDc3HdGRBlScaENBaRNsDjes/U4cK2lEbWMXUhIjER1lhMM5equ/o43dONzaC+eF85B92cJxxZV622L0PnEetuUi6DUAGiwWlHZI322CSAo9Fhu6eoKbMPOXIEyOpJpofwuitxGCoBn8uuiB6G0HXAcA11F5gpvEmBwgIqKQcPnMWXjjy/9P7jBCkj49Su4QworoE5E6M0nOCMZ0tEKtQn1UBA6XNqK7d/gbjqbWXlTXje1pZW+fA0U6DXLvuhQK9dh2kza8cAiz9/dhmiF47RK/6JPqSlnmJRpNqNUbGGxyJAfgWAex/UKIjk0AANG5Bz7L7wDb84D7OKAwA4JS1hAnIyYHiIgoZGRHx2BGdIwsc+fExkEpBKfg2liJsXq5Qwg7pmiJC/L5KWGaBs8f0mMsF+jd1a1IqG6FWh24C13B44PXPbZq5QKAhv8dQOIzpYEJahSfVjE5QKEpFLcUnDRZVg4M8ALeBvi6vgmx+2uA7WWIfX+G2PNdiJ3XAJqz5A5w0mFygIiIQsrqjKygzhet02FeQhLKOjsQbzRicXIK/EkR6FUqGFXBWbreH6tGcm4ypp+Xi1k3LcaM21cEZd5w5pGhxZhKDTzxqRNJyftw9R1xYzq3fmcJ5gBQKgNzaeaz9Pv1dT2U3oLmcZ87EcUd7Wiw9MowM9HIQnnlgDBZVg58Rux7EHDtPPMNzUoIqsygxzPZMTlAREQh5cLs6UGdL8VkxvG2FgBAi9WKQ81NSDGZsTApecjjjWo1lqemQa1UIsVsDkqCYEeqGzvvzMAnV0dh/VlqbMgHss6ZGfB5w1n7GJffS+GxDZGINB8HAHz3d9vwcsHYlvGrGjsRva0ICw0a5KTFQKGQ7pa8xaiHMd6MWdevwIyrlozpXJ/Dg0S9UbJYxuLT6ipZ5iUaSSivHIAQ3Pog8hAgGL8mdxCTEpMDREQUUlakTcOXZ88N2nxG9Zk39419FhxpaUZGZBTmJw7sXTdpNFiWmgZBELCvsQEWpxMVXZ1INZuhVwW/M3D/6qGTFzTAaXdCowteUcK7/xGPmbnbT30swIvY2ENQa/27wVdrVWiqbEF/uwWla3eg7h/rEburFIuSoiSJr6WzDx3n5OGYT0SBUom8b5w/pvPjBK0kcYwVtxZQqBFFESfqQnnlwGSkALQXALprAUUyhJgXIWjPlTuoSYnJASIiCjm/W3M+ZsXEBmm24S+lant7cKy1BRmRUfCJIvY3NsDqGtwiqryrE+mRUdApg1sYydQ9tv3jU0VEpAH5q/Pgdnrgcoxe1X8i1FoBd/whHm9VeHHx9RuHPCYyxr/EUUSUEd2tg5fQW1t60LkrMPv9D/f0I/d7l0Cp9S8+9WOHcG6nAbONE2uNOFb7mxrQbbcHdU6ikXT32tDbF8pfk5Nv5YAQ8yIU0f+CEPEdCHHrIWiWyR3SpMXkABERhRy9Wo0nLr8SkdrAtTacHR+PmTGx2N/UMOqxtb096HcPf6NZ1tmBrOgYaBTBSRBEuZVofvloUOYKF3qTDvNWz4bX50PB9hI4+p0BnS8lW4v3qxtw/Tc3IsI4fK/tB1/XwZ/ihN2tvVCqzvz6aSuow5y0wCTKjjT3wH3Nckz/weWjRmgpbkX9A5vh/PZ6rLGbAxLPUHyiiM011UGbj2g0oVxvAJhsBQkB6G+AoFkKABBU2RAUBpkDmtyYHCAiopA0IyYWG2/9Bm6UcIuBShAwPzEJObFxKG5vR0WXdBd5JR3tWJAcnKX+Zx12wjZCy7upaMbCLBzfXgx7nyMo8zVVO+DPTX/m9J14+H3/bu6jh9pCIIqoeeoT5KUFpouH0+WButs6pqXI9b/6BOeI0UjSG5GsNyLFEIFYXeA6arxTWgyPb/I9DaXwdLSoXu4QRjGZkgNqCKafnfpIdB2Gz/IARG8nRDE4P+unGkEUxcn0FURERJPQ4eYmvFxwDFE6PXyiD88dO+LXeRmRUdCplPD5gCi9DmWdHbA4A/dEeVlKKvY3NQZsfADIsKuhvW83vDJU4w9lOctmoGx/cPenP39Ih6TkfaMeJ0KDL6XnwTPKTpDp8zNRdaxmyPdUOjWSv3Uhyhu7xhHpgPTESMSolYAICKIIwScCbg+K/7NpwvuUBZWA1AcvxnZtb0BuTc5KS8ffL70CsQY+NSR5+HwinnllJ158e/TveTl98vet0CnL5Q5DGqocKOI+AACInkqInTcCohNCxA8A4x0QBD7nllrwKygRERGN0aLkFCxKTgEArK8sHzE5kJ+QiH6XCz1OB/pdLtSefMLeHfg4nV5pb9jVXmBFixq6fi+KMhRo0nqQu6ULlUwMnEGr0wR9zmO7zUi6fvTjBLiQf44JR7b2jXiczjh80T+Pw43W57Zg+tfORVXT+L6YY60OlL60/YzXpShgJnpEuHfVQ3NRtOTfBwCwp6EOV736Iv55+VWYP0wnEaJA6bc5cf/j67DrYBh0z5hM2woEM0TRB4i9ELu/A4hWQJkFGL7KxECAMDlARERhJSMyCk9dcRVi9Abcv30LCttaT71n0mhQ1d0Fm9sNvUoF+2iPaiVmcUqzzDHbrkZOgR3NH5eiqcsKANADWDUnFZVFgV2ZEI5mnz0Lx7cXB33ej1/qxyV+JAcAYOFq3ajJgaFqDnyRy+pA54vbkHXLapxo7vEzys85OyxjPsdfcWuyUXBJHJxu1+gHj1Oz1Yqb3nwNC5OTcXVOHm6eOy9gcxGd1NDcjV8+9C5qGkK71sBJwmTaVuA+ALHnroGkgLcegAAh+kkICpPckU1aTA4QEVFYmR2fgNnxCQCAV6+/CT/Z8NGpXuh5cQmnCgwGOzEAAG39/RM6/5wmNbRbG1GzvxpDLQptYmLgDDMWZaF0nzzt7or39cPjS4ZK0TzqsTPnj/403evHE3enxY6eV3ci/caVqDutu8FJep0amR0WqE16dMaZ0dhuwaLESBQ/9YkkqwSilqQh4vrZ6IlVweAENBY3CmI86HMGvoK7y+fFvsYG9LvdTA5QwB08Xov7HvkAfdZw2t8+iZIDAODc9PmfVbMhqGbIF8sUwOQAERGFLYNajaeuuBqHmpvwXlkJtshY1dyk0aLPNbF6BpanD6G/h4UG/TUtNwUNZU3weeUrVne8Zj5ys2wwCEPfqJ+Umu1H4sjPa3pHVz+Ub+9D2rXL0NA2eDWAOUKHhIom1OytGHhBEJC9OBsl7+yTJDEw7f4LsdVsBWABTn6pGgEEtjnEGYraWtHjsCMqgIUQaeoSRRFvrjuCJ57bAq8vvG62hUnYyvAUtjAMOCYHiIgorAmCgCUpqViSkgqnx4NttSfwbmkJNp+ohssXvL358UbDhJIDKh+YGBiDuLQY9Lb3Bbxl4UjSzk3C02o3nPXzEKM2I00XgVSNiLP0BZimKBl0bOlhM4D2EccbbVvBF/W39ULxwUEkX7EYXRY7psWZYBJFdGwtQmPxF9pziiKaJdwnLYTIjZIIYG9DAy6dMVPuUGiS6bc58fj/NmPdliK5Q6HTCJrlcocw6TE5QEREk4ZWpcLF02fi4ukz0etw4HhrCzRKJXRqNbrsNtz+/jsBm9ukGb6Y3Gim96sxY3sX5FkcH35MMUYoFApYOkfewx9o6b9ORI14AgDQ5bagy23BcQAfIx5nR83HNRG7oIUNO52rsa9dDwjtI64OcDndY5q/r6kb2td2QWlzoTFIRSrFDhsQFZSpRvXgjq3IiYtDVlS03KHQJLHnUDUe/venaJP5Z8tECMJkXTkgAJolcgcx6TE5QEREk1KkTodVGZmnPnZ5vVAIAnwB6uDbaLFAKQjwDjH+ZXvdcMfqsHGGBxA+X9ydYVcjb2cPKtcVopKdhf2i1WsQnRiFuhL56y8IbQrAfObrIkTs6mnEvt6BvbEesQM4F1i8Owe9f3Og8vXaIccbT7LDaQn8Pv8vcjf1ATMigjrncBr7LLj2tbXIiopGlE6P/1x5DZQKVjCnsbP02fH4s1uwYVvwC5tKb5L+LlHNhqAY4gcuSYo/QYmIaErQKJWYn5gUsPE77DbMG2L8ZR0alL96CCee3IWLP7Ag2jPwq1fpE5H4z2JUfFQAkYkBvwgKAemz00IiMQAAtpKRtzR4RA884ueFMZuFZth+2o2zP5mPuHlnPu1urw/9aujuVqvcIQxicTpxrLUF22pPYHd9ndzhUJgRRRFb95Tjlh8/O0kSAwAma80B1hsICq4cICKiKePNL/8/HGlpxrulxfiwogw9DmkrUPe7XIjyKBHhVUDvEWBwA77/Hj/1ftXmEkwviYL3jnkw2UQ0hsHNYCjJPydPlpaFw+k5bgGuHPt5NeYTMD6jRk75QjS93o7ka+PhznLgwHklo58sM68z+F1A/PV2afGg1UJEw+m3ObFhezHe3XAM1XUdcocjKSkKj4Yi1hsIDiYHiIhoyhAEAYuSU7AoOQX3rj4P2z8rXrjxRBVcfrSRG4lKoUDK4V54H9sFYODZzVDPWLubeyDcvwNiTGgszQ4nYggtl51xYwa0PwOc43xI5xbdODGzCrgHqIEFoihCpVHB4wrdm28AEJ3BK/I5VhuqKmB1uRCh0cgdCoWoqtp2vLPhKMqqWlFW3QpfiBTYlNSkrDnAegPBwuQAERFNSRqlEhdmz8CF2TNgcTrxcWU53isrwd6G+jHfghrVaizcZkH968f8Ol4URfSFccErOZhjI1Bb1DD6gQEmKAWc9Z/5qMurgc0n7UW4LkILa1doJwe8jrEVTQwmh8eDjyvLccPsuXKHQiHE7fZi695yvLPhKESfiEX56ahv6p6ciQEAQgglUSXDegNBw+QAERFNeWatFjfOyceNc/JR2NaKOz96D019o9+8KwQBq08oYT/YgOadJ4IQ6dSVlJWIcglb8o3X8i1zUKOplnzctPeycKDr+OgHysy8KFXuEEb0enEhrs7Jg1rpf1tImrz6bU788Hevo7KmHb/98RVo6+jDP1/cNmkTAwMm4efGegNBw4KEREREXzA3IRHv3XQLVqROG/XYDIMJ9Y/tRAcTA5LKX5UHhXLgEkWlVg58rBAwZ2UuNDq1bHGlrklEnUb6ondJh1Nx8M8Fko8rtcj8ZBSsiZI7jGEZ1GpolEpcsvZ5vFJ4HE5PaK/CoMByujz41Z/fRVlVK77x5bOw93A1nnh+6yRPDAAhnxxQTgN0V4zpFNYbCB4mB4iIiE4TazDg+Wuux9cXLBrxuCQHF+BJbVpuCgp3lmLO2TmIS4lB8vQkFOwoQen+ShTtKoXWoMXcc3JliS3jlmTJx4xuiEXJz0+EfMcKTawBXT/MR49r5A4NcrK53ShobcW3Fy3BoaZGXPTSs/jvkUOwOKUtPErhYf/RGsyfnYZ7fnAZOnv6sW5LkdwhBUlo1xwQTL+AoF44ljNYbyCIeFVDREQ0BLVSid+sPg9z4hNwz+ZPBxUsNGu0WNSuQu+rh2SMcHKKSohEfWkTyg5WQa1RoaOpa9D7fV1WVB+vlSU211zpbzJFhQ8+iWsXBIL+wXNR0t81+oEy63M58ZstG/GbNefjO4uX4W97dyE7OhrvlBbjB0vPwszYWLlDpAARRRFlVa1Yv7UIc3NScNGqPKxaNgMAcOma2ThnyXSsfXc/DhfWyxxpYIVmzQEFoMoBFGZAexHgPuj/qao81hsIIiYHiIiIRnB93hzMiInF9z56D83Wgf4DC4/YUf/Mfpkjm5y8noEkjMvugsvuGvIYm8WO1JnJaKxolnz+uNQYaA0axCZHo2BnKcTPliBHzTKjWZB+vp6Ubsz73Swc+Hmh5GNLSRO6TQrOYNZqIQDwij5cmZOLFJMZdrcbl738PC6bMRPfX3YWcmLj5A6TJOJ2e7FhWzHe33gcRoMGSfFmOE9ruSkIApYvzMLyhVkormjGo89sRGlVq0wRB1qIJQeEKAhRjwG+dkA1C4IgQFTl+XmyAoLp/wIZHZ2GyQEiIqJRzE9Mwrs334K71n0AdasdDc+skzukSau3zeLXcdFJkZInB1JnJsPa04+Oxi40VrQgbVYyBIWA+tImzPpWJhpQI+l8AJB8IA0+ow9zr8lB4btlko8vFee/DkN9RzbcYbDKodvhwHtlJfjrnp2wOAe2QSxJScVNc/JR09ONK15+AavSM5FgNEKlUAz7n1JQQK1UIDs6BudnZkMQJmsH+dBg6bOjtrELdU1dqG3sQn1jN2obuzArOwH3/uAyqFSDi0w6nW58sKkAL793AJ1dVjx8z/VYtiBz1Hlmz0yG0aAN0GcRCkLpe1QFaJZA0J4NUXRBEAbajAqKCIjKTMBbM+LZQsTdELQrAx8mncLkABERkR/iDUa8dO2X8dDX/442uYOZxJpPtEGlVsLjHvlRtccp7aPs6fMz0FTdCnvf51sHGsqboVAIAwURFwbmaZzgFXDwB0WnCjCGKkthC5Z7F2Kn0C3JeLON0Sjul2asoRxqbhr08cGmRhxsaoRaocA0cyT21NfB5fP/a2h1eiZ+d+75yIyKljrUKcXj9aG5tffzBMBn/69r7EKPxT7kOXVNXbA73Lj/7iuh1ahgs7vwzoaj2La3AueeNQsatQr/d+fFfiUGAMDa78TRYvnbok4NHsBngejYBEF3weC3FLEjJwe0lwDGbwU0OjqTIIZ6BRwiIqIQ4rA58X8X/B6l+yrkDmXSSpuVjIbykVcFmGIi0NdlHdO4UYmRSM5OgFKphKWzD+ZYE3xeHwSFgLL9lSMmJGadlw3bA13wqaR9Kqe16lB7cXtYVFA3pEeh996l0AtKGHwKaN3AcfTB5nGPeawV73dAHW9E64XJKO/vkT7YANAolbhz8TLcuWQpdCr5umaEg75uK+rLmtBQ1oT60kbYVArss9jR0NIDj2d830NL52fgjz+/Gjv2V0KrUWHl0hkQALR3WZEU7/+e9C17yvCPZ7fC7fHC0meHNwy+98Zi25OvQUCv3GF8ThEDIfZ9CMqEUy+J7mKIndeMeJoQ9SQE3UUBDo5Ox+QAERHRGO1ffwT3XPFHucMICEEADCYDdBFaaA0aaHQaqLVqqDQqNFe2oKfdv2X/EzFnZQ6Kdo2+xD45OxHN1SPvG87KT4fBbEB7fQfa6jomFFf+dbno+FkjBIW0y8u1P4zCif3St0gMhvRfn4stCWMv1HhehwF1f9gMEcC0by5F7VnRqOkP/NeWFNLNkXjumuu5imAIr/zpHbz9+EfoaRt8c2qKNaFrzWx4xnjXMXtmMu6+40I8+/pu7DxQhcvOnYN7fnDZuOPz+UT8/rEPsftQNeyOsSe1wsG2J1+BgD65wzhFiP4PBO3qQa/5en4EONaPfF7sOxDUcwIZGg0htNewERERhSC71QGFxDeIoWJabhr6LTZ0NnWjqbIVNYX1qDhUjZI95UiZkRSUGBQK/y5PYlNGvzlzuzwo2lU64cQAABS8XYrk/2VI3nYw7pwoSccLprqHtiHHGDXm8yxpegCAAKDhfweg/M6nOLdSQKohQtoAA6DO0ovfb9sS8u0ng8nr8WLT2h3IWTbjjMQAAPR19mG2TjOmMW+/6Wz8+VfXIjbaiEiTHtdcMh//7+qlE4rz461F2LSrbNImBgaE0Nel4ZtnJAZETyXg+Hj0c5XSt46l0bHmABER0Rit+fJZSMpKwKPf/heqj8nTVi8QclfMROne4bdLFO8px7ScFNSXNQ17TESkAV6fb9De/bHqt9j8Os47Sl2CuNQYNIwQ63gc/k8hlsbmo/Ha0/7dvYDeagAEEXbz0Hunh+NcMrbjQ4pPROSLZVDdkAzPacUKFYKA2YYoxFXbUZypQJv983/XKp8VMRhIDpwcp/6JPdCrlTj37nOwNckZtE9hPLbVnsBla5/HzNhYzIiJxcyYgf9nRkVDo1SOPsAkUlfaiEdu/ydK91Xg7a7nhq0Z4iltBDLi/R63pd2C9z89DqVSQFpyNJ5/cw+uvHDemGLzen0oLG/CroNV2H2wCjUNod+Oc+JCJDmgmgvB9NMzXhatT2H0GLWAwJU5cmBygIiIaBxylkzHk/sfwpuPfIBn73sVPm8oVYgeH7V69MuCfosNOUuno+xA1anX9BE6ZM/LgMvhQtWxWvi8PkQlmBGbHAODSQcIAuxWB1RqBTQ6LdwuD0r2lg87R01hPXKWzUDZ/soRY6k6VoOY5Ch0NfcM+X5iZgI6GqW/GTjw5wIsjZ6LxnMHtgLo+vRovKobTrsFCdlx0D6nhHeU3n+iKJ6qft+R0QpTbAT6OsdWQyFUdG4/gbO/NAvbNb1QCALmGKIRV9mPzteOo7+mG/UAZt93PtpiPz8nRzSiUyVAPG2duej2ov6hbch+5hJU94fQvukhlHd1oryrc9BrSkHARdkz8OTlV0767ga2PjvWPvAm3nrso1MtSAt3lAxbu+PE4WosToqCoFR8ISuEgb1MnylSq2D/7GfpR5s/b++pUimQkRKDT7YXQ6dRISPtC19Mw/hwUwGeemn7sIUOJ68Q+F0kGCFE/e1Ud4KTRFEEFGYAagAjrN5QJk/6759QxeQAERHROKnUKtz8y2vhtLvw0gNvyh3OhPmT4Ohq7kFXcw8yZqfBGGWEz+NF1bFaFO0eXCOgp82CnmHaEipVSkxfkImqozWYe07uQN9rnw9utxdl+yvh8/pQfrAKeStmomSElQwuhxuJGfFnJAc0OjWy8jNQtKt09E96nA7dU4yFf8tD24ImxH6agGr7QO2DtuoOLHknH003Db2iRBRFpG3IQuOrrUi6Oxot+U2AEshck4aCtwMXb6C1/H4Lzv3OMnS8UQhbfQ9Or6DQ8o89MP9xGfrdLqxu1aH2j+sw0qX/tDYfqo2BjDgwvKKIj6sq8HpRAW6aO7an3OFCFEVsfnknnv75i+hqHtxxYt+6IyOeW7zu8Ijv629aeSo58EUejw9VdR2oquuA1+vDl69YjFc/OIjUxCikJUchJTEKqYmR0GoHCkU2tvQgYlK3KxxJEFcOCBEQjN8GBA0ADSBoB/6syoagyjjzcEGAYP4NROPtEK3/AuxvA/CcOS63FMiGBQmJiIgmyOP24Idn34OKQ9VyhzIhuctnoHTfyE/rpWIw6TF9YSZOHK+Dtaf/1OuzFmejsaIF/RYbBAHIW5GD4j0jFyfMnpeB6uMDN+PmWBOiEsyoK2kMaPwjUWvVmP5GEiwJg598q5xqRD4ePygJkH9tDuzfsSB6axwOPFQQ7FCDKut3F8FxrBnN7xSOemzcOVnYd0NiEKIKjAi1Butv+RpSTf5X0Q8GURThdrrhtLvgtDnhsA38/+THzs8+nr4wCzaLDdbufvR196O/px/WnoE/F+woHrZgaGJGPFpr28cdn+bGs9E7wnYhpULAG0/dgcMFdfjva7vRfFp9g7iYCKQlRSElKQqpiVF479NjaOsIneJ8wbDtyechIEjbcox3QjHE1gF/iZ56iH0PAs7Ng9/QXwdF5EMTDI7Gg8kBIiIiCdSWNOB7i38OVxgXujr5NF9u8dNiodaq0VTZAgDIWz4TJSO0jkyZkYTWmjakTE+C3eoIyFaCscq9cDp6H2iDIAjQ9ekRuzcBDS+1obnszO4KBrMeLocbHtcQT9AmEaPZABEibH4s8xYBuJ6+CA228L2xWzktHS9cc4Nsy6M9bg92v3cA1cdr8dHTG+Hod8Bpc/lVSPGpIw/D4/LggRsfndDN/lgpbzwb1lFqiXzl6qVoauvF1j3Db02ayrY9+SyEkZbsS0XQQ4jfAkERM6FhhmprKJh/C8Hw1QmNS+PDbgVEREQSyMhLw+1/Cu+LmVBJbLTXd6KjsQv5q/NgNBvQPUT18y9qqmyBKAL1ZU0hkRgAgNKNVch6byZM98Sj5tJ2HLivYMjEAADYLPZJnxgABupVxKb4dyMhAMje3hnWxf121dfhlcLjQZ+3s7kbu987gK2v7Ubushm4/NsXoqetF45+p1+JAbVGhXXPbMTRLUVnbBsINJ8f8b383gEcPD55CsFKL0jPffU3TTgxAABQ5QJC1OcfqxcA+psnPi6NC1cOEBERScTn8+EXFz+Ao5tHXzYdihIy4tEWxKeE/tDoNXDZXXKHMS75q/NQsL1E7jBGNC03Bb3tFliCUAxxzsqcYZejDyf5hnk4dK4Zdk94Jk+MajXWf/VrSDNHBnQeURTR2dSFnnYLjm8rhlqrRltdB9rrO1BX0oCKwyfGPKYpJgJ9XcEtkilevwIOH29NJmLbk/+FgJFXX0ycGkL8JghKadrb+rp/ADg3ANBBiHsPgipLknFp7FiQkIiISCIKhQK/eOEHePORD7B/3eERW/6FIkf/+NsPBkq4JgYAwO0I3RvamKQomOPMqCmsw8zF2QFPDhjNhnHVgWh+8zgW2vJQcEU8+tzh97XQ73bjFxs/wYvX3gBFALYXdDZ3Qx+hg1KlQGxKDN7/5wa88qd3JBk72IkBwL+VAzQyIRjdCvTXSZYYAABBexZETzGgu5KJAZlxWwEREZGE4lJicOcjX8P/Sh7H8xX/wPce+wYWXTQPak1o5+NVaiXSc1PlDmNSsXSF7n75xMwE1BQO9BRorh56u4NUZi2djtjUmHHfbLauK8Eii07iqIJnT0MdXi44Jtl4fd1WrP/vJvz8ovvxgxW/glY/0C5u59v7JEsMyCXQz7unhkAnWBQDHQqkpLsS8PVCUM+XdlwaM24rICIiCgK71Y7DGwuw76PD2LfucND38o4kLScFXo8XzVWBvUmcajQ6NZKzE1Fb3CB3KINkzE4bFNOsJdNRfrBK8nlmLZmOnrZetNV1THis1JvnY/sKvQRRycOgVmP9V76GaZHj217gsDmx94OD2PzKThxYfwSez4r2qbVqqNRK2K2ht+pnPOzXLAPY334CRGx/8pnATmH4KhTm30o6pOiphGj5AwTz/RBU6ZKOTWPD5AAREVGQiaKIyiMnTiUKyvZX+lUoTEpqrQpJWQmISohE0a4y+IboLU7SiEuLRXJ2Asr2V4ZE0ceMOdNQW1R/6uN5q/NwXOLaCJlzpqGholmyQotqsw72R1ajtt8iyXhyWJE6DS9d92W/theIoogOmw3HWptRuO44Nv3qbTj6g9SeTkb2a5fLHUJYUylFbP57gJIDigQI5vsA7cUB6cAhek4AynQIQvgWIZ0MmBwgIiKSWVtdO957cgPWPbMR1p7+gM0zfUEm1Fo1ult60FbXEfSExFSXs2wGyvZXyhpD1rx0nDheN+i1OWfnoGj36IUCBQHIys9ARJQRIkRYOvqGXBURlxIDl9MNS6e02yqMWTEwzUtGx5emodpuQaxWjxZ74L5fAmF2XDy+tmARrpqVC61KdSoJUN7VgcquTpR3dqKiqxOVXZ3ocQysBojUaDHjqXL0HG+WOfrAUigV6L9qqdxhhDWNWsTGxwKTHBDid0JQJgRkbGAgISZX20/6HJMDREREIcLe78DGF7bhnb+vC0gxw7nn5KJwZ6nk45J/Zp81Cx2NXTDFRKDqaI0sMRijjLD32QetFNEZtUjKTEDNF1YTnC51ZjIUCuGMr8vopCikzUyGIAjweX1wOVxoq+9AT1vgnvAnXJKDvuJW2Ot7oE0wImZVNlSz42FP1qFF7UG9rS/kC9vF6vXIio4ZlAQYyRq7GQ2/+iQIkclr9mULcUyvgSe0//lCll4rYsOjAUgOKKdDEb9e+nEp5DA5QEREFGJ8Ph8ObjiGd/7+EQ5ukK6Q2YyFWag8MvaWZiS92WfPQvHuclnmnr4g84zkhC5Ch8T0uCFXAuSvno2iXaVhs/VEZdIg8s8XYr+rS+5QJLPaFYnGn2+QO4ygSJ+XgY68NHSOY0tKik4Dg1KAIAIKAVCIQLvXhw6n/Nt5gsGoF7H+rwFIDuhvgiLyAenHpZAT2qWTiYiIpiCFQoFlly3EsssWora4Hu/+Yz0KdpSgobwZXs/463n3tIfvfu3Jprm6DWqtCm5n8Nsd6k1nFvZzWB1or+/EtNxU1Jd+3nJwxsJMFGwvDmZ4E+bpc6HnZ58i9/ELUdofOoU/J8KrnToNxuqO18LU2IVZly5EuW1sdRb0hyrRWH7m9ousGUmIzU1Ff5QBJVbnpC16qAzQl4mgWRaYgSnkcOUAERFRmPC4PWisaEZtcQNqixtQVzLw//rSxlPVy4ejUCoAUYTPx1/7oSJ/dR4KJCgEKAhAZJwZKq0Kao0aKo0Sao0aCpUCXU3d6GrpGXR8VEIketp6hxzLYNYjJjkaDWVN0OjUiIwzo72hc8IxyiH52rnYuSZC7jAkEaHWIPOPx2BvHPrfbTJSKATk3XAWDro8/t3MiyKiNx6HY5TODdlLpqNjZjJaQ6A4qNSiTCLef0jilQP6L0MwPwBBmDoJqqmMyQEiIqIwZ+93YN+Hh7DtjT3Yv+7wkBXxE9LjJGkpR9LRGbWYuXg67H021BY3DLmKwGg2wOv1jlipPn9VHgp2DJ1kyJw7DXUljWdsCUjPS0VdSeOQ50REGREZb0ZMcpQkyQu5xJ8/A3uvipM7DMmc441C890fB2x8QQBC8a4ge+l09M9KQY3NNeJxRpUSvjd2+zWmRq/BjCuX4LDbAxGTZxVBTKSId//oZ3JAMALaiwDnp4A4TGFP/VcgmH/DxMAUwuQAERHRJGLrs2PvBwex9fXdOPjxUbg/27c7c1EWKg4P1BtY8aXF+MnT34HH7UVbXQdK9pTjpQfehK3PLmfoU5pKo0J6XioMJj3cTjesPf3obumFrc+OpKwE2Cz2Iav/5y6fgdJ9I3dAmLVkOqqP18Lj8gwkJBZlo3Bn6YjdKiKijLCdVrgw3EQvTsPBW9PkDkMyyzQx6PzeOsnH1eo1mLEwC3Wljciam462una01LRLPs9E5Z47By3J0Wge5ol/ul6D9pd3jGnMaXOnwTQtDoJaCSiVgEoBUSHApVKiYJRkRCiKjxHx1gOjJAcUMRAMXwMMX4GgiITobYTYey/g2jX4OMNtEEz3sIPAFMPkABER0SRl7enHnvcPYuvru+Cyu1C8pxx3PHwbrvreJWdc8HU0deGfP34WO97cK1O0NJLk6Yno7+mHpdN66rWE9Dj0dVth7xu92n32/AxodGq01XWgq7kngJGGjqQrZ2PXBWa5w5DMuR161P9hi+Tjzj5rFor3DC6OmTl3GkwxEfB6vOjrtKK1tn3IFUnBplAqEJkQCeDznQYnf5Z5XB70SlRXJWl6Ek7My5BkrGBKihXx+v0jJwcE0y8gGG8f9JooioD9LYh9fwLEPkB3BYTIR5kYmIJYkJCIiGiSiogy4qLb1uCi29ZAFEW4nW5odJohj41LicFvXr8b+z46hH98/79orQ29J4dTWXNVK1KmJyI9Lw3Vx2oRnRQJp93tV2IAAKqP1QY4wtCiNutQd2UqYDtztUW4ch1uCci4yiGq2NUUDm5rKQgCzLERg5JTwZC7fAY0Wg1K9pXD7fRA9PnQ12EZtcbKxIXns1NB4c/N/JmfmyAIgOEGQHsORMtvIKjnMDEwRXEDCRER0RQgCMKwiYEvWn7FYjxT+CiWXrYwCFHRWDRVtaKrpRt2qwONFS3oCNNCgcEQ84fzUT+JEgMAIF6WhehFqZKP23lawcqhCAKCnhiYe04uyvZX4fj2YuQtnwWNXgNRBDxuL/JX5wV07nBdV63y585uhE9OUCZBiPo3oL9BuqAorDA5QERERIPojTr84vnvIy41Ru5Q6DRqjXrEWgEEpN2+FLt9XXKHIbk93i4cum0aop66HOa5SZKMaTDr0VQ5+ooEc5xJkvn8Nfec3EF1MY5vL4bL/nkNgILtJYiINgZsftEnQqEQTv0nCBj0X6hSKPz52TByHRFBECAooiSJh8IPtxUQERHRGSLjzPj1yz/Gz877LdsfhhBzbHBv0sKNaVY8ji42AK7huzuEMxHAIUcXlnx/MXDnRxMeL21WMsoPVo96nCk6Aj1t0uznH0lEtBHwiX4tj4+fFgtr9zBV9idIrVZi+xt3j/v80xN4X/zwjPfOPHmkDyFihPdFEYLmB6cPeNrHvP2j4fGrg4iIiIaUvyoPt/3uJjz3m1flDoU+01QVmH3nk0XUl3LQO0kTA1900NGJFRfMRPumigmNozPo/DpOb9JPaJ6RTMtJQXRiJBorW9DZ1A0AfrXQVGvUAYtpok7frz/4w0AvPQjdvxcKfdxWQERERMO6+VfXYMH5c+UOgwCk56WeunmioTX+cy/idQbJxlMrFEjUB275+kSU35AGx9MXIv3/Vo97jL5u/+oIqDXSPk9MmZGIeatnIyE9DvVlTTi+vWRMX9t6kw49bb0BW+IfylsHiAKJyQEiIiIallKpxC9f/CGi4idPS7hwFcl/g1H5HB7MrZNmG8wCfQzmPVuLmbbRC3nKoctpR6PNii2pLmieuQzp95yHiJnxfp+vUitRX9bk17Eup3RtDGefnYOmylYc316MtrqOcY1h73Ogra4DgkKBmYuyJYuNaKpjcoCIiIhGFJscjV+/8mOYAlgAjEbndnrkDiEsND6+C7G68S+DT9ZHYM1RDyzfWYeeI41QOkcu4BYKSvq7sSXejuN3TUfM8nS/zknLSYHH5d/XVG+7NPUGDGY9ult7JBkLAHxeHyoOV2PGwkzJxgTO3BZANFUwOUBERESjWnh+Pv5b/BjOvelsKFVKJgooZHn7XZjXOLabu0X6GJzbbcSaUsD00+1oeO4gBAAqkwbNseFzoygC0Hxljl/HmmL8L27Z0djlV5HAkSRlxiMi2ojmqtYJjTMUrZ+1E/zG5ABNUSxISERERH6JTozCPa/8BKIowufz4deXPYjDGwvkDovoDE2P7UTMX85Gl9Mx4nECgDXdRtT9eB16h3g/5o8XYk9/eLVFPKzsQ1aCEc624Sv5x6XGoL3e/yX9Pq8PCelx494GMHNxNhrKm2DvG/nfg4jkxZUDRERENCaCIECpVOJXa3+E+LRYucMhOoOnz4X5rcoRjzGq1Vh12I36328atn68antDwGvLS83u8SDhrrOGfT93+UzYLHa0nGgb07jjrXmRvzoPlYdPBDQxIPW/ERcO0FTF5AARERGNS1R8JO59/adQqUe+CSNpKFX8ex6L5sd2I9UQMeg1tUKB6cZInKWKwZy1dWh84dCIYzS9cRyrnZGBDDMgdkbbkHLzgkGvqbUqzD0nF6X7KmDrs495zN52C+aszMHcc3L9Ol6tVSFvxSwUbC+BKEpTJHJYEt/Ms+YATVWCGPDvViIiIprMGiqa8dIDb2Dz2p2BvwmYwmKSo9Dfa4PT5pI7lLAhCkDy1XOgzoqG/WgzuvbUwucYW2FHQSVA/a9LUdIfXm0kz+00oP6Bzac+nr4gE1VHayQZO2fpdJQdqBr2/ejESERER6C+tFGS+UaTlJWAhGmxsHRZ0VDWBI/bO6HxMman4T+Ff5MoOqLwweQAERERSaK2pAEv3f8Gtr62W+5QJq38VXko2FEidxhTjjkvEVU/yIXF5ZQ7FL+ds9OG5jePAwCy8tNxoqBOsrET0uPQ2dQFr+fMTg6Zc6ahu7UHvR19ks03Fiq1EmmzUuD1eP1u1Xi6zDnT8EzBoxJHRhT6uK2AiIiIJJGRl4Z7XvkJnj72V5xz3XK5w5mUCneWYFpuqtxhTDmWklYsPGiTO4wx6b04DSqTBgCg1khbg7ytrgNzzs454/U5K3PQUN4kW2IAADxuL2qK6hGVMIHtINxVQFMUkwNEREQkqaz8DPz2zZ/hX4f+ghVXLpY7nElFFAFzTMToB5LkGv53ACsRLXcYfiuwdUH96AVIX5iB8kPVko9ffqgauctnAgAEhYD8VXko2lU24SX9Uulo7EL+qjwkZcbLHQpR2OC2AiIiIgqo0v0V+OePn0XJ3gq5Q5kUZi2djvIR9ntT4CgNangfPx9V/UM1PgxN5x7zov7ZAwEbf8bCLIiiKFk9A6lpDRqYoiLQ0eR/S8qs/HQ8feyRAEZFFJq4coCIiIgCKnfZTPzmjbuhj9DJHcqk4LKzIKFcvDY3VD/dgrM+6sQqT5Tc4Ywq1xiNugAmBgCg8siJkE0MAIDT5kJCRtyYzmG3ApqqmBwgIiKigItLjcVtv7tR7jAmBbs1cP3iaXSePhfaPq1Az9/3hvTW9FxjNIz/PB7SMQaLz8eF0kT+kLY6CREREdEwrvnBZeho7MKmtTvQ0xY+y7JDjbUnvArjTVa2uh7MMkahrL9H7lAGMarVWFqvQN2f18PNe2Jkz89A6b4ztzQplApo9RpodGpo9BpodJpTH2fOmSZDpETyY80BIiIiCiqvx4vDG49j40vbseud/XBymfyY5Sydjrb6TnS39MgdypSWfvcq1OUa0Odzo8flhMsrbzG+RfoY+B45gL7ydlnjCCVzV+Xizr9+DdGJkYOSAEqVUu7QiEIOkwNEREQkG1ufHbve2Y+Na7fj6KYCLv8dA51Ri5mLslG4sxS8nJOfCEAbqYc+LRLaZBPUCRFQxuoBsxY+kxoevQourQC70od++NDndaHX5YTb55vw3LE6PeYe6kf9M/u5jWAISZnxuPf1u5GzZLrcoRCFNCYHiIiIKCR0NHVhyyu7sGnt9pAucBZq0vNS4fX40FjRLHcoNEYiAG2sAYbUSGiSTFBF6qAwaSEY1YBBDUGvgk+rhFergE+tgFsFuBWASyHCCR8cohcZTg16HtgGZ1u/3J9OSFOqlDDFRMDtdOOOv9yKy799odwhEYUcJgeIiIgo5JworMOml7Zj88s70d7QKXc4IU9QCJi7MhdlB6vYzWCKMcVGoK/TKncYYcVg1uM/hX9DfFqs3KEQhRQmB4iIiChk+Xw+HN9WjI0vbseOt/bC1meXO6SQljl3GhrKm+FxeeQOhYIkNiUGnU1dcocRdlZ8aTHuf+8XbFtI9AVMDhAREVFYcNqd2PP+QWxauwMHPj4Kr0fe4m+hKm/FLJTsLZc7DAqSpOwEtFS3yR1GWPr1yz/GeTevlDsMopDB5AARERGFnZ72Xmx9bTc2rd0xZJuyqc4ca4Kls0/uMCjAVBoVkjIT0FDeJHcoYckUbcSN/3c1LrxtDeJSYuQOh0h2TA4QERFRWGsob8KmtTuwae0ONFe3yh2O7FJnJrM44RQRGW9Gb7tF7jDCnkanxvOVTzBBQFMekwNEREQ0KYiiiOI95dj88g5UHatBy4k2dDZ1yx1W0OWvykPBjhK5w6AgMEYa0N9rkzuMSeGq712CHzzxLbnDIJIVkwNEREQ0abkcLuz76DDefWI9jm8rljucoJi+IJOtIKcIjU4Nl8MtdxiTgkqtxHPl/0BiRrzcoRDJhskBIiIimhKqj9fi3X+sx4bntsDn9ckdTkBodGr4fCK7FUwBgkIAxIEVMySNGQuzcOtvv4zUGUko2VuBS795vtwhEQUVkwNEREQ0pbz4+zdwfHsRWk60oaWmXe5wJJU5dxpqCuvlDoMCLHPuNLjsLjRVscZGIJhjTchdPgO/ffNn0Og0codDFDRMDhAREdGU4nF70FLTDkuHBT9aea/c4UiK9QYmt4hoIzLy0lC0u0zuUKaEvBUzcd7N5yBn2QzMWJDJRAFNeiq5AyAiIiIKJpVahbSZyWhWKSbdnm2vxyt3CBRA+ggdEwNBVLK3AiV7B1qlKlVKXHnnxbjzb1+DUqmUOTKiwFDIHQARERGRHJKzEvFi9ZO47kdXQKNTyx3OhMWlxKD5RJvcYVAATdZaGeHA6/Hi3SfW4/4bHoHD5pQ7HKKA4LYCIiIimvI6m7vx2p/fxYf//hRuZ/itJJizMhdVx2rgsDrkDoUCKCkrAS1MAMlu9tk5eHjTb6HRhn9SkeiLmBwgIiIi+ozT7kR9aRNqiupRU1iH2uIG1BTWhWThwqz8dLidHng9XjRXszDdVJA2KwUN5U1yh0EAbv7ltbj9j1+ROwwiSTE5QERERDQKu9U+kCgoavgsaVCPmsJ6dDR2yRpXVn46ThTUyRoDBU/arGQ0lDfLHQYBUCgE/G3nHzB7xSy5QyGSDAsSEhEREY1CH6FH7rKZyF02c9Dr1p5+1BTVo7ZoIFlQ81nSoKetN+Ax5a2YiapjtQGfh0LDzMXZqDhULXcY9BmfT0Tl4RNMDtCkwuQAERER0ThFRBkxd2Uu5q7MHfR6T3svagrrse313dj44nbJC5jNWz0bx7cXSzomhS6VRhWUhBONTW+HBf29/TBGGuUOhUgS3FZAREREFEDWnn588vxWvP/PDWisGFgSHpMUhZjkaFQeOTGmsbR6DTLmTEP5wapAhEohismg0PVy3VOIT4uVOwwiSTA5QERERBQEPp8PhzcWQKlSYN6a2fC6vbjv6j/j8KfH/R4jdWbyqQQDTQ3x02LR3doLj8sjdyh0Gq1eg0e2/h45S2fIHQqRJJgcICIiIpKJw+bEvV/6E45tLfLr+JTpiWiqYmeCqSQ2JRqdTd1yh0HDWHPjWVjxpSUQRRELL8hHXEqM3CERjRuTA0REREQyslvt+NVlD6JoV9mox7LP/dQ0Y2HWmLegUPAplAp8+e4r8a2HbpE7FKJxUcgdABEREdFUpo/Q48GPfo3c5TNHPZbPdEKTIAi4+q5LYTDrAzK+RqcOyLgkLZ/Xh09f3I5nfvESPvjXBnQ0dsodEtGYcOUAERERUQiw9vTj5xf+HhWHP39CPC03BVEJkfC6fbD29qO9vgP2PoeMUdLpYpKi8MuXfoiF5+ejcGcJfnnJH+C0uySdQ6VRQaNTw2axSzouBdaNP7sK3/7LrXKHQeQ3rhwgIiIiCgERUUY89Ml9yJ6XAQDIXz0bjRUtKNheguI9ZagrbmBiIMQsumgenjryMBaenw8AmHtOHu57424oVUoAgD5Chzsevg2zz86Z0DwelwfT52dONFwKosg4ExZfskDuMIjGhCsHiIiIiEJIT3sv1v7hLXz41CfwuL1yh0NDUCgV+Pr9N+OmX1wNhWLws7Z+iw13LvgZvB4fHvjgl5g+PxOiKOLwxuO454o/wesZ37/ptNxU1Jc2ShE+BUFiRjz+efDPMMea5A6FyG9MDhARERGFoN4OC7a8sgufvLAVFYeq5Q6HPmMw6/GbN+7G4ovmn/FeR1MXPvjnBhz85Bjuf+8XiE2OPvXe249/hH/95LlBx0fGmXDZ7RdApVHhpQfeHHVudi4ID2qtGo/tfACzFk+XOxSiMWFygIiIiCjE1RTVo3R/JepLGlBX1oj60iY0V7XA5+NlnFwi40xISI9DUlYCVl6zHOl5qehp68WMhVnQm/TQGbQABopIbn1tN/52x1OwWwdvC8ldNgP/2PsnAMDbj32Ef/30uWHni0qIRG+7hUUpw8C5N6/Er9f+CIIgyB0K0ZgwOUBEREQUhlxON5qrWlBX2oT60kZUHqnGjrf2yR3WlBURZURsSjRiU2Nww0++hKWXLkTxnjI8dffzKNlbMeQ5cakxeKX+36c+3vDcFmx8aTuKd5dBFIELvroKdqsd217fg/xVeSjYURKsT4cmYObibDy5/yEmByjsqOQOgIiIiIjGTqNVI2P2NKTMSIJWr0FflxWZc6ehprBe7tAmpdt+eyNu+sXV8Li98Lg88Lg98Lg8cLs8n7/22Z+1Bg28Hi8ExUBtArvVAVufHQ6rA/0WO9rrO9BS04a22g786ZbHcdX3LkViZjzOuXYZLvn6eXA5XHDaXTBFR8ButaPiUDV62nrl/isgPyVnJ8Lj9kCtYQtKCi9cOUBEREQ0CVg6+/DBU5/gvSfWo7uVN5JSiEmKwhV3XIRZS6Yjf1UujJFGyedwOd3Y+fY+FO4owe73D8DR78S03FTc9/pPkTAtDgBQsq8CPz7nXvi8PsnnJ+mptWo8V/73U/9+ROGCyQEiIiKiScTlcGHT2h1445EPWN1+As7/yjm46+/fhDkmeNXm68sa8dHTG/HJ81sRFW/GV+65HgvOn4u4lBhYOvtwZFMBDn5yDIc+OYb2hs6gxUVjc/m3LsCPnrrjjE4WRKGOyQEiIiKiScjn82H/uiN445H3cXxbsdzhhI2oeDN++K87sOq65bLF4HK4sPPtffjw6U9RsL0E03JTcfVdl+Lquy4FMFDksL6sCa/95V188txW2eKUmynaiKTsRGkGk/CWKHNuOn76zJ1QqbmDm8ILkwNEREREk9xj3/k3Pnpmo9xhhDyDSY/nK/+BqPhIuUM5pbakAeuf2YhPXtiGi25dg+88ctupJ9L2fge+mfsjdDR2yRylPP64/h4svWSB3GEQTRpc60JEREQ0yS26aB70ETq5wwh5Cy/MD6nEAABk5KXhzke/jlcb/o2Zi7Px3hMfw+VwoexAJZw2J3KXz5Q7RFmsvGYpEwNEEuPKASIiIqIpoKOxE//66fPY8eZe8PJvsKTMeFzzg8txzQ8vg1KplDucUXm9XpQfrMaj3/7XlOxOodGp8Z+ivyE5S6ItBUQEgMkBIiIioinF6/Git8OCrpYedLf0oKulB13NPehq6UZ3a8+g120Wu9zhBkzu8pk468olOOuqJcicMy0se9J73B689beP8NL9b8Bhc8odTtDc9tsbcetvvyx3GESTDpMDRERERDQkh82J7tbPkwUn/19b0oBdb++Dzxc+l5EanRqLLpqHs65cihVfWoSYpGi5Q5JMa207nvzR/7Dn/YNyhxJwSZnx+E/R36DVa+UOhWjSYXKAiIiIiMastrgez//2Nex4a5/coQwrOjESK740sDpg4QX50Bkm9w3l7vcP4Mkf/g9tdR1yhxIwv3/n5zj76qVyh0E0KTE5QERERETjVnG4Gs/e9yoOrD8idygAgMy50z7bLrAUOUunT7le8/Z+B9Y+8CbefPRDeD1eucOR1NJLF+DBj34dlltAiMIBkwNERERENGGFu0rx7L2v4Pi24qDPbYo24oa7r8J5N69EslR978PcicI6/OOu/6BgR4ncoUhCpVbimYJHkTYrRe5QiCYtJgeIiIiISBKiKOLwxuN49t5XUHagKuDzafUaXPvDy3HTL65BRJQx4POFG1EU8cnzW/HMz19Eb0ef3OFMyE0/vxrfeugWucMgmtSYHCAiIiIiSYmiiN3vHcBzv3k1IK32FEoFLrv9AtzymxsQlxIj+fiTTW+HBX+65e849MkxuUMZl9iUaDxb+jj0EXq5QyGa1JgcICIiIqKA8Hq9KDtQhaJdZSjaXYqiXWXoaeud0JhrbjwLX7//Zi4vHyOv14vn7nsNrz70jtyhjNmvX/4xzrt5pdxhEE16TA4QERERUVCIooimqpaBZMGuUhTtLkNtccOp9+eek4vbfncjlColFEoFFEoFlJ/9X6FUwBhpQFJmgoyfQfjb8fY+PPz1J2C3OuQOxS/z1szGXzf/jkUIiYKAyQEiIiIiko2lqw8le8pRur8S1/7ocphjTHKHNOnVljTg99c9jPqyJrlDGZFCqcBTh/+CrPwMuUMhmhKYHCAiIiIimmL6LTY8/PUnsOvdA3KHMqxrf3g5vvfYN+QOg2jKYHKAiIiIiGgK8vl8eO3P7+HZe19BqN0SRCVE4tnSx9mFgiiIFHIHQEREREREwadQKPD/fnUtHlz3a5iiQ+sm/FsPfZWJAaIgY3KAiIiIiGgKW3rJAjx54M/Inh8ae/vzVszERbetkTsMoimHyQEiIiIioikuOTsRj+96EGdfvVTWOARBwPf/cTsUCt6mEAUbv+uIiIiIiAg6gxb3vvYTrLhysWwxXP6tCzBr8XTZ5ieayliQkIiIiIiITnE53fjddQ/jwPojQZ3XFG3Es2V/R2ScOajzEtEArhwgIiIiIqJTNFo1fvfWz7DoonlBnfcbf/h/TAwQyYjJASIiIiIiGkSj0+D37/wcC86bE5T5pi/IxOV3XBiUuYhoaEwOEBERERHRGXQGLe5//5fIX50X8Lm+/4/boVQqAz4PEQ2PyQEiIiIiIhqS3qjDHz74FeaszAnYHBfcsgpzV+YGbHwi8g+TA0RERERENCyDSY8/f3IfvnrP9VCppX+6X1NYD4fNKfm4RDQ27FZARERERER+qS1pwOPffRr2Pgfa6jpg6eyTZNwLb12Nnz/3fQiCIMl4RDR2TA4QEREREZHfRFFEXUkDRBHY8dZevPC71yUZ9/v/uB1X33WpJGMR0dgxOUBERERERGPi9Xjxk9X3QavXoLa4Ad2tvRMeU6lS4q9bfsf6A0QyYc0BIiIiIiIaE6VKiV+++ENUH6+DSq2SZEyvx4sHvvwIOpq6JBmPiMaGyQEiIiIiIhqzlOlJ+POn90laTLCrpQeb1+6QbDwi8h+TA0RERERENC4zFmThL5/+BqZooyTjXfndS/Dln10lyVhENDZMDhARERER0bjNWJiFP0uQILjyzovxgyduZ8cCIpkwOUBERERERBMyc1E2HvrkPkREjT9BcM51y5kYIJIRkwNERERERDRhsxZPn1CCoKdt4h0PiGj8mBwgIiIiIiJJ5CyZjoc23AtjpGHM59r6HAGIiIj8xeQAERERERFJJmfpDDy04V4YzHq/z5m5OBsX3bY6gFER0WiYHCAiIiIiIknlLpuJhzbc53eC4HuPfQNavTbAURHRSJgcICIiIiIiyeUtn4k/fXwvDKbREwStNe1BiIiIRsLkABERERERBcTsFbPwp4/vgT5CN+JxVUdPBCkiIhoOkwNERERERBQws8/KwZ8+vnfEBEHVsZrgBUREQ2JygIiIiIiIAmrO2Tn44/p7oDMOXVeg6mgNRFEMclRE9EVMDhARERERUcDNXZmLP64bOkHgtLngcXtkiIqITmJygIiIiIiIgiJ/VR4e/OjXZyQIVt2wAmqNWqaoiAhgcoCIiIiIiIJo3urZ+MOHv4LO8HmC4OKvnStfQEQEABBEbu4hIiIiIqIgO7a1CI9/7xl8+8+34Kwrl8gdDtGUx+QAERERERHJQhRFCIIgdxhEBG4rICIiIiIimTAxQBQ6mBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIprimBwgIiIiIiIimuKYHCAiIiIiIiKa4pgcICIiIiIiIpri/j+jQmQngm+JmwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 337, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot(column=\"PCGDP1940\", k=5, scheme=\"Quantiles\", legend=True)\n", + "ax.set_axis_off()\n", + "ax.set_title(\"PC GDP 1940\");\n", + "# plt.savefig(\"1940.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "------------------------------------------------\n", + "\n", + "### 2. Classic Gini Coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.985182Z", + "start_time": "2023-01-17T02:01:02.978350Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.3537237117345285" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gini_1940 = inequality.gini.Gini(gdf[\"PCGDP1940\"])\n", + "gini_1940.g" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.993505Z", + "start_time": "2023-01-17T02:01:02.988524Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "range(1940, 2010, 10)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "decades = range(1940, 2010, 10)\n", + "decades" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.010083Z", + "start_time": "2023-01-17T02:01:02.996515Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.3537237117345285,\n", + " 0.29644613439022827,\n", + " 0.2537183285655905,\n", + " 0.25513356494927303,\n", + " 0.24505338049421577,\n", + " 0.25181825879538217,\n", + " 0.2581130824882791]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", + "ginis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------------------------------------\n", + "\n", + "### 3. Spatial Gini Coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.023820Z", + "start_time": "2023-01-17T02:01:03.017957Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "inequality.gini.Gini_Spatial" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inequality.gini.Gini_Spatial" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.029897Z", + "start_time": "2023-01-17T02:01:03.026482Z" + } + }, + "outputs": [], + "source": [ + "regimes = gdf[\"HANSON98\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.038550Z", + "start_time": "2023-01-17T02:01:03.032955Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w = libpysal.weights.block_weights(regimes, silence_warnings=True)\n", + "w" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.201808Z", + "start_time": "2023-01-17T02:01:03.041647Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 337, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot(column=\"HANSON98\", categorical=True)\n", + "ax.set_title(\"Regions\")\n", + "ax.set_axis_off()\n", + "# plt.savefig(\"regions.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.234210Z", + "start_time": "2023-01-17T02:01:03.204552Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.01" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.random.seed(12345)\n", + "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], w)\n", + "gs.p_sim" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.388274Z", + "start_time": "2023-01-17T02:01:03.237277Z" + } + }, + "outputs": [], + "source": [ + "gs_all = [\n", + " inequality.gini.Gini_Spatial(gdf[\"PCGDP%s\" % decade], w) for decade in decades\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.396504Z", + "start_time": "2023-01-17T02:01:03.391373Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.04, 0.01, 0.01, 0.01, 0.02, 0.01, 0.01]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_values = [gs.p_sim for gs in gs_all]\n", + "p_values" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.404200Z", + "start_time": "2023-01-17T02:01:03.399458Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.2940179879590452,\n", + " 0.24885041274552472,\n", + " 0.21715641601961586,\n", + " 0.2212882581200239,\n", + " 0.20702733316567423,\n", + " 0.21270360014540865,\n", + " 0.2190953550725723]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wgs = [gs.wcg_share for gs in gs_all]\n", + "wgs" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.412352Z", + "start_time": "2023-01-17T02:01:03.407034Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.7059820120409548,\n", + " 0.7511495872544753,\n", + " 0.7828435839803841,\n", + " 0.778711741879976,\n", + " 0.7929726668343258,\n", + " 0.7872963998545913,\n", + " 0.7809046449274277]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bgs = [1 - wg for wg in wgs]\n", + "bgs" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.419153Z", + "start_time": "2023-01-17T02:01:03.414765Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1940, 1950, 1960, 1970, 1980, 1990, 2000])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "years = numpy.array(decades)\n", + "years" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.733573Z", + "start_time": "2023-01-17T02:01:03.421484Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 469, + "width": 629 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots()\n", + "t = years\n", + "s1 = ginis\n", + "ax1.plot(t, s1, \"b-\")\n", + "ax1.set_xlabel(\"Year\")\n", + "# Make the y-axis label, ticks and tick labels match the line color.\n", + "ax1.set_ylabel(\"Gini\", color=\"b\")\n", + "ax1.tick_params(\"y\", colors=\"b\")\n", + "\n", + "ax2 = ax1.twinx()\n", + "s2 = bgs\n", + "ax2.plot(t, s2, \"r-.\")\n", + "ax2.set_ylabel(\"Spatial Inequality Share\", color=\"r\")\n", + "ax2.tick_params(\"y\", colors=\"r\")\n", + "\n", + "fig.tight_layout()\n", + "\n", + "# plt.savefig(\"share.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "-----------------------" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/user-guide/measure/intro.rst b/docs/user-guide/measure/intro.rst new file mode 100644 index 00000000..720dbc5a --- /dev/null +++ b/docs/user-guide/measure/intro.rst @@ -0,0 +1,14 @@ +.. _measure: + +============================ +Measuring Spatial Inequality +============================ + +.. toctree:: + :maxdepth: 1 + + + Gini Index + Theil Index + Wolfson Index + diff --git a/docs/user-guide/measure/theil.ipynb b/docs/user-guide/measure/theil.ipynb new file mode 100644 index 00000000..5045a33a --- /dev/null +++ b/docs/user-guide/measure/theil.ipynb @@ -0,0 +1,848 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Demonstrating the Theil Index of Inequality:\n", + "## Spatial Inequality in Mexico: 1940-2000\n", + "\n", + "1. Imports & Input Data\n", + "2. Classic Theil Index\n", + "3. Theil Regional Inequality Decomposition\n", + "\n", + "-------------------------\n", + "\n", + "### Imports & Input Data" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:00:59.142457Z", + "start_time": "2023-01-17T02:00:59.104306Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The watermark extension is already loaded. To reload it, use:\n", + " %reload_ext watermark\n", + "Last updated: 2024-09-12T10:33:11.784894-07:00\n", + "\n", + "Python implementation: CPython\n", + "Python version : 3.12.4\n", + "IPython version : 8.26.0\n", + "\n", + "Compiler : GCC 12.3.0\n", + "OS : Linux\n", + "Release : 6.8.0-40-generic\n", + "Machine : x86_64\n", + "Processor : x86_64\n", + "CPU cores : 16\n", + "Architecture: 64bit\n", + "\n" + ] + } + ], + "source": [ + "%config InlineBackend.figure_format = \"retina\"\n", + "%load_ext watermark\n", + "%watermark" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.756177Z", + "start_time": "2023-01-17T02:00:59.145113Z" + } + }, + "outputs": [], + "source": [ + "import geopandas\n", + "import inequality\n", + "import libpysal\n", + "import matplotlib.pyplot as plt\n", + "import numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.770545Z", + "start_time": "2023-01-17T02:01:01.761777Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Watermark: 2.4.3\n", + "\n", + "matplotlib: 3.9.1\n", + "inequality: 0.1.dev212+g0df9cfc.d20240912\n", + "geopandas : 1.0.1\n", + "numpy : 2.0.1\n", + "libpysal : 4.12.0\n", + "\n" + ] + } + ], + "source": [ + "%watermark -w\n", + "%watermark -iv" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.776633Z", + "start_time": "2023-01-17T02:01:01.772340Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mexico\n", + "======\n", + "\n", + "Decennial per capita incomes of Mexican states 1940-2000\n", + "--------------------------------------------------------\n", + "\n", + "* mexico.csv: attribute data. (n=32, k=13)\n", + "* mexico.gal: spatial weights in GAL format.\n", + "* mexicojoin.shp: Polygon shapefile. (n=32)\n", + "\n", + "Data used in Rey, S.J. and M.L. Sastre Gutierrez. (2010) \"Interregional inequality dynamics in Mexico.\" Spatial Economic Analysis, 5: 277-298.\n", + "\n" + ] + } + ], + "source": [ + "libpysal.examples.explain(\"mexico\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.962407Z", + "start_time": "2023-01-17T02:01:01.779047Z" + } + }, + "outputs": [], + "source": [ + "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", + "gdf = geopandas.read_file(pth)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.103640Z", + "start_time": "2023-01-17T02:01:01.964971Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 316, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot(edgecolor='grey')\n", + "ax.set_axis_off()" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.138110Z", + "start_time": "2023-01-17T02:01:02.106331Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...GR9000LPCGDP40LPCGDP50LPCGDP60LPCGDP70LPCGDP80LPCGDP90LPCGDP00TESTgeometry
017.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...0.054.354.324.254.404.474.434.481.0MULTIPOLYGON (((-113.13972 29.01778, -113.2405...
127.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...0.003.984.204.224.394.464.414.422.0MULTIPOLYGON (((-111.20612 25.80278, -111.2302...
232.731957e+10MX18Nayarit1034770.3416.750785e+062731956.8594836.07515.07621.0...-0.053.683.883.884.044.134.114.063.0MULTIPOLYGON (((-106.62108 21.56531, -106.6475...
347.961008e+10MX14Jalisco2324727.4361.967200e+077961008.2855309.08232.09953.0...0.033.733.924.004.214.324.304.334.0POLYGON ((-101.5249 21.85664, -101.5883 21.772...
455.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...0.134.023.793.944.214.324.324.445.0POLYGON ((-101.8462 22.01176, -101.9653 21.883...
\n", + "

5 rows × 35 columns

\n", + "
" + ], + "text/plain": [ + " POLY_ID AREA CODE NAME PERIMETER \\\n", + "0 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", + "1 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", + "2 3 2.731957e+10 MX18 Nayarit 1034770.341 \n", + "3 4 7.961008e+10 MX14 Jalisco 2324727.436 \n", + "4 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", + "\n", + " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... GR9000 \\\n", + "0 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 0.05 \n", + "1 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 0.00 \n", + "2 6.750785e+06 2731956.859 4836.0 7515.0 7621.0 ... -0.05 \n", + "3 1.967200e+07 7961008.285 5309.0 8232.0 9953.0 ... 0.03 \n", + "4 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 0.13 \n", + "\n", + " LPCGDP40 LPCGDP50 LPCGDP60 LPCGDP70 LPCGDP80 LPCGDP90 LPCGDP00 TEST \\\n", + "0 4.35 4.32 4.25 4.40 4.47 4.43 4.48 1.0 \n", + "1 3.98 4.20 4.22 4.39 4.46 4.41 4.42 2.0 \n", + "2 3.68 3.88 3.88 4.04 4.13 4.11 4.06 3.0 \n", + "3 3.73 3.92 4.00 4.21 4.32 4.30 4.33 4.0 \n", + "4 4.02 3.79 3.94 4.21 4.32 4.32 4.44 5.0 \n", + "\n", + " geometry \n", + "0 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", + "1 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", + "2 MULTIPOLYGON (((-106.62108 21.56531, -106.6475... \n", + "3 POLYGON ((-101.5249 21.85664, -101.5883 21.772... \n", + "4 POLYGON ((-101.8462 22.01176, -101.9653 21.883... \n", + "\n", + "[5 rows x 35 columns]" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.975365Z", + "start_time": "2023-01-17T02:01:02.141021Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 337, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot(column=\"PCGDP1960\", k=5, scheme=\"Quantiles\", \n", + " edgecolor='grey',legend=True)\n", + "ax.set_axis_off()\n", + "ax.set_title(\"PC GDP 1960\");\n", + "# plt.savefig(\"1940.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "------------------------------------------------\n", + "\n", + "### Classic Theil Coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.985182Z", + "start_time": "2023-01-17T02:01:02.978350Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.1047294148824586" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "theil_1940 = inequality.theil.Theil(gdf[\"PCGDP1960\"])\n", + "theil_1940.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------------------------------------\n", + "\n", + "### Theil Regional Inequality Decomposition" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.023820Z", + "start_time": "2023-01-17T02:01:03.017957Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "inequality.theil.TheilD" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inequality.theil.TheilD" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.029897Z", + "start_time": "2023-01-17T02:01:03.026482Z" + } + }, + "outputs": [], + "source": [ + "regimes = gdf[\"HANSON98\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.201808Z", + "start_time": "2023-01-17T02:01:03.041647Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 337, + "width": 515 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = gdf.plot(column=\"HANSON98\", categorical=True,\n", + " edgecolor='grey')\n", + "ax.set_title(\"Regions\")\n", + "ax.set_axis_off()\n", + "# plt.savefig(\"regions.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.234210Z", + "start_time": "2023-01-17T02:01:03.204552Z" + } + }, + "outputs": [], + "source": [ + "numpy.random.seed(12345)\n", + "ts = inequality.theil.TheilD(gdf['PCGDP1960'], regimes)" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.1047294148824586" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts.T" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.05260921])" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts.bg" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.0521202])" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts.wg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A measure of *spatial polarization* is obtained as the ratio of the `bg` component to overall inequality `T`:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.50233466])" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts.bg[0] / ts.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In other words, inequality between the regions accounts for just over 50 percent of overall inequality between the states in Mexico in 1969.\n", + "\n", + "This leads to a question of how to interpret this polarization measure. One way to answer this, is to compare this value against that obtained from a random distribution. That is, does the assignment of states to the regions actually matter?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inference on inequality decomposition" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We address the inference question by randomly assigning states to the regions. This is done though a random permutation of the 32 states. We repeat this random permutation a large number of times, and for each random permutation we calculate the decomposition. Since the random permutations are the counterfactuals where state incomes were random in space, this gives us a distribution of the between group (region) component under the null.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.random.seed(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "ts = inequality.theil.TheilDSim(gdf['PCGDP1960'], regimes, permutations=999)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.001])" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts.bg_pvalue" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The p-value is a pseudo p-value obtained as the share of all realizations (including the observed realization) that generated `bg` values as large as the one observed. Since we asked for 999 permutations, our p-value indicates that none of the counterfactual realizations generated values as large as what we observed. " + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sbn" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 432, + "width": 562 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "kdeplot = sbn.kdeplot(ts.bg, fill=False, legend=False)\n", + "x_vals = kdeplot.lines[0].get_xdata()\n", + "y_vals = kdeplot.lines[0].get_ydata()\n", + "plt.fill_between(x_vals, y_vals, where=(x_vals > ts.bg[0]), color='red')\n", + "plt.xlabel('Between Regions Inequality 1960');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "-----------------------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dynamics of Regional Inequality" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:02.993505Z", + "start_time": "2023-01-17T02:01:02.988524Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.20894344230358594,\n", + " 0.1522245052653123,\n", + " 0.1047294148824586,\n", + " 0.10194724969688372,\n", + " 0.09560112758525613,\n", + " 0.10511256397981851,\n", + " 0.10660832349588023]" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "decades = range(1940, 2010, 10)\n", + "decades\n", + "\n", + "ts = [inequality.theil.Theil(gdf[\"PCGDP%s\" % decade]).T for decade in decades]\n", + "ts" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/user-guide/measure/wolfson.ipynb b/docs/user-guide/measure/wolfson.ipynb new file mode 100644 index 00000000..29f2d17c --- /dev/null +++ b/docs/user-guide/measure/wolfson.ipynb @@ -0,0 +1,145 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "55aba049-984e-4563-9bb6-8292f2c92a22", + "metadata": {}, + "source": [ + "# Demonstrating the Wolfson Bipolarization Coefficient:\n", + "\n", + "\n", + "-------------------------\n", + "\n", + "### 1. Imports & Input Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "64243a0a-7c9b-424d-940b-86004ab8c0d1", + "metadata": {}, + "outputs": [], + "source": [ + "from inequality.wolfson import wolfson\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "76fe1f4d-ba15-468f-8334-23777b611cac", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "# Distribution 1: Low polarization (normal distribution)\n", + "income_low_polarization = np.random.normal(loc=50000, scale=15000, size=10000)\n", + "\n", + "# Distribution 2: High polarization (bimodal distribution)\n", + "income_high_polarization = np.concatenate([\n", + " np.random.normal(loc=30000, scale=5000, size=5000),\n", + " np.random.normal(loc=70000, scale=5000, size=5000)\n", + "])\n", + "\n", + "# Plotting the distributions\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "# Plot for low polarization\n", + "plt.subplot(1, 2, 1)\n", + "plt.hist(income_low_polarization, bins=50, color='blue', alpha=0.7)\n", + "plt.title('Low Polarization Income Distribution')\n", + "plt.xlabel('Income')\n", + "plt.ylabel('Frequency')\n", + "\n", + "# Plot for high polarization\n", + "plt.subplot(1, 2, 2)\n", + "plt.hist(income_high_polarization, bins=50, color='red', alpha=0.7)\n", + "plt.title('High Polarization Income Distribution')\n", + "plt.xlabel('Income')\n", + "plt.ylabel('Frequency')\n", + "\n", + "# Show plots\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4020946f-6f78-45e6-9d72-895de8807bc3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.17571224182763848)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(income_high_polarization)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6d105e2b-5549-425c-a594-37372d5fc75c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.07016937981819878)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(income_low_polarization)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/user-guide/measure/wolfson_spatial.ipynb b/docs/user-guide/measure/wolfson_spatial.ipynb new file mode 100644 index 00000000..afca7b0b --- /dev/null +++ b/docs/user-guide/measure/wolfson_spatial.ipynb @@ -0,0 +1,3079 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "55aba049-984e-4563-9bb6-8292f2c92a22", + "metadata": {}, + "source": [ + "# Demonstrating the Wolfson Bipolarization Coefficient:\n", + "\n", + "\n", + "-------------------------\n", + "\n", + "### 1. Imports & Input Data" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "64243a0a-7c9b-424d-940b-86004ab8c0d1", + "metadata": {}, + "outputs": [], + "source": [ + "from inequality.wolfson import wolfson\n" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "id": "76fe1f4d-ba15-468f-8334-23777b611cac", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "# Distribution 1: Low polarization (normal distribution)\n", + "income_low_polarization = np.random.normal(loc=50000, scale=15000, size=10000)\n", + "\n", + "# Distribution 2: High polarization (bimodal distribution)\n", + "income_high_polarization = np.concatenate([\n", + " np.random.normal(loc=30000, scale=5000, size=5000),\n", + " np.random.normal(loc=70000, scale=5000, size=5000)\n", + "])\n", + "\n", + "# Plotting the distributions\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "# Plot for low polarization\n", + "plt.subplot(1, 2, 1)\n", + "plt.hist(income_low_polarization, bins=50, color='blue', alpha=0.7)\n", + "plt.title('Low Polarization Income Distribution')\n", + "plt.xlabel('Income')\n", + "plt.ylabel('Frequency')\n", + "\n", + "# Plot for high polarization\n", + "plt.subplot(1, 2, 2)\n", + "plt.hist(income_high_polarization, bins=50, color='red', alpha=0.7)\n", + "plt.title('High Polarization Income Distribution')\n", + "plt.xlabel('Income')\n", + "plt.ylabel('Frequency')\n", + "\n", + "# Show plots\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "4020946f-6f78-45e6-9d72-895de8807bc3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.17571224182763848)" + ] + }, + "execution_count": 161, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(income_high_polarization)" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "id": "6d105e2b-5549-425c-a594-37372d5fc75c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.07016937981819878)" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(income_low_polarization)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3241b6ae-dd3a-4e76-a773-95c6f5b846ef", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "b3184d08-5e44-4983-a271-3e26f0f616bd", + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas\n", + "import inequality\n", + "import libpysal\n" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "id": "2d86fcfd-55eb-4380-a6ab-b1bcceceaaf1", + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:01.962407Z", + "start_time": "2023-01-17T02:01:01.779047Z" + } + }, + "outputs": [], + "source": [ + "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", + "gdf = geopandas.read_file(pth)" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "id": "d08c11c1-f788-41a5-98d8-1f9b5977bd81", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.11070986960431652)" + ] + }, + "execution_count": 165, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(gdf.PCGDP1960)" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "f4d889b2-36cc-49f3-bd72-8bb4d7da8c3e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2534197/4115592875.py:1: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", + " w = libpysal.weights.Queen.from_dataframe(gdf)\n" + ] + } + ], + "source": [ + "\n", + "w = libpysal.weights.Queen.from_dataframe(gdf)\n", + "w.transform = 'r'" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "id": "f49c6c0b-19a7-4cac-819e-1b50d7f033a4", + "metadata": {}, + "outputs": [], + "source": [ + "l60 = libpysal.weights.lag_spatial(w, gdf.PCGDP1960)" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "108d9217-c01d-4d02-837d-6de9a34f53c9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.07039175526018514)" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(l60)" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "6f3967c4-8cc4-4b60-8b1f-1e17e5d516ad", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "id": "e5e772f1-e5a7-4bb4-99e4-1654a8f5c8db", + "metadata": {}, + "outputs": [], + "source": [ + "r60 = np.random.permutation(gdf.PCGDP1960)" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "31ba5fa8-52cb-4afe-a71a-76934cd671aa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.05767316232696517)" + ] + }, + "execution_count": 171, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lr60 = libpysal.weights.lag_spatial(w, r60)\n", + "wolfson(lr60)" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "id": "4332eb63-a418-4542-b61e-5d520659cf75", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "bins=10\n", + "\n", + "# Plotting the distributions\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "# Plot for low polarization\n", + "plt.subplot(1, 2, 1)\n", + "plt.hist(gdf.PCGDP1960, bins=bins, color='blue', alpha=0.7)\n", + "plt.title('Income Distribution')\n", + "plt.xlabel('Income')\n", + "plt.ylabel('Frequency')\n", + "\n", + "# Plot for high polarization\n", + "plt.subplot(1, 2, 2)\n", + "plt.hist(l60, bins=bins, color='red', alpha=0.7)\n", + "plt.title('Spatial Lag Income Distribution')\n", + "plt.xlabel('Income')\n", + "plt.ylabel('Frequency')\n", + "\n", + "# Show plots\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "id": "90baa6a7-1110-4475-bfcc-b33a64d031d6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Generate two sets of random data\n", + "data1 = np.random.normal(0, 1, size=1000)\n", + "data2 = np.random.normal(2, 0.5, size=1000)\n", + "\n", + "# Set the same range for both KDE plots\n", + "common_range = (-3, 5)\n", + "\n", + "# Create the plot\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot the first KDE\n", + "sns.kdeplot(data1, label='Data 1', bw_adjust=0.5, clip=common_range)\n", + "\n", + "# Plot the second KDE\n", + "sns.kdeplot(data2, label='Data 2', bw_adjust=0.5, clip=common_range)\n", + "\n", + "# Add labels and title\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('KDE of Two Distributions Over the Same Range')\n", + "plt.legend()\n", + "\n", + "# Show the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "id": "51852c08-e7a5-46be-bf47-5fe6fbaa76fa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Generate two sets of random data\n", + "data1 = np.random.normal(0, 1, size=1000)\n", + "data2 = np.random.normal(2, 0.5, size=1000)\n", + "\n", + "# Set the same range for both KDE plots\n", + "y = gdf.PCGDP1960\n", + "common_range = (y.min() *.5, y.max())\n", + "\n", + "# Create the plot\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot the first KDE\n", + "sns.kdeplot(y, label='Observed', bw_adjust=0.5, clip=common_range)\n", + "\n", + "# Plot the second KDE\n", + "sns.kdeplot(l60, label='Spatial Lag', bw_adjust=0.5, clip=common_range)\n", + "\n", + "# Plot the random lag\n", + "sns.kdeplot(lr60, label='Spatial Lag (Random)', bw_adjust=0.5, clip=common_range)\n", + "\n", + "# Add labels and title\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('KDE of Three Distributions Over the Same Range')\n", + "plt.legend()\n", + "\n", + "# Show the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "id": "78aef533-2ad6-4b46-9bf3-9fd0c64bb076", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statistic: 0.196044921875, p-value: 0.2800978640494538\n" + ] + } + ], + "source": [ + "from scipy.stats import cramervonmises_2samp\n", + "\n", + "# Perform the Cramér-von Mises test\n", + "result = cramervonmises_2samp(l60, lr60)\n", + "print(f\"Statistic: {result.statistic}, p-value: {result.pvalue}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "id": "cffaf80d-02df-49dd-9cda-1901d7aded1d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statistic: -0.05261469967768734, p-value: 0.25\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2534197/3482703562.py:4: UserWarning: p-value capped: true value larger than 0.25. Consider specifying `method` (e.g. `method=stats.PermutationMethod()`.)\n", + " result = anderson_ksamp([l60, lr60])\n" + ] + } + ], + "source": [ + "from scipy.stats import anderson_ksamp\n", + "\n", + "# Perform the Anderson-Darling test\n", + "result = anderson_ksamp([l60, lr60])\n", + "print(f\"Statistic: {result.statistic}, p-value: {result.significance_level}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "id": "0bae35f6-865f-4416-b61f-008bf5a63526", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2534197/725806687.py:1: UserWarning: p-value capped: true value larger than 0.25. Consider specifying `method` (e.g. `method=stats.PermutationMethod()`.)\n", + " results = [anderson_ksamp([l60, libpysal.weights.lag_spatial(w, np.random.permutation(gdf.PCGDP1960))]) for i in range(99)]\n" + ] + } + ], + "source": [ + "results = [anderson_ksamp([l60, libpysal.weights.lag_spatial(w, np.random.permutation(gdf.PCGDP1960))]) for i in range(99)]" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "id": "aaf9c29e-1797-472a-9116-e5a8c5de5509", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Anderson_ksampResult(statistic=np.float64(0.6589920653729476), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.17652713244839607),\n", + " Anderson_ksampResult(statistic=np.float64(-0.34697170363520224), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.7007267012841933), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.16942821297845637),\n", + " Anderson_ksampResult(statistic=np.float64(0.4035584032053961), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.22725447554330247),\n", + " Anderson_ksampResult(statistic=np.float64(0.2780484965634238), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(1.8683704810168367), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.055134205150877004),\n", + " Anderson_ksampResult(statistic=np.float64(1.2469655114478362), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.09958961390750354),\n", + " Anderson_ksampResult(statistic=np.float64(0.7067324861420466), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1684312996840937),\n", + " Anderson_ksampResult(statistic=np.float64(0.11592853083147192), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(2.0333865163064724), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.04723398451863168),\n", + " Anderson_ksampResult(statistic=np.float64(-0.20903121842789757), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(1.085054660506413), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.11644621318761145),\n", + " Anderson_ksampResult(statistic=np.float64(0.7593864347578005), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1599475065483019),\n", + " Anderson_ksampResult(statistic=np.float64(0.5833021834141229), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.19019996927764632),\n", + " Anderson_ksampResult(statistic=np.float64(3.1742107372015806), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.016660129096606503),\n", + " Anderson_ksampResult(statistic=np.float64(0.36647777432413087), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.235788798880333),\n", + " Anderson_ksampResult(statistic=np.float64(0.6110174890064242), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1850701708742307),\n", + " Anderson_ksampResult(statistic=np.float64(1.2176360813517806), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.10244367505054722),\n", + " Anderson_ksampResult(statistic=np.float64(-0.6018524519181122), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(1.0636927180924765), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.11888205135355742),\n", + " Anderson_ksampResult(statistic=np.float64(-0.1960624985804575), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(2.861832014678324), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.022057525462241476),\n", + " Anderson_ksampResult(statistic=np.float64(1.2152615000589706), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.10267843551015848),\n", + " Anderson_ksampResult(statistic=np.float64(0.5724431239900444), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.19224988094003514),\n", + " Anderson_ksampResult(statistic=np.float64(-0.6476569345904948), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(1.4832296479641838), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.07940717524015867),\n", + " Anderson_ksampResult(statistic=np.float64(1.1884054212362711), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.10537278422420467),\n", + " Anderson_ksampResult(statistic=np.float64(1.3253739239381608), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.09235823423276689),\n", + " Anderson_ksampResult(statistic=np.float64(-0.7790760267649309), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.5326350540730636), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.20578211806890973), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.5597971873163465), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1946660241786323),\n", + " Anderson_ksampResult(statistic=np.float64(0.22543423025002296), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.48043578122094976), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.7977518563804589), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.13996800002570875), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(1.5535144405015517), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.07426277991400779),\n", + " Anderson_ksampResult(statistic=np.float64(1.3844842980708991), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.0872688165845278),\n", + " Anderson_ksampResult(statistic=np.float64(-0.28123025275724345), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.2550329852639916), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(2.0073728056876083), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.048396546760625984),\n", + " Anderson_ksampResult(statistic=np.float64(-0.2750600121179492), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.010850295765853488), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.13274487939863963), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.9512090762324987), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.13261051225873643),\n", + " Anderson_ksampResult(statistic=np.float64(-0.28636581408686024), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.3690838545026225), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.3984297392729227), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.2284155211233201),\n", + " Anderson_ksampResult(statistic=np.float64(-0.6260277299031528), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.8541439594398893), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.14577888769400463),\n", + " Anderson_ksampResult(statistic=np.float64(-0.8467974536037051), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.1705605761274296), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.4448369626593231), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.21812964636396412),\n", + " Anderson_ksampResult(statistic=np.float64(0.6723402530641444), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.17422367951475473),\n", + " Anderson_ksampResult(statistic=np.float64(-0.9852196721139579), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.5916393714077337), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.18864151678856184),\n", + " Anderson_ksampResult(statistic=np.float64(0.3687163477796152), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.2352642723040588),\n", + " Anderson_ksampResult(statistic=np.float64(0.7935148577646094), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1546865727777048),\n", + " Anderson_ksampResult(statistic=np.float64(0.36225911524755317), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.23678058301119323),\n", + " Anderson_ksampResult(statistic=np.float64(0.05211697031946774), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.44625767463085647), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.21782243948841373),\n", + " Anderson_ksampResult(statistic=np.float64(0.8494735126856523), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.14644575376587035),\n", + " Anderson_ksampResult(statistic=np.float64(0.05390367245731991), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.141833691382348), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.46873719592473606), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.2130208594913156),\n", + " Anderson_ksampResult(statistic=np.float64(-0.2890511480742549), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.2971292941433096), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.6969563041852672), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.39875697333723115), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.22834125731330776),\n", + " Anderson_ksampResult(statistic=np.float64(-0.23968496539063935), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(1.8685176053343069), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.0551265789876067),\n", + " Anderson_ksampResult(statistic=np.float64(-0.06057229957419835), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.3617881403799545), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.23689157473972228),\n", + " Anderson_ksampResult(statistic=np.float64(-0.42038155652396053), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.6044322197563446), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(1.2955828869945099), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.09503925863382233),\n", + " Anderson_ksampResult(statistic=np.float64(2.791401053066109), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.02350982454498939),\n", + " Anderson_ksampResult(statistic=np.float64(0.06968101490507873), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.5555633367888577), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.5908798173850676), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.8354076523933401), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.9778231143201137), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.12922016441401524),\n", + " Anderson_ksampResult(statistic=np.float64(0.004199594528309553), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.4760468347297224), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.3250924936882813), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.2457073955757966),\n", + " Anderson_ksampResult(statistic=np.float64(2.0083290909255993), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.048353286592078784),\n", + " Anderson_ksampResult(statistic=np.float64(0.7912081121389084), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.15503643544817583),\n", + " Anderson_ksampResult(statistic=np.float64(0.767511600731924), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.15867838853780442),\n", + " Anderson_ksampResult(statistic=np.float64(-0.7160810220571034), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.6938017145731582), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.6909435225161504), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1710652750792323),\n", + " Anderson_ksampResult(statistic=np.float64(1.1228235007862648), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.11226559521036106),\n", + " Anderson_ksampResult(statistic=np.float64(-0.31242288592769335), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(-0.4063418357707226), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(0.8896983931178999), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1408044977403145),\n", + " Anderson_ksampResult(statistic=np.float64(1.8097574385906525), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.05826154520775699),\n", + " Anderson_ksampResult(statistic=np.float64(2.65730159253264), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.026557820745559617),\n", + " Anderson_ksampResult(statistic=np.float64(-0.05180271475731241), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", + " Anderson_ksampResult(statistic=np.float64(1.4996392384643258), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.07817382723730883)]" + ] + }, + "execution_count": 189, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "id": "b0a61d38-e133-428c-8d3c-ee4ad93c1af2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 17865.0\n", + "1 16707.0\n", + "2 7621.0\n", + "3 9953.0\n", + "4 8714.0\n", + "5 8209.0\n", + "6 7110.0\n", + "7 6399.0\n", + "8 5244.0\n", + "9 9053.0\n", + "10 23174.0\n", + "11 6036.0\n", + "12 10499.0\n", + "13 10067.0\n", + "14 5925.0\n", + "15 6542.0\n", + "16 9677.0\n", + "17 4357.0\n", + "18 4991.0\n", + "19 4140.0\n", + "20 6494.0\n", + "21 5280.0\n", + "22 12134.0\n", + "23 16265.0\n", + "24 12318.0\n", + "25 9613.0\n", + "26 9323.0\n", + "27 5821.0\n", + "28 6440.0\n", + "29 20117.0\n", + "30 8383.0\n", + "31 11404.0\n", + "Name: PCGDP1960, dtype: float64" + ] + }, + "execution_count": 179, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d82ce31d-aa0f-45cf-896e-f7926827d2c1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "58be93a2-5cdb-4999-80e8-38617c45183a", + "metadata": {}, + "outputs": [], + "source": [ + "def spatial_wolfson(y, w, permutations=99):\n", + " observed = wolfson(libpysal.weights.lag_spatial(w,y))\n", + " sim = [ wolfson(libpysal.weights.lag_spatial(w, np.random.permutation(y))) for i in range(permutations)]\n", + " pvalue = (sim >= observed).sum()\n", + " pvalue = (pvalue+1) / (permutations+1)\n", + " return np.array(sim), pvalue, observed\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "f4ba6f0b-4099-4031-8dac-878f86a47c5c", + "metadata": {}, + "outputs": [], + "source": [ + "res = spatial_wolfson(y, w)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "5b1374b6-3afc-4fa6-8f80-0e209ffaa342", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([0.06539695, 0.06713867, 0.04803813, 0.04857902, 0.04507344,\n", + " 0.06627576, 0.07870363, 0.04253836, 0.03973175, 0.06051153,\n", + " 0.05608921, 0.06021101, 0.07564086, 0.03975564, 0.05635009,\n", + " 0.06511387, 0.04174943, 0.06306224, 0.0730056 , 0.05791516,\n", + " 0.05286226, 0.07373472, 0.04765563, 0.04857054, 0.06190831,\n", + " 0.05162562, 0.06172844, 0.04583417, 0.07501084, 0.11193408,\n", + " 0.04552564, 0.04283921, 0.04329658, 0.05832185, 0.07772928,\n", + " 0.04047874, 0.04841504, 0.04501951, 0.05523765, 0.0475723 ,\n", + " 0.06828713, 0.04525536, 0.06769643, 0.0558426 , 0.0506755 ,\n", + " 0.06199921, 0.05579397, 0.05585677, 0.09021329, 0.0544272 ,\n", + " 0.0406228 , 0.08515166, 0.0740715 , 0.05776597, 0.05415043,\n", + " 0.06458409, 0.04897898, 0.04006921, 0.05886143, 0.07962785,\n", + " 0.04940512, 0.07872911, 0.05386425, 0.08311664, 0.05348995,\n", + " 0.04765452, 0.06376714, 0.05855543, 0.04082106, 0.04745616,\n", + " 0.06442704, 0.06553425, 0.04288452, 0.04812785, 0.04894455,\n", + " 0.06905272, 0.0602209 , 0.04586896, 0.0698854 , 0.05729252,\n", + " 0.04559973, 0.06587604, 0.05511078, 0.06419779, 0.06250691,\n", + " 0.08599654, 0.06595336, 0.06086615, 0.07498169, 0.09536185,\n", + " 0.05469088, 0.05244167, 0.03935122, 0.06451485, 0.04419627,\n", + " 0.06332076, 0.05733736, 0.06198856, 0.07252816]),\n", + " np.float64(0.18),\n", + " np.float64(0.07039175526018514))" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "80c48c53-6602-4979-af20-0f9e8894915e", + "metadata": {}, + "outputs": [], + "source": [ + "obs = wolfson(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "df5c8132-2f74-4816-b6af-ad871443edc0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.int64(0)" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(res>=obs).sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "ea59c601-08ff-40c6-af20-bc217e0f5663", + "metadata": {}, + "outputs": [], + "source": [ + "ws = [spatial_wolfson(gdf[\"PCGDP%s\"%decade], w) for decade in range(1960, 2010, 10)]" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "20530e99-41eb-4c07-b8fa-17ff256645fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(array([0.06399817, 0.05730565, 0.06040884, 0.05500907, 0.05836557,\n", + " 0.06164464, 0.05958563, 0.06570759, 0.06142175, 0.06731981,\n", + " 0.08534805, 0.0617286 , 0.06364233, 0.05853294, 0.04225007,\n", + " 0.09780308, 0.04982557, 0.06711588, 0.08898018, 0.04221016,\n", + " 0.06565352, 0.06681079, 0.05739507, 0.04954549, 0.05125345,\n", + " 0.04718223, 0.05498083, 0.04545973, 0.0540994 , 0.0424817 ,\n", + " 0.05898962, 0.07024661, 0.06074863, 0.07066664, 0.06242651,\n", + " 0.04565519, 0.06414492, 0.04937377, 0.05820772, 0.05345118,\n", + " 0.04500619, 0.06637167, 0.05637192, 0.04594513, 0.05969457,\n", + " 0.06350877, 0.04855286, 0.05160559, 0.04743384, 0.06009093,\n", + " 0.05286712, 0.05857483, 0.05711692, 0.05565814, 0.06642243,\n", + " 0.05922773, 0.07874094, 0.05336004, 0.05476206, 0.06935363,\n", + " 0.05440816, 0.05604029, 0.05229941, 0.05705131, 0.04054759,\n", + " 0.06761293, 0.0582651 , 0.04896406, 0.04387207, 0.04990111,\n", + " 0.04852645, 0.05223442, 0.04525114, 0.05729694, 0.07727919,\n", + " 0.05421121, 0.05184796, 0.06725892, 0.06645797, 0.06464184,\n", + " 0.05877181, 0.05390285, 0.08371761, 0.05007482, 0.05415703,\n", + " 0.04423753, 0.06638531, 0.06073962, 0.04924119, 0.07641581,\n", + " 0.05837826, 0.06324694, 0.05734933, 0.0458635 , 0.04621606,\n", + " 0.05506024, 0.04414513, 0.04342484, 0.06010447]),\n", + " np.float64(0.09),\n", + " np.float64(0.07039175526018514)),\n", + " (array([0.07375257, 0.05322617, 0.05325353, 0.04696744, 0.04317728,\n", + " 0.05794446, 0.0473618 , 0.06348036, 0.04495332, 0.05926916,\n", + " 0.06528046, 0.06455026, 0.04939538, 0.05380263, 0.04947549,\n", + " 0.04634907, 0.04739405, 0.06420582, 0.04776508, 0.05064736,\n", + " 0.05052153, 0.04605473, 0.05597446, 0.05923986, 0.04963141,\n", + " 0.05024416, 0.0470866 , 0.06147468, 0.05120261, 0.05325013,\n", + " 0.05907336, 0.07208191, 0.06265521, 0.06540315, 0.05855876,\n", + " 0.05616487, 0.05759238, 0.05054927, 0.04851202, 0.05770022,\n", + " 0.03855235, 0.04244541, 0.05929439, 0.03518702, 0.0345028 ,\n", + " 0.05086469, 0.04570133, 0.0424409 , 0.04575415, 0.0448708 ,\n", + " 0.0619705 , 0.07582869, 0.06189237, 0.06782979, 0.05565611,\n", + " 0.07448442, 0.05422385, 0.04879481, 0.06445292, 0.04724643,\n", + " 0.05296554, 0.05530129, 0.06237563, 0.05875956, 0.06345624,\n", + " 0.04278562, 0.04658493, 0.05887244, 0.0501407 , 0.0573893 ,\n", + " 0.05940238, 0.04527428, 0.04179717, 0.05625261, 0.05840339,\n", + " 0.04988315, 0.05312827, 0.08382752, 0.04447995, 0.04881509,\n", + " 0.04445801, 0.05664504, 0.05407206, 0.03941519, 0.06802547,\n", + " 0.03924929, 0.06722294, 0.04854335, 0.04390084, 0.04969997,\n", + " 0.06657087, 0.05892878, 0.05082889, 0.05667752, 0.06481969,\n", + " 0.05951592, 0.05354451, 0.05747577, 0.04229047]),\n", + " np.float64(0.13),\n", + " np.float64(0.06458755747501611)),\n", + " (array([0.05033127, 0.04700798, 0.04103977, 0.07538355, 0.04112311,\n", + " 0.06615506, 0.04453466, 0.03956272, 0.0559403 , 0.07123237,\n", + " 0.04459841, 0.04753727, 0.04855087, 0.05553912, 0.06185091,\n", + " 0.05400744, 0.04992578, 0.03346874, 0.04487453, 0.03684066,\n", + " 0.05521159, 0.05685337, 0.04712887, 0.06597157, 0.04778912,\n", + " 0.06999686, 0.04035529, 0.05890795, 0.04481618, 0.05266949,\n", + " 0.04737869, 0.04306247, 0.04747678, 0.0568642 , 0.05679127,\n", + " 0.04947256, 0.06467962, 0.04402462, 0.07214468, 0.04718601,\n", + " 0.05295228, 0.05176914, 0.05245056, 0.06655257, 0.06489889,\n", + " 0.06603038, 0.04786268, 0.04795592, 0.04551103, 0.04488756,\n", + " 0.06854131, 0.0487532 , 0.04578864, 0.0477281 , 0.04675841,\n", + " 0.05455999, 0.06030091, 0.05302252, 0.04863036, 0.04781797,\n", + " 0.06369217, 0.06025116, 0.06384903, 0.0405927 , 0.04698614,\n", + " 0.07869102, 0.04758183, 0.03263553, 0.03831249, 0.04796655,\n", + " 0.04591898, 0.04584463, 0.04062107, 0.0488645 , 0.0603707 ,\n", + " 0.05355981, 0.04952536, 0.06370592, 0.04953925, 0.05547352,\n", + " 0.07183587, 0.06520107, 0.0412738 , 0.05457979, 0.0439007 ,\n", + " 0.04595009, 0.05120643, 0.04823029, 0.04201842, 0.05575521,\n", + " 0.06146726, 0.0583632 , 0.05099475, 0.03872909, 0.04949733,\n", + " 0.04837158, 0.04262712, 0.05790155, 0.06261165]),\n", + " np.float64(0.3),\n", + " np.float64(0.056196203586731525)),\n", + " (array([0.05089817, 0.05528466, 0.08045331, 0.05936524, 0.05285502,\n", + " 0.05410273, 0.04620467, 0.05475286, 0.05104453, 0.06202621,\n", + " 0.05064131, 0.06741257, 0.04894234, 0.05904049, 0.05587145,\n", + " 0.05246733, 0.06224116, 0.06106836, 0.0515984 , 0.05113487,\n", + " 0.05909191, 0.0559149 , 0.0821928 , 0.05622605, 0.05231114,\n", + " 0.06329065, 0.04736246, 0.07123851, 0.06574514, 0.0489701 ,\n", + " 0.04499568, 0.04580277, 0.0562551 , 0.03862931, 0.05251387,\n", + " 0.04771329, 0.0414628 , 0.05214177, 0.0663516 , 0.04836285,\n", + " 0.07526369, 0.05255606, 0.05234393, 0.0518273 , 0.05775702,\n", + " 0.04794933, 0.05531654, 0.03901103, 0.07111561, 0.04637675,\n", + " 0.04911504, 0.05491385, 0.03986179, 0.04676961, 0.05197573,\n", + " 0.0575125 , 0.04797334, 0.05838801, 0.04241979, 0.05943017,\n", + " 0.05841517, 0.05510606, 0.04788195, 0.06229748, 0.05391753,\n", + " 0.04514206, 0.05408954, 0.07382082, 0.04850161, 0.06388372,\n", + " 0.05241611, 0.04477122, 0.05878543, 0.05708606, 0.05448938,\n", + " 0.04191157, 0.05990564, 0.0411684 , 0.0522561 , 0.06080695,\n", + " 0.03891136, 0.07214188, 0.05617103, 0.03836531, 0.05112539,\n", + " 0.04999048, 0.05133658, 0.05696502, 0.06433724, 0.05764536,\n", + " 0.06258384, 0.03395186, 0.05659637, 0.0558076 , 0.06146492,\n", + " 0.05893703, 0.06443537, 0.04988729, 0.05977899]),\n", + " np.float64(0.22),\n", + " np.float64(0.0608058722438404)),\n", + " (array([0.05683646, 0.05955162, 0.05060906, 0.05105952, 0.0674761 ,\n", + " 0.04296224, 0.04873719, 0.06215176, 0.06466715, 0.049016 ,\n", + " 0.05207931, 0.05824445, 0.06037747, 0.0512273 , 0.04774765,\n", + " 0.05236435, 0.05106755, 0.05966975, 0.05082296, 0.05912647,\n", + " 0.07411187, 0.07027358, 0.04942302, 0.04676499, 0.06164883,\n", + " 0.06279849, 0.08558803, 0.07172823, 0.0577911 , 0.0414989 ,\n", + " 0.04955619, 0.05088413, 0.04619596, 0.05367508, 0.04737543,\n", + " 0.06204673, 0.05370197, 0.06083933, 0.05834855, 0.04591643,\n", + " 0.0442099 , 0.0564311 , 0.05975146, 0.04872401, 0.03549547,\n", + " 0.04486098, 0.05414305, 0.06679501, 0.05207422, 0.07390964,\n", + " 0.06640899, 0.05524119, 0.0615557 , 0.05469754, 0.05127429,\n", + " 0.05254732, 0.06219754, 0.0516383 , 0.03086267, 0.04985092,\n", + " 0.04235153, 0.05291973, 0.03852379, 0.05510399, 0.05145997,\n", + " 0.05774483, 0.03696932, 0.04993209, 0.06249942, 0.0545463 ,\n", + " 0.04719057, 0.05951003, 0.04600707, 0.05749058, 0.05318125,\n", + " 0.06549651, 0.06608467, 0.05603467, 0.04383301, 0.0389345 ,\n", + " 0.06418092, 0.05376811, 0.05726171, 0.05376693, 0.04974215,\n", + " 0.05113359, 0.04969371, 0.04602827, 0.03984234, 0.05504227,\n", + " 0.06589274, 0.04886909, 0.0437662 , 0.07461233, 0.05929708,\n", + " 0.08857284, 0.04211861, 0.08160934, 0.06044722]),\n", + " np.float64(0.18),\n", + " np.float64(0.06267192008890492))]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ws" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "e69b35e4-d017-4da5-8566-3b821b2158fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statistic: 2.598293978249068, p-value: 0.028027151010668033\n" + ] + } + ], + "source": [ + "from scipy.stats import anderson_ksamp\n", + "\n", + "# Perform the Anderson-Darling test\n", + "result = anderson_ksamp([l60, lr60])\n", + "print(f\"Statistic: {result.statistic}, p-value: {result.significance_level}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "518f96e6-3670-47fe-968f-66c59bdd251c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statistic: 0.619140625, p-value: 0.019955165439173306\n" + ] + } + ], + "source": [ + "from scipy.stats import cramervonmises_2samp\n", + "\n", + "# Perform the Cramér-von Mises test\n", + "result = cramervonmises_2samp(l60, lr60)\n", + "print(f\"Statistic: {result.statistic}, p-value: {result.pvalue}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "1a494a27-be2c-4d41-8170-de7828029543", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KS Statistic: 0.40625, p-value: 0.009516275438959759\n" + ] + } + ], + "source": [ + "from scipy.stats import ks_2samp\n", + "\n", + "# Perform the KS test\n", + "statistic, p_value = ks_2samp(l60, lr60)\n", + "print(f\"KS Statistic: {statistic}, p-value: {p_value}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "21332e7d-7e0c-47f7-924d-722c81e841a3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(9246.631758432539), np.float64(10370.867571924602))" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l60.mean(), lr60.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "bdf4e2a2-86ad-41b0-b959-60827762049d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(2647.393845526429), np.float64(2631.9423970054327))" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l60.std(), lr60.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "c39241f8-3426-4b5e-aa15-5a7d8e084174", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "could not broadcast input array from shape (200,) into shape (1000,)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[59], line 17\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, data \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(datasets):\n\u001b[1;32m 16\u001b[0m kde \u001b[38;5;241m=\u001b[39m sns\u001b[38;5;241m.\u001b[39mkdeplot(data, bw_adjust\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m, clip\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m5\u001b[39m), fill\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m---> 17\u001b[0m \u001b[43mkde_values\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m kde\u001b[38;5;241m.\u001b[39mget_lines()[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mget_data()[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;66;03m# Get KDE values from the plot object\u001b[39;00m\n\u001b[1;32m 18\u001b[0m plt\u001b[38;5;241m.\u001b[39mcla() \u001b[38;5;66;03m# Clear the current axes after each KDE\u001b[39;00m\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# Calculate the envelope (min and max KDE values) at each x-value\u001b[39;00m\n", + "\u001b[0;31mValueError\u001b[0m: could not broadcast input array from shape (200,) into shape (1000,)" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Create multiple datasets for KDEs\n", + "n_samples = 100\n", + "n_datasets = 50\n", + "datasets = [np.random.normal(loc=np.random.uniform(-2, 2), scale=np.random.uniform(0.5, 1.5), size=n_samples) for _ in range(n_datasets)]\n", + "\n", + "# Set up an array to store KDE estimates at each point\n", + "x_values = np.linspace(-5, 5, 1000)\n", + "kde_values = np.zeros((n_datasets, len(x_values)))\n", + "\n", + "# Calculate KDE for each dataset and store the estimates\n", + "for i, data in enumerate(datasets):\n", + " kde = sns.kdeplot(data, bw_adjust=0.5, clip=(-5, 5), fill=False)\n", + " kde_values[i, :] = kde.get_lines()[-1].get_data()[1] # Get KDE values from the plot object\n", + " plt.cla() # Clear the current axes after each KDE\n", + "\n", + "# Calculate the envelope (min and max KDE values) at each x-value\n", + "kde_min = kde_values.min(axis=0)\n", + "kde_max = kde_values.max(axis=0)\n", + "\n", + "# Plot the envelope\n", + "plt.fill_between(x_values, kde_min, kde_max, color='skyblue', alpha=0.4, label='KDE Envelope')\n", + "\n", + "# Optional: Plot the mean KDE for reference\n", + "kde_mean = kde_values.mean(axis=0)\n", + "plt.plot(x_values, kde_mean, color='blue', label='Mean KDE')\n", + "\n", + "# Add labels and show the plot\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('Envelope of Multiple KDEs')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "a51d64b4-081b-4f84-854f-d3628bcb2f3f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from scipy.interpolate import interp1d\n", + "\n", + "# Create multiple datasets for KDEs\n", + "n_samples = 100\n", + "n_datasets = 50\n", + "datasets = [np.random.normal(loc=np.random.uniform(-2, 2), scale=np.random.uniform(0.5, 1.5), size=n_samples) for _ in range(n_datasets)]\n", + "\n", + "# Set up an array to store KDE estimates at each point\n", + "x_values = np.linspace(-5, 5, 1000)\n", + "kde_values = np.zeros((n_datasets, len(x_values)))\n", + "\n", + "# Calculate KDE for each dataset and store the estimates\n", + "for i, data in enumerate(datasets):\n", + " kde = sns.kdeplot(data, bw_adjust=0.5, clip=(-5, 5), fill=False)\n", + " \n", + " # Extract x and y values from the current plot's KDE\n", + " kde_x, kde_y = kde.get_lines()[-1].get_data()\n", + "\n", + " # Interpolate the KDE y-values to match the x_values grid\n", + " interp = interp1d(kde_x, kde_y, bounds_error=False, fill_value=0)\n", + " kde_values[i, :] = interp(x_values) # Interpolate to match the x_values grid\n", + " \n", + " plt.cla() # Clear the current axes after each KDE\n", + "\n", + "# Calculate the envelope (min and max KDE values) at each x-value\n", + "kde_min = kde_values.min(axis=0)\n", + "kde_max = kde_values.max(axis=0)\n", + "\n", + "# Plot the envelope\n", + "plt.fill_between(x_values, kde_min, kde_max, color='skyblue', alpha=0.4, label='KDE Envelope')\n", + "\n", + "# Optional: Plot the mean KDE for reference\n", + "kde_mean = kde_values.mean(axis=0)\n", + "plt.plot(x_values, kde_mean, color='blue', label='Mean KDE')\n", + "\n", + "# Add labels and show the plot\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('Envelope of Multiple KDEs')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "2e6fd9d8-e7d8-4391-aa11-027f7fff2b25", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The history saving thread hit an unexpected error (OperationalError('attempt to write a readonly database')).History will not be written to the database.\n" + ] + } + ], + "source": [ + "datasets = [ libpysal.weights.lag_spatial(w, np.random.permutation(y)) for i in range(99)]" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "734767cb-bdcc-4682-9fbf-dc17b639c231", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "99" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(datasets)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "ea7ac23b-d571-4096-83a1-9dba2cc1a2c7", + "metadata": {}, + "outputs": [], + "source": [ + "l60.min(),l60.max()\n", + "x_values = np.linspace(l60.min()/2.5, l60.max()*1.5, 100)\n", + "x_min = x_values.min()\n", + "x_max = x_values.max()\n", + "n_datasets = 99\n", + "kde_values = np.zeros((n_datasets, len(x_values)))\n", + "common_range = (x_min, x_max)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "8d4236a2-6060-468c-9ae0-304c86386f50", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i, data in enumerate(datasets):\n", + " kde = sns.kdeplot(data, bw_adjust=0.5, clip=(x_min, x_max), fill=False)\n", + " \n", + " kde_x, kde_y = kde.get_lines()[-1].get_data()\n", + "\n", + " # Interpolate the KDE y-values to match the x_values grid\n", + " interp = interp1d(kde_x, kde_y, bounds_error=False, fill_value=0)\n", + " kde_values[i, :] = interp(x_values) # Interpolate to match the x_values grid\n", + " \n", + " plt.cla() # Clear the current axes after each KDE\n", + "\n", + "# Calculate the envelope (min and max KDE values) at each x-value\n", + "kde_min = kde_values.min(axis=0)\n", + "kde_max = kde_values.max(axis=0)\n", + "# Plot the envelope\n", + "plt.fill_between(x_values, kde_min, kde_max, color='skyblue', alpha=0.4, label='KDE Envelope')\n", + "\n", + "# Optional: Plot the mean KDE for reference\n", + "kde_mean = kde_values.mean(axis=0)\n", + "plt.plot(x_values, kde_mean, color='blue', label='Mean KDE')\n", + "sns.kdeplot(l60, label='Spatial Lag', bw_adjust=0.5, clip=common_range)\n", + "\n", + "\n", + "# Add labels and show the plot\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('Envelope of Multiple KDEs')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "32e1c2fd-8295-4ccd-9bc1-38b9411a7f58", + "metadata": {}, + "source": [ + "## Monte Carlo Example" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "8f897dd4-21d9-4c61-a9b2-4f12b8ae318d", + "metadata": {}, + "outputs": [], + "source": [ + "n_samples = 100\n", + "\n", + "k = 10\n", + "\n", + "w = libpysal.weights.lat2W(k,k)\n", + "w.transform='r'" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "c470b65b-1f85-42d2-8939-da1420101508", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rhos = np.arange(0, .9, .1)\n", + "rhos" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "23b4d3dd-19f6-4355-9c50-2619d25c15e6", + "metadata": {}, + "outputs": [], + "source": [ + "mu = 50\n", + "I = np.eye(k*k)\n", + "AIS = []\n", + "for rho in rhos:\n", + " A = I - rho *w.full()[0]\n", + " AI = np.linalg.inv(A)\n", + " AIS.append(AI)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "59a2e652-0a3a-4fce-8569-76f15029e73f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1.37859246, 0.70986085, 0.25233372, 0.09186194],\n", + " [0.47324057, 1.43289633, 0.48630564, 0.17150269],\n", + " [0.16822248, 0.48630564, 1.35206531, 0.45653987],\n", + " [0.06124129, 0.17150269, 0.45653987, 1.34096643]])" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "AI[0:4,0:4]" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "a198a599-2079-47ed-aa70-53783f54bdfc", + "metadata": {}, + "outputs": [], + "source": [ + "res = {}\n", + "permutations = 100\n", + "for rho, i in enumerate(rhos):\n", + " for realization in range(n_samples):\n", + " e = np.random.normal(0, 50, size=(k*k,1))\n", + " mue = mu + e\n", + " y = np.dot(AI, mue)\n", + " wy = libpysal.weights.lag_spatial(w, y)\n", + " counter = 0\n", + " for perm in range(permutations):\n", + " yr = np.random.permutation(y)\n", + " wyr = libpysal.weights.lag_spatial(w, yr)\n", + " result = cramervonmises_2samp(wy, wyr)\n", + " if result.pvalue <= 0.05:\n", + " counter += 1\n", + " res[(rho, realization)] = counter\n" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "00ae88b6-3997-462e-83d9-09d50595d087", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(287.8508507836729)" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "yr.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "440685e2-ad0d-44bf-9dce-e81aa0c2c080", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(288.4577613659621), np.float64(289.0009182556533))" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wy.mean(), wyr.mean()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "57d8433a-30dc-440d-bf7a-272bfeee835e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{(0, 0): 1,\n", + " (0, 1): 2,\n", + " (0, 2): 0,\n", + " (0, 3): 0,\n", + " (0, 4): 11,\n", + " (0, 5): 25,\n", + " (0, 6): 7,\n", + " (0, 7): 0,\n", + " (0, 8): 9,\n", + " (0, 9): 0,\n", + " (0, 10): 31,\n", + " (0, 11): 0,\n", + " (0, 12): 0,\n", + " (0, 13): 5,\n", + " (0, 14): 33,\n", + " (0, 15): 15,\n", + " (0, 16): 0,\n", + " (0, 17): 3,\n", + " (0, 18): 0,\n", + " (0, 19): 1,\n", + " (0, 20): 9,\n", + " (0, 21): 16,\n", + " (0, 22): 0,\n", + " (0, 23): 3,\n", + " (0, 24): 2,\n", + " (0, 25): 1,\n", + " (0, 26): 0,\n", + " (0, 27): 52,\n", + " (0, 28): 31,\n", + " (0, 29): 0,\n", + " (0, 30): 4,\n", + " (0, 31): 98,\n", + " (0, 32): 1,\n", + " (0, 33): 0,\n", + " (0, 34): 5,\n", + " (0, 35): 0,\n", + " (0, 36): 77,\n", + " (0, 37): 87,\n", + " (0, 38): 1,\n", + " (0, 39): 7,\n", + " (0, 40): 0,\n", + " (0, 41): 0,\n", + " (0, 42): 32,\n", + " (0, 43): 30,\n", + " (0, 44): 42,\n", + " (0, 45): 0,\n", + " (0, 46): 0,\n", + " (0, 47): 19,\n", + " (0, 48): 0,\n", + " (0, 49): 33,\n", + " (0, 50): 0,\n", + " (0, 51): 0,\n", + " (0, 52): 0,\n", + " (0, 53): 33,\n", + " (0, 54): 0,\n", + " (0, 55): 35,\n", + " (0, 56): 2,\n", + " (0, 57): 2,\n", + " (0, 58): 0,\n", + " (0, 59): 16,\n", + " (0, 60): 3,\n", + " (0, 61): 33,\n", + " (0, 62): 4,\n", + " (0, 63): 1,\n", + " (0, 64): 4,\n", + " (0, 65): 2,\n", + " (0, 66): 3,\n", + " (0, 67): 0,\n", + " (0, 68): 0,\n", + " (0, 69): 0,\n", + " (0, 70): 8,\n", + " (0, 71): 3,\n", + " (0, 72): 0,\n", + " (0, 73): 69,\n", + " (0, 74): 0,\n", + " (0, 75): 0,\n", + " (0, 76): 26,\n", + " (0, 77): 28,\n", + " (0, 78): 4,\n", + " (0, 79): 68,\n", + " (0, 80): 4,\n", + " (0, 81): 3,\n", + " (0, 82): 0,\n", + " (0, 83): 0,\n", + " (0, 84): 2,\n", + " (0, 85): 71,\n", + " (0, 86): 0,\n", + " (0, 87): 38,\n", + " (0, 88): 0,\n", + " (0, 89): 23,\n", + " (0, 90): 0,\n", + " (0, 91): 0,\n", + " (0, 92): 0,\n", + " (0, 93): 39,\n", + " (0, 94): 86,\n", + " (0, 95): 0,\n", + " (0, 96): 6,\n", + " (0, 97): 29,\n", + " (0, 98): 1,\n", + " (0, 99): 0,\n", + " (1, 0): 19,\n", + " (1, 1): 44,\n", + " (1, 2): 10,\n", + " (1, 3): 0,\n", + " (1, 4): 11,\n", + " (1, 5): 5,\n", + " (1, 6): 0,\n", + " (1, 7): 11,\n", + " (1, 8): 19,\n", + " (1, 9): 14,\n", + " (1, 10): 0,\n", + " (1, 11): 95,\n", + " (1, 12): 36,\n", + " (1, 13): 0,\n", + " (1, 14): 0,\n", + " (1, 15): 23,\n", + " (1, 16): 23,\n", + " (1, 17): 3,\n", + " (1, 18): 73,\n", + " (1, 19): 0,\n", + " (1, 20): 12,\n", + " (1, 21): 28,\n", + " (1, 22): 20,\n", + " (1, 23): 28,\n", + " (1, 24): 0,\n", + " (1, 25): 1,\n", + " (1, 26): 53,\n", + " (1, 27): 0,\n", + " (1, 28): 0,\n", + " (1, 29): 3,\n", + " (1, 30): 0,\n", + " (1, 31): 6,\n", + " (1, 32): 0,\n", + " (1, 33): 34,\n", + " (1, 34): 0,\n", + " (1, 35): 5,\n", + " (1, 36): 2,\n", + " (1, 37): 0,\n", + " (1, 38): 0,\n", + " (1, 39): 64,\n", + " (1, 40): 0,\n", + " (1, 41): 8,\n", + " (1, 42): 1,\n", + " (1, 43): 0,\n", + " (1, 44): 19,\n", + " (1, 45): 0,\n", + " (1, 46): 0,\n", + " (1, 47): 70,\n", + " (1, 48): 0,\n", + " (1, 49): 6,\n", + " (1, 50): 9,\n", + " (1, 51): 50,\n", + " (1, 52): 11,\n", + " (1, 53): 67,\n", + " (1, 54): 29,\n", + " (1, 55): 0,\n", + " (1, 56): 36,\n", + " (1, 57): 0,\n", + " (1, 58): 1,\n", + " (1, 59): 12,\n", + " (1, 60): 7,\n", + " (1, 61): 2,\n", + " (1, 62): 13,\n", + " (1, 63): 43,\n", + " (1, 64): 5,\n", + " (1, 65): 86,\n", + " (1, 66): 2,\n", + " (1, 67): 6,\n", + " (1, 68): 63,\n", + " (1, 69): 0,\n", + " (1, 70): 0,\n", + " (1, 71): 0,\n", + " (1, 72): 0,\n", + " (1, 73): 2,\n", + " (1, 74): 2,\n", + " (1, 75): 3,\n", + " (1, 76): 4,\n", + " (1, 77): 0,\n", + " (1, 78): 46,\n", + " (1, 79): 9,\n", + " (1, 80): 73,\n", + " (1, 81): 26,\n", + " (1, 82): 0,\n", + " (1, 83): 50,\n", + " (1, 84): 0,\n", + " (1, 85): 17,\n", + " (1, 86): 87,\n", + " (1, 87): 39,\n", + " (1, 88): 0,\n", + " (1, 89): 0,\n", + " (1, 90): 0,\n", + " (1, 91): 7,\n", + " (1, 92): 5,\n", + " (1, 93): 15,\n", + " (1, 94): 0,\n", + " (1, 95): 65,\n", + " (1, 96): 49,\n", + " (1, 97): 40,\n", + " (1, 98): 47,\n", + " (1, 99): 23,\n", + " (2, 0): 12,\n", + " (2, 1): 5,\n", + " (2, 2): 3,\n", + " (2, 3): 12,\n", + " (2, 4): 12,\n", + " (2, 5): 0,\n", + " (2, 6): 96,\n", + " (2, 7): 49,\n", + " (2, 8): 0,\n", + " (2, 9): 0,\n", + " (2, 10): 0,\n", + " (2, 11): 0,\n", + " (2, 12): 77,\n", + " (2, 13): 98,\n", + " (2, 14): 0,\n", + " (2, 15): 0,\n", + " (2, 16): 12,\n", + " (2, 17): 74,\n", + " (2, 18): 1,\n", + " (2, 19): 3,\n", + " (2, 20): 21,\n", + " (2, 21): 4,\n", + " (2, 22): 14,\n", + " (2, 23): 3,\n", + " (2, 24): 1,\n", + " (2, 25): 1,\n", + " (2, 26): 0,\n", + " (2, 27): 9,\n", + " (2, 28): 2,\n", + " (2, 29): 16,\n", + " (2, 30): 3,\n", + " (2, 31): 4,\n", + " (2, 32): 35,\n", + " (2, 33): 16,\n", + " (2, 34): 0,\n", + " (2, 35): 3,\n", + " (2, 36): 0,\n", + " (2, 37): 0,\n", + " (2, 38): 0,\n", + " (2, 39): 0,\n", + " (2, 40): 0,\n", + " (2, 41): 2,\n", + " (2, 42): 0,\n", + " (2, 43): 0,\n", + " (2, 44): 0,\n", + " (2, 45): 5,\n", + " (2, 46): 1,\n", + " (2, 47): 44,\n", + " (2, 48): 8,\n", + " (2, 49): 79,\n", + " (2, 50): 9,\n", + " (2, 51): 0,\n", + " (2, 52): 0,\n", + " (2, 53): 30,\n", + " (2, 54): 12,\n", + " (2, 55): 0,\n", + " (2, 56): 0,\n", + " (2, 57): 39,\n", + " (2, 58): 53,\n", + " (2, 59): 0,\n", + " (2, 60): 0,\n", + " (2, 61): 3,\n", + " (2, 62): 0,\n", + " (2, 63): 0,\n", + " (2, 64): 1,\n", + " (2, 65): 5,\n", + " (2, 66): 6,\n", + " (2, 67): 0,\n", + " (2, 68): 0,\n", + " (2, 69): 3,\n", + " (2, 70): 0,\n", + " (2, 71): 1,\n", + " (2, 72): 61,\n", + " (2, 73): 3,\n", + " (2, 74): 6,\n", + " (2, 75): 0,\n", + " (2, 76): 23,\n", + " (2, 77): 9,\n", + " (2, 78): 14,\n", + " (2, 79): 0,\n", + " (2, 80): 3,\n", + " (2, 81): 32,\n", + " (2, 82): 10,\n", + " (2, 83): 63,\n", + " (2, 84): 0,\n", + " (2, 85): 1,\n", + " (2, 86): 5,\n", + " (2, 87): 0,\n", + " (2, 88): 0,\n", + " (2, 89): 2,\n", + " (2, 90): 2,\n", + " (2, 91): 1,\n", + " (2, 92): 1,\n", + " (2, 93): 0,\n", + " (2, 94): 3,\n", + " (2, 95): 8,\n", + " (2, 96): 4,\n", + " (2, 97): 1,\n", + " (2, 98): 82,\n", + " (2, 99): 0,\n", + " (3, 0): 3,\n", + " (3, 1): 0,\n", + " (3, 2): 37,\n", + " (3, 3): 70,\n", + " (3, 4): 0,\n", + " (3, 5): 34,\n", + " (3, 6): 0,\n", + " (3, 7): 2,\n", + " (3, 8): 18,\n", + " (3, 9): 0,\n", + " (3, 10): 9,\n", + " (3, 11): 21,\n", + " (3, 12): 0,\n", + " (3, 13): 15,\n", + " (3, 14): 4,\n", + " (3, 15): 10,\n", + " (3, 16): 64,\n", + " (3, 17): 1,\n", + " (3, 18): 76,\n", + " (3, 19): 58,\n", + " (3, 20): 0,\n", + " (3, 21): 1,\n", + " (3, 22): 0,\n", + " (3, 23): 0,\n", + " (3, 24): 4,\n", + " (3, 25): 1,\n", + " (3, 26): 0,\n", + " (3, 27): 76,\n", + " (3, 28): 0,\n", + " (3, 29): 1,\n", + " (3, 30): 0,\n", + " (3, 31): 3,\n", + " (3, 32): 1,\n", + " (3, 33): 20,\n", + " (3, 34): 87,\n", + " (3, 35): 27,\n", + " (3, 36): 0,\n", + " (3, 37): 0,\n", + " (3, 38): 0,\n", + " (3, 39): 0,\n", + " (3, 40): 61,\n", + " (3, 41): 1,\n", + " (3, 42): 0,\n", + " (3, 43): 24,\n", + " (3, 44): 60,\n", + " (3, 45): 2,\n", + " (3, 46): 0,\n", + " (3, 47): 1,\n", + " (3, 48): 65,\n", + " (3, 49): 0,\n", + " (3, 50): 0,\n", + " (3, 51): 8,\n", + " (3, 52): 0,\n", + " (3, 53): 0,\n", + " (3, 54): 0,\n", + " (3, 55): 0,\n", + " (3, 56): 29,\n", + " (3, 57): 1,\n", + " (3, 58): 17,\n", + " (3, 59): 39,\n", + " (3, 60): 0,\n", + " (3, 61): 14,\n", + " (3, 62): 29,\n", + " (3, 63): 0,\n", + " (3, 64): 1,\n", + " (3, 65): 0,\n", + " (3, 66): 3,\n", + " (3, 67): 27,\n", + " (3, 68): 2,\n", + " (3, 69): 14,\n", + " (3, 70): 1,\n", + " (3, 71): 0,\n", + " (3, 72): 0,\n", + " (3, 73): 3,\n", + " (3, 74): 0,\n", + " (3, 75): 14,\n", + " (3, 76): 0,\n", + " (3, 77): 56,\n", + " (3, 78): 0,\n", + " (3, 79): 15,\n", + " (3, 80): 0,\n", + " (3, 81): 37,\n", + " (3, 82): 30,\n", + " (3, 83): 37,\n", + " (3, 84): 6,\n", + " (3, 85): 15,\n", + " (3, 86): 3,\n", + " (3, 87): 0,\n", + " (3, 88): 14,\n", + " (3, 89): 96,\n", + " (3, 90): 6,\n", + " (3, 91): 18,\n", + " (3, 92): 1,\n", + " (3, 93): 1,\n", + " (3, 94): 48,\n", + " (3, 95): 6,\n", + " (3, 96): 2,\n", + " (3, 97): 0,\n", + " (3, 98): 71,\n", + " (3, 99): 59,\n", + " (4, 0): 72,\n", + " (4, 1): 25,\n", + " (4, 2): 1,\n", + " (4, 3): 24,\n", + " (4, 4): 0,\n", + " (4, 5): 0,\n", + " (4, 6): 6,\n", + " (4, 7): 2,\n", + " (4, 8): 7,\n", + " (4, 9): 0,\n", + " (4, 10): 0,\n", + " (4, 11): 0,\n", + " (4, 12): 2,\n", + " (4, 13): 1,\n", + " (4, 14): 2,\n", + " (4, 15): 4,\n", + " (4, 16): 76,\n", + " (4, 17): 0,\n", + " (4, 18): 66,\n", + " (4, 19): 24,\n", + " (4, 20): 8,\n", + " (4, 21): 1,\n", + " (4, 22): 61,\n", + " (4, 23): 54,\n", + " (4, 24): 3,\n", + " (4, 25): 26,\n", + " (4, 26): 0,\n", + " (4, 27): 17,\n", + " (4, 28): 0,\n", + " (4, 29): 23,\n", + " (4, 30): 26,\n", + " (4, 31): 37,\n", + " (4, 32): 2,\n", + " (4, 33): 1,\n", + " (4, 34): 22,\n", + " (4, 35): 9,\n", + " (4, 36): 63,\n", + " (4, 37): 4,\n", + " (4, 38): 0,\n", + " (4, 39): 0,\n", + " (4, 40): 13,\n", + " (4, 41): 2,\n", + " (4, 42): 0,\n", + " (4, 43): 3,\n", + " (4, 44): 19,\n", + " (4, 45): 4,\n", + " (4, 46): 2,\n", + " (4, 47): 1,\n", + " (4, 48): 1,\n", + " (4, 49): 2,\n", + " (4, 50): 18,\n", + " (4, 51): 57,\n", + " (4, 52): 17,\n", + " (4, 53): 3,\n", + " (4, 54): 11,\n", + " (4, 55): 100,\n", + " (4, 56): 41,\n", + " (4, 57): 0,\n", + " (4, 58): 1,\n", + " (4, 59): 4,\n", + " (4, 60): 0,\n", + " (4, 61): 1,\n", + " (4, 62): 0,\n", + " (4, 63): 1,\n", + " (4, 64): 45,\n", + " (4, 65): 0,\n", + " (4, 66): 1,\n", + " (4, 67): 47,\n", + " (4, 68): 70,\n", + " (4, 69): 34,\n", + " (4, 70): 11,\n", + " (4, 71): 2,\n", + " (4, 72): 2,\n", + " (4, 73): 32,\n", + " (4, 74): 2,\n", + " (4, 75): 41,\n", + " (4, 76): 0,\n", + " (4, 77): 2,\n", + " (4, 78): 29,\n", + " (4, 79): 85,\n", + " (4, 80): 0,\n", + " (4, 81): 18,\n", + " (4, 82): 5,\n", + " (4, 83): 75,\n", + " (4, 84): 7,\n", + " (4, 85): 54,\n", + " (4, 86): 1,\n", + " (4, 87): 0,\n", + " (4, 88): 27,\n", + " (4, 89): 1,\n", + " (4, 90): 1,\n", + " (4, 91): 0,\n", + " (4, 92): 1,\n", + " (4, 93): 0,\n", + " (4, 94): 0,\n", + " (4, 95): 3,\n", + " (4, 96): 6,\n", + " (4, 97): 0,\n", + " (4, 98): 0,\n", + " (4, 99): 12,\n", + " (5, 0): 0,\n", + " (5, 1): 1,\n", + " (5, 2): 2,\n", + " (5, 3): 0,\n", + " (5, 4): 1,\n", + " (5, 5): 2,\n", + " (5, 6): 40,\n", + " (5, 7): 39,\n", + " (5, 8): 0,\n", + " (5, 9): 0,\n", + " (5, 10): 95,\n", + " (5, 11): 0,\n", + " (5, 12): 0,\n", + " (5, 13): 16,\n", + " (5, 14): 0,\n", + " (5, 15): 81,\n", + " (5, 16): 2,\n", + " (5, 17): 5,\n", + " (5, 18): 0,\n", + " (5, 19): 34,\n", + " (5, 20): 0,\n", + " (5, 21): 0,\n", + " (5, 22): 7,\n", + " (5, 23): 7,\n", + " (5, 24): 3,\n", + " (5, 25): 0,\n", + " (5, 26): 0,\n", + " (5, 27): 12,\n", + " (5, 28): 0,\n", + " (5, 29): 5,\n", + " (5, 30): 31,\n", + " (5, 31): 19,\n", + " (5, 32): 99,\n", + " (5, 33): 33,\n", + " (5, 34): 1,\n", + " (5, 35): 100,\n", + " (5, 36): 8,\n", + " (5, 37): 0,\n", + " (5, 38): 2,\n", + " (5, 39): 10,\n", + " (5, 40): 9,\n", + " (5, 41): 86,\n", + " (5, 42): 45,\n", + " (5, 43): 22,\n", + " (5, 44): 49,\n", + " (5, 45): 8,\n", + " (5, 46): 2,\n", + " (5, 47): 5,\n", + " (5, 48): 37,\n", + " (5, 49): 3,\n", + " (5, 50): 62,\n", + " (5, 51): 21,\n", + " (5, 52): 1,\n", + " (5, 53): 20,\n", + " (5, 54): 0,\n", + " (5, 55): 3,\n", + " (5, 56): 12,\n", + " (5, 57): 0,\n", + " (5, 58): 20,\n", + " (5, 59): 3,\n", + " (5, 60): 0,\n", + " (5, 61): 2,\n", + " (5, 62): 9,\n", + " (5, 63): 6,\n", + " (5, 64): 0,\n", + " (5, 65): 0,\n", + " (5, 66): 0,\n", + " (5, 67): 0,\n", + " (5, 68): 2,\n", + " (5, 69): 5,\n", + " (5, 70): 0,\n", + " (5, 71): 59,\n", + " (5, 72): 70,\n", + " (5, 73): 16,\n", + " (5, 74): 0,\n", + " (5, 75): 0,\n", + " (5, 76): 0,\n", + " (5, 77): 0,\n", + " (5, 78): 0,\n", + " (5, 79): 81,\n", + " (5, 80): 0,\n", + " (5, 81): 0,\n", + " (5, 82): 0,\n", + " (5, 83): 2,\n", + " (5, 84): 0,\n", + " (5, 85): 0,\n", + " (5, 86): 1,\n", + " (5, 87): 25,\n", + " (5, 88): 0,\n", + " (5, 89): 0,\n", + " (5, 90): 30,\n", + " (5, 91): 3,\n", + " (5, 92): 2,\n", + " (5, 93): 2,\n", + " (5, 94): 0,\n", + " (5, 95): 1,\n", + " (5, 96): 2,\n", + " (5, 97): 3,\n", + " (5, 98): 71,\n", + " (5, 99): 6,\n", + " (6, 0): 0,\n", + " (6, 1): 11,\n", + " (6, 2): 0,\n", + " (6, 3): 0,\n", + " (6, 4): 0,\n", + " (6, 5): 0,\n", + " (6, 6): 82,\n", + " (6, 7): 53,\n", + " (6, 8): 0,\n", + " (6, 9): 14,\n", + " (6, 10): 17,\n", + " (6, 11): 1,\n", + " (6, 12): 4,\n", + " (6, 13): 0,\n", + " (6, 14): 2,\n", + " (6, 15): 0,\n", + " (6, 16): 0,\n", + " (6, 17): 28,\n", + " (6, 18): 0,\n", + " (6, 19): 3,\n", + " (6, 20): 6,\n", + " (6, 21): 7,\n", + " (6, 22): 54,\n", + " (6, 23): 4,\n", + " (6, 24): 0,\n", + " (6, 25): 30,\n", + " (6, 26): 11,\n", + " (6, 27): 0,\n", + " (6, 28): 2,\n", + " (6, 29): 9,\n", + " (6, 30): 2,\n", + " (6, 31): 0,\n", + " (6, 32): 0,\n", + " (6, 33): 0,\n", + " (6, 34): 0,\n", + " (6, 35): 1,\n", + " (6, 36): 17,\n", + " (6, 37): 91,\n", + " (6, 38): 0,\n", + " (6, 39): 18,\n", + " (6, 40): 0,\n", + " (6, 41): 0,\n", + " (6, 42): 2,\n", + " (6, 43): 0,\n", + " (6, 44): 1,\n", + " (6, 45): 0,\n", + " (6, 46): 35,\n", + " (6, 47): 29,\n", + " (6, 48): 5,\n", + " (6, 49): 0,\n", + " (6, 50): 6,\n", + " (6, 51): 20,\n", + " (6, 52): 68,\n", + " (6, 53): 5,\n", + " (6, 54): 48,\n", + " (6, 55): 89,\n", + " (6, 56): 18,\n", + " (6, 57): 0,\n", + " (6, 58): 0,\n", + " (6, 59): 0,\n", + " (6, 60): 8,\n", + " (6, 61): 9,\n", + " (6, 62): 7,\n", + " (6, 63): 17,\n", + " (6, 64): 9,\n", + " (6, 65): 2,\n", + " (6, 66): 0,\n", + " (6, 67): 22,\n", + " (6, 68): 0,\n", + " (6, 69): 0,\n", + " (6, 70): 96,\n", + " (6, 71): 21,\n", + " (6, 72): 7,\n", + " (6, 73): 0,\n", + " (6, 74): 0,\n", + " (6, 75): 2,\n", + " (6, 76): 0,\n", + " (6, 77): 48,\n", + " (6, 78): 1,\n", + " (6, 79): 16,\n", + " (6, 80): 99,\n", + " (6, 81): 6,\n", + " (6, 82): 0,\n", + " (6, 83): 1,\n", + " (6, 84): 0,\n", + " (6, 85): 50,\n", + " (6, 86): 5,\n", + " (6, 87): 13,\n", + " (6, 88): 62,\n", + " (6, 89): 38,\n", + " (6, 90): 72,\n", + " (6, 91): 1,\n", + " (6, 92): 21,\n", + " (6, 93): 0,\n", + " (6, 94): 69,\n", + " (6, 95): 11,\n", + " (6, 96): 7,\n", + " (6, 97): 0,\n", + " (6, 98): 70,\n", + " (6, 99): 1,\n", + " (7, 0): 3,\n", + " (7, 1): 0,\n", + " (7, 2): 0,\n", + " (7, 3): 42,\n", + " (7, 4): 0,\n", + " (7, 5): 3,\n", + " (7, 6): 31,\n", + " (7, 7): 0,\n", + " (7, 8): 5,\n", + " (7, 9): 4,\n", + " (7, 10): 19,\n", + " (7, 11): 0,\n", + " (7, 12): 0,\n", + " (7, 13): 1,\n", + " (7, 14): 23,\n", + " (7, 15): 0,\n", + " (7, 16): 0,\n", + " (7, 17): 94,\n", + " (7, 18): 15,\n", + " (7, 19): 0,\n", + " (7, 20): 4,\n", + " (7, 21): 2,\n", + " (7, 22): 1,\n", + " (7, 23): 0,\n", + " (7, 24): 54,\n", + " (7, 25): 65,\n", + " (7, 26): 21,\n", + " (7, 27): 0,\n", + " (7, 28): 5,\n", + " (7, 29): 36,\n", + " (7, 30): 6,\n", + " (7, 31): 1,\n", + " (7, 32): 0,\n", + " (7, 33): 11,\n", + " (7, 34): 20,\n", + " (7, 35): 7,\n", + " (7, 36): 0,\n", + " (7, 37): 0,\n", + " (7, 38): 0,\n", + " (7, 39): 9,\n", + " (7, 40): 0,\n", + " (7, 41): 46,\n", + " (7, 42): 0,\n", + " (7, 43): 0,\n", + " (7, 44): 4,\n", + " (7, 45): 0,\n", + " (7, 46): 0,\n", + " (7, 47): 20,\n", + " (7, 48): 0,\n", + " (7, 49): 0,\n", + " (7, 50): 13,\n", + " (7, 51): 96,\n", + " (7, 52): 92,\n", + " (7, 53): 44,\n", + " (7, 54): 33,\n", + " (7, 55): 0,\n", + " (7, 56): 59,\n", + " (7, 57): 0,\n", + " (7, 58): 10,\n", + " (7, 59): 38,\n", + " (7, 60): 0,\n", + " (7, 61): 9,\n", + " (7, 62): 16,\n", + " (7, 63): 0,\n", + " (7, 64): 1,\n", + " (7, 65): 15,\n", + " (7, 66): 7,\n", + " (7, 67): 97,\n", + " (7, 68): 0,\n", + " (7, 69): 12,\n", + " (7, 70): 2,\n", + " (7, 71): 0,\n", + " (7, 72): 0,\n", + " (7, 73): 34,\n", + " (7, 74): 34,\n", + " (7, 75): 86,\n", + " (7, 76): 3,\n", + " (7, 77): 4,\n", + " (7, 78): 8,\n", + " (7, 79): 0,\n", + " (7, 80): 1,\n", + " (7, 81): 19,\n", + " (7, 82): 0,\n", + " (7, 83): 11,\n", + " (7, 84): 82,\n", + " (7, 85): 17,\n", + " (7, 86): 1,\n", + " (7, 87): 16,\n", + " (7, 88): 43,\n", + " (7, 89): 1,\n", + " (7, 90): 0,\n", + " (7, 91): 4,\n", + " (7, 92): 28,\n", + " (7, 93): 73,\n", + " (7, 94): 1,\n", + " (7, 95): 93,\n", + " (7, 96): 4,\n", + " (7, 97): 0,\n", + " (7, 98): 0,\n", + " (7, 99): 15,\n", + " (8, 0): 10,\n", + " (8, 1): 4,\n", + " (8, 2): 4,\n", + " (8, 3): 17,\n", + " (8, 4): 0,\n", + " (8, 5): 18,\n", + " (8, 6): 0,\n", + " (8, 7): 0,\n", + " (8, 8): 23,\n", + " (8, 9): 3,\n", + " (8, 10): 63,\n", + " (8, 11): 5,\n", + " (8, 12): 15,\n", + " (8, 13): 5,\n", + " (8, 14): 4,\n", + " (8, 15): 0,\n", + " (8, 16): 0,\n", + " (8, 17): 0,\n", + " (8, 18): 3,\n", + " (8, 19): 43,\n", + " (8, 20): 0,\n", + " (8, 21): 0,\n", + " (8, 22): 83,\n", + " (8, 23): 3,\n", + " (8, 24): 1,\n", + " (8, 25): 0,\n", + " (8, 26): 0,\n", + " (8, 27): 3,\n", + " (8, 28): 9,\n", + " (8, 29): 0,\n", + " (8, 30): 52,\n", + " (8, 31): 10,\n", + " (8, 32): 73,\n", + " (8, 33): 0,\n", + " (8, 34): 0,\n", + " (8, 35): 20,\n", + " (8, 36): 63,\n", + " (8, 37): 38,\n", + " (8, 38): 52,\n", + " (8, 39): 0,\n", + " (8, 40): 2,\n", + " (8, 41): 0,\n", + " (8, 42): 0,\n", + " (8, 43): 0,\n", + " (8, 44): 51,\n", + " (8, 45): 4,\n", + " (8, 46): 0,\n", + " (8, 47): 5,\n", + " (8, 48): 21,\n", + " (8, 49): 12,\n", + " (8, 50): 0,\n", + " (8, 51): 0,\n", + " (8, 52): 12,\n", + " (8, 53): 0,\n", + " (8, 54): 0,\n", + " (8, 55): 0,\n", + " (8, 56): 5,\n", + " (8, 57): 1,\n", + " (8, 58): 13,\n", + " (8, 59): 10,\n", + " (8, 60): 63,\n", + " (8, 61): 19,\n", + " (8, 62): 1,\n", + " (8, 63): 0,\n", + " (8, 64): 18,\n", + " (8, 65): 82,\n", + " (8, 66): 10,\n", + " (8, 67): 7,\n", + " (8, 68): 4,\n", + " (8, 69): 8,\n", + " (8, 70): 61,\n", + " (8, 71): 24,\n", + " (8, 72): 0,\n", + " (8, 73): 0,\n", + " (8, 74): 0,\n", + " (8, 75): 0,\n", + " (8, 76): 0,\n", + " (8, 77): 0,\n", + " (8, 78): 1,\n", + " (8, 79): 57,\n", + " (8, 80): 14,\n", + " (8, 81): 0,\n", + " (8, 82): 31,\n", + " (8, 83): 0,\n", + " (8, 84): 12,\n", + " (8, 85): 29,\n", + " (8, 86): 0,\n", + " (8, 87): 6,\n", + " (8, 88): 0,\n", + " (8, 89): 0,\n", + " (8, 90): 44,\n", + " (8, 91): 1,\n", + " (8, 92): 0,\n", + " (8, 93): 1,\n", + " (8, 94): 0,\n", + " (8, 95): 45,\n", + " (8, 96): 0,\n", + " (8, 97): 1,\n", + " (8, 98): 38,\n", + " (8, 99): 3}" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "f4e23eed-f1f2-44f6-a5b1-5c2d278d1e86", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 100)" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "e6b3dc46-5e71-49ee-99a2-44c4b10e4ff4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1. , -0.4 , 0. , ..., 0. ,\n", + " 0. , 0. ],\n", + " [-0.26666667, 1. , -0.26666667, ..., 0. ,\n", + " 0. , 0. ],\n", + " [ 0. , -0.26666667, 1. , ..., 0. ,\n", + " 0. , 0. ],\n", + " ...,\n", + " [ 0. , 0. , 0. , ..., 1. ,\n", + " -0.26666667, 0. ],\n", + " [ 0. , 0. , 0. , ..., -0.26666667,\n", + " 1. , -0.26666667],\n", + " [ 0. , 0. , 0. , ..., 0. ,\n", + " -0.4 , 1. ]])" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "172ac907-e02b-4ecb-8355-73e6e2fff132", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulated vector with mean 60:\n", + "[[59.50335141]\n", + " [57.96317815]\n", + " [61.08512045]\n", + " [59.10510888]\n", + " [60.21937925]\n", + " [61.00814328]\n", + " [59.16297447]\n", + " [60.28034152]\n", + " [61.69432809]\n", + " [57.71526519]\n", + " [59.38207926]\n", + " [59.20458413]\n", + " [60.08153114]\n", + " [60.1698427 ]\n", + " [59.01124681]\n", + " [59.48614337]\n", + " [59.43299963]\n", + " [59.85719209]\n", + " [60.39571047]\n", + " [61.12774218]\n", + " [61.23385475]\n", + " [60.81496405]\n", + " [59.33564438]\n", + " [60.17891651]\n", + " [62.55035785]]\n", + "Mean of the simulated vector: 60.0\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "# Number of observations\n", + "n = 25\n", + "\n", + "# Mean of the desired vector\n", + "desired_mean = 60\n", + "\n", + "# Spatial autoregressive parameter\n", + "rho = 0.5\n", + "\n", + "# Generate a spatial weights matrix W (e.g., random weights)\n", + "W = np.random.rand(n, n)\n", + "W = W / W.sum(axis=1)[:, np.newaxis] # Row-normalize W\n", + "\n", + "# Generate random error term epsilon\n", + "sigma = 1 # Standard deviation of the error term\n", + "epsilon = np.random.normal(0, sigma, size=(n, 1))\n", + "\n", + "# Simulate y using the SAR equation: y = (I - rho * W)^(-1) * epsilon\n", + "I = np.eye(n)\n", + "y = np.linalg.inv(I - rho * W) @ epsilon\n", + "\n", + "# Adjust the vector to have a mean of 60\n", + "y_adjusted = y - np.mean(y) + desired_mean\n", + "\n", + "# Reshape to ensure it's a 25x1 vector\n", + "y_adjusted = y_adjusted.reshape((n, 1))\n", + "\n", + "# Print the simulated vector\n", + "print(\"Simulated vector with mean 60:\")\n", + "print(y_adjusted)\n", + "print(f\"Mean of the simulated vector: {np.mean(y_adjusted)}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "b2f560c7-37ff-4d6b-92ad-6098bad2bb95", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulated vector with mean 60 and standard deviation 30:\n", + "[[ 30.34774906]\n", + " [ 5.61321136]\n", + " [ 64.31617731]\n", + " [ 47.16960984]\n", + " [ 40.69502379]\n", + " [ 61.29060489]\n", + " [ 29.48728248]\n", + " [ 64.93173035]\n", + " [ 85.3314396 ]\n", + " [ 13.08798606]\n", + " [ 37.80721574]\n", + " [ 31.9878886 ]\n", + " [ 57.51533994]\n", + " [ 70.09962914]\n", + " [ 45.85430486]\n", + " [ 48.74656631]\n", + " [ 44.79416714]\n", + " [ 58.99032309]\n", + " [ 86.42163388]\n", + " [107.68137292]\n", + " [ 88.82310993]\n", + " [ 80.87627414]\n", + " [ 60.92027067]\n", + " [ 93.55725214]\n", + " [143.65383678]]\n", + "Mean of the simulated vector: 60.0\n", + "Standard deviation of the simulated vector: 30.000000000000004\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "# Number of observations\n", + "n = 25\n", + "\n", + "# Desired mean and standard deviation\n", + "desired_mean = 60\n", + "desired_std = 30\n", + "\n", + "# Spatial autoregressive parameter\n", + "rho = 0.8\n", + "\n", + "# Generate a spatial weights matrix W (e.g., random weights)\n", + "W = np.random.rand(n, n)\n", + "W = W / W.sum(axis=1)[:, np.newaxis] # Row-normalize W\n", + "W = libpysal.weights.lat2W(5,5)\n", + "W.transform = 'r'\n", + "W = W.full()[0]\n", + "\n", + "# Generate random error term epsilon\n", + "sigma = 1 # Standard deviation of the error term\n", + "epsilon = np.random.normal(0, sigma, size=(n, 1))\n", + "\n", + "# Simulate y using the SAR equation: y = (I - rho * W)^(-1) * epsilon\n", + "I = np.eye(n)\n", + "y = np.linalg.inv(I - rho * W) @ epsilon\n", + "\n", + "# Step 1: Adjust to have the desired standard deviation\n", + "current_std = np.std(y)\n", + "y_scaled = y * (desired_std / current_std)\n", + "\n", + "# Step 2: Adjust to have the desired mean\n", + "current_mean = np.mean(y_scaled)\n", + "y_adjusted = y_scaled - current_mean + desired_mean\n", + "\n", + "# Reshape to ensure it's a 25x1 vector\n", + "y_adjusted = y_adjusted.reshape((n, 1))\n", + "\n", + "# Print the simulated vector\n", + "print(\"Simulated vector with mean 60 and standard deviation 30:\")\n", + "print(y_adjusted)\n", + "print(f\"Mean of the simulated vector: {np.mean(y_adjusted)}\")\n", + "print(f\"Standard deviation of the simulated vector: {np.std(y_adjusted)}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "6e973fca-219e-4b4c-9eef-235096ecac2e", + "metadata": {}, + "outputs": [], + "source": [ + "import esda" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "id": "fb4aa11d-2392-4791-b4f6-b8ce77bd6e18", + "metadata": {}, + "outputs": [], + "source": [ + "w = libpysal.weights.lat2W(5,5)\n", + "w.transform = 'r'" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "e0c08044-2294-4389-a0c1-b6b51dd13425", + "metadata": {}, + "outputs": [], + "source": [ + "res = esda.moran.Moran(y, w)" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "id": "1f80875a-586f-4b4e-9133-bbcf0b741b20", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.46970954423793404)" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res.I" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "e4833b58-8f78-488d-bdaf-e1cf00bafdff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.0006645744943399919)" + ] + }, + "execution_count": 130, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res.p_norm" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "id": "13d77794-2be7-4fa1-bcae-7cc7082df3f3", + "metadata": {}, + "outputs": [], + "source": [ + "wy = libpysal.weights.lag_spatial(w, y_adjusted)" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "d7576180-c441-41b0-9f57-d715272c124d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 33.45190812],\n", + " [ 41.38373628],\n", + " [ 39.23818385],\n", + " [ 63.4475469 ],\n", + " [ 30.12879795],\n", + " [ 32.54741576],\n", + " [ 40.9558588 ],\n", + " [ 59.16255983],\n", + " [ 48.82223884],\n", + " [ 57.29358942],\n", + " [ 47.3416866 ],\n", + " [ 42.40100132],\n", + " [ 56.50239279],\n", + " [ 68.78067957],\n", + " [ 63.62299604],\n", + " [ 57.1414976 ],\n", + " [ 55.15026303],\n", + " [ 62.41285291],\n", + " [ 82.58214432],\n", + " [ 91.97659184],\n", + " [ 64.81142022],\n", + " [ 64.84584925],\n", + " [ 77.80794979],\n", + " [ 96.99858044],\n", + " [100.61931253]])" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wy" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "dc21b455-9997-4333-bf96-469e0eec005a", + "metadata": {}, + "outputs": [], + "source": [ + "wyr = libpysal.weights.lag_spatial(w, np.random.permutation(y_adjusted))" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "87eb45b9-4b5a-4912-9aef-25362440c145", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[39.57874922],\n", + " [45.79804245],\n", + " [78.97744342],\n", + " [65.61006938],\n", + " [75.05685741],\n", + " [32.54741576],\n", + " [57.10613664],\n", + " [68.50510947],\n", + " [76.71388441],\n", + " [63.6822521 ],\n", + " [36.76605371],\n", + " [59.68093082],\n", + " [56.82169114],\n", + " [86.60776913],\n", + " [53.63380636],\n", + " [53.4911186 ],\n", + " [47.24513808],\n", + " [93.24792464],\n", + " [46.43915145],\n", + " [70.89752468],\n", + " [59.2178053 ],\n", + " [72.18241354],\n", + " [58.19952244],\n", + " [78.2660102 ],\n", + " [53.8684447 ]])" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wyr" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "ef3c9172-7bea-4327-b958-8f2e2d920865", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "KstestResult(statistic=array([0.16]), pvalue=array([0.91499322]), statistic_location=array([42.40100132]), statistic_sign=array([-1.]))" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ks_2samp(wyr, wy)" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "f0556e22-3234-437c-8d35-d7e068f476ee", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(59.17708216045005), np.float64(61.205650601843516))" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wy.mean(), wyr.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "53179cd8-51f8-402f-b82e-13d4d7d3a429", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(19.124769670399136), np.float64(15.18306374176247))" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wy.std(), wyr.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "11a28149-a9cd-49d4-a4ac-f198e377a6b6", + "metadata": {}, + "outputs": [], + "source": [ + "result = cramervonmises_2samp(wy, wyr)" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "5b5c0afe-2be1-424b-b301-40dfeea1308f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CramerVonMisesResult(statistic=[0.0712], pvalue=[0.77119716])" + ] + }, + "execution_count": 139, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "a12fdf73-60d0-4714-9ab6-6a91978a4345", + "metadata": {}, + "outputs": [], + "source": [ + "import inequality.gini" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "06e53e74-7bbf-4f97-b69c-fbfdba5f8608", + "metadata": {}, + "outputs": [], + "source": [ + "from inequality.gini import Gini" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "id": "87f639ac-cd31-4829-af47-889aa2c6ab76", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(13.65740614902654)" + ] + }, + "execution_count": 146, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Gini(wy).g" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "59bb7c20-cf22-4a6c-9923-194c9d55b53e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(15.772948960181928)" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Gini(wyr).g" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "id": "e1938bce-0497-4d9a-a274-fdca54d6e639", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Generate two sets of random data\n", + "data1 = np.random.normal(0, 1, size=1000)\n", + "data2 = np.random.normal(2, 0.5, size=1000)\n", + "\n", + "# Set the same range for both KDE plots\n", + "y = gdf.PCGDP1960\n", + "common_range = (min(wy.min(), wyr.min()) *.5, 1.5*max(wy.max(), wyr.max()))\n", + "\n", + "# Create the plot\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "\n", + "# Plot the second KDE\n", + "sns.kdeplot(wy, label='Spatial Lag', bw_adjust=0.5, clip=common_range)\n", + "\n", + "# Plot the random lag\n", + "sns.kdeplot(wyr, label='Spatial Lag (Random)', bw_adjust=0.5, clip=common_range)\n", + "\n", + "# Add labels and title\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.title('KDE of Three Distributions Over the Same Range')\n", + "plt.legend()\n", + "\n", + "# Show the plot\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "id": "7408967a-d25d-4297-a570-8c1b45225692", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(np.float64(-13.86162796406077), np.float64(-16.252926813534494))" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(wy), wolfson(wyr)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "4de509be-ab7b-4518-a99c-d08e38cea790", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":2: SyntaxWarning: invalid escape sequence '\\m'\n" + ] + }, + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mwolfson\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mincome_distribution\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mSource:\u001b[0m \n", + "\u001b[0;32mdef\u001b[0m \u001b[0mwolfson\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mincome_distribution\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"\u001b[0m\n", + "\u001b[0;34m Calculate the Wolfson Bipolarization Index for a given income distribution.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m The Wolfson index is constructed from the polarization curve,\u001b[0m\n", + "\u001b[0;34m which is a rotation and rescaling of the Lorenz curve by the\u001b[0m\n", + "\u001b[0;34m median income:\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m .. math::\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m W = (2D_{50} - G)\\\\frac{\\\\mu}{m}\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Where :math:`D_{50} =0.5 - L(0.5)`, :math:`L(0.5)` is the\u001b[0m\n", + "\u001b[0;34m value of the Lorenz curve at the median, :math:`G` is the Gini\u001b[0m\n", + "\u001b[0;34m index, :math:`\\mu` is the mean, and :math:`m` is the median.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m \u001b[0m\n", + "\u001b[0;34m See :cite:t:`wolfson1994WhenInequalities,hoffmann2024MeasuringMismeasuring`.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m \u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Parameters\u001b[0m\n", + "\u001b[0;34m ----------\u001b[0m\n", + "\u001b[0;34m income_distribution : list of int or float\u001b[0m\n", + "\u001b[0;34m A list representing the income distribution.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Returns\u001b[0m\n", + "\u001b[0;34m -------\u001b[0m\n", + "\u001b[0;34m w: float\u001b[0m\n", + "\u001b[0;34m The Wolfson Bipolarization Index value.\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m Example\u001b[0m\n", + "\u001b[0;34m -------\u001b[0m\n", + "\u001b[0;34m >>> income_distribution = [20000, 25000, 27000, 30000, 35000, 45000, 60000,\u001b[0m\n", + "\u001b[0;34m ... 75000, 80000, 120000]\u001b[0m\n", + "\u001b[0;34m >>> wolfson_index = wolfson(income_distribution)\u001b[0m\n", + "\u001b[0;34m >>> print(f\"Wolfson Bipolarization Index: {wolfson_index:.4f}\")\u001b[0m\n", + "\u001b[0;34m Wolfson Bipolarization Index: 0.2013\u001b[0m\n", + "\u001b[0;34m >>> income_distribution = [6, 6, 8, 8, 10, 10, 12, 12]\u001b[0m\n", + "\u001b[0;34m >>> wolfson_index = wolfson(income_distribution)\u001b[0m\n", + "\u001b[0;34m >>> print(f\"Wolfson Bipolarization Index: {wolfson_index:.4f}\")\u001b[0m\n", + "\u001b[0;34m Wolfson Bipolarization Index: 0.0833\u001b[0m\n", + "\u001b[0;34m >>> income_distribution = [2, 4, 6, 8, 10, 12, 14, 16]\u001b[0m\n", + "\u001b[0;34m >>> wolfson_index = wolfson(income_distribution)\u001b[0m\n", + "\u001b[0;34m >>> print(f\"Wolfson Bipolarization Index: {wolfson_index:.4f}\")\u001b[0m\n", + "\u001b[0;34m Wolfson Bipolarization Index: 0.1528\u001b[0m\n", + "\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mincome_distribution\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0my_med\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmedian\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mordinate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlorenz_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0ml50\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minterp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mordinate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0md50\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m.5\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0ml50\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mrat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0my_med\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGini\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0md50\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mrat\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFile:\u001b[0m ~/para/1_projects/code-pysal-inequality/inequality/inequality/wolfson.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wolfson??" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68a5c4e1-6a1b-4ed3-a69a-bb49b556d620", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/user-guide/viz/intro.rst b/docs/user-guide/viz/intro.rst new file mode 100644 index 00000000..b3ce8153 --- /dev/null +++ b/docs/user-guide/viz/intro.rst @@ -0,0 +1,11 @@ +.. _viz: + +============================== +Visualizing Spatial Inequality +============================== + +.. toctree:: + :maxdepth: 1 + + Lorenz Curves and Schutz Line + Pen's Parade and Pengrams diff --git a/docs/user-guide/viz/pengram.ipynb b/docs/user-guide/viz/pengram.ipynb new file mode 100644 index 00000000..42b8b611 --- /dev/null +++ b/docs/user-guide/viz/pengram.ipynb @@ -0,0 +1,641 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cf8f8182-169a-4fe9-92b5-2fa012b3b2fb", + "metadata": {}, + "source": [ + "# Pen's Parade and Pengrams\n", + "\n", + "This notebook explores the concepts of Pen's Parade and Pengrams, which are graphical methods used to depict income inequality, both at the individual level and in spatial analysis. The Pen's Parade, named after economist Jan Pen, illustrates the distribution of income by visualizing individuals as different heights proportional to their income. This notebook adapts the Pen's Parade for spatial data, treating regions as units and showing the spatial distribution of income levels across different areas. Through this approach, we can visualize income inequality both geographically and statistically, allowing for a clearer understanding of wealth concentration across regions. Additionally, the notebook demonstrates how to create weighted Pengrams, which adjust the visual representation based on factors such as population size.\n", + "\n", + "Although we illustrate these methods using income, it is important to highlight that the Pen's Parade and Pengram can be applied not only to income but to other variables like wealth, education levels, or even health metrics." + ] + }, + { + "cell_type": "markdown", + "id": "aef3cd69-bd75-469a-8e77-9f76353257f1", + "metadata": {}, + "source": [ + "## Data\n", + "To illustrate the concepts of Pen's Parade and Pengrams, this notebook utilizes data on per capita Gross Domestic Product (GDP) for Mexico's 32 states, covering the decades from 1940 to 2000. Per capita GDP is calculated by dividing the total GDP of a region by its population, providing a measure of the average economic output per person. This metric serves as a useful indicator of the standard of living and economic development across different states. By analyzing this data, we can effectively visualize and assess income inequality and economic disparities both over time and across various regions within Mexico.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "f75933de-3bc1-4dcd-95aa-fa89b06ae83c", + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6bc6ebcc-6dc3-4760-9434-4497a4203522", + "metadata": {}, + "outputs": [], + "source": [ + "gdf = gpd.read_file('weighted.shp')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "1fa5a919-b988-439c-a922-e4c071b53bc9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...TESTName_1PopulationNAMEppopulati_1Y2000y2000_1pStategeometry
055.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...5.0Aguascalientes944285Aguascalientes9442852.623413e+1027782.00.009647AguascalientesPOLYGON ((-101.8462 22.01176, -101.9653 21.883...
117.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...1.0Querétaro de Arteaga1404306Baja California Norte14043064.192556e+1029855.00.014347Baja California NorteMULTIPOLYGON (((-113.13972 29.01778, -113.2405...
227.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...2.0Baja California Sur424041Baja California Sur4240411.106874e+1026103.00.004332Baja California SurMULTIPOLYGON (((-111.20612 25.80278, -111.2302...
3155.016584e+10MX04Campeche1575361.1461.239620e+075016583.7233758.04929.05925.0...15.0Campeche690689Campeche6906892.497739e+1036163.00.007056CampecheMULTIPOLYGON (((-91.83446 18.63805, -91.84195 ...
4227.339157e+10MX05Chiapas1477195.1991.813538e+077339157.3762934.04138.05280.0...22.0Chiapas3920892Chiapas39208923.404903e+108684.00.040057ChiapasPOLYGON ((-91.4375 17.24111, -91.35278 17.1763...
\n", + "

5 rows × 43 columns

\n", + "
" + ], + "text/plain": [ + " POLY_ID AREA CODE NAME PERIMETER \\\n", + "0 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", + "1 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", + "2 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", + "3 15 5.016584e+10 MX04 Campeche 1575361.146 \n", + "4 22 7.339157e+10 MX05 Chiapas 1477195.199 \n", + "\n", + " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... TEST \\\n", + "0 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 5.0 \n", + "1 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 1.0 \n", + "2 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 2.0 \n", + "3 1.239620e+07 5016583.723 3758.0 4929.0 5925.0 ... 15.0 \n", + "4 1.813538e+07 7339157.376 2934.0 4138.0 5280.0 ... 22.0 \n", + "\n", + " Name_1 Population NAMEp populati_1 \\\n", + "0 Aguascalientes 944285 Aguascalientes 944285 \n", + "1 Querétaro de Arteaga 1404306 Baja California Norte 1404306 \n", + "2 Baja California Sur 424041 Baja California Sur 424041 \n", + "3 Campeche 690689 Campeche 690689 \n", + "4 Chiapas 3920892 Chiapas 3920892 \n", + "\n", + " Y2000 y2000_1 p State \\\n", + "0 2.623413e+10 27782.0 0.009647 Aguascalientes \n", + "1 4.192556e+10 29855.0 0.014347 Baja California Norte \n", + "2 1.106874e+10 26103.0 0.004332 Baja California Sur \n", + "3 2.497739e+10 36163.0 0.007056 Campeche \n", + "4 3.404903e+10 8684.0 0.040057 Chiapas \n", + "\n", + " geometry \n", + "0 POLYGON ((-101.8462 22.01176, -101.9653 21.883... \n", + "1 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", + "2 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", + "3 MULTIPOLYGON (((-91.83446 18.63805, -91.84195 ... \n", + "4 POLYGON ((-91.4375 17.24111, -91.35278 17.1763... \n", + "\n", + "[5 rows x 43 columns]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf.head()" + ] + }, + { + "cell_type": "markdown", + "id": "28d73a8e-842a-49f5-adb3-a0b90348fa2f", + "metadata": {}, + "source": [ + "## Pen's Parade\n", + "\n", + "\n", + "The parade proceeds from the poorest individuals to the wealthiest, where those with the lowest incomes appear as very short figures, while the wealthiest individuals tower above the rest. This visualization allows us to see the stark disparities in income distribution, often revealing that a large portion of the population has much lower incomes, with only a small percentage earning exceptionally high amounts. As the parade progresses, there is usually a gradual increase in height, but the final segment often shows a dramatic spike, symbolizing the extreme concentration of wealth in the hands of a few.\n", + "\n", + "This method is particularly powerful because it combines a vivid, intuitive picture with a clear, ordered progression of income distribution. The Pen’s Parade makes inequality tangible by visually showing not only the presence of inequality but also its scale and extremity. It emphasizes the vast differences between individuals at the lower and upper ends of the income spectrum, making it clear how much of the total wealth is held by the top earners. This graphical representation is useful in discussions about income inequality as it demonstrates the inequality's real-world impact, illustrating the imbalance in a way that is more immediate and relatable than abstract statistical measures alone, such as the Gini coefficient.\n", + "\n", + "For spatial analysis, the regions take the place of individuals, as the focus is on the spatial distribution of incomes, rather than the distribution of individual incomes." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "253bedb6-8989-4743-82d0-0636d24cfaa6", + "metadata": {}, + "outputs": [], + "source": [ + "from inequality.pen import pengram, pen" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "7430bd3d-7e84-49c5-9a2b-1f0bbd609ade", + "metadata": {}, + "outputs": [], + "source": [ + "col='PCGDP2000'\n", + "weight='p'\n", + "name='NAME'\n", + "figsize=(16,9)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "01ec901b-3fce-4752-8704-34ea00b8c844", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = pen(gdf,col, name)" + ] + }, + { + "cell_type": "markdown", + "id": "c97d9d12-24a7-473e-b708-c765412bbd72", + "metadata": {}, + "source": [ + "As can be seen in this Pen's Parade for 2000, the sharp rise at the end signifies concentration of income among the highest income states, suggesting high income inequality." + ] + }, + { + "cell_type": "markdown", + "id": "c403fc19-e7c2-44c5-b2ce-3b3b8d27d884", + "metadata": {}, + "source": [ + "### Pen Parade Options" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "544a9020-d8ad-40ae-a93e-80ca7ebd7e8e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = pen(gdf,col, name, xticks=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e51eeab1-ebdc-4c53-a0f2-5d2ad8b39cc2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p = pen(gdf, col, name, ascending=False)" + ] + }, + { + "cell_type": "markdown", + "id": "cbeff046-369b-4766-87ae-6b736db656fa", + "metadata": {}, + "source": [ + "## Weighted Pen's Parade\n", + "\n", + "Weighting the Pengram by population size provides a more nuanced understanding of inequality. Without weighting, each state’s income distribution may obscure the fact that some regions have larger populations, which can distort how we perceive inequality on a per-person basis." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fd7973a7-3a84-438a-89c7-f642d7eeda33", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjUAAAN5CAYAAABAIbm5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hU1eL18TXpPVKTIB0hgIAUFQJI6B1EUASUIhaKEuoPKSJRKZeuUiyIVJErICCgSBFEpINBBESpkU5CCIH05Lx/cDOvQxJIIOEw4ft5njw3s/eeM2uOgauzcvaxGIZhCAAAAAAAAAAA4AHnYHYAAAAAAAAAAACArKDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAB4yCxbtkwWi0X//e9/08098cQTslgs+vHHH9PNlSlTRtWrV8/Wa/Xo0UMlS5a8q5yhoaGyWCyKiIi449px48Zp5cqVd/U6t3Pq1ClZLBbNmzfvtuu2bNkii8Vi/XJ0dJSfn59eeOEFHTlyJMdz3Un9+vVt8ri7u+uJJ57Qhx9+qNTU1PueJzNZPb+54cqVK+rUqZMKFy4si8Widu3aZbo27Xw2b9483Vzae5g8eXKGz/3uu+9ksVhUoEABJSQkZLimZMmSslgsql+/fobzCxYssP6z3LJli3U87c9IZl+nTp3K9D2lvW7r1q1vuyYn3JrL19dX9evX19q1a9OtTUhI0IwZM1S3bl3ly5dPLi4uevTRR9WxY0f9/PPP6dafPHlSISEhqlChgjw9PeXm5qaSJUvq5Zdf1ubNm2UYhnXtvHnzbHK4ubnJ399fDRo00Pjx43Xp0qV0x7/1HLu4uKhUqVLq37+/rl69al33008/qWfPnipfvrw8PT316KOP6tlnn9W+ffsyPCf79+9X48aN5eXlpUceeUTt27fXiRMnMlw7ffp0lS9fXq6uripVqpTee+89JSUlpVt36dIl9ejRQwULFpSHh4eCgoK0adOmDI8JAABgzyg1AAAAHjJpH9Bu3rzZZvzKlSs6ePCgPD09082dOXNGJ06cUIMGDbL1WqNGjdKKFSvuOfOd5FapcTc5duzYoc2bN+vtt9/Whg0bVKdOHZ09e/a+ZyldurR27NihHTt26L///a8effRRDRw4UMOHD7/vWR5EH3zwgVasWKFp06Zpx44dmjhx4h2f8+OPP+qnn37K1uvMmTNH0s0/X7f7GfX29tbWrVt1/PjxdHNffvmlfHx8Mn3uunXrrP+s//0VEBCQray56fnnn9eOHTv066+/aubMmbpw4YLatGljU2xERESoTp06GjRokCpVqqR58+Zp06ZNmjJlihwdHdWoUSMdOHDAuv67775T5cqV9d1336l79+5asWKFfvzxR40aNUqRkZFq2LBhhv+85s6dqx07dmjDhg2aOXOmqlatqgkTJqhChQrauHFjhvnTzvHatWvVrl07TZ8+XS1atLCWJp988olOnTql/v376/vvv9dHH32kS5cuqVatWuky/Pnnn6pfv74SExP1zTff6Msvv9Rff/2lZ555RpcvX7ZZO3bsWPXv31/t27fXjz/+qL59+2rcuHF68803bdYlJCSoUaNG2rRpkz766COtWrVKfn5+at68eYZlEAAAgF0zAAAA8NCpXLmyERgYaDP27bffGs7OzkZISIjx9NNP28wtWLDAkGSsXr36vmUcPXq0Icm4fPnyHdd6enoa3bt3z/EMJ0+eNCQZc+fOve26zZs3G5KMpUuX2ozPmTPHkGSMGTMmx7PdTnBwsPH444/bjCUmJhqlS5c2PDw8jMTExHs6fmJiopGUlHRPxzCMrJ/f3NC4cWOjQoUKWVobHBxslCtXzihdurRRo0YNIzU11TqX9h4mTZqU7nnnz583nJycjIYNGxpubm5GkyZNMjx+iRIljBYtWhhFixY1RowYYTN37Ngxw2KxGK+//rohydi8ebN1Ljt/RjJ73VatWt3Vc7NDkvHmm2/ajB07dsyQZDRu3Ng61qJFC8PJycnYtGlThsfZvXu3cfr0aevzPTw8jKeeesqIjo7OcP3mzZuNsLAw6+O5c+cakow9e/akW3v69GmjWLFihre3t3HhwgXreGbnuGvXroYkY9u2bYZhGMbFixfTHTMmJsbw8/MzGjVqZDP+wgsvGAULFrTJferUKcPZ2dkYOnSodSwiIsJwc3Mz3njjDZvnjx071rBYLMahQ4esYzNnzjQkGdu3b7eOJSUlGRUrVkz39zkAAIC940oNAACAh1CDBg109OhRnT9/3jq2ZcsWPfXUU2rZsqX27dunmJgYmzlHR0c988wzkiTDMDRr1ixVrVpV7u7uypcvn55//vl026dktP3U1atX9eqrryp//vzy8vJSq1atdOLECVksFoWGhqbLevHiRXXu3Fm+vr7y8/NTz549FR0dbZ23WCy6ceOG5s+fb90i5t/b+Fy4cEG9evVS0aJFrVvHvPfee0pOTrZ5nXPnzqljx47y9vaWr6+vXnzxRV24cCG7p9ZGrVq1JEmnT5+2jv33v/9VUFCQPD095eXlpWbNmum3336zeV6PHj3k5eWlY8eOqWXLlvLy8lKxYsU0ePDgTLcwuhNnZ2fVqFFDsbGxunz5so4dO6ZXXnlFZcuWlYeHhx599FG1adNGBw8etHle2tZaCxcu1ODBg/Xoo4/K1dVVx44d0+XLl9W3b19VrFhRXl5eKly4sBo2bKhffvkl3etn5/zu3btXbdu2Vf78+eXm5qZq1arpm2++ydL7vHLlivr27atHH31ULi4uKl26tEaOHGk9b2nbRW3cuFFHjhzJcFunzM7f2LFjtW/fvgy3bsvI/PnzlZycrIEDB6p9+/batGmTzc/Cvzk4OKhbt26aP3++zRZhX375pYoVK6bGjRtn6TXvxooVK1SlShW5ubmpdOnS+vjjj61z169f1yOPPKJevXqle96pU6fk6OioSZMmZfs1y5Qpo0KFClnPx759+/TDDz/o1VdfVcOGDTN8zlNPPaXixYtLkqZOnarY2FjNmjUr06tY6tevryeeeCJLeYoXL64pU6YoJiZGn3322R3X3/pnu3DhwunWeHl5qWLFivrnn3+sY8nJyVqzZo06dOhgk7tEiRJq0KCBzZVt69atU3x8vF555RWb477yyisyDMPmyp8VK1YoMDBQQUFB1jEnJye9/PLL2r17tylXiwEAAOQWSg0AAICHUNo2Uv/+IHfz5s0KDg5WnTp1ZLFYbD6Y3rx5s6pXry5fX19JUq9evTRgwAA1btxYK1eu1KxZs3To0CHVrl1bFy9ezPR1U1NT1aZNGy1evFhvv/22VqxYoZo1a2Z4r4I0HTp0ULly5bR8+XINGzZMixcv1sCBA63zO3bskLu7u1q2bGnddmfWrFmSbhYaTz/9tH788Ue9++671g9Nx48fr9dff916jLi4ODVu3Fjr16/X+PHjtXTpUvn7++vFF1/M3om9xbFjxyRJhQoVknRze6rOnTurYsWK+uabb7Rw4ULFxMTomWee0eHDh22em5SUpLZt26pRo0ZatWqVevbsqWnTpmnChAl3nef48eNycnJSvnz5dO7cORUoUED/+c9/tG7dOs2cOVNOTk6qWbOmjh49mu65w4cPV3h4uD799FOtXr1ahQsX1pUrVyRJo0eP1tq1azV37lyVLl1a9evXt/nZys753bx5s+rUqaOrV6/q008/1apVq1S1alW9+OKLd7z3Rnx8vBo0aKAFCxZo0KBBWrt2rV5++WVNnDhR7du3lyQFBARox44dqlatms0WXVm5X8yLL76oGjVq6J133snwnga3+vLLLxUQEKAWLVqoZ8+eSk1Nve176Nmzp86dO2e9p01KSormz5+vHj16yMEh8/90S0lJUXJyss1XSkrKHfNJUlhYmAYMGKCBAwdqxYoVql27tvr372+9R4iXl5d69uypr776yqZMlKRZs2bJxcVFPXv2zNJr/VtUVJQiIyOtfzbWr18vSbe9t8m/bdiwQQEBAXryySez/dqZadmypRwdHbV169Y7rr31z3ZGoqOjtX//fj3++OPWsePHjysuLk5VqlRJt75KlSo6duyY4uPjJUl//PGHJKly5co26wICAlSwYEHrfNrazI4pSYcOHbrjewIAALAbZl8qAgAAgPvvypUrhoODg3Vbk4iICMNisRjr1q0zDMMwnn76aWPIkCGGYRhGeHi4Icm6LcqOHTsMScaUKVNsjvnPP/8Y7u7uNtundO/e3ShRooT18dq1aw1JxieffGLz3PHjxxuSjNGjR1vH0rZ9mThxos3avn37Gm5ubjZbAGW2/VSvXr0MLy8v65Y1aSZPnmxIsm7f8sknnxiSjFWrVtmsS9vyJ6vbT/33v/81kpKSjNjYWGPr1q3GY489Zjg6OhoHDhwwwsPDDScnJ6Nfv342z42JiTH8/f2Njh07Wse6d+9uSDK++eYbm7UtW7ZMt21YRtK2n0pKSjKSkpKMc+fOGcOGDTMkGS+88EKGz0lOTjYSExONsmXLGgMHDkz33urVq3fH101OTjaSkpKMRo0aGc8995x1PDvnt3z58ka1atXSbW/VunVrIyAgwEhJScn09T/99NMMz9uECRMMScb69eutYxlt0ZWZf6/duHGjIcmYPn26YRiZbz+1detWQ5IxbNgwwzAMIzU11ShVqpRRokQJm59dw7DdBio4ONh4/vnnDcO4+efFYrEYJ0+eNJYuXZrp9lMZfZUpU+aO76tEiRKGxWKx2aLJMAyjSZMmho+Pj3Hjxg3DMAzj+PHjhoODgzFt2jTrmri4OKNAgQLGK6+8csfXkWT07dvXSEpKMhITE40jR44YLVq0MCQZM2fONAzDMHr37m1IMv788887Hs8wDMPNzc2oVatWuvGUlBTrz31SUpLNz8vttp9K4+fnZ7MtWdo5vnDhgpGUlGRERUUZixYtMtzd3Y1ixYoZcXFxmR7rpZdeMpycnIy9e/dax3799VdDkvH111+nWz9u3DhDknHu3DnDMG7++XB1dc3w2OXKlTOaNm1qfezs7Gz06tUr3brt27cbkozFixdnmhMAAMDecKUGAADAQyhfvnx64oknrL9N//PPP8vR0VF16tSRJAUHB1tvFp72v2lXd6xZs0YWi0Uvv/yyzW+G+/v72xwzI2k3rO3YsaPNeOfOnTN9Ttu2bW0eV6lSRfHx8bp06dId3+eaNWvUoEEDFSlSxCZrixYtbPJs3rxZ3t7e6V6rS5cud3yNf3vxxRfl7OwsDw8P1atXTykpKVq2bJmqVKmiH3/8UcnJyerWrZtNFjc3NwUHB6c7bxaLRW3atEn33jPbvuhWhw4dkrOzs5ydnVWkSBFNmTJFL730kmbPni3p5jY448aNU8WKFeXi4iInJye5uLjo77//1pEjR9Idr0OHDhm+zqeffqrq1avLzc1NTk5OcnZ21qZNm2yOkdXze+zYMf3555966aWXrBnTvlq2bKnz589neBVJmp9++kmenp56/vnnbcZ79OghSdq0aVOmz82qRo0aqWnTpnr//fdttmi7VdoNwtOuYrBYLOrRo4dOnz592xw9e/bUd999p8jISM2ZM0cNGjRIt4XbrTZu3Kg9e/bYfN3upuT/9vjjj6fboqlLly66du2a9u/fL+nmTedbt26tWbNmWW+MvXjxYkVGRuqtt97K0uvMmjVLzs7OcnFxUYUKFbR9+3a9//776tu3b5aen1Xt27e3/tw7OzsrJCQkW89Pe3+38vf3l7Ozs/Lly6eXX35Z1atX17p16+Tm5pbh+lGjRumrr77StGnTVKNGjXTzFosl0wz/nsvquuyuBQAAsGdOZgcAAACAORo0aKCpU6fq3Llz2rx5s2rUqCEvLy9JN0uNKVOmKDo6Wps3b5aTk5Pq1q0r6eY9LgzDkJ+fX4bHLV26dKavGRkZKScnJ+XPn99mPLNjSVKBAgVsHru6ukq6uaXRnVy8eFGrV6+Ws7NzhvMRERHWXBll8Pf3v+Nr/NuECRPUsGFDOTo6qmDBgipWrJhNFunmfQEycuv2Qh4eHuk+MHV1dbVuTXMnZcqU0ZIlS2SxWOTm5qZSpUrJw8PDOj9o0CDNnDlTb7/9toKDg5UvXz45ODjotddey/DcBgQEpBubOnWqBg8erN69e+uDDz5QwYIF5ejoqFGjRtmUGlk9v2nnaMiQIRoyZEiG7yvtn1lGIiMj5e/vn+4D3MKFC8vJyUmRkZGZPjc7JkyYoOrVq2vy5Mnp7ncgSTExMVq6dKmefvppFSpUSFevXpUkPffccwoNDdWcOXMyvUfG888/r379+mnatGlavXr1HbfckqQnnnhCBQsWvKv3ktHPeNrYv89X//791ahRI23YsEFNmzbVzJkzFRQUlKVtu6SbReb//d//yWKxyNvbW2XKlJGjo6N1Pu1eGSdPnlRgYOAdj1e8ePEMC74pU6bonXfekZT5n7XM3LhxQ5GRkem2e5JuFke+vr5ydnZW0aJF0/299G/vvfeexowZo7Fjx6YrfdKel9HP4pUrV2SxWPTII49Y18bHxys2Ntbmz27a2n+XJQUKFMj0mJLS/Z0LAABgzyg1AAAAHlJppcaWLVu0ZcsWtWzZ0jqXVmBs3brVegPxtMKjYMGC1ntupBUM/5bRWJoCBQooOTlZV65csfmQ7V5vyJ2ZggULqkqVKho7dmyG80WKFLHm2r17d7r57OYqXbp0pnv8p33ovGzZMpUoUSJbx70bbm5ut73fwKJFi9StWzeNGzfOZjwiIsL6oeq/ZfSb3osWLVL9+vX1ySef2IzfegVDVs9v2jkaPny49R4Yt7rdB94FChTQrl27ZBiGTd5Lly4pOTn5rj/4v1XVqlXVuXNnTZ061ebPTZqvv/5asbGx2r17t/Lly5dufsWKFYqKispwzsPDQ506ddL48ePl4+OT6XnIKRn9jKeN/fuD+4YNG6pSpUqaMWOGvLy8tH//fi1atCjLr1OoUKHb/jw2a9ZMI0aM0MqVK297j500TZo00cyZM7V3716b45YpUybLmW61du1apaSkqH79+unmslocvffeewoNDVVoaKhGjBiRbr5MmTJyd3fXwYMH080dPHhQjz32mLXMTCtXDh48qJo1a1rXXbhwQREREapUqZJ1rHLlypkeU5LNWgAAAHvH9lMAAAAPqXr16snR0VHLli3ToUOHbD7I8/X1VdWqVTV//nydOnXKuvWUJLVu3VqGYejs2bN68skn031l9FvOaYKDgyVJ//3vf23GlyxZck/vxdXVNcOrC1q3bq0//vhDZcqUyTBrWqnRoEEDxcTE6LvvvrN5/uLFi+8p1781a9ZMTk5OOn78eIZZcvKGx1lhsVjSFVBr167V2bNn7+kYv//+u3bs2GEzltXzGxgYqLJly+rAgQOZniNvb+9M8zRq1EjXr19Pt/XSggULrPM5ZcyYMUpMTNR7772Xbm7OnDny9vbWpk2btHnzZpuvSZMmKSEhQV999VWmx+7Tp4/atGmjd999N9PtjXLKoUOHdODAAZuxxYsXy9vbO91VGCEhIVq7dq2GDx8uPz8/vfDCCzmWo3r16mrRooXmzJmjn376KcM1e/fuVXh4uCRp4MCB8vDw0JtvvnnbbcCyKjw8XEOGDJGvr6969ep1V8f44IMPFBoaqnfeeUejR4/OcI2Tk5PatGmjb7/91iZ3eHi4Nm/ebFNiNW/eXG5ubumu1pk3b54sFovNTdWfe+45/fnnn9q1a5d1LDk5WYsWLVLNmjWtf9cBAADkBVypAQAA8JDy8fFR9erVtXLlSjk4OFjvp5EmODhYH374oSTZlBp16tTRG2+8oVdeeUV79+5VvXr15OnpqfPnz2vbtm2qXLmy+vTpk+FrNm/eXHXq1NHgwYN17do11ahRQzt27LB+6HzrFkxZVblyZW3ZskWrV69WQECAvL29FRgYqPfff18bNmxQ7dq1FRISosDAQMXHx+vUqVP6/vvv9emnn6po0aLq1q2bpk2bpm7dumns2LEqW7asvv/+e/344493lScjJUuW1Pvvv6+RI0fqxIkTat68ufLly6eLFy9q9+7d8vT0zPAD8tzSunVrzZs3T+XLl1eVKlW0b98+TZo0SUWLFs3WMT744AONHj1awcHBOnr0qN5//32VKlVKycnJ1nXZOb+fffaZWrRooWbNmqlHjx569NFHdeXKFR05ckT79+/X0qVLM83TrVs3zZw5U927d9epU6dUuXJlbdu2TePGjVPLli0z3fLpbpQqVUp9+vTRRx99ZDP+xx9/aPfu3erTp48aNmyY7nl16tTRlClTNGfOnEzvR1G1atUs3xNDkvbt2ydfX9904xUrVpSPj89tn1ukSBG1bdtWoaGhCggI0KJFi7RhwwZNmDAh3ZZHL7/8soYPH66tW7fqnXfekYuLS5YzZsWCBQvUvHlztWjRQj179lSLFi2UL18+nT9/XqtXr9bXX3+tffv2qXjx4ipTpoy+/vprde7c2fp3TvXq1eXq6qpLly5p/fr1kpTh+//jjz+s92q5dOmSfvnlF82dO1eOjo5asWKFChUqlO3sU6ZM0bvvvqvmzZurVatW2rlzp818rVq1rN+/9957euqpp9S6dWsNGzZM8fHxevfdd1WwYEENHjzYui5//vx65513NGrUKOXPn19NmzbVnj17FBoaqtdee00VK1a0ru3Zs6dmzpypF154Qf/5z39UuHBhzZo1S0ePHtXGjRuz/X4AAAAeaKbephwAAACmGjp0qCHJePLJJ9PNrVy50pBkuLi4GDdu3Eg3/+WXXxo1a9Y0PD09DXd3d6NMmTJGt27djL1791rXdO/e3ShRooTN865cuWK88sorxiOPPGJ4eHgYTZo0MXbu3GlIMj766CPrutGjRxuSjMuXL9s8f+7cuYYk4+TJk9axsLAwo06dOoaHh4chyQgODrbOXb582QgJCTFKlSplODs7G/nz5zdq1KhhjBw50rh+/bp13ZkzZ4wOHToYXl5ehre3t9GhQwdj+/bthiRj7ty5tz2PmzdvNiQZS5cuve06w7h5Xhs0aGD4+PgYrq6uRokSJYznn3/e2Lhxo8158/T0TPfctHNyJ8HBwcbjjz9+2zVRUVHGq6++ahQuXNjw8PAw6tata/zyyy9GcHCwzfm73XtLSEgwhgwZYjz66KOGm5ubUb16dWPlypUZ/nPPzvk9cOCA0bFjR6Nw4cKGs7Oz4e/vbzRs2ND49NNP7/jeIyMjjd69exsBAQGGk5OTUaJECWP48OFGfHx8ts/RndZevnzZ8PHxMSQZkyZNMgzDMAYMGGBIMsLCwjI93rBhwwxJxr59+wzDMIwSJUoYrVq1um2GpUuXGpKMzZs3W8fSfh4y+9qwYcNtj5n2usuWLTMef/xxw8XFxShZsqQxderUTJ/To0cPw8nJyThz5sxtj/1vkow333wzS2vj4uKMjz/+2AgKCjJ8fHwMJycno0iRIkb79u2NtWvXplt//Phxo1+/fkZgYKDh7u5u/TP1wgsvGCtWrDBSU1Ota9P+7kj7cnFxMQoXLmwEBwcb48aNMy5dupTu+Jn9PXSr4ODg2/6zuNXevXuNRo0aGR4eHoaPj4/Rrl0749ixYxke+6OPPjLKlStnuLi4GMWLFzdGjx5tJCYmplt34cIFo1u3bkb+/PkNNzc3o1atWnf8GQAAALBHFsMwjNwuTgAAAIDbWbx4sV566SX9+uuvql27ttlxAGQgMTFRJUuWVN26dfXNN9+YHQcAAAAPKbafAgAAwH319ddf6+zZs6pcubIcHBy0c+dOTZo0SfXq1aPQAB5Aly9f1tGjRzV37lxdvHhRw4YNMzsSAAAAHmKUGgAAALivvL29tWTJEo0ZM0Y3btxQQECAevTooTFjxpgdDUAG1q5dq1deeUUBAQGaNWtWuhuIAwAAAPcT208BAAAAAAAAAAC74GB2AAAAAAAAAAAAgKyg1AAAAAAAAAAAAHaBe2rkoNTUVJ07d07e3t6yWCxmxwEAAAAAAAAAwC4YhqGYmBgVKVJEDg6ZX49BqZGDzp07p2LFipkdAwAAAAAAAAAAu/TPP/+oaNGimc5TauQgb29vSTdPuo+Pj8lpAAAAAAAAAACwD9euXVOxYsWsn7NnhlIjB6VtOeXj40OpAQAAAAAAAABANt3p1g7cKBwAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBUoNAAAAAAAAAABgFyg1AAAAAAAAAACAXaDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBUoNAAAAAAAAAABgFyg1AAAAAAAAAACAXaDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBSezAwAAAAAAAAAAkCY8PFwRERFZXp+QkCBXV9ccX3s/1hcsWFDFixfP8npQagAAAAAAAAAAHhDh4eEqX6G84mLjsvwci4NFRqqR42vvx3p3D3f9eeRPio1soNQAAAAAAAAAADwQIiIiFBcbp1emdVLAY4XvuP7g5j+1eur6LK3Pztr7sf78sUuaO3CJIiIiKDWygVIDAAAAAAAAAPBACXissIpXKnrHdReOXcry+uysvR/rcXe4UTgAAAAAAAAAALALlBoAAAAAAAAAAMAuUGoAAAAAAAAAAAC7QKkBAAAAAAAAAADsAqUGAAAAAAAAAACwC5QaAAAAAAAAAADALlBqAAAAAAAAAAAAu0CpAQAAAAAAAAAA7AKlBgAAAAAAAAAAsAuUGgAAAAAAAAAAwC5QagAAAAAAAAAAALtAqQEAAAAAAAAAAOwCpQYAAAAAAAAAALALlBoAAAAAAAAAAMAuUGoAAAAAAAAAAAC7QKkBAAAAAAAAAADsAqUGAAAAAAAAAACwC5QaAAAAAAAAAADALlBqAAAAAAAAAAAAu0CpAQAAAAAAAAAA7AKlBgAAAAAAAAAAsAuUGgAAAAAAAAAAwC5QagAAAAAAAAAAALtAqQEAAAAAAAAAAOwCpQYAAAAAAAAAALALlBoAAAAAAAAAAMAuUGoAAAAAAAAAAAC7QKkBAAAAAAAAAADsAqUGAAAAAAAAAACwC5QaAAAAAAAAAADALlBqAAAAAAAAAAAAu0CpAQAAAAAAAAAA7AKlBgAAAAAAAAAAsAuUGgAAAAAAAAAAwC5QagAAAAAAAAAAALtAqQEAAAAAAAAAAOwCpQYAAAAAAAAAALALlBoAAAAAAAAAAMAuUGoAAAAAAAAAAAC7QKkBAAAAAAAAAADsAqUGAAAAAAAAAACwC5QaAAAAAAAAAADALlBqAAAAAAAAAAAAu0CpAQAAAAAAAAAA7AKlBgAAAAAAAAAAsAuUGgAAAAAAAAAAwC5QagAAAAAAAAAAALtgaqkRGhoqi8Vi8+Xv72+dNwxDoaGhKlKkiNzd3VW/fn0dOnTI5hgJCQnq16+fChYsKE9PT7Vt21ZnzpyxWRMVFaWuXbvK19dXvr6+6tq1q65evWqzJjw8XG3atJGnp6cKFiyokJAQJSYm5tp7BwAAAAAAAAAA2WP6lRqPP/64zp8/b/06ePCgdW7ixImaOnWqZsyYoT179sjf319NmjRRTEyMdc2AAQO0YsUKLVmyRNu2bdP169fVunVrpaSkWNd06dJFYWFhWrdundatW6ewsDB17drVOp+SkqJWrVrpxo0b2rZtm5YsWaLly5dr8ODB9+ckAAAAAAAAAACAO3IyPYCTk83VGWkMw9CHH36okSNHqn379pKk+fPny8/PT4sXL1avXr0UHR2tOXPmaOHChWrcuLEkadGiRSpWrJg2btyoZs2a6ciRI1q3bp127typmjVrSpJmz56toKAgHT16VIGBgVq/fr0OHz6sf/75R0WKFJEkTZkyRT169NDYsWPl4+OTYfaEhAQlJCRYH1+7di1Hzw0AAAAAAAAAAPj/TL9S4++//1aRIkVUqlQpderUSSdOnJAknTx5UhcuXFDTpk2ta11dXRUcHKzt27dLkvbt26ekpCSbNUWKFFGlSpWsa3bs2CFfX19roSFJtWrVkq+vr82aSpUqWQsNSWrWrJkSEhK0b9++TLOPHz/euqWVr6+vihUrlgNnBAAAAAAAAAAAZMTUUqNmzZpasGCBfvzxR82ePVsXLlxQ7dq1FRkZqQsXLkiS/Pz8bJ7j5+dnnbtw4YJcXFyUL1++264pXLhwutcuXLiwzZpbXydfvnxycXGxrsnI8OHDFR0dbf36559/snkGAAAAAAAAAABAVpm6/VSLFi2s31euXFlBQUEqU6aM5s+fr1q1akmSLBaLzXMMw0g3dqtb12S0/m7W3MrV1VWurq63zQIAAAAAAAAAAHKG6dtP/Zunp6cqV66sv//+23qfjVuvlLh06ZL1qgp/f38lJiYqKirqtmsuXryY7rUuX75ss+bW14mKilJSUlK6KzgAAAAAAAAAAIA5HqhSIyEhQUeOHFFAQIBKlSolf39/bdiwwTqfmJion3/+WbVr15Yk1ahRQ87OzjZrzp8/rz/++MO6JigoSNHR0dq9e7d1za5duxQdHW2z5o8//tD58+eta9avXy9XV1fVqFEjV98zAAAAAAAAAADIGlO3nxoyZIjatGmj4sWL69KlSxozZoyuXbum7t27y2KxaMCAARo3bpzKli2rsmXLaty4cfLw8FCXLl0kSb6+vnr11Vc1ePBgFShQQPnz59eQIUNUuXJlNW7cWJJUoUIFNW/eXK+//ro+++wzSdIbb7yh1q1bKzAwUJLUtGlTVaxYUV27dtWkSZN05coVDRkyRK+//rp8fHzMOTkAAAAAAAAAAMCGqaXGmTNn1LlzZ0VERKhQoUKqVauWdu7cqRIlSkiShg4dqri4OPXt21dRUVGqWbOm1q9fL29vb+sxpk2bJicnJ3Xs2FFxcXFq1KiR5s2bJ0dHR+uar776SiEhIWratKkkqW3btpoxY4Z13tHRUWvXrlXfvn1Vp04dubu7q0uXLpo8efJ9OhMAAAAAAAAAAOBOTC01lixZctt5i8Wi0NBQhYaGZrrGzc1N06dP1/Tp0zNdkz9/fi1atOi2r1W8eHGtWbPmtmsAAAAAAAAAAIB5Hqh7agAAAAAAAAAAAGSGUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBUoNAAAAAAAAAABgFyg1AAAAAAAAAACAXaDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBUoNAAAAAAAAAABgFyg1AAAAAAAAAACAXaDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBUoNAAAAAAAAAABgFyg1AAAAAAAAAACAXaDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBUoNAAAAAAAAAABgFyg1AAAAAAAAAACAXaDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBUoNAAAAAAAAAABgFyg1AAAAAAAAAACAXaDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAAAAANgFSg0AAAAAAAAAAGAXKDUAAAAAAAAAAIBdoNQAAAAAAAAAAAB2gVIDAAAAAAAAAADYBUoNAAAAAAAAAABgFyg1AAAAAAAAAACAXaDUAAAAAAAAAAAAdoFSAwAAAAAAAAAA2AVKDQAAAAAAAAAAYBcoNQAAAAAAAAAAgF2g1AAAAAAAAAAAAHaBUgMAAAAAAADIg1JSUvTRRx/prbfekiQdP35cP/30k8mpAODeOJkdAAAAAAAAAEDO69evn5KSkrRt2zZJUoECBdSpUyft2bPH5GQAcPcoNQAAAAAAAIA8aPv27QoLC1O1atUkSY888ogSExNNTgUA94btpwAAAAAAAIA8yM3NzeZxSkqKUlNTTUoDADmDUgMAAAAAAADIg6pUqaKvvvpKhmHo1KlT6tu3r+rVq2d2LAC4J5QaAAAAAAAAQB40depUbd26VefPn1fNmjWVmpqqCRMmmB0LAO4J99QAAAAAAAAA8iAvLy999tln+uyzz8yOAgA5hlIDAAAAAAAAyKN27dql48ePKzk52TrWrVs3ExMBwL2h1AAAAAAAAADyoD59+ujHH39U1apV5ejoKEmyWCyUGgDsGqUGAAAAAAAAkAdt3LhRhw8flpubm9lRACDHcKNwAAAAAAAAIA8KCAig0ACQ53ClBgAAAAAAAJCHfP/995Kk2rVrq2PHjurUqZNNudGyZUuzogHAPaPUAAAAAAAAAPKQSZMm2TyePn269XuLxUKpAcCuUWoAAAAAAAAAecjmzZvNjgAAuYZ7agAAAAAAAAB50Oeff64rV65YH0dGRmr27NkmJgKAe0epAQAAAAAAAORBs2bNUv78+a2PCxQooJkzZ5qYCADuHaUGAAAAAAAAkAcZhpFuLDU11YQkAJBzKDUAAAAAAACAPCggIEDLly+3Pl6+fLn8/f1NTAQA944bhQMAAAAAAAB50Icffqhnn31Wb7/9tiTJxcVFq1atMjkVANwbSg0AAAAAAAAgDypfvrwOHz6so0ePSpICAwPl6OhocioAuDdsPwUAAAAAAADkUWvWrNHq1atVsWJFXbx4UQcPHjQ7EgDcE0oNAAAAAAAAIA8KDQ3Vp59+qjlz5kiSLBaLevfubXIqALg3lBoAAAAAAABAHrRy5UqtWbNGnp6ekm7eODwmJsbkVABwbyg1AAAAAAAAgDzIzc2Ne2gAyHO4UTgAAAAAAACQB5UoUULbtm2TxWJRamqqxo0bp8qVK5sdCwDuCaUGAAAAAAAAkAd9/PHH6t69u/744w95eHjomWee0VdffWV2LAC4J5QaAAAAAAAAQB7k5+endevWKTY2VqmpqfLy8jI7EgDcM0oNAAAAAAAAII9atmyZNm7cKIvFoiZNmqh9+/ZmRwKAe8KNwgEAAAAAAIA8aOjQoZowYYIqVKig8uXLa8KECRo2bJjZsQDgnnClBgAAAAAAAJScnKzExETrYw8PDxPTICesWrVKYWFhcnd3lyS98cYbqlq1qv7zn/+YnAwA7h5XagAAAAAAADzEdu/ercqVK8vNzU3e3t7WL9i/IkWKyNXV1frYxcVFRYoUMTERANw7rtQAAAAAAAB4iIWEhOiLL75Q7969tXXrVn388cfW3+yHfatatapatmyp7t27S5IWLlyoOnXq6Pvvv5cktWzZ0sx4AHBXKDUAAAAAAAAeYklJSapZs6aSk5Pl7e2tkSNHqn79+ho0aJDZ0XCPwsLCJEmff/65dezXX3/Vr7/+KovFQqkBwC5RagAAAAAAADzEnJxufjxUoEABhYWFqWjRojp9+rTJqZATNm/ebHYEAMhxlBoAAAAAAAAPsU6dOikyMlIjRoxQvXr1lJycrPfee8/sWMghx44d04kTJ5ScnGwd4woNAPaMUgMAAAAAAOAhNnDgQElS06ZNFRkZqfj4eG4UnkcMHjxYixYtUmBgoBwdHSWJbacA2D1KDQAAAAAAgIdYo0aNNGrUKNWvX1/Ozs5ydnbWG2+8YXMfBtinVatW6eTJk/Lw8DA7CgDkGAezA6QZP368LBaLBgwYYB0zDEOhoaEqUqSI3N3dVb9+fR06dMjmeQkJCerXr58KFiwoT09PtW3bVmfOnLFZExUVpa5du8rX11e+vr7q2rWrrl69arMmPDxcbdq0kaenpwoWLKiQkBAlJibm1tsFAAAAAAB4IPz555/q1auXFi9ebB3bu3eviYmQU0qUKCEXFxezYwBAjnogrtTYs2ePPv/8c1WpUsVmfOLEiZo6darmzZuncuXKacyYMWrSpImOHj1qvQxywIABWr16tZYsWaICBQpo8ODBat26tfbt22e9rK5Lly46c+aM1q1bJ0l644031LVrV61evVqSlJKSolatWqlQoULatm2bIiMj1b17dxmGoenTp9/HMwEAAAAAAHB/+fn56fvvv1erVq0UHh6uYcOGyTAMs2MhB0yZMkVt2rRRkyZN5ObmZh3v27eviakA4N6YXmpcv35dL730kmbPnq0xY8ZYxw3D0IcffqiRI0eqffv2kqT58+fLz89PixcvVq9evRQdHa05c+Zo4cKFaty4sSRp0aJFKlasmDZu3KhmzZrpyJEjWrdunXbu3KmaNWtKkmbPnq2goCAdPXpUgYGBWr9+vQ4fPqx//vlHRYoUkXTzL/0ePXpo7Nix8vHxuc9nBQAAAAAA4P7x9/fXzz//rBdeeEGnTp1Samqq2ZGQA8aPH6/z588rLCzM5p4aAGDPTN9+6s0331SrVq2spUSakydP6sKFC2ratKl1zNXVVcHBwdq+fbskad++fUpKSrJZU6RIEVWqVMm6ZseOHfL19bUWGpJUq1Yt+fr62qypVKmStdCQpGbNmikhIUH79u3LNHtCQoKuXbtm8wUAAAAAAGBP0j7s9vLy0po1a5SUlKQ//vjD5FTICfv379dvv/2mBQsWaO7cuZo7d66+/PJLs2MBwD0xtdRYsmSJ9u/fr/Hjx6ebu3DhgqSbl0D+m5+fn3XuwoULcnFxUb58+W67pnDhwumOX7hwYZs1t75Ovnz55OLiYl2TkfHjx1vv0+Hr66tixYrd6S0DAAAAAAA8UPbs2WP93tHRUXPmzNHJkydNTIScUr58ed24ccPsGACQo0zbfuqff/5R//79tX79eps9/W516yVxhmHc8TK5W9dktP5u1txq+PDhGjRokPXxtWvXKDYAAAAAAIBdSU5O1kcffaSNGzfKYrGoSZMm6tevn9mxkAO8vb1Vo0YNNWvWzObzt4kTJ5qYCgDujWmlxr59+3Tp0iXVqFHDOpaSkqKtW7dqxowZOnr0qKSbV1EEBARY11y6dMl6VYW/v78SExMVFRVlc7XGpUuXVLt2beuaixcvpnv9y5cv2xxn165dNvNRUVFKSkpKdwXHv7m6usrV1TW7bx0AAAAAAOCBMWjQIB0/fly9evWSJOuVGh9//LHJyXCvAgMDFRgYaHYMAMhRppUajRo10sGDB23GXnnlFZUvX15vv/22SpcuLX9/f23YsEHVqlWTJCUmJurnn3/WhAkTJEk1atSQs7OzNmzYoI4dO0qSzp8/rz/++MPaOAcFBSk6Olq7d+/W008/LUnatWuXoqOjrcVHUFCQxo4dq/Pnz1sLlPXr18vV1dWmdAEAAAAAAMhrtmzZorCwMDk43NylvHXr1qpevbrJqZATRo8ebXYEAMhxppUa3t7eqlSpks2Yp6enChQoYB0fMGCAxo0bp7Jly6ps2bIaN26cPDw81KVLF0mSr6+vXn31VQ0ePFgFChRQ/vz5NWTIEFWuXNl64/EKFSqoefPmev311/XZZ59Jkt544w21bt3a2lQ3bdpUFStWVNeuXTVp0iRduXJFQ4YM0euvvy4fH5/7dUoAAAAAAADuO8MwlJqaai01DMOQYRgmp0JO+fbbbxUWFqb4+HjrGNtPAbBnppUaWTF06FDFxcWpb9++ioqKUs2aNbV+/Xp5e3tb10ybNk1OTk7q2LGj4uLi1KhRI82bN0+Ojo7WNV999ZVCQkLUtGlTSVLbtm01Y8YM67yjo6PWrl2rvn37qk6dOnJ3d1eXLl00efLk+/dmAQAAAAAATNCsWTM1a9ZMr776qiwWi+bNm6cWLVqYHQs5YMCAATp+/Lj27dunzp07a+nSpWrSpInZsQDgnjxQpcaWLVtsHlssFoWGhio0NDTT57i5uWn69OmaPn16pmvy58+vRYsW3fa1ixcvrjVr1mQnLgAAAAAAgN2bOHGiPvvsM3377bcyDEPPPfec3njjDbNjIQds2rRJBw4cULVq1TRlyhQNHTpUr732mtmxAOCePFClBgAAAAAAAO4vBwcH9enTR3369DE7CnKYm5ubHBwcZLFYlJSUJD8/P509e9bsWABwTyg1AAAAAAAAHmIvvPCCLBaLzZivr6+CgoLUo0cP6702YH+8vb0VGxurunXrqnv37vL395ezs7PZsQDgnvD/SgAAAAAAAA+xwoUL659//lHdunVVt25dnT17Vu7u7vrmm280YMAAs+PhLly7dk2nTp3S119/LScnJ02aNEkVK1bU6dOntWzZMrPjAcA9odQAAAAAAAB4iP3+++/asmWLQkJCFBISok2bNunIkSP67rvvtHHjRrPj4S4MHTpU+/btk5+fn1xcXOTu7q533nlH7dq10/jx482OBwD3hFIDAAAAAADgIXbp0iW5uLhYHzs7O+vMmTNycXGRq6uriclwt7Zu3aoOHTqkG+/atau2bt1qQiIAyDncUwMAAAAAAOAhFhwcrFatWqlr166yWCxatGiR6tatq+vXr1Nq2ClHR8dM5269fwoA2BtKDQAAAAAAgIfYzJkz9emnn2rZsmUyDEPNmjVT79695ezsrJ07d5odD3chOTlZ165dk4+Pj814dHS0kpKSTEoFADmDUgMAAAAAAOAh5uzsrH79+qlfv35mR0EO6dy5s7p27ap58+YpX758kqSoqCi9+uqr6tSpk8npAODeUGoAAAAAAAA8xOLj4zVr1iyFhYUpPj7eOv7NN9+YmAr3YuTIkerZs6eKFSumsmXLSpL+/vtvdejQQaNGjbJZGx4eroiIiCwfOyEhIVvbkj1I6x+kLA/a+gcpy5EjR7J8XDycKDUAAAAAAAAeYq+//rq8vb21detWDR48WPPmzVO9evXMjoV74OjoqPnz5+vdd9/V/v37JUnVq1dXmTJlbNaFh4erQvnyio2Ly/KxHSwWpRqGXa5/kLI8aOsfpCzAnVBqAAAAAAAAPMTCwsJ08OBBValSRf369VOPHj30/PPPmx0LOaBMmTLpiox/i4iIUGxcnN59rbtKBPjf8Xg7Dx7S7JVr7HL9g5TlQVv/IGX593ogM5QaAAAAAAAg16SkpOj06dM22xpVrFjRxES4lbu7uyTJyclJsbGx8vb21tmzZ01OhfupRIC/AksUu+O60+cv2O36BynLg7b+Qcry7/VAZig1AAAAAABArvjhhx/02muvKTIyUp6enrp69aqKFy+ukydPmh0N/5I/f35FRUWpZcuWatGihQoUKKCAgACzYyEHGYahmJgYeXt7y2KxmB0HAO4JpQYAAAAAAMgVI0eO1Pbt29WuXTv99ttvWrRokQ4ePGh2LNxi7dq1cnR01AcffKDFixcrKipK3bp1MzsWclBMTIx8fX0VHR0tHx8fs+MAwD2h1AAAAAAAALnCYrGoRIkSSk5OliS9/PLL3ID6AZOSkqLmzZtrw4YNslgseumll8yOBADAbVFqAAAAAACAXOHs7CxJKlq0qFavXq0SJUrozJkzJqfCvzk6OsowDKWkpMjR0dHsOAAA3BGlBgAAAAAAyBX9+/dXVFSUxowZo06dOunq1av68MMPzY6FW9SqVUvt2rVT165d5eXlZR1v2bKliakAAMgYpQYAAAAAAMgVnTt3liTVqFFDf//9t8lpkJlff/1VkvTJJ59YxywWS54vNZKTk5WYmGh97OHhYWIaAEBWUWoAAAAAAIBcMWvWrHRjvr6+evrpp1W2bFkTEiEjmzdvNjvCfbV79269+uqrOnLkiAzDsI6npKSYmAoAkFWUGgAAAAAAIFf88MMP2rp1qxo1aiRJ+umnn1S3bl0NHz5coaGh6tmzp8kJkebixYs6dOiQ4uPjrWN59UqNkJAQffHFF+rdu7e2bt2qjz/+WO7u7mbHAgBkkYPZAQAAAAAAQN71xx9/6Ntvv9W3336rgwcPytPTU7t379bUqVPNjob/mTdvnvW+GqNGjVLbtm01btw4s2PlmqSkJNWsWVPJycny9vbWyJEj9d1335kdCwCQRZQaAAAAAAAgV5w6dUrFihWzPi5WrJj++usv+fv7y8mJzSMeFFOnTtX+/ftVpkwZ7du3Tz/99JPKly9vdqxck/azV6BAAYWFhSkiIkKnT582ORUAIKsoNQAAAAAAQK7w8/PTuHHjdP78eV24cEHjx49X/vz5lZKSIovFYnY8/I+zs7Py5cun5ORkSVK9evV0+PBhk1Plnk6dOikyMlIjRoxQvXr1VLx4cb355ptmxwIAZBG/FgEAAAAAAHLFggULFBISoilTpkiSGjRooPnz5yspKUkLFiwwOR3SuLq6yjAMlStXTtOnT1eJEiUUERFhdqxcM3DgQElS06ZNFRkZqfj4eHl7e5ucCgCQVZQaAAAAAAAgVxQpUkTLli3LcK5y5cr3OQ0yM2bMGF27dk0TJ05U7969dfXqVc2aNcvsWLlm69atGY7Xq1fvPicBANwNSg0AAAAAAJBr9u/fr7CwMMXHx1vH+vbta2Ii3Kphw4aSJF9fX23YsMHkNLlv8ODB1u/j4+N19OhRVapUSfv37zcxFQAgqyg1AAAAAABArpgwYYL++9//Kjw8XMHBwdqwYYMaNWpEqfGAqFixoqZPn65GjRqlm6tevXqe/ZB/z549No93796t+fPnm5QGAJBd3CgcAAAAAADkioULF2r79u0qWrSoli9frj179sjFxcXsWPifiIgIvfzyy5o0aVK6OcMwTEhkjqeffjrPFjgAkBdxpQYAAAAAAMgVbm5ucnNzU2pqqgzDUGBgoE6dOmV2LPxP0aJFtXLlSj333HPau3ev5s6dKw8PD0mSxWIxOV3uOXz4sPX7lJQU7dq1SzExMSYmAgBkB6UGAAAAAADIFR4eHkpKSlLVqlX19ttvq2jRooqNjTU7Fv6lePHi2rZtm3r16qWaNWtq5cqVKlOmTJ6+UqNVq1bW752cnPTYY4+x/RQA2BFKDQAAAAAAkCtmzZqlxMRETZkyRSNGjNCJEye0cOFCs2PhFu7u7lqwYIE+/vhj1a5dW19++WWevlLj5MmTZkcAANwDSg0AAAAAAJArKlWqJElydXXV7NmzTU6DW916NUZISIiqVaumF198UdHR0Saluj9SU1N14cIFJScnW8eKFy9uYiIAQFZxo3AAAAAAAJArDh06pKpVq6pUqVKSpH379untt982ORXS9O7dO93YM888oz179qhbt24mJLo/5s2bp0ceeUSVK1dWjRo1VKNGDT355JNmxwIAZBGlBgAAAAAAyBVvvfWWZsyYoYIFC0qSqlevrrVr15qcCml69eqV4fijjz6qTz755D6nuX8++OAD7d69W5GRkbp8+bIuX76sS5cumR0LAJBFlBoAAAAAACBXxMTEqG7dutbHFotFzs7OJiYCpEKFCql8+fJmxwAA3CVKDQAAAAAAkCucnJyUlJRkven0mTNn5ODARxEwR2xsrGJjY9W+fXvNmDFDV65csY7FxsaaHQ8AkEXcKBwAAAAAAOSKt956S88995wiIiIUGhqqBQsWaNy4cWbHwkPKy8tLFovFeoP0kJAQ62OLxaKUlBSTEwIAsoJSAwAAAAAA5IqXX35ZpUuX1qpVqxQbG6v58+frmWeeMTsWbnHt2jW9++67OnnypFatWqXDhw/rwIED6ty5s9nRclRqaqrZEQAAOYBSAwAAAAAA5Iovv/xSPXv2VO3atdON4cHRu3dvVaxYURs3bpQklSpVSl26dMlzpcatkpOTlZiYaH3s4eFhYhoAQFZRagAAAAAAgFwxY8aMdAVGRmMw159//qnFixdr+fLlkiR3d3frFk150e7du/Xqq6/qyJEjNu8zr2w/FR4eroiICJux69evS5LCwsLk5eVlHT9y5Mh9zQYAOYFSAwAAAAAA5Ki9e/dq165dioiI0KxZs6zj0dHRNr8ZjweDi4uLzeO4uLg8XWqEhIToiy++UO/evbV161Z9/PHHcnd3NztWjggPD1eFChUyvfF5cHDwfU4EADmPUgMAAAAAAOSos2fPau/evbpx44b27NljHffx8dG8efPMC4YMNWjQQOPGjVNCQoK2bNmiqVOnql27dmbHyjVJSUmqWbOmkpOT5e3trZEjR6p+/foaNGiQ2dHuWUREhGJjY9U/dKaKlixrHTcMQwnxsXJ185DFYrGO79++SV9/PsGMqABw1yg1AAAAAABAjnr22WfVunVrffXVV+rWrZvZcXAHH3zwgSZNmiRvb28NHTpUbdu21bBhw8yOlWucnG5+HFagQAGFhYWpaNGiOn36tMmpclbRkmVVJrDKHdedOfX3fUgDADmLUgMAAAAAAOQ4R0dHffbZZ5QadsDJyUnDhw/X8OHDzY5yX3Tq1EmRkZEaMWKE6tWrp+TkZL3//vtmxwIAZBGlBgAAAAAAyBVPPvmkduzYoaCgILOjIBN79uzR5MmTdejQIUlSpUqVNHjwYD311FMmJ8s9AwcOlCQ1bdpUkZGRio+Pl7e3t8mpAABZRakBAAAAAAByxdatWzVz5kyVK1dOXl5e1vHdu3ebmAppduzYoZYtW6pv377q3LmzDMPQ7t271axZM/3www+qWbOm2RFzxdatWzMcr1ev3n1OAgC4G5QaAAAAAAAgV3z44YdmR8BtTJw4UfPnz1fbtm2tY88995xq1aql8ePHa+XKleaFy0WDBw+2fh8fH6+jR4+qUqVK2r9/v4mpAABZRakBAAAAAAByRXBwsM3jyMhILVy4MN04zHH48GGbQiPNs88+q//7v/8zIdH9sWfPHpvHu3fv1vz5801KAwDILgezAwAAAAAAgLxt/fr1evHFF1WqVCn98ssvZsfB/7i7u2c65+HhcR+TmOvpp5/mKg0AsCNcqQEAAAAAAHLc6dOn9eWXX2revHkqXLiwTp06pdOnTytfvnxmR8P/JCYm6siRIzIMI8O5vOrw4cPW71NSUrRr1y7FxMSYmAgAkB2UGgAAAAAAIEc1bdpUYWFh6tKli1avXq0qVaqoVKlSFBoPmNjYWLVs2TLDOYvFcp/T3D+tWrWyfu/k5KTHHnuM7acAwI5QagAAAAAAgBz1119/qUiRIgoMDFTJkiUl5e0Pye3VqVOnzI5gipMnT5odAQBwD7inBgAAAAAAyFGnTp3S5MmTtXXrVpUsWVIvvfSS4uPjzY4FWKWmpurcuXMKDw+3fgEA7AOlBgAAAAAAyHGNGzfW119/rePHj6tWrVry8/NTsWLFNHToULOj4SE3b948PfLII6pcubJq1KihGjVq6MknnzQ7FgAgiyg1AAAAAABArsmXL5/69eun3377TStWrND169fNjoSH3AcffKDdu3crMjJSly9f1uXLl3Xp0iWzYwEAsoh7agAAAAAAgPviySef5DfiYbpChQqpfPnyZscAANwlSg0AAAAAAICH3LfffquwsDCbe59MnDjRxEQ5LzY2VpLUvn17zZgxQ126dJGbm5t13sPDw6xoAIBsoNQAAAAAAAB4iA0YMEDHjx/Xvn371LlzZy1dulRNmjQxO1aO8/LyksVikWEYkqSQkBDrY4vFopSUFJMTAgCygntqAAAAAACAXJWcnGx2BNzGpk2btGrVKhUqVEhTpkzRnj178uQ9JlJTU5WSkqLU1FTrV9pjCg0AsB+UGgAAAAAAIFccOnRIVatWValSpSRJ+/bt09tvv21yKtzKzc1NDg4OslgsSkpKkp+fn86ePWt2LAAAMkSpAQAAAAAAcsVbb72lGTNmqGDBgpKk6tWra+3atSanwq28vb0VGxurunXrqnv37ho0aJCcnZ3NjpXjGjVqJOnmjcILFy5s/Up7DACwD9xTAwAAAAAA5IqYmBjVrVvX+thiseTJD8vt3ddffy1HR0dNmjRJU6dOVVRUlJYuXWp2rBy3aNEiSdLevXtNTgIAuBeUGgAAAAAAIFc4OTkpKSlJFotFknTmzBk5OLBpxIPGz8/P+v3IkSNNTJK7AgICJEklSpQwOQkA4F5QagAAAAAAgFzx1ltv6bnnnlNERIRCQ0O1YMECjRs3zuxY+J8XXnjBWjhl5JtvvrmPae6f/fv3a8SIETpx4oTNTexPnDhhYioAQFZRagAAAAAAgFzx8ssvq3Tp0lq1apViY2M1f/58PfPMM2bHwv+0bt3a7Aim6N69u9566y0FBQXJ0dHR7DgAgGyi1AAAAAAAALmmdu3aql27ttkxkIHu3bubHcEUjo6O6tWrl9kxAAB3iVIDAAAAAADkqKeeeuq22xrt3r37PqZBZj766CP1799fQ4cOzXB+4sSJ9znR/VGnTh399ttvqlatmtlRAAB3gVIDAAAAAADkqMmTJ0uS1qxZo7/++ks9e/aUJM2bN09PPPGEmdHwL25ubpIkT09Pk5PcH2llW1JSkr744gsFBgZaz4FE2QYA9oJSAwAAAAAA5Kjg4GBJUmhoqH766SfrVRutW7dW48aNzYyGf0nbgmn06NEmJ7k/3nnnHV25ckWlS5e2GT9+/LgKFChgUioAQHZRagAAAAAAgFxx5swZxcfHy93dXZKUkJCgM2fOmJwKt3r//fczHH/33Xfvc5Lc9cMPP6hJkybW0i1NeHi4fvzxRz377LMmJQMAZAelBgAAAAAAyBUvvviigoKC9OKLL0qSvvnmG3Xq1MnkVLhVTEyM9fv4+Hh9//33qlWrlomJcsfWrVv16aefphvv2rWrJkyYYEIiAMDdoNQAAAAAAAC5YsyYMapVq5Y2b94swzA0ZswYtWrVyuxYuMWkSZNsHoeGhur11183KU3ucXR0zHTudje2BwA8WCg1AAAAAABArmndurVat25tdgxkQ4ECBXT8+HGzY+S45ORkXbt2TT4+Pjbj0dHRSkpKMilV1oSHhysiIuKO644cOXIf0gCAuSg1AAAAAAAAHmKzZs2yfp+SkqJdu3apYMGCJibKHZ07d1bXrl01b9485cuXT5IUFRWlV1999YHeFi08PFzly5dXXFyc2VEA4IFAqQEAAAAAAPAQ27Nnj/V7JycnVapUSdOnTzcxUe4YOXKkevbsqWLFiqls2bKSpL///lsdOnTQqFGjTE6XuYiICMXFxem5555ToUKFbrv277//1ubNm+9TMgAwB6UGAAAAAADAQ2zu3LlmR7gvHB0dNX/+fL377rvav3+/JKl69eoqU6aMycmyplChQgoICLjtmqxsUQUA9o5SAwAAAAAA5Jrly5dr48aNslgsaty4sdq3b292JGRg165dOn78uJKTk61j3bp1MzFR7ilTpozdFBkAgPQoNQAAAAAAQK54//33tXLlSuuH4+PGjdPhw4f1zjvvmJwM/9anTx/9+OOPqlq1qhwdHSVJFoslz5YaAAD7RqkBAAAAAAByxbJly7Rz5055eHhIkl5//XUFBQVRajxgNm7cqMOHD8vNzc3sKPeVYRiKiYmRt7e3LBaL2XEAAFnkYHYAAAAAAACQNxmGYS00JMnT01OGYZiYCBkJCAh46AoNSYqJiZGvr69iYmLMjgIAyAau1AAAAAAAALniqaeeUrdu3dS7d29ZLBbNnj1bTz31lNmx8D/ff/+9JKl27drq2LGjOnXqZFNutGzZ0qxoAABkilIDAAAAAADkiunTp+uDDz5QSEiIDMNQkyZNNGrUKLNj4X8mTZpk83j69OnW7y0WC6UGAOCBRKkBAAAAAAByXEpKinr37q2FCxeaHQWZ2Lx5s9kRAADINkoNAAAAAACQ4xwdHXX27FmzYyCLLl68qEOHDik+Pt46xpUaAIAHEaUGAAAAAADIFY0bN1afPn30yiuvyMvLyzpesWJFE1PhVvPmzdN7772nyMhIlS1bVgcOHFCtWrUoNQAADyRKDQAAAAAAkCtmz54tSVq3bp11zGKx6MSJE2ZFQgamTp2q/fv3q2HDhtq3b5+2bt2qBQsWmB0LAIAMUWoAAAAAAIBccfLkSbMjIAucnZ2VL18+JScnS5Lq1aunYcOGmZwKAICMUWoAAAAAAIBck5KSotOnT9vcq4Htpx4srq6uMgxD5cqV0/Tp01WiRAlFRESYHQsAgAxRagAAAAAAgFzxww8/6LXXXlNkZKQ8PT119epVFS9enCs4HjBjxozRtWvXNHHiRPXu3VtXr17VrFmzzI4FAECGKDUAAAAAAECuGDlypLZv36527drpt99+06JFi3Tw4EGzY+EWDRs2lCT5+vpqw4YNJqcBAOD2HMwOAAAAAAAA8iaLxaISJUpY79Xw8ssva8eOHSanwq1iYmL01ltvqUKFCqpYsaL69++vmJgYs2MBAJAhSg0AAAAAAJArnJ2dJUlFixbV6tWr9fvvv+vMmTMmp8Kt+vbtq6SkJH399ddavHixkpKS1LdvX7NjAQCQIbafAgAAAAAAuaJ///6KiorSmDFj1KlTJ129elUffvih2bFwi99//10HDhywPp41a5aeeOIJExMBAJA5Sg0AAAAAAJArmjRponz58qlGjRr6+++/JUkREREmp8KtUlJSFBMTI29vb0nSjRs3lJqaanIqAAAyRqkBAAAAAAByRdOmTbV///47jsFc3bp1U61atfTSSy/JYrFoyZIl6t69u9mxAADIULZLjRs3bmjx4sXavn27Lly4IIvFIj8/P9WpU0edO3eWp6dnbuQEAAAAAAB2Ijk5WYmJiUpNTVVcXJwMw5AkRUdHKzY21uR0uNXQoUNVpUoVbdy4UYZhaMKECWrevLnZsQAAyFC2bhR++PBhlStXTkOHDlVUVJSKFy+uokWLKioqSv/3f/+nwMBAHT58OLeyAgAAAAAAOzB27Fh5eXnp4MGD8vT0lJeXl7y8vFShQgW99NJLZsfD/1y7dk2nTp2SJDVv3lyTJ0/WlClTFBgYqGvXrpkbDgCATGTrSo0333xT9erV0/z58+Xi4mIzl5iYqB49eujNN9/U5s2bczQkAAAAAACwH6NHj9bo0aPVp08fffLJJ2bHQSaGDh2qJk2aqGTJkjbj27Zt044dOzRr1ixzggEAcBvZulJj165dGjVqVLpCQ5JcXFw0YsQI7dq1K8fCAQAAAAAA+/XJJ58oLCxMixcvliRdvXpV58+fNzkV0mzdulUdOnRIN961a1dt3brVhEQAANxZtkqNfPny6e+//850/tixY8qXL989hwIAAAAAAPbv008/Vffu3TVq1ChJUmRkJNtPPUAcHR0znbNYLPcxCQAAWZetUuP1119X9+7dNXnyZB04cEAXLlzQxYsXdeDAAU2ePFk9e/ZUr169cisrAAAAAACwI5999pl27twpHx8fSVKZMmV06dIlk1MhTXJycob3zoiOjlZSUpIJiQAAuLNs3VMjNDRU7u7umjp1qoYOHWpt7Q3DkL+/v4YNG6ahQ4fmSlAAAAAAAGBfXFxc5O7ubjPm5JStjyKQizp37qyuXbtq3rx51p03oqKi9Oqrr6pTp04mpwMAIGPZ/jeJt99+W2+//bZOnjypCxcuSJL8/f1VqlSpHA8HAAAAAADsV6FChfTXX39Zfyly4cKFKlasmMmpkGbkyJHq2bOnihUrprJly0qS/v77b3Xo0MG6ZRgAAA+au/71iFKlSlFkAAAAAACATH344Yfq0qWLjh49qpIlS8rDw0OrV682Oxb+x9HRUfPnz9e7776r/fv3S5KqV6+uMmXKmJwMAIDMZbvUOHPmjD755BNt375dFy5ckMVikZ+fn2rXrq3evXvzGxcAAAAAAEApKSk6cOCAdu7cqaNHj8owDAUGBt725tQwR5kyZSgyAAB2I1ulxrZt29SiRQsVK1ZMTZs2VdOmTWUYhi5duqSVK1dq+vTp+uGHH1SnTp3cygsAAAAAAOyAo6Ojpk6dqg4dOqhChQpmx8FDLjw8XBERETZj169flySFhYXJy8vLZi4hIUGurq5ZPn5urj9y5EiWjwsAD4NslRoDBw7Ua6+9pmnTpmU6P2DAAO3ZsydHwgEAAAAAAPv15JNPaseOHQoKCjI7CrLIMAzFxMTI29vbei8UexceHq4KFcorNjYuw/ng4OB0Y44OFqWkGll+jdxeDwD4/7JVavzxxx9atGhRpvO9evXSp59+es+hAAAAAACA/du6datmzpypcuXK2fwm/O7du01MhduJiYmRr6+voqOj5ePjY3acHBEREaHY2DgtGtZGFYoXsI4bhqEb8UnydHO2KXC+331co+b9km59Zu7XegDATdkqNQICArR9+3YFBgZmOL9jxw4FBATkSDAAAAAAAGDfPvzwQ7MjAFYVihdQ9bL+d1x3JDzygVwPALgpW6XGkCFD1Lt3b+3bt09NmjSRn5+fLBaLLly4oA0bNuiLL77gX1gAAAAAAICkm9v6pKSk6J9//lHJkiXNjgMAAPKAbJUaffv2VYECBTRt2jR99tlnSklJkXTz5l81atTQggUL1LFjx1wJCgAAAAAA7Msvv/yizp07y8HBQeHh4dqzZ48+/vhjLVy40OxoAADATjlk9wkvvviidu7cqdjYWJ09e1Znz55VbGysdu7cme1C45NPPlGVKlXk4+MjHx8fBQUF6YcffrDOG4ah0NBQFSlSRO7u7qpfv74OHTpkc4yEhAT169dPBQsWlKenp9q2baszZ87YrImKilLXrl3l6+srX19fde3aVVevXrVZEx4erjZt2sjT01MFCxZUSEiIEhMTs3dyAAAAAACA1dChQ/Xzzz+rQIGb9w146qmntH//fpNTAQAAe5btUiONs7OzAgICFBAQIGdn57s6RtGiRfWf//xHe/fu1d69e9WwYUM9++yz1uJi4sSJmjp1qmbMmKE9e/bI399fTZo0UUxMjPUYAwYM0IoVK7RkyRJt27ZN169fV+vWra1XkUhSly5dFBYWpnXr1mndunUKCwtT165drfMpKSlq1aqVbty4oW3btmnJkiVavny5Bg8efJdnBwAAAAAAJCcnq0yZMjZjLi4uJqUBAAB5QbZLjT179uill15SqVKl5O7uLg8PD5UqVUovvfSS9u7dm61jtWnTRi1btlS5cuVUrlw5jR07Vl5eXtq5c6cMw9CHH36okSNHqn379qpUqZLmz5+v2NhYLV68WJIUHR2tOXPmaMqUKWrcuLGqVaumRYsW6eDBg9q4caMk6ciRI1q3bp2++OILBQUFKSgoSLNnz9aaNWt09OhRSdL69et1+PBhLVq0SNWqVVPjxo01ZcoUzZ49W9euXcs0f0JCgq5du2bzBQAAAAAAbnJzc9P169dlsVgkSYcOHZKbm5vJqQAAgD3LVqmxcuVK1alTR1euXFH//v315Zdf6osvvlD//v0VFRWlOnXqaNWqVXcVJCUlRUuWLNGNGzcUFBSkkydP6sKFC2ratKl1jaurq4KDg7V9+3ZJ0r59+5SUlGSzpkiRIqpUqZJ1zY4dO+Tr66uaNWta19SqVUu+vr42aypVqqQiRYpY1zRr1kwJCQnat29fppnHjx9v3dLK19dXxYoVu6v3DgAAAABAXjRq1Cg1a9ZM586dU48ePdSoUSN98MEHZscCAAB2LFs3Cn/nnXf0/vvva9iwYenmBgwYoAkTJmjEiBF69tlns3zMgwcPKigoSPHx8fLy8tKKFStUsWJFa+Hg5+dns97Pz0+nT5+WJF24cEEuLi7Kly9fujUXLlywrilcuHC61y1cuLDNmltfJ1++fHJxcbGuycjw4cM1aNAg6+Nr165RbAAAAAAA8D9NmzZV2bJltW7dOhmGoXfeeUePPfaY2bHwgAoPD1dERESW1iYkJMjV1TVLa48cOXIvsQAAD5hslRrHjh1T+/btM51v166dRo8ena0AgYGBCgsL09WrV7V8+XJ1795dP//8s3U+7RLVNIZhpBu71a1rMlp/N2tu5erqmuX/AwUAAAAA4GFUqlQp9enTx+wYeMCFh4crsHwFxcfFZu0JFgfJSM3dUACAB1K2So0yZcpo5cqVGjp0aIbzq1atUunSpbMVwMXFxfpbGk8++aT27Nmjjz76SG+//bakm1dRBAQEWNdfunTJelWFv7+/EhMTFRUVZXO1xqVLl1S7dm3rmosXL6Z73cuXL9scZ9euXTbzUVFRSkpKSncFBwAAAAAAyJpSpUpl+MuCJ06cMCENHmQRERGKj4tVgdaD5Vzg9rtgxJ3Yq+hfFmVp7b/XAwDyhmyVGu+//746deqkn3/+WU2bNpWfn58sFosuXLigDRs2aP369VqyZMk9BTIMQwkJCSpVqpT8/f21YcMGVatWTZKUmJion3/+WRMmTJAk1ahRQ87OztqwYYM6duwoSTp//rz++OMPTZw4UZIUFBSk6Oho7d69W08//bQkadeuXYqOjrYWH0FBQRo7dqzOnz9vLVDWr18vV1dX1ahR457eDwAAAAAAD6s1a9ZYv4+Pj9fChQvTbSEN/JtzgWJy9b/9FmVJkf9kee2/1wMA8oZslRodOnTQ1q1b9dFHH2nq1KnW+034+/srKChIP//8s4KCgrJ8vBEjRqhFixYqVqyYYmJitGTJEm3ZskXr1q2TxWLRgAEDNG7cOJUtW1Zly5bVuHHj5OHhoS5dukiSfH199eqrr2rw4MEqUKCA8ufPryFDhqhy5cpq3LixJKlChQpq3ry5Xn/9dX322WeSpDfeeEOtW7dWYGCgpJt7fFasWFFdu3bVpEmTdOXKFQ0ZMkSvv/66fHx8snOKAAAAAADA/zz++OM2j2vUqKFGjRqZlAYAAOQF2So1pJtXNWSnuLidixcvqmvXrjp//rx8fX1VpUoVrVu3Tk2aNJEkDR06VHFxcerbt6+ioqJUs2ZNrV+/Xt7e3tZjTJs2TU5OTurYsaPi4uLUqFEjzZs3T46OjtY1X331lUJCQtS0aVNJUtu2bTVjxgzrvKOjo9auXau+ffuqTp06cnd3V5cuXTR58uQceZ8AAAAAANyLlJQUnT59WvHx8daxihUrmpjo7kRFRenkyZNmxwAAAHYs26VGTpozZ85t5y0Wi0JDQxUaGprpGjc3N02fPl3Tp0/PdE3+/Pm1aNHt904sXry4zWWxAAAAAAA8CH744Qe99tprioyMlKenp65evarixYvbRTnw1FNPWe+pkZKSopMnT2rIkCEmpwIAAPYs26XGgQMHtHr1auXPn18dO3ZUwYIFrXPXrl3TgAED9OWXX+ZoSAAAAAAAHlYjR47U9u3b1a5dO/32229atGiRDh48aHasLPn3DghOTk4qVaqUihQpYmIiAABg7xyys3j9+vV6+umntWTJEk2YMEEVKlTQ5s2brfNxcXGaP39+jocEAAAAAOBhZbFYVKJECSUnJ0uSXn75Ze3YscPkVFkTHBysihUrqkaNGqpTpw6FBgAAuGfZKjVCQ0M1ZMgQ/fHHHzp16pSGDh2qtm3bat26dbmVDwAAAACAh5qzs7MkqWjRolq9erV+//13nTlzxuRUdzZr1iwVKVJE/v7+1vtobty4UZJ09epVc8MBAAC7la1S49ChQ+rZs6ekm78p8n//93/6/PPP9fzzz2v16tW5EhAAAAAAgIdZ//79FRUVpTFjxmjQoEFq1KiRxowZY3as25o9e7ZmzJihOXPmKDIyUpGRkfrPf/6jwYMHa/369WrUqJHZEQEAgJ3K1j01XF1d0/02RefOneXg4KBOnTppypQpOZkNAAAAAICHWkpKilxcXJQvXz7VqFFDf//9t9mRsuTjjz/WunXrVLx4cetYy5YtVbFiRZUrV06DBg0yMR0AALBn2bpSo2rVqjb30Ejz4osv6osvvlBISEiOBQMAAAAA4GHn6OioqVOnmh0j21JTU20KjTQlS5ZUyZIl9Z///MeEVAAAIC/IVqnRp08fnT17NsO5zp07a/78+apXr16OBAMAAAAAANKTTz5pNzcGT5OYmKj4+Ph043FxcUpNTTUhEQAAyCuyVWo899xzmjZtWqbznTt3zvBKDgAAAAAAcHe2bt2qZ555RhUrVtTTTz9t/XqQtW/fXl27drXZwjoqKkrdunVThw4dzAsGAADsXrbuqSFJS5cu1cqVK5WUlKTGjRvrjTfeyI1cAAAAAABA0ocffmh2hGwbM2aMunfvrqJFi6ps2bKyWCz666+/1KZNmwf+JucAAODBlq1S4/PPP1fv3r1VtmxZubm5afny5Tp58qTGjx+fW/kAAAAAAHioBQcHS5IuXrwoi8WiwoULm5zozpydnbV48WIdP35c+/fvlyRVq1ZNjz32mMnJAACAvctWqTF9+nSNHDlSH3zwgSRp3rx56tevH6UGAAAAAAC55MiRI+rYsaPOnDkjSSpWrJi++eYblS9f3uRkd1amTBmVKVPG7BjIRHh4uCIiImzGrl+/LkkKCwuTl5eXzVxCQoJcXV2zfPzsrD9y5EiWjwsAeLhlq9Q4ceKEXnnlFevjrl276o033tCFCxfk7++f4+EAAAAAAHjY9e3bV8OHD1eXLl0kSUuWLFGfPn24pyXuSXh4uCpUKK/Y2LgM59OuEPo3RweLUlKNLL9GdtcDAJAV2So14uLibFp6R0dHubq6KjY2NseDAQAAAACAmzfYTis0JKlTp06aMGGCiYnujmEYiomJkbe3tywWi9lxHnoRERGKjY3TomFtVKF4Aeu4YRi6EZ8kTzdnm39O3+8+rlHzfkm3PjN3ux4AgDvJ9o3Cv/jiC5tiIzk5WfPmzVPBggWtYyEhITmTDgAAAACAh5yjo6MOHz6sihUrSpKOHj0qBwcHk1NlX0xMjHx9fRUdHS0fHx+z4+B/KhQvoOpl77z7xpHwyPuyHgCAO8lWqVG8eHHNnj3bZszf318LFy60PrZYLJQaAAAAAADkkLFjxyo4OFjVqlWTxWJRWFiYzX+HAwAAPEyyVWqcOnUql2IAAAAAAICMNG/eXIcPH9auXbtkGIaCgoJsdksAAAB4mGR7+ykAAAAAAHB/FSpUSK1btzY7BgAAgOmyvQlnamqqvvzyS7Vu3VqVKlVS5cqV1bZtWy1YsECGYeRGRgAAAAAAHlrr1q1T+fLl5eLiIkdHRzk4OMjR0dHsWAAAAKbI1pUahmGobdu2+v777/XEE0+ocuXKMgxDR44cUY8ePfTtt99q5cqVuRQVAAAAAICHT0hIiKZPn66goCDKDNxWeHi4IiIisrT2yJEjuZwGAIDcka1SY968edq6das2bdqkBg0a2Mz99NNPateunRYsWKBu3brlaEgAAAAAAB5WPj4+atasmdkx8IALDw9XYPkKio+LNTsKAAC5Klulxtdff60RI0akKzQkqWHDhho2bJi++uorSg0AAAAAAHJIq1attGbNGu6pgduKiIhQfFysCrQeLOcCxe64Pu7EXkX/sug+JAMAIGdlq9T4/fffNXHixEznW7RooY8//vieQwEAAAAAgJtmzZqlyMhIeXl5yc3NTYZhyGKx6NKlS2ZHwwPIuUAxufo/dsd1SZH/3Ic0AADkvGyVGleuXJGfn1+m835+foqKirrnUAAAAAAA4Ka9e/eaHQEAAOCBka1SIyUlRU5OmT/F0dFRycnJ9xwKAAAAAADcVKJECcXFxen333+XxWJR5cqV5e7ubnYsAAAAU2Sr1DAMQz169JCrq2uG8wkJCTkSCgAAAAAA3LR9+3Y9//zz8vPzk2EYunz5spYtW6agoCCzowEAANx32So1unfvfsc13CQcAAAAAICcM2jQIC1dulR16tSRdLPkGDhwoHbu3GlyMgAAgPsvW6XG3LlzcysHAAAAAADIQHx8vLXQkKTatWsrPj7exEQAAADmcTA7AAAAAAAAyJyHh4c2btxofbxlyxZ5eHiYmAgAAMA82bpS4/z585oxY4bGjh0rSapbt65iY2Ot846Ojlq5cqUeffTRnE0JAAAAAMBD6uOPP1aHDh3k6uoqi8WihIQELV++3OxYAAAApshWqTFr1ixdvXrV+vjAgQPq2bOn8ufPL0n64YcfNG3aNE2ePDlHQwIAAAAA8LB68skndezYMR09elQrVqxQ1apVVaNGDbNjAQAAmCJb20+tXr1a7dq1sxnr37+/Ro8erdGjR+u9997TDz/8kJP5AAAAAABZEBcXp127dmn37t2Ki4szOw5yQJMmTRQWFiZJunz5surVq6ft27dr6NChmjBhgrnhAAAATJKtKzVOnTqlMmXKWB83adJEnp6e1seBgYE6efJkzqUDAAAAANzR9u3b9fzzz8vPz0+GYejy5ctatmyZgoKCzI6Ge3D27FlVrVpVkrR48WIFBwdrxYoVioqKUnBwsN5++21zAwIAAJggW6VGcnKyoqOjrY+//fZbm/moqCg5OHDvcQAAAAC4nwYNGqSlS5eqTp06km6WHAMHDtTOnTtNToZ74ebmZv1++/btatmypSQpX758cnLK1n/OAwAA5BnZaiACAwO1ffv2TOd/+eUXlStX7p5DAQAAAACyLj4+3lpoSFLt2rUVHx9vYiLkBAcHB505c0Y3btzQzz//rODgYOtcbGysickAAADMk61So1OnTnr33Xf1+++/p5s7cOCA3nvvPXXu3DnHwgEAAAAA7szDw0MbN260Pt6yZYs8PDxMTIScMGLECNWoUUOBgYFq0KCB9ZcIt2/frpIlS5obDgAAwCTZul51wIABWrNmjWrUqKEmTZooMDBQFotFf/75pzZs2KCgoCANGDAgl6ICAAAAADLy8ccfq0OHDnJ1dZXFYlFCQoKWL19udizco/bt26tOnTo6f/68nnjiCet4yZIl9fnnn5uYDAAAwDzZKjWcnZ21YcMGTZ06VUuWLNGWLVskSWXLltUHH3yggQMHytnZOTdyAgAAAAAy8eSTT+rYsWM6evSoDMNQ+fLl+W+zPMLPz09+fn42Y0WKFDEpDQAAgPmyfWcxFxcXDRs2TMOGDcuNPAAAAACAbFq9erWeeeYZVapUSZIUFRWlX3/9Va1btzY5GXKSYRiKiYmRt7e3LBaL2XEAAABMka1SIyoqSosWLVL37t3l4+NjMxcdHa0FCxZkOAcAAAAAyD2jRo1SWFiY9fEjjzyiUaNGUWrkMTExMfL19VV0dPQD/9/d4eHhioiIsBm7fv26JCksLExeXl7W8YSEBLm6umb52A/T+uysPXLkSJYzAABgz7JVasyYMUO///67+vXrl27O19dXv/zyi65du6aRI0fmWEAAAAAAQPZYLBalpqaaHQN5SEYlRWbOnz+vF154QXFxcRnOBwcH2zx2cHDI1s/rw7Q+u8cGAOBhkK1SY/ny5ZoyZUqm87169dKQIUMoNQAAAADgPvLx8dGuXbtUs2ZNSdLOnTvl7e1tcirkFeHh4apQoYJiY2Oz9bwv/2+8yhcrZX1sGIZi4+Pk4eZu3T7rx73b9N6CGenWZuZhWn+3xwYAIK/LVqlx/PhxlS1bNtP5smXL6vjx4/ccCgAAAACQdRMmTFC7du30+OOPyzAM/fnnn1qxYoXZsZBHREREKDY2Vv1DZ6poycw/E0izf/smff35BJUvVkrVHqt427VH/zkpSVla+7Ctv9tjAwCQ12Wr1HB0dNS5c+dUvHjxDOfPnTsnBweHHAkGAAAAAMiaoKAgHT58WDt27JAk1a5dW4888oi5oZDnFC1ZVmUCq9xx3ZlTf9+HNAAA4GGVrQaiWrVqWrlyZabzK1asULVq1e41EwAAAAAgG/755x95enqqZcuW8vX11aJFixQTE2N2LAAAACDHZavUeOuttzRlyhTNmDFDKSkp1vGUlBRNnz5d06ZN05tvvpnjIQEAAAAAmXv22WeVmpqqs2fPqlOnTvr111/Vs2dPs2MBAAAAOS5bpUaHDh00dOhQhYSEKH/+/KpWrZqqV6+u/Pnza8CAARo0aJCef/753MoKAAAAAMiEm5ub1q5dq169eunrr7/WX3/9ZXYkAAAAIMdl654akjR27Fi1a9dOX331lf7++28ZhqF69eqpS5cuevrpp3MjIwAAAADgNhISEpSQkKANGzZowIABZscBAAAAck22So3Y2Fj93//9n1auXKmkpCQ1atRI06dPV8GCBXMrHwAAAADgDjp37ix/f3+VK1dOtWvX1vnz5+Xh4WF2LAAAACDHZWv7qdGjR2vevHlq1aqVOnfurI0bN6pPnz65lQ0AAAAAkAXvvPOOTp48qR07dshiscjb21vLli0zOxYAAACQ47J1pca3336rOXPmqFOnTpKkl156SXXq1FFKSoocHR1zJSAAAAAAIGMnT55UqVKldPjwYUnSuXPnbOYfffRRM2IBAAAAuSZbpcY///yjZ555xvr46aeflpOTk86dO6dixYrleDgAAAAAQOb69eunNWvWqFWrVunmLBaLTpw4YUIqAAAAIPdkq9RISUmRi4uL7QGcnJScnJyjoQAAAAAAd7ZmzRpJN6/YAAAAAB4G2So1DMNQjx495Orqah2Lj49X79695enpaR379ttvcy4hAAAAACBDsbGxt53nZuEAAADIa7JVanTv3j3d2Msvv5xjYQAAAIC8pFGjRtq0aZMKFSoki8ViHTcMQxaLRZcuXTIxHfICLy8vWSwWGYaRbs5isSglJcWEVAAAAEDuyVapMXfu3NzKAQAAAOQ5ixYtkiTt3bvX5CTIq1JTU82OAAAAANxXDmYHAAAAAPKqgIAA6/+WKFFCJUqUUEpKig4ePKiiRYuanA55UXJysmJjY61fAAAAQF5DqQEAAADksjp16igmJkaRkZF65plnNH78eL355ptmx0Iesnv3blWuXFlubm7y9va2fgEAAAB5DaUGAAAAkMuSk5Pl7e2ttWvXqnv37vr111+1fft2s2MhDwkJCdEXX3yhypUr6+rVq3r//fc1adIks2MBAAAAOY5SAwAAAMhlCQkJkqQtW7aoYcOGkiQHB/5VHDknKSlJNWvWtBZoI0eO1HfffWd2LAAAACDHZetG4QAAAACyr2HDhqpYsaKSk5P12WefKSoqSk5O/Ks4co6jo6MkqUCBAgoLC1PRokV1+vRpk1MBAAAAOY//kgIAAABy2fTp03XgwAGVLl1azs7OSklJ0ezZs82OhTykc+fOioyM1IgRI1SvXj0lJyfr/fffNzsWAAAAkOMoNQAAAIBcZrFYlJycrE8++UQWi0UNGzbUk08+aXYs5AGHDx+WJDVr1kwXL15U0aJF9euvv0qSPD09lZCQIFdXVzMjAgAAADmKUgMAAADIZbNnz9YHH3yg9u3bS5I6dOigUaNG6bXXXjM5Gexdq1at0o1ZLBZJN++zcf36dU2ZMkU9e/a839EAAACAXEGpAQAAAOSy6dOna9++fSpUqJAkaeTIkWrUqBGlBu7ZyZMnbzt//vx5NWzYkFIDAAAAeQalBgAAAHAfpBUaad+n/TY9kJsCAgL0xhtvmB0DdyE8PFwRERE2Y9evX5ckhYWFycvLy2Yuu1uNZWf9kSNHsnxcAACA3EapAQAAAOSyxx57TCNHjtSbb74pi8Wizz//XGXKlDE7Fh4SAwcONDsCsik8PFwVKgQqNjY+w/ng4OB0Yw4OUmpq1l8ju+sBAAAeFJQaAAAAQC779NNPFRISoipVqshisahx48b69NNPzY6FHLJ69WoFBwfLx8dHkydP1s6dOxUaGqpKlSqZHQ12KiIiQrGx8Ro+vJCKF3exjhuGofh4Q25uFpurvXbvvqG5c6+mW5+Zu10PAADwIKDUAAAAAHKZg4ODlixZYjN267YysF8jR47U77//rgMHDmjRokXq06eP+vTpo19++cW0TIZhKCYmRt7e3mx1ZseKF3dR2XJ33iIqPDzxvqwHAAB4EDiYHQAAAADI65o2bZqlMdgnJ6ebvyu2fv16vfHGG+rVq5du3LhhaqaYmBj5+voqJibG1BwAAABATuNKDQAAACCXJCcnKzExUampqYqLi5NhGJKk6OhoxcbGmpwOOSUlJUU7d+7U8uXLNXfuXElSUlKSyakAAACAvIlSAwAAAMglY8eO1XvvvSeLxSJPT0/ruI+PjwYPHmxiMuSkMWPGqHfv3mrUqJEqVKigo0ePqmzZsmbHwl0IDw/P1tZwCQkJcnW98/ZN2V1/5MiRLB8TAADgYUOpAQAAAOSS0aNHa/To0erTp48++eQTs+M80OLi4vT777/LYrGocuXKcnd3NztSlrVp00Zt2rSxPg4MDNS3335rYiLcjfDwcFWoUF6xsXFZfo6Dg0WpqUaurQcAAEB6lBoAAABALvvkk0909uxZbdu2TRaLRXXr1lWRIkXMjvXA2L59u55//nn5+fnJMAxdvnxZy5YtU1BQkNnRsiQmJkYjRozQxo0bZbFY1LhxY40dO1be3t5mR0M2REREKDY2TpMnd9Fjj/ndcf2WLUf04YfrcmV92loAAACkR6kBAAAA5LJVq1bp1VdfVd26dSVJb731lubMmWPz2/0Ps0GDBmnp0qWqU6eOpJslx8CBA7Vz506Tk2VN37595eHhoa+//lqS9Pnnn6tv375auHChyclwNx57zE+PP170juuOH7+Ya+vT1gIAACA9Sg0AAAAgl7333nvauXOnHnvsMUnS8ePH9cILL1Bq/E98fLy10JCk2rVrKz4+3sRE2fP777/rwIED1sezZs3SE088YWIiAAAAIO9yMDsAAAAAkNelpKT8P/buPT7n+v/j+POzg81hRiunlvM5tDmf5Txn5fB1GnImJKQiRZQQFdo3lZBjpBShHIqcGXNOmcMc05gZO2/X7w8/19cyDNf2ua5rj/vttlvX5/15976euzbbtc/r836/rQUNSSpWrJiSk5NNTGRfsmXLpg0bNliPf/vtN2XLls3ERA8nKSlJUVFR1uObN2/y9QUAAADSCTM1AAAA0llUVJTefPNNbdy4kfX2M6k8efJozpw56tWrlwzD0Pz58/Xkk0+aHctuzJgxQ+3atZOHh4cMw1BcXJxWrFhhdqw06969u6pXr66uXbvKMAwtXbpUPXr0MDsWAAAA4JQoagAAAKQz1tvHZ599pq5du+rll1+WYRjy8/PTokWLzI5lNypXrqwTJ07o+PHjslgsKl26tNzd3c2OlWajRo1S+fLltXHjRlksFk2ePFkBAQFmxwIAAACcEkUNAACAdMZ6+5nb1atXFRkZqfXr18swDFksFmbp/MvRo0clSS4ut1bH/euvv+Tt7a2nn37azFgPpVmzZmrWrJnZMQAAAACnR1EDAAAgnd1eb//2hWzW2888vv32W/Xo0UM5cuRQfHy8fvzxR9WpU8fsWHanefPmOnv2rLy9vSVJkZGRyps3r7JkyaKlS5eqevXqJidMXYcOHWQYxj3PL1u2LAPTAAAAAJkDRQ0AAIB0ltp6+927dzc7FjLAxIkTtW3bNvn5+WnDhg0aN26cNm7caHYsu9O6dWs1aNBAbdu2lST98MMP2rFjhwICAjR06FDt3r3b3ID30LJlS7MjAAAAAJkORQ0AAIB0NmrUKFWoUEEbNmxgvf1M5vb+GZLUqFEjvfbaa+YGslNbtmzRjBkzrMdt2rTRpEmT9MEHHyg2NtbEZPf3783AExMT5ebGn1gAAABAenIxOwAAAICz++qrrxQQEKAPP/xQ06ZNU0BAgL766iuzYyEDWCwWxcTEKDo6WtHR0Xcd45bk5GRt377derxjxw7FxMRI+t8+G/bs6NGj8vPzU5EiRSRJwcHBev31101OBQAAADgn+/8LAQAAwMHNmjUrTW1wPgcPHlSOHDmsH3ces1n4/3z66af6z3/+o1KlSql06dLq2LGjZs2apRs3bujVV181O94Dvfzyy5o1a5aefPJJSVLFihX1008/mZwKAAAAcE7MjQYAAEgne/fu1a5duxQeHq6goCBre2RkpOLj401MhozChvBpU6dOHYWGhur48eOyWCwqXbq0smTJIunuJZ7sUVRUlGrXrm09NgxD7u7uJiYCAAAAnBdFDQAAgHRy/vx57d27Vzdv3tSePXus7Tlz5tS8efPMCwbYITc3N/n4+CgxMVGXLl2SJBUsWNDkVGnj5uamhIQEGYYhSTp37pxDLJsFAAAAOCKKGgAAAOmkTZs2atOmjdauXatmzZqZHQewW/PmzdPQoUPl7u5uLQYYhqHLly+bnCxtBg8erBdeeEHh4eEaN26cvv76a73//vtmxwIAAACcEkUNAACAdNasWTPt27dPISEhio2NtbYPGjTIxFSA/ZgwYYJ2796t0qVLmx3lkXTr1k1FixbVDz/8oOjoaM2fP1916tQxOxYAAADglChqAAAApLPJkyfrm2++UVhYmOrVq6f169erYcOGFDWA//fUU085bEEjKSlJfn5+OnTokGrWrGl2HAAAAMDpsdArAABAOluwYIG2b98uX19frVixQnv27LFugozMYfbs2YqMjJQkvfzyy6pcubK2bNlicir78eKLL2rWrFm6evWqoqOjrR+OwNXVVb6+voqJiTE7CgAAAJApMFMDAAAgnXl6esrT01PJycmyWCwqVaqUTp8+bXYsZKBPP/1U/fv317Zt23T48GG99957GjlypHbv3m12NLvwxhtvSJKGDh0qwzBksVhkGIaSkpJMTpY2JUuWVJ06ddSxY0flyJHD2s5sLAAAAMD2KGoAAACks2zZsikhIUF+fn56/fXX5evr6zB3ocM23Nxuve3etGmTunfvrqZNm+rNN980OZX9SE5ONjvCY7l+/brKly+vY8eOWdsMwzAxEQAAAOC8KGoAAACks6CgIMXHx2vatGkaPXq0Tp48qQULFpgdCxnIxcVFS5cu1TfffKPVq1dLkuLj401OZX8SExNTvC7ZsmUzMU3azZ071+wIAAAAQKZBUQMAACCdlStXTpKUPXt2ffHFFyangRlmzZqlDz74QH379lXhwoX1559/qn79+mbHshu7d+9W7969dezYMVksFmu7oyw/lZiYqE8++UQbNmyQYRhq3LixhgwZYp2hk97CwsIUHh6eou3GjRuSpJCQkBRLYklSXFycPDw80jx+eva3pyx3zrQBAACA/aKoAQAAkM5eeumlVJei+eqrr0xIAzNUr15dK1eutB6XLFlSM2fONC+QnRk6dKi+/PJLDRgwQFu2bNGMGTOUNWtWs2Ol2fDhwxUaGqr+/ftLkubMmaNTp05pxowZ6f7cYWFhKl26jGJiUl/Srl69ene1GYaLLJa0L/mVnv3tKQsAAAAcA0UNAACAdFa5cmXr49jYWK1YsUL+/v4mJkJG+eSTT/TKK69o1KhRqZ6fMmVKBieyTwkJCapWrZoSExPl5eWlMWPG6Pnnn9fw4cPNjpYmv/32m0JCQuTi4iJJatmypSpWrJghzx0eHq6YmGj1aPCm8uUqaG23WCyKT4xVFjfPFEXVI2d3a/WeuXf1v5f07G9PWe7sDwAAAPtGUQMAACCdvfzyyymOBw4cqPbt25uUBhnJ09NT0q2lx3Bvrq6ukiQfHx+FhITI19dXZ86cMTlV2lksFiUnJ1uLGhaLJcUyWhkhX66Ceuapkg/sdykizG7621OWO/sDAADAvlHUAAAAyGBZs2bV6dOnzY6BDHB7OaJ33nnH5CT2rXPnzrpy5YpGjx6tunXrKjExUe+++67ZsdKsadOmatq0qXr37i3DMDRv3jwFBAQ88nip7ZFxL+wDAQAAgMyGogYAAEA6u3PpoaSkJO3du1dly5Y1MREy2r0u0L/99tsZnMT+JCcnq2bNmvLx8VGTJk105coVxcbGysvLy+xoaTZlyhR9/vnn+u677yRJL774ovr16/dIY4WFhalU6VKKjYm1ZUQAAADAaVDUAAAgjZKSkjRr1iz99ddfmjVrlkJDQ3XmzBk1aNDA7Giwc3cuPeTm5qaBAweqXbt2JiZCRouKirI+jo2N1Zo1a1S9enUTE9kPFxcXDRkyRLt375Ykubu7y93d3eRUafPvvVKKFCkiSQoNDdXrr7/+SHumhIeHKzYmVr79fOVRwOOB/aMORunyd5cf+nkAAAAAR0VRAwCANBoyZIgSEhK0detWSbfWfu/UqZP27NljcjLYO5YewtSpU1Mcjxs3Tn379jUpjf0pU6aMTp48qaJFi5od5aF8+OGHqlKligICAqz7adiKRwEPZS2c9YH94i7E2fR5AQAAAHtHUQMAgDTavn27QkJC5O/vL0nKlSuX4uPjTU4Fe7Z8+XJ16NBBQUFBd50zDEM+Pj5q0aIFm0hnQj4+PgoNDTU7ht24fPmy/Pz8VLt2beXIkcPavmzZMhNTPdiGDRs0d+5cLV68WB07dlSvXr1UrFgxs2MBAAAATo2iBgAAaeTp6ZniOCkpScnJySalgSM4fPiwOnTocM/ZPJcvX9ann36qzZs3Z3AyZLQ7C1tJSUnatWuXnnzySRMT2ZdOnTqpU6dOZsd4aA0aNFCDBg10/fp1LVmyRF27dlXWrFn1wQcfqFq1ambHAwAAAJwSRQ0AANKoQoUKWrRokSwWi06fPq1Jkyapbt26ZseCHRs/frwkae7cuffs07hx44yKAxPdWdhyc3NTuXLlNGvWLBMT2ZcePXqYHeGx5MyZU61bt9bVq1c1Y8YM/fHHHxQ1AAAAgHRCUQMAgDSaPn26RowYoYsXL6patWpq3br1I20Ci8xp3759CgkJUWxsrLVt0KBBWr9+vYmpkFFSK2yNHDlSH374oQlp7E+vXr1Sbf/qq68yOMnDSUpK0o8//qg5c+bo1KlTCgwM1L59+5Q/f36zowEAAABOi6IGAABplCNHDs2ePVuzZ882OwoczOTJk/XNN98oLCxM9erV0/r169WwYUMNGjTI7Ggw0bJlyyhq/L9KlSpZH8fGxmrFihXW/Yvs2dNPP62CBQuqV69e1pl7ERERioiIkCSVLVvWzHgAAACAU6KoAQBAGlWqVEm9e/dWly5dlCtXLrPjwIEsWLBAe/fuVfXq1bVixQodP35cb7/9ttmxYDKLxWJ2BLvx8ssvpzgeOHCg2rdvb1KatPP09NQ///yjyZMna8qUKSm+poZh6OTJkyamAwAAAJwTRQ0AANJo2rRpmjdvnsaOHavGjRvrpZdeUpMmTWQYhtnRYOc8PT3l6emp5ORkWSwWlSpVSqdPnzY7FkzGz457y5o1q0P8G3GEjAAAAICzoagBAEAaPf/883r++ed148YNLVu2TBMnTlTfvn0VFhZmdjTYuWzZsikhIUF+fn56/fXX5evrq+joaLNjIQN06NAh1eKFxWLR1atXTUhkn1577TXr65SUlKS9e/eydBMAAACAVFHUAADgIUVHRysiIkLXrl2Tt7e32XHgAIKCghQfH69p06Zp9OjROnnypBYsWGB2LGSAli1bPtK5zCZHjhzWooabm5sGDhyodu3amZzq4VgsFkVFRcnLy4tZOAAAAEA6oqgBAEAaff/99/rqq6+0a9cutW/fXl999ZWqVKlidiw4gHLlykmSsmfPri+++MLkNMhIPXr0MDuC3duzZ4+OHDmiI0eOyDAMlStXTo0aNZK7u7vZ0R5KVFSUvL29FRkZqZw5c5odBwAAAHBaLmY++aRJk1SlShV5eXkpT548atu2rY4fP56ij8Vi0bhx41SgQAFlzZpVzz//vI4cOZKiT1xcnIYMGaInn3xS2bNnV+vWrXXu3LkUfSIiIhQYGChvb295e3srMDBQ165dS9EnLCxMrVq1Uvbs2fXkk09q6NChio+PT5fPHQDgeIKCgtSlSxedPXtWQUFBFDSQZteuXdPkyZPVr18/9erVy/oBZHY7duxQkyZNVLJkSb333nuaMGGCihYtqoCAAO3atcvseAAAAADskKkzNTZv3qyXX35ZVapUUWJiosaMGaMmTZro6NGjyp49uyRpypQpmj59uubNm6eSJUtq4sSJaty4sY4fPy4vLy9J0rBhw7Rq1SotXbpUPj4+GjFihFq2bKng4GC5urpKkrp06aJz585p3bp1kqR+/fopMDBQq1atknRr7d4WLVroqaee0tatW3XlyhX16NFDFotFM2fONOHVAQDYm/Xr15sdAQ6qffv2euqpp1SjRg3rexMAt97rz58/X61bt7a2vfDCC6pWrZomTZqklStXmhcOAAAAgF0ytahxu8Bw29y5c5UnTx4FBwerbt26slgs+vjjjzVmzBi9+OKLkqT58+crb968Wrx4sfr376/IyEjNmTNHCxYsUKNGjSRJCxcu1DPPPKMNGzaoadOmOnbsmNatW6edO3eqWrVqkqQvvvhCNWrU0PHjx1WqVCn98ssvOnr0qM6ePasCBQpIkqZNm6aePXvqvffeS3UKeVxcnOLi4qzH169fT5fXCQBgH8LDw/Xuu+8qJCREsbGx1vbdu3ebmAqO4OLFi9qwYYPZMQC7c/To0RQFjdvatGmj1157zYREAAAAAOydqctP/VtkZKQk6YknnpAknTp1SpcuXVKTJk2sfTw8PFSvXj1t375dkhQcHKyEhIQUfQoUKKBy5cpZ++zYsUPe3t7WgoYkVa9eXd7e3in6lCtXzlrQkKSmTZsqLi5OwcHBqeadNGmSdTkrb29vPfPMM7Z4GQAAdqpXr156+umndenSJY0dO1Z58uRR06ZNzY4FB1CsWDHr+xwA/5M1a9Z7nsuWLVsGJgEAAADgKOxmo3CLxaLhw4erdu3a1s00L126JEnKmzdvir558+bVmTNnrH2yZMmi3Llz39Xn9v9/6dIl5cmT567nzJMnT4o+/36e3LlzK0uWLNY+//bmm29q+PDh1uPr169T2AAAJxYWFqYff/xRixYtUqtWrdS0aVM1a9bM7FhwAF5eXqpcubKaNWsmT09Pa/uUKVNMTIWMtG7dOg0bNkwnT55UUlKSLBaLDMNQUlKS2dFMFR8fr2PHjslisaR6DgAAAAD+zW6KGoMHD9bBgwe1devWu84ZhpHi+PYfgffz7z6p9X+UPnfy8PCQh4fHfXMAAJxHlixZJN36+X/16lXlypVL586dMzkVHEHJkiVVsmRJs2PAREOHDtXMmTPZV+VfoqOj1bx581TPPej9PgAAAIDMyS6KGkOGDNGPP/6oLVu2yNfX19qeL18+SbdmUeTPn9/afvnyZeusinz58ik+Pl4REREpZmtcvnxZNWvWtPb5+++/73ref/75J8U4u3btSnE+IiJCCQkJd83gAABkTqVKldLVq1fVrVs36zKG/v7+ZseCA3jnnXfMjgCT5cyZk+XqUnH69GmzIwAAAABwMKYWNSwWi4YMGaLvv/9ev/32m4oUKZLifJEiRZQvXz6tX7/eetEoPj5emzdv1uTJkyVJlSpVkru7u9avX6+OHTtKurUZ5+HDh61LOtSoUUORkZHavXu3qlatKknatWuXIiMjrYWPGjVq6L333tPFixetBZRffvlFHh4eqlSpUvq/GAAAu7dgwQJJ0iuvvKJKlSrp2rVrLD+FNPvuu+/u2mSe5acyjxYtWmj16tVq2bKl2VEAAAAAwKGZWtR4+eWXtXjxYv3www/y8vKy7l3h7e2trFmzyjAMDRs2TO+//75KlCihEiVK6P3331e2bNnUpUsXa9/evXtrxIgR8vHx0RNPPKGRI0eqfPnyatSokSSpTJkyCggIUN++fTV79mxJUr9+/dSyZUuVKlVKktSkSROVLVtWgYGBmjp1qq5evaqRI0eqb9++ypkzpwmvDgDAntWuXdvsCHAgw4YNU2hoqIKDg9W5c2ctX75cjRs3NjsWMlBQUJCuXLmiHDlyyNPT07rE6eXLl82OZlcsFouioqLk5eXF8lMAAAAAUmVqUeO///2vJOn5559P0T537lz17NlTkjRq1CjFxMRo0KBBioiIULVq1fTLL7/Iy8vL2v+jjz6Sm5ubOnbsqJiYGDVs2FDz5s1LsV7xokWLNHToUDVp0kSS1Lp1a82aNct63tXVVT/99JMGDRqkWrVqKWvWrOrSpYs+/PDDdPrsAQCO4qmnnrrvvktclMSDbNy4UQcOHJC/v7+mTZumUaNGqU+fPmbHQgbau3ev2REcQlRUlLy9vRUZGcmNRQAAAABSZfryUw9iGIbGjRuncePG3bOPp6enZs6cqZkzZ96zzxNPPKGFCxfe97kKFiyo1atXPzATACBz4WIkHpenp6dcXFxkGIZ1v67z58+bHQsZqFChQmZHAAAAAACnYBcbhQMAYM/udzGyVq1a2rZtWwamcR7nz5/X1q1bZRiGatWqpaefftrsSOnGy8tL0dHRql27tnr06KF8+fLJ3d3d7FjIQKGhoRo2bJgOHDiQYl8VZnoBAAAAwMNxMTsAAACOLCwszOwIDumHH37Qc889p6VLl2rx4sXy9/fXqlWrzI6VbpYsWSJXV1dNnTpVzz77rFxcXLR8+XKzYyED9enTR926dZOXl5c2btyotm3batiwYWbHAgAAAACHw0wNAAAeAxvZPprx48dr586dKl68uKRbd7F36NBBrVq1MjlZ+sibN6/18ZgxY0xMArNERkbqP//5jyZOnKjy5ctr9uzZatCggUaPHm12NAAAAABwKBQ1AABAhktKSrIWNCSpWLFiSk5ONjFR+qpfv36qBbBNmzaZkAZmuL3cmJeXl86cOaO8efPqzJkzJqcCAAAAAMdDUQMAgAd46qmnUr0gbbFYdO3atYwP5ATy5MmjOXPmqFevXjIMQ/Pnz9eTTz5pdqx0M3LkSOvj2NhYLV68OEVRB86vXr16unr1qgYPHqzKlSvLw8NDHTp0MDsWAAAAADgcihoAADzA3r17zY7gdD777DN17dpVgwcPliT5+flp4cKFJqdKPy1atEhx3KZNGzVv3tykNDDDlClTJEldunRRnTp1FBkZqXLlypmcCgAAAAAcD0UNAAAeoFChQne1HTlyRM8++6wJaZxDsWLFtHPnTt24cUMWi0VeXl5mR8pQycnJOnXqlNkxYIKTJ0/qxx9/VLFixShqAAAAAMAjcDE7AAAAjigwMNDsCA7t888/19WrV5UjRw55eXnpypUr+uKLL8yOlW46dOigjh07qmPHjmrXrp3Kli2rxo0bmx0LGaBx48YKCQmRJF24cEGVK1fWzz//rNdee02TJ082NxwAAAAAOCBmagAA8AgsFovZERxaUFCQ+vXrZz328fHRp59+qr59+5qYKv20bNnS+tjNzU2vvfaaqlevbmIiZJTz58/Lz89PkrR48WLVq1dP33//vSIiIlSvXj29/vrr5gYEAAAAAAdDUQMAgEdQt25dsyM4tNSKQsnJySYkSV8HDx7UkSNH1KNHD0lSv379rJvLv/baa6pSpYqJ6ZARPD09rY+3b99u3Usld+7ccnPjrTgAAAAAPCyWnwIAII1+//1364X3Tz75RJK0b98+MyM5rPz582vFihXW4xUrVihfvnwmJkof48aNU86cOa3HW7ZsUYsWLfT888/rgw8+MDEZMoqLi4vOnTunmzdvavPmzapXr571XHR0tInJAAAAAMAxcXsYAABpVL9+fTVp0kTLly9X9uzZJUl9+vShsPEIPvroI7Vt29a69E6WLFn0ww8/mJzK9s6cOaMWLVpYj7NmzWqdtbFkyRKzYiEDjR49WpUqVZK7u7vq16+vkiVLSro1a6Nw4cLmhgMAAAAAB0RRAwCANCpfvrxq166tevXq6aefflLevHnZW+MRlSlTRkePHtXx48clSaVKlZKrq6vJqWwvPj4+xfGds1MiIiIyOg5M8OKLL6pWrVq6ePGinnvuOWt74cKF9fnnn5uYDAAAAAAcE0UNAADSyDAMjR49WgULFlTdunW1cuVKGYZhdiyHtGfPHj377LMqW7asli1bpq+++krDhw9XgQIFzI5mU4mJibp+/bp1CaqiRYtKkiIjI5WYmGhmNGSgvHnzKm/evCnanO17PTMKCwtTeHi49fjGjRuSpJCQEOXIkSNF37i4OHl4eKRp3GPHjtkuJAAAAOCEKGoAcBqJiYn65JNPtGHDBhmGoUaNGmno0KFsxAqbuT0ro1u3bipQoICaN2/OmviP6PayXX/99ZfGjBmj9u3b66WXXtLPP/9sdjSb6tSpk3r27Km5c+fK29tb0q2CRu/evdWpUyeT0wF4VGFhYSpdupRiYmLvOnfnvim3GYbBzD4AAADARrjSB8BpDB8+XKGhoerfv78kac6cOTp9+rRmzJhhcjI4i8GDB1sfN2jQQKtWrdL06dNNTOS4XF1d5erqqrVr12rgwIEaPny4/P39zY5lc2PGjFHPnj3l6+ur4sWLyzAM/fXXX2rTpo3eeusts+PBJBaLRVFRUfLy8mK2l4MKDw9XTEysulTzU56ct2ZlWCwWxSclKYura4qv6x8XL2vd4T9T9L2f2/0BAAAApI6iBgCn8dtvvykkJEQuLi6SpJYtW6pixYomp4Iz6d27d4rjcuXK6auvvjIpjWOLi4vTpUuXtHr1an3wwQeSpKSkJJNT2Z6bm5sWLlyoEydOaP/+/ZIkf39/FS9e3ORkMFNUVJS8vb0VGRlpXZoMjilPzhzyze193z6Xr99Ic987+wMAAABIHUUNAE7DYrEoOTnZWtSwWCws9QCbKlKkSKp3VZ88edKENI7t1VdfVenSpdWwYUNVrFhRoaGhypUrl9mx0k3x4sUpZAAAAAAAYAMUNQA4jaZNm6pp06bq3bu3DMPQvHnz1KxZM7NjwYmsXr3a+jg2NlYLFixQ7ty5TUzkuPr06aM+ffpYj4sUKaINGzaYmChjsOwQAAAAAACPh6IGAKcxZcoUff755/ruu+9ksVj0wgsvqF+/fmbHghN59tlnUxxXqlRJDRs2NCmN49u3b59CQkIUG/u/jXYHDRpkYqL0x7JDAAAAAAA8HooaAJxCUlKSAgICtH79eg0YMMDsOMgkIiIidOrUKbNjOKTJkyfrm2++UVhYmOrVq6f169erYcOGTl/UAAAAAAAAj4eiBgCn4OrqeteeGoCtValSxbpkUFJSkk6dOqWRI0eanMoxLViwQHv37lX16tW1YsUKHT9+XG+//bbZsQA4kbCwMIWHh6e5f1xcnDw8PNLU99ixY48aCwAAAMBjoqgBwGlUr15dbdq0UWBgoHLkyGFtb968uYmp4Ew+/PBD62M3NzcVKVJEBQoUMDGR4/L09JSnp6eSk5NlsVhUqlQpnT592uxYAJxEWFiYSpcpo5jo6DT/P4aLiyzJyemYCgAAAIAtUNQA4DS2bdsmSfrvf/9rbTMMg6IGbCIpKUlffvmlFixYYHYUp5AtWzYlJCTIz89Pr7/+unx9fRX9EBcfATi+1GZS3LhxQ5IUEhKS4gYF6eFnUsRER6vvhzNVoFiJB/Y/uHmTvv94ykP3BwAAAJDxKGoAcBq//vqr2RHgxFxdXXX+/HmzYziNoKAgxcfHa9q0aRo9erROnjxJwQjIRG7NpCitmOiYVM/Xq1fvrjbDxZAl2fJQz1OgWAkVerb8A/tdDP3rkfoDAAAAyHgUNQA4jaSkJM2aNUsnTpzQzJkzFRoaqjNnzqhBgwZmR4OTaNSokQYOHKiXXnopxR3EZcuWNTGVYypXrpwkKXv27Priiy9MTgMgo4WHhysmOkYvfdRJ+YvnsbZbLBbFx8QrS9Ys1j2MJOnQr39o1fRf7up/L7f7AwAAAHA+FDUAOI0hQ4YoISFBW7dulST5+PioU6dO2rNnj8nJ4CxuX3xft26dtc0wDJ08edKsSA7r3Llz6t+/v3799VcZhqEGDRooKChIzzzzjNnRAGSg/MXzqGA53wf2u3Ti8iP1BwAAAOB8KGoAcBrbt29XSEiI/P39JUm5cuVSfHy8yangTE6dOmV2BKcRGBio5s2ba/HixbJYLPryyy/VvXt3lpEDAAAAAAD35WJ2AACZy513uN+v7VF4enqmOE5KSlJycrJNxgYkadWqVbp27Zr1OCIiQqtXrzYvkAO7du2aXnvtNXl7eytXrlwaOXJkitcWAAAAAAAgNRQ1AGSo0aNHp6ntUVSoUEGLFi2SxWLR6dOnNWjQINWtW9cmYwOSNHbsWOXKlct6nCtXLo0dO9a8QA6sWLFiOnHihPX4xIkTevbZZ01MBAAAAAAAHAHLTwHIECdOnNCff/6p69eva82aNdb2yMhIRUdH2+Q5pk+frhEjRujixYuqVq2aWrdurSlTpthkbCA1hmEwG+ghdejQQYZh6Pr163ruuedUu3ZtSdK2bdtUr149k9MBAAAAAAB7R1EDQIbYtm2b5s2bp7///ltTp061tufMmVPTpk177PGTkpI0YcIEzZ49W7Nnz37s8YDU5MyZU7t27VK1atUkSTt37pSXl5fJqRxLy5YtrY+7du1qfdylSxcz4gAAAAAAAAdDUQNAhujRo4d69OihOXPmqHfv3jYf39XVVbt377b5uMCdJk+erLZt2+rZZ5+VxWLRH3/8oe+//97sWA6lR48eZkcAAAAAAAAOjKIGgAxx6tQpFSlSRDVq1NDRo0fvOl+2bNnHfo5WrVpp8uTJeumll5QjRw5re7Zs2R57bECS9ft3x44dkqSaNWum2GMDaRcbG6ugoCCFhIQoNjbW2r5s2TITUwEAAAAAAHtHUQNAhhgyZIhWr16tFi1a3HXOMAydPHnysZ9j5MiRkqQ333xThmHIYrHIMAwlJSU99tjAbblz51aTJk0UHx8vSYqOjqZw9gj69u0rLy8vbdmyRSNGjNC8efNUt25ds2MBAAAAAAA752J2AACZw+rVq2WxWLRt2zadOnUqxYctChrJycnavn27kpOTlZycrKSkJOt/AVvZvXu3ypcvL09PT3l5eVk/8PBCQkIUFBSknDlzasiQIfrtt99SncUFAAAAAABwJ2ZqAMhQzZs3V0hIiM3HdXFx0dChQ9lXA+lq6NCh+vLLLzVgwABt2bJFM2bMUNasWc2O5ZBuv25ubm6Kjo6Wl5eXzp8/b3IqwPmFhYUpPDw8zf3j4uLk4eFh877Hjh1LcwYAAAAAuBNFDQAZxjAMFStWTFeuXJGPj4/Nxy9TpoxOnjypokWL2nxsQJISEhJUrVo1JSYmysvLS2PGjNHzzz+v4cOHmx3NYXTu3FlLlizRE088oYiICDVv3lzNmjWTj4+P8ufPb3Y8wKmFhYWpTJkyio6OTvP/4+LiouTkZJv3BQAAAIBHRVEDQIbKnj27/P391bJlyxSbeU+ZMuWxx758+bL8/PxUu3btFGOz8TBsxdXVVZLk4+OjkJAQ+fr66syZMyancix//PGHJOmnn36Sq6urJkyYoEWLFunatWvq3r27yekA5xYeHq7o6Gi9/epkFfZ98A0AO4J/1xeLZ6Sp/8P0vbM/AAAAADwsihoAMlSxYsVUrFixdBm7U6dO6tSpU7qMDUi3ZhlcuXJFo0ePVt26dZWYmKh3333X7FgOxTAMSf8rEBmGoW7dupkZCch0CvsWValiZR/Y78y5k2nu/zB97+wPAAAAAA+LogaADPXOO++k29g9evSQJCUmJsrNjR9vsK3k5GTVrFlTPj4+atKkia5cuaLY2Fg2Cn9Ihw4dUp48ee55/vLlyxmYBgAAAAAAOBqu+gHIcN99951CQkIUGxtrbbPF8lNHjx5Vly5ddOXKFZ09e1bBwcFatmyZJk+e/NhjAy4uLhoyZIh1M3p3d3e5u7ubnMrxlCxZUmvWrDE7BpBhUtuY+8aNG5KkkJCQFMslSg+32fbD9mdzbgAAAADOgKIGgAw1bNgwhYaGKjg4WJ07d9by5cvVuHFjm4z98ssva9asWRoyZIgkqWLFiurRowdFDdgMm9E/Pg8PDxUqVMjsGECGCAsLU+nSpRUTE5Pq+Xr16t3VZhiGLBZLmp/jYfsDAAAAgKOjqAEgQ23cuFEHDhyQv7+/pk2bplGjRqlPnz42GTsqKkq1a9e2HhuGwZ30sCk2o398XHxFZhIeHq6YmBi98MILeuqpp6ztFotFCQkJcnd3t+4zI0l//fWXfv3117v638uj9gcAAAAAR0ZRA0CG8vT0lIuLiwzDUEJCgvLmzavz58/bZGw3NzclJCRYLxCdO3dOLi4uNhkbkNiM3hb2799vdgSkg9SWWLqf9FxiKb37P8pyT0899ZTy58//wP63X8P07g8AAAAAjoyiBoAM5eXlpejoaNWuXVs9evRQvnz5bDabYvDgwXrhhRcUHh6ucePG6euvv9b7779vk7EBic3o04vFYlFUVJS8vLxS3LXu6OxpL4WH7f8wfS9evKgO7TsoJjb1JZZS42K4KNmS7JD9H3ZsAAAAAIBtcUUGQIZasmSJXF1dNXXqVE2fPl0RERFavny5Tcbu1q2bihYtqh9++EHR0dGaP3++6tSpY5OxAYnN6NNLVFSUvL29FRkZqZw5c5odxybCwsJUplQpRcfGpno+tb0UXCQ9zKXy9Oz/sGNL0oyWb6m4z4P3S/n15E5N/X2OQ/Z/1LEBAAAAALZDUQNAhoqIiFDevHklSWPGjLH5+DVr1lTNmjVtPi4gsRk90i48PFzRsbGanD+/imX534wHi8WiGItFWQ0jxayULTdvaEZ4+F397yU9+z/q2MV9Cql8vlIP7H/iyhlJcsj+jzo2AAAAAMB2KGoAyFABAQEqUaKEBg8erNatW9t0qZn69eunOt6mTZts9hzI3NiMHg+rWBYPlfX0fGC/k3FxdtP/UccGAAAAACAjUNQAkKFOnjyp77//Xp988omGDRumgQMHqnfv3vLx8XnssUeOHGl9HBsbq8WLF6t48eKPPS5wG5vR27/03LD6UTaIBgAAAAAAtkVRA0CGcnFxUbt27dSuXTvt2bNH7dq107hx49S1a1eNHz9eBQoUeOSxW7RokeK4TZs2at68+eNGBvTDDz+oZcuWbEZv58LCwlSmTBlFR0en+f9xcXFRcnIaN4h+iL4AAAAAACB9UNQAkOFCQ0MVFBSkZcuWqWXLlurbt682bNiggIAAHTx40GbPk5ycrFOnTtlsPGRe77zzjgYMGKDu3btrzJgxWrlyJZvR26Hw8HBFR0dr3LhxKly48AP7b9++XZ9//nma+j9M3zv7AwAAAAAA26KoASBDBQQE6M8//9SgQYN06NAh5cqVS9KtDZe//vrrxxq7Q4cO1mWBkpKSdODAATVp0uRxIwMKCQnR3r17NXfuXLVs2VJly5ZV7969ValSJbOjIRWFCxdWqVIP3sT59OnTae7/MH3v7A8AAAAAAGyLogaADNWnTx+9+OKLqe5DcPjw4ccau2XLltbHbm5ueu2111S9evXHGhO4rXLlyqpcubKmT5+uFStWaO7cuXr11VfVoUMH7sgHAAAAAADIIBQ1AGSo9u3bKykpSSdPnlRsbKy1vWzZso885sGDB3XkyBH16NFDktSvXz9du3ZNkvTaa6+pSpUqj5UZuJOHh4c6duwoT09Pvf/++1q6dClFDQAAAAAAgAxy963SAJCO1q5dq4IFC6ps2bKqU6eOypcvf9cG3w9r3Lhxypkzp/V4y5YtatGihZ5//nl98MEHjxsZsDp06JBeffVVPf300/rwww81YMAAXbhwwexYAAAAAAAAmQYzNQBkqDFjxmj79u1q27at9u/fr4ULF+rQoUOPNeaZM2dSFEayZs1qnbWxZMmSxxobkKSgoCB99dVXOnfunLp166Zff/31sWYXAQAAAAAA4NFQ1ABsLDw8XOPHj9eBAwdSLK+0e/duE1PZD8MwVKhQISUmJkqSunXrprp16z7WmPHx8SmOV6xYYX0cERHxWGMDkrR69Wq9+eabat26tdzd3c2OAwAAAAAAkGmx/BRgY7169ZKvr68uXbqksWPHKk+ePGratKnZsezG7QvCvr6+WrVqlQ4ePKhz58491piJiYm6fv269bho0aKSpMjISGvxBHgca9asUbt27ShoAAAAAAAAmIyiBmBjYWFhev311+Xp6alWrVrpu+++0/bt282OZTdeeeUVRUREaOLEiRo+fLgaNmyoiRMnPtaYnTp1Us+ePRUZGWlti4yMVO/evdWpU6fHjQwAAAAAAADATrD8FGBjWbJkkSR5eHjo6tWrypUr12PPRHAGW7ZskSQ9/fTT1j00vvzyS0m3lqR6HGPGjFHPnj3l6+ur4sWLyzAM/fXXX2rTpo3eeuutxwsO3IPFYlFUVJS8vLwe+3sYAAAAAAAAaUNRA7CxUqVK6erVq+rWrZuqV68ub29v+fv7mx3LdCNGjLirzTAMXbhwQRcvXlRSUtIjj+3m5qaFCxfqxIkT2r9/vyTJ399fxYsXf+QxgQeJioqSt7e3IiMjlTNnTrPjAAAAAAAAZAoUNQAbW7BggaRbyyxVrlxZERERatasmcmpzLdnz54Ux1evXtXEiRO1cOFCjR8/3ibPUbx4cQoZAAAAAAAAgBNjTw3Axvbs2aOoqChJUq1atVS3bl3r7AFIsbGxmjRpksqUKaPk5GQdPXqUJaIAAAAAAAAApAlFDcDG+vfvr2zZslmPs2XLpv79+5uYyD4kJyfr888/V4kSJXTkyBHt3LlTH3/8sZ588kmbP5fFYtH169dlsVhsPjYAAAAAAAAA87D8FGBjycnJcnV1tR67ubkpMTHRxET2oVy5coqLi9OkSZNUsWJFxcTE6OjRo9bzZcuWtdlzsdcBAAAAAAAA4JwoagA2liVLFoWGhqpYsWKSpBMnTsjd3d3kVOaLjo6WYRgaO3asDMNIMYvCMAydPHnSxHQAAAAAAAAAHAFFDcDG3nnnHdWuXVstWrSQJK1du1Zz5swxOZX5Tp8+bXYEAAAAAAAAAA6OPTUAG2vRooU2b96sihUrqmLFitqyZYsCAgLMjmV32PcCAAAAAAAAwMNipgaQDkqWLKmSJUuaHcOuse8FAAAAAAAAgIfFTA3AxkJDQ9WqVSsVLFhQefLksX4AAAAAAAAAAB4PMzUAG+vTp48GDBigkydP6qefftLMmTNVuHBhs2MBAAAAAAAAgMOjqAHYWGRkpP7zn/9o4sSJKl++vGbPnq0GDRpo9OjRZkcDANOFhYUpPDw8RduNGzckSSEhIcqRI0eKc3FxcfLw8EjT2MeOHbNNSAAAAAAAYLcoagA25u7uLkny8vLSmTNnlDdvXp05c8bkVABgvrCwMJUpU0rR0bGpnq9Xr95dbS4uUnJyeicDAAAAAACOgqIGYGP16tXT1atXNXjwYFWuXFkeHh5q37692bEAwHTh4eGKjo7Vm28+pYIFs1jbLRaLYmMt8vQ0ZBiGtX337puaO/faXf3v5XZ/AAAAAADgvChqADY2ZcoUSVKXLl1Up04dRUZGqly5cianAgD7UbBgFpUo+eAlpcLC4h+pPwAAAAAAcF4uZgcAnM327dutj5955hmVK1dOy5cvNzERAAAAAAAAADgHihqAjXXv3l1Tp06VJCUkJGjQoEH64IMPTE4FAAAAAAAAAI6PogZgY7t379bvv/+u5s2bq0aNGpJSzt4AAAAAAAAAADwaihqAjT3xxBPq3r27tm/frkuXLmno0KHy8HjwWvAAAAAAAAAAgPtjo3DAxoYOHapt27YpODhYx44dU0BAgCZOnKhu3bqZHQ0AAAAAAAAAHBpFDcDGYmNjtX37dnl4eKhYsWKqUKGCOnfuTFEDAAAAAAAAAB4TRQ3Axj7//PMUxwULFtSWLVtMSgMAAAAAAAAAzoOiBpAOvvvuO4WEhCg2NtbaNmXKFBMTAQAAAAAAAIDjo6gB2NiwYcMUGhqq4OBgde7cWcuXL1fjxo3NjgUgEwsLC1N4eHia+sbFxcnDwyPNYz9M/2PHjqV5XAAAAAAAgNRQ1ABsbOPGjTpw4ID8/f01bdo0jRo1Sn369DE7FoBMKiwsTGVKl1Z0TEya+rsahpIsljSP/7D9AQAAAAAAHgdFDcDGPD095eLiIsMwlJCQoLx58+r8+fNmxwLwGFKb6XDjxg1JUkhIiHLkyJHiXHrOdnjY/seOHVN0TIwWvtRTZfLnu2/fNYeOaOyqVWnq+zj9AQAAAAAAHhVFDcDGvLy8FB0drVq1aqlHjx7Kly+f3N3dzY4F4BGFhYWpVJkyio2OTvV8vXr17m50cZGSk9P+JOndX1KZ/PlUsWDB+/Y5dulSmvs+Tn8AAAAAAIBHRVEDsLGlS5cqIiJCb7zxhr7++mtdu3ZNy5cvNzsWgEcUHh6u2Oho5Rz9ntwKFrG2WywWKTZG8swqwzCs7XG7t+rmV0F39b+XjOoPAAAAAADgDChqADb05Zdf6t1339W5c+dkGIZ8fX01ZswYFUzDHcwA7JtbwSJyL1nmgf0Sw07ZZX8AAAAAAABnQFEDsJF58+Zp+vTpmj17tmrUqCFJ2r59u0aOHCl3d3e99NJLJid0To6810F697enLPbW/2H3pAAAAAAAAIB9oKgB2Mj06dO1bt26FLMymjdvrrJly6p169YUNdJBWFiYypQureiYmFTPp7bXgathKMliSfNzpHd/FxcXJT/E3ggP0z89x3b0/g87NgAAAAAAAOwDRQ3ARpKSklJdZqpw4cJKSkoyIZHjSm32RWqOHTum6JgYLXypp8rkz2dtt1gsuhkfr+xZsqTY62DNoSMau2rVXf3vJaP6v/3qZBX2LfrA/juCf9cXi2ekqf/D9M1s/R91bAAAAAAAAJiPogZgI/Hx8YqNjZWnp2eK9piYGMXFxZmUyvGEhYWpVJkyio2OTvP/UyZ/PlVMw74lxy5dssv+hX2LqlSxsg/sf+bcyTT3f5i+ma3/o44NAAAAAAAA81HUAGzkxRdfVGBgoL744gvlypVLkhQREaF+/frpxRdfNDecAwkPD1dsdLRyjn5PbgWL3Ldv3O6tuvlVUAYlAwAAAAAAAGA2ihqAjUycOFE9evSQr6+vSpQoIcMw9Oeff6pVq1Z67733zI5nqofZzPv2psxuBYvIvWSZ+46bGHbKxkkBAAAAAAAA2DOKGoCNuLu7a/HixQoNDdW+ffskSf7+/ipevLjJycwVFham0qVLKSYmNtXzqW3mDQAAAAAAAACpoagB2FixYsVUrFgxs2PYjfDwcMXExKpLNT/lyfm/GRkWi0XxSUnK4uqaYjPvPy5e1rrDf5oRFQAAAAAAAICdo6gBpCOLxaKoqCh5eXmluHCfGeXJmUO+ub0f2O/y9RsZkAYAAAAAAACAI6KoAaSjqKgoeXt7KzIyUjlz5jQ7zj2ltufF/cTFxcnDwyNNfW/vkQEAAAAAAAAAj4uiBpDJhYWFqXSZMoqJjk7z/2O4uMiSnJyOqQAAAAAAAADgbhQ1gEwuPDxcMdHR6vvhTBUoVuKB/Q9u3qTvP57y0P0BAAAAAAAA4HFR1AAgSSpQrIQKPVv+gf0uhv71SP0BAAAAAAAA4HG5mB0AAAAAAAAAAAAgLShqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDMLWosWXLFrVq1UoFChSQYRhauXJlivMWi0Xjxo1TgQIFlDVrVj3//PM6cuRIij5xcXEaMmSInnzySWXPnl2tW7fWuXPnUvSJiIhQYGCgvL295e3trcDAQF27di1Fn7CwMLVq1UrZs2fXk08+qaFDhyo+Pj49Pm0AAAAAAAAAAPAITC1q3Lx5U88995xmzZqV6vkpU6Zo+vTpmjVrlvbs2aN8+fKpcePGioqKsvYZNmyYvv/+ey1dulRbt27VjRs31LJlSyUlJVn7dOnSRSEhIVq3bp3WrVunkJAQBQYGWs8nJSWpRYsWunnzprZu3aqlS5dqxYoVGjFiRPp98gAAAAAAAAAA4KG4mfnkzZo1U7NmzVI9Z7FY9PHHH2vMmDF68cUXJUnz589X3rx5tXjxYvXv31+RkZGaM2eOFixYoEaNGkmSFi5cqGeeeUYbNmxQ06ZNdezYMa1bt047d+5UtWrVJElffPGFatSooePHj6tUqVL65ZdfdPToUZ09e1YFChSQJE2bNk09e/bUe++9p5w5c2bAqwEAAAAAAAAAAO7HbvfUOHXqlC5duqQmTZpY2zw8PFSvXj1t375dkhQcHKyEhIQUfQoUKKBy5cpZ++zYsUPe3t7WgoYkVa9eXd7e3in6lCtXzlrQkKSmTZsqLi5OwcHB98wYFxen69evp/gAAAAAAAAAAADpw26LGpcuXZIk5c2bN0V73rx5recuXbqkLFmyKHfu3PftkydPnrvGz5MnT4o+/36e3LlzK0uWLNY+qZk0aZJ1nw5vb28988wzD/lZAgAAAAAAAACAtLLbosZthmGkOLZYLHe1/du/+6TW/1H6/Nubb76pyMhI68fZs2fvmwsAAAAAAAAAADw6uy1q5MuXT5Lumilx+fJl66yKfPnyKT4+XhEREfft8/fff981/j///JOiz7+fJyIiQgkJCXfN4LiTh4eHcubMmeIDAAAAAAAAAACkD7stahQpUkT58uXT+vXrrW3x8fHavHmzatasKUmqVKmS3N3dU/S5ePGiDh8+bO1To0YNRUZGavfu3dY+u3btUmRkZIo+hw8f1sWLF619fvnlF3l4eKhSpUrp+nkCAAAAAAAAAIC0cTPzyW/cuKETJ05Yj0+dOqWQkBA98cQTKliwoIYNG6b3339fJUqUUIkSJfT+++8rW7Zs6tKliyTJ29tbvXv31ogRI+Tj46MnnnhCI0eOVPny5dWoUSNJUpkyZRQQEKC+fftq9uzZkqR+/fqpZcuWKlWqlCSpSZMmKlu2rAIDAzV16lRdvXpVI0eOVN++fZl9AQAAAAAAAACAnTC1qLF3717Vr1/fejx8+HBJUo8ePTRv3jyNGjVKMTExGjRokCIiIlStWjX98ssv8vLysv4/H330kdzc3NSxY0fFxMSoYcOGmjdvnlxdXa19Fi1apKFDh6pJkyaSpNatW2vWrFnW866urvrpp580aNAg1apVS1mzZlWXLl304YcfpvdLAAAAAAAAAAAA0sjUosbzzz8vi8Vyz/OGYWjcuHEaN27cPft4enpq5syZmjlz5j37PPHEE1q4cOF9sxQsWFCrV69+YGYAAAAAAAAAAGAOu91TAwAAAAAAAAAA4E4UNQAAAAAAAAAAgEOgqAEAAAAAAAAAABwCRQ0AAAAAAAAAAOAQTN0oHHAmYWFhCg8PT9F248YNSVJISIhy5MiR4lxcXJw8PDzSNPbD9H3Y/seOHUvzuAAAAAAAAABgJooagA2EhYWpTOkyio6JTvV8vXr17mpzMVyUbElO0/gP0/dR+gMAAAAAAACAI6CoAdhAeHi4omOiNaPlWyruU8jabrFYFJMQq6zunjIMw9r+68mdmvr7nLv6p+Zh+j5OfwAAAAAAAACwdxQ1ABsq7lNI5fOVemC/E1fOpLn/w/R9nP4AAAAAAAAAYO8oaiBdpbbPxL2k574R6d2ffSkAAAAAAAAAIP1R1EC6ubXPRClFx8Smqb+rISVZ0j6+vfUHAAAAAAAAAKQvihpIN7f2mYjVwheyqsxTLvftu+avRI39NS5Nfe25PwAAAAAAAAAg/VDUQLor85SLKuZ3vW+fY+FJae5rz/0BAAAAAAAAAOnnwbegAwAAAAAAAAAA2AGKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAAAAAAAAAAAcAkUNAAAAAAAAAADgEChqAAAAAAAAAAAAh0BRAwAAAAAAAAAAOASKGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6Bosa/BAUFqUiRIvL09FSlSpX0+++/mx0JAAAAAAAAAACIokYK33zzjYYNG6YxY8Zo//79qlOnjpo1a6awsDCzowEAAAAAAAAAkOm5mR3AnkyfPl29e/dWnz59JEkff/yxfv75Z/33v//VpEmT7uofFxenuLg463FkZKQk6fr16xkT2M7duHFDkhR8IUk34i337Xvsn+Q097Xn/ocu/ano+JgH9j9x5Uya+z9M38fpf/rIQcVF33xg/wuhJx6p//mrkYpLTHxg/8vXoyRJCX8dkyUm+r59E8NOSZKCz4Tpxh3/Fu/l2IVLdtn/eOhRxcTe/3OVpNPnTqa5/8P0zWz9H3XstHxPSv/7vrS3/mn5vsyo7/m//opVTEzyA/uHhcU/Uv8//vhDMTEP/vl3+vTpNPd/mL539j8SG6Po5AdnD42Ps5v+jzp2ev+esof+jzr2hQsXFB8f/8D+//zzT4b0t6efrWcOn1dc9IN/flw4cfmR+tvD+5vb720e9r1QzOkYJcc++N9g7MVYSVJY+F+KS3jw9+WlyDC76W9PWe7sf/jwOUWn4fvsxP9/n6VH/9t90/t35sP2D/3joGJjHvxv5PzpvyRJ+08c080HvF85fvZUmvtmtv6POnbcpRNKjo99YP+EK2clScF/XdKNmAf/HjkWFp4h/dOS/3Z2R/9cH7Z/Wn7n3/59/7D/Xv88E6aYNLynP3PxksP2t6cs9tbfnrLc2T893is+6vvK9Op/6eStf983btzgmrL+d13dYrn/9VjD8qAemUR8fLyyZcum5cuX64UXXrC2v/LKKwoJCdHmzZvv+n/GjRun8ePHZ2RMAAAAAAAAAACc1tmzZ+Xr63vP88zU+H/h4eFKSkpS3rx5U7TnzZtXly5dSvX/efPNNzV8+HDrcXJysq5evSofHx8ZhpGueR3Z9evX9cwzz+js2bPKmTOn2XFwD/b2dbK3POkpM32uMEdm+x7LbJ+vveB1dxyZ6WvlyJ+rI2d3dLz298Zr4xgc/evk6PnTS3q/LrzusEd8Xzo/i8WiqKgoFShQ4L79KGr8y7+LERaL5Z4FCg8PD3l4eKRoy5UrV3pFczo5c+bkB5ADsLevk73lSU+Z6XOFOTLb91hm+3ztBa+748hMXytH/lwdObuj47W/N14bx+DoXydHz59e0vt14XWHPeL70rl5e3s/sA8bhf+/J598Uq6urnfNyrh8+fJdszcAAAAAAAAAAEDGo6jx/7JkyaJKlSpp/fr1KdrXr1+vmjVrmpQKAAAAAAAAAADcxvJTdxg+fLgCAwNVuXJl1ahRQ59//rnCwsI0YMAAs6M5FQ8PD73zzjt3Ld0F+2JvXyd7y5OeMtPnCnNktu+xzPb52gted8eRmb5Wjvy5OnJ2R8drf2+8No7B0b9Ojp4/vaT368LrDnvE9yVuMywWi8XsEPYkKChIU6ZM0cWLF1WuXDl99NFHqlu3rtmxAAAAAAAAAADI9ChqAAAAAAAAAAAAh8CeGgAAAAAAAAAAwCFQ1AAAAAAAAAAAAA6BogYAAAAAAAAAAHAIFDUAAAAAAAAAAIBDoKgBAHYgKipKgwcPVpkyZVS2bFkNHTpUUVFRZscCAADIlM6ePav4+HhJ0rZt2zRr1izem0lKSkpS+fLlzY6BTOKHH37Q5MmTJUnnz5/XoUOHTE5kvsTERE2bNk3NmjVT8+bNNX36dCUmJpodC0gX0dHR9/1A5kZRAxli1apVun79uiTpww8/VPv27XX48GGTUyE1e/bssf5yWLZsmUaOHKkLFy6YkiU8PFxDhgxR3bp1VbVqVeuHMxo0aJASEhK0ZMkSLV68WImJiRo0aJDZsQAAgB34+++/tWnTJq1Zs8b6gfTVpk0bJScn6/z58+rUqZO2bdumXr16mR3LdK6urvL19VVMTIzZUfAAs2fPVmRkpCTp5ZdfVuXKlbVlyxaTU6XduHHj9Nlnn2nOnDmSJBcXFw0YMMDkVOYbPny4Nm3apP79+6tfv3769ddfNXz4cJuNv2/fPgUEBKhkyZIqWrSo9QMwQ44cOeTl5aUcOXJYP24fe3l5mR0PJjMsFovF7BBwfhUqVNDBgwd14MAB9ejRQwMHDtTChQv1+++/mx0N//Lcc89p3759OnnypJo3b6727dtr3759+vnnnzM8S+vWrVWrVi3NmTNH06ZN0+zZs+Xv768JEyZkeJb09txzz+nAgQMPbANsYe/evdq4caMMw1CDBg1UuXJlsyPZXHh4uMaPH68DBw4oNjbW2r57924TU2Ue+/btU0hISIrXnkKtfYqJidHBgwdlGIbKly+vrFmzmh3J5k6fPq3JkycrNDQ0xd2smzZtMjFV2s2bN0/jx4/XlStXVKJECR04cEDVq1fX1q1bzY7m1CpWrKh9+/bp888/1+XLl/XWW2/x3uz/vfLKK9q2bZs6duyoHDlyWNv5OW9fbv8Nvm3bNo0ePVqjR4/W2LFjHea9kJ+fn4KDg1W5cmXt379f0v8+p8ysQoUKCgkJkYvLrXuUExMTVbFiRZu9LuXLl9fgwYNVo0YNubq6WtufffZZm4wPALbiZnYAZA5ubre+1X755Rf169dP/fv31+zZs01OhdS4urrK1dVVa9eu1cCBAzV8+HD5+/ubkiUsLEw//vijFi1apFatWqlp06Zq1qyZKVnSW1JSkqKioqx3G9y8eVPJyckmp4Iz+uKLLzRhwgS9+OKLkqR27dpp7Nix6tOnj8nJbKtXr16qVauWfv755xRFUaS/yZMn65tvvlFYWJjq1aun9evXq2HDhlzsskPbt29X+/btlTdvXlksFv3zzz/69ttvVaNGDbOj2VTHjh3VsGFDDR48OMUFGkcxffp07du3Tw0aNFBwcLC2bNmir7/+2uxYTi8uLk5xcXFav369hg0bZnYcu3L9+nWVL19ex44ds7YZhmFiIqTm9t/gmzZtUvfu3dW0aVO9+eabJqdKO09PT4f8mZ3eLBaLkpOTrUUNi8UiW96r7Orqqv79+9tsPMCWEhMTrUtDSlK2bNlMTAOzUdRAhkhKStLOnTu1YsUKzZ07V5KUkJBgciqkJi4uTpcuXdLq1av1wQcfSLr19TNDlixZJEkeHh66evWqcuXKpXPnzpmSJb11795d1atXV9euXWUYhpYuXaoePXqYHQtOaObMmQoODtZTTz0lSRozZowaNmzodEWNzFQUtTcLFizQ3r17Vb16da1YsULHjx/X22+/bXYspGL48OFavny5atWqJelWkePVV1/Vzp07TU5mW7GxsZo0aZLZMR6Zu7u7cufObZ1lUrduXb3xxhsmp3J+nTt3Vr58+VSyZEnVrFlTFy9e5OLJ/7v99xzsm4uLi5YuXapvvvlGq1evlqQUFwPtXaFChbR161YZhqHk5GS9//777OciqWnTpmratKl69+4twzA0b948m77HrVWrlvbv38/NQLAru3fvVu/evXXs2LEURTyzrlXBPlDUQIaYOHGiBgwYoIYNG6pMmTI6fvy4SpQoYXYspOLVV19V6dKl1bBhQ1WsWFGhoaHKlSuXKVlKlSqlq1evqlu3bqpevbq8vb2d9s3VqFGjVL58eW3cuFEWi0WTJ09WQECA2bHgpG4XNG4/dsa7KzNTUdTeeHp6ytPTU8nJybJYLCpVqpROnz5tdiykIjY21lrQkKSaNWumWDLMWZQrV07nzp2Tr6+v2VEeiYeHhywWi0qWLKmZM2eqUKFCCg8PNzuW03vrrbc0ePBg5cyZU4ZhyMvLS99++63ZsezCvWYKde/ePYOT4H4+/fRTTZo0SX379lXhwoX1559/qn79+mbHSrMZM2aoR48eOnz4sLJly6Y6depo4cKFZscy3ZQpUzR79mx99913slgseuGFF9SvXz+bjb99+3Z9+eWXKlWqlDw9Pa3tjrJsGZzT0KFD9eWXX2rAgAHasmWLZsyY4ZRLpuLhsKcGgPtKTk5WYmKi9QKhWbZu3apr166pWbNmTj0N+dKlSzIMQ3nz5jU7CpzUiy++qDJlyujll1+WYRj6/PPPdeDAAX333XdmR7OpwMBAffLJJ1qwYIE+/fRTeXt7q1ixYlq6dKnZ0Zxe3bp1tXHjRvXu3Vv58uWTr6+vvvjiCx06dMjsaPiXmjVr6t1331WjRo0kSb/99ptGjx6t7du3m5zMtgICArR7927Vrl07xQWaZcuWmZgq7TZt2qRKlSopPDxcAwYM0LVr1zRp0iTr1w3p5++//9aRI0dSFPuaN29uYiL70KFDB+vj2NhYbd26VdWrV9fatWtNTIV7SUxMtC5F5Yiio6OVnJycYv8WpJ/Nmzen2l6vXr0MTgL8T6VKlRQcHKzy5ctb/6Z4/vnn9dtvv5kbDKaiqIEM89133921aeiUKVNMTIR7YYPXjHfw4EF16dJFFy5ckCQ9/fTTWrx4MVOsYXOXL1/W0KFDtWHDBklS48aN9cknnyhPnjwmJ0s/27ZtU0REhNMXRe3F4cOHVaRIEUVHR2v06NGKiIjQW2+9JT8/P7Oj4V/27t2rdu3aycPDQ4ZhKC4uTitWrFClSpXMjmZT8+fPT7WdZR5xP2zQnnanTp3S2LFjuYvezhw9elRdunTRlStXdPbsWQUHB2vZsmWaPHmy2dHSpGrVqnfNDkitLbO5cOGC+vXrp19//VWS1LBhQ82ePVv58+e36fP8/fffMgzDqf9GgOO4/W//+eef18cffyxfX19VqVJFp06dMjsaTERRAxli2LBhCg0NVXBwsDp37qzly5ercePGmjNnjtnR8C/32uD1+++/z7AM91oOx2KxyDAMXb58OcOyZJSqVavqtddes9759u2332ry5Mnas2ePyckAx3X+/HnrWsy1atXS008/bXYkwO4kJCTo+PHjslgsKl26tNzd3c2OhH+Jjo7W4sWLdfLkSeu+GhI3B6W3ChUqaPPmzWrQoIH2799v3aD9yy+/NDuaXapSpQrvW+1M/fr1NWHCBA0ZMkT79++XxWJR+fLldfjwYbOjpUnFihW1b98+63FSUpLKly+vo0ePmpjKfK1atVKNGjWsNx1+9tln2rZtm1atWmWT8Y8dO6aOHTtal2195plntGzZMpUuXdom4wOP4qOPPlL37t0VHBys9u3bKzExUe+++65GjhxpdjSYyHHnIMKhbNy4UQcOHJC/v7+mTZumUaNGOd2mtM7CHjZ43bt3b4Y+nz1ITk5OMZW/ffv2DnMXFRxLUFDQXW3e3t6qWrWqU+119MMPP6h3796qU6eOLBaLBg8erDlz5qhVq1ZmR3Nao0aNuu95LsDan1WrVqlOnToqV66cJCkiIkLbtm1Ty5YtTU5mW7GxsQoKCrprFqqjLD/1wgsvyM3NTZUqVZKHh4fZcTINNmi/tzVr1lgfJyUladeuXU65P5eji4qKUu3ata3HhmE4ROF66tSpmjJliiIjI1PMEoiOjlbXrl1NTGYfzp49m6KA8cYbb9h0NuygQYP05ptvqkuXLpKkpUuXauDAgdaZIUBGS05OVs2aNeXj46MmTZroypUrio2NlZeXl9nRYDKKGsgQnp6ecnFxkWEYSkhIUN68eXX+/HmzYyEV9rDBa6FChTL0+exBhQoV9Pvvv6tOnTqSbu0hUq1aNZNTwRmtXbtWW7ZsUcOGDSXdWqu9du3aevPNNzVu3Dj16tXL5IS2MX78eO3cuVPFixeXJIWGhqpDhw4UNdJR9uzZzY6AhzR27FiFhIRYj3PlyqWxY8c6XVGjb9++8vLy0pYtWzRixAjNmzdPdevWNTtWmp07d05HjhwxO0amwwbt9zZ16lTrYzc3NxUrVkzffPONiYmQGjc3NyUkJFgLTufOnZOLi4vJqR6sX79+6tChgwYOHKjPPvvM2p4zZ07lzp3bxGT2ITk5WZcuXVK+fPkk3Vpa1pYLsERERFgLGpLUqVMnbraDqVxcXDRkyBDr0nPu7u4OUaBF+qOogQzh5eWl6Oho1a5dWz169FC+fPn4IWSnsmXLpoSEBPn5+en111+Xr6+voqOjTckSGhqqYcOG6cCBAynurHTG5af27dun+fPnWy/AnjhxQn5+fqpataokZfq1Y2Fbhw8f1jPPPCPp1t1eI0eO1O7du9WoUSOnKWokJSVZ/z1JUrFixZScnGxiIuf3zjvvmB0Bj8kwDKf8dxISEqJDhw6pQoUKGjJkiHr27Kn27dubHSvNypcvr4sXL9p8vXTc38SJE3X9+nVNmTLFukF7arMdMyPu2HYMgwcP1gsvvKDw8HCNGzdOX3/9td5//32zYz2Qt7e3cuTIocTExEx5s9uDvPbaa/L391erVq1kGIbWrFlj06+rq6urjh49qrJly0qSjh8/7hDFMDi3MmXK6OTJkypatKjZUWBHKGogQyxZskSurq6aOnWqpk+froiICC1fvtzsWEhFUFCQ4uPjNW3aNI0ePVonT57UggULTMnSp08fDRgwQCdPntRPP/2kmTNnqnDhwqZkSW+ffPKJ2RGQSZw+fdpa0JBurZP7559/Kl++fHJzc563BXny5NGcOXPUq1cvGYah+fPn68knnzQ7VqYQGRmpMWPGaMOGDTIMQ40bN9aECRPk7e1tdjT8S86cObVr1y7rzMCdO3c65VT+rFmzSrp113J0dLS8vLwcasbw2LFjVa1aNfn5+cnT09Pa7ijLZzmqBg0aSLp1gXX9+vUmp7EP//zzj7Jnz65s2bJJkrZv365ly5apePHiGjRoEBc+7Uy3bt1UtGhR/fDDD4qOjtb8+fOts8LtnaurqywWi5KSkuTq6mp2HLsSGBgof39//fbbb7JYLHrllVesBQhbeO+991SvXj35+/vLMAyFhISYdj0AuO3y5cvy8/NT7dq1lSNHDms774UyNzYKR4a6dOmSDMNQ3rx5zY4CB3B7c7jy5cvr0KFDslgsatCgAXeHAY+hUaNGatCggV566SUZhqG5c+dqw4YN+uWXX1S5cmXt37/f7Ig2ERoaqq5duyokJESGYcjPz08LFy5UsWLFzI7m9Nq2baunn35a/fr1kyTNmTNHYWFhWrlypbnBcJcdO3boxRdf1LPPPivp1uag33//vXWWoLMICAjQkiVLNG3aNP3+++/y8fFRVFSUw1yorly5sqpXr66KFSumuLjXo0cPE1M5v8jISI0ePVobN26kQPv/6tSpo6+++kolSpTQX3/9pYoVK6pbt246duyYqlSpkmJZKpjvq6++umsGbmpt9uqtt97SgQMHFBgYmOIiZvPmzU1MZX9++OEHjRs3zqbv4f/55x/t2rVLFotFNWrU4MYgmG7+/PmptvNeKHOjqIEMcfDgQXXp0kXnz5+XYRh6+umntXjxYpUvX97saPiX5s2ba8GCBfLx8ZEkhYeHq2fPnlq9enWGZ6lWrZp27dqlmjVrasmSJcqbN6/Kli2rkydPZniW9Hbs2DG99957OnnypHVDSollp2B7Fy5c0NChQ/Xrr7/KMAw9//zz+vjjj/Xkk0/qr7/+crqfyzdu3JDFYnHKu8/t1e1C9IPaYB8iIiK0Y8cOSVLNmjWVK1cucwOlg9t3+losFi1evFgRERHq0aOHw/xcqFChgg4ePGh2jEyHAu3dnn32Wev+LhMnTtSff/6pr7/+WjExMapSpYoOHz5sckLc6fYNYg9qs1f169e/q80wDG3atMmENObbtWuXevXqpbCwMHXu3Nm6mff58+c1ceJEde/e3WbPFRISoqNHj6pLly66du2aYmJiWAIRdiExMdGpVhfA4+E7ARmiT58+euedd9ShQwdJ0rfffqtevXppz549JifDv124cMFa0JCkJ598UhcuXDAlS7169XT16lUNHjxYlStXloeHh0Otgf0wOnbsqO7du6tXr15MsUa6KlCggL799ttUzzlDQePo0aP3PW/L6flIXcGCBRUeHm69qy88PFxFihQxORXuJXfu3E5/1+ukSZP01ltvyTAMde3aVdKtC7JvvfWWycnSplatWjp06JBT/Ix2JKGhoSkKGDNmzMj0XwMPDw/r4x07dug///mPpFtLvLFfov3Yu3evdu3apfDw8BT7wERGRio+Pt7EZA+H2fkpDRs2TIMHD1b9+vW1fPlyVatWTW3bttWmTZusyyzawmeffab//ve/unHjhrp06aIrV66ob9++mbaYBPtwu8h25coVnT17VsHBwVq2bBmb2GdyzNRAhqhcubL27t2boq1KlSoUNexQhQoVtG/fPmv1Oz4+Xv7+/ta7ssxy9uxZRUZGqly5cqbmSC+OdNcUHNOaNWvue95ZLmre7+K5YRhOOdPLXowaNUqSdObMGW3dulUtW7aUJP30009q2LDhPaeNI+M1bNhQGzdu1FNPPSXDMKztFotFhmHo8uXLJqazPUe/W9nf319Hjx5VqVKlUuypwWzO9NWiRYsU+zGFh4erV69e+vHHH01OZp6aNWvqs88+U758+VS8eHEdOXLEuk9X6dKl9ccff5icENKt5YhWrlypH3/8Ua1bt7a258yZU4GBgapcubKJ6R7OihUrUuzR9cILL5gdyTR+fn4KCQmxHufPn1/nzp2z+Q1x/v7+2r59u2rWrGld0qpcuXLMxIKp6tevrwkTJmjIkCHav3+/LBaLypcvz/dlJsdMDWSIChUq6Pfff7duTLZ161brppSwLwEBAerUqZOGDRsmSfr444/VokULU7KsWrVKderUUa5cufTMM88oR44cWr16tfVCmTMJCAjQunXrFBAQYHYUOKn7rXNtGIbTFDVOnTpldoRMK3v27JJuzYa5c0ZM3759zYqEe1i4cKEk3XXDibNZv369fvnlF124cMFadJNu3a3sSD7++GOzI2RKOXLk0HPPPXdXgfb299KUKVPMjGeKDz74QA0aNNCNGzc0cOBAa0Fj3bp1Kl26tMnpcFubNm3Upk0brV27Vs2aNTM7ziN79913tXLlSuuySu+9956OHDniMLPsbM3FxSXFcf78+dNlhn+WLFnumvnBcj8wW1RUlGrXrm09NgyDGYJgpgYyhp+fnw4dOqTixYtLkk6cOCE/Pz/rL2HuNLMfCQkJev/99/XTTz9Jklq3bq3XX3/dlF8Y/74bxWKxqGLFik6zkfGdNm7cqDZt2sjV1VUeHh5Oe7cskJGSkpJ05swZxcbGWttYfgr4n6tXr+qJJ55I0RYaGqpixYqZlMi2Nm/erN9++02fffaZBgwYYG3PmTOnXnjhBRUuXNi8cLB748ePv+/5d955J4OS2JekpCRFRUWl2H/n5s2bslgsKTZzhn3YtWuXQkNDU+zZZ8u9F9JThQoVtHPnTmXLlk3Sre+zGjVqZNo9hrJnz65nn33WenzkyJEUx7a6ptKyZUtNnz5dnTp10r59+7RgwQItW7ZMq1atssn4wKOoXr26fv/9d1WrVk379u3TuXPn1KZNGwUHB5sdDSaiqIEMsXnz5vuer1evXgYlgSP5d1FDkp577jkdOHDAnEDpqHjx4vrggw9UsWLFFHfcFCpUyMRUcFZ///23jhw5kuJiv7PM1Lht7dq16tOnj65cuaLs2bPr2rVrKliwIDM5MsD58+f18ssvW9e7DQkJ0W+//WadAQj7UbRoUS1atEg1atSQJC1btkwjR45UWFiYycls68CBA3ruuefMjvHQXn/9dU2ePFkdOnRIsUzYbcuWLTMhFQBHMWjQIK1bty7FzYSGYTjMz47y5cvr0KFDD2zLLDLqmsqJEyfUpUsXHTlyRE899ZSyZcumVatWOc0ND3BMCxcu1NKlS3Xw4EH16tVLX3/9td5//3116tTJ7GgwEXPIkCEoWjgOe7oYlTNnTu3atcu6VNnOnTvl5eWV4Tkygo+Pj9Nugg77Mm/ePI0fP15XrlxRiRIldODAAVWvXt3pihpjxozR9u3b1bZtW+3fv18LFy7MtH8EZ7T+/furU6dO1iXPypUrp8DAQIoadmjRokUKDAxU3759FRYWph07djjlRqDPPfecvvvuO4WEhKQo5tr78kG3l1lwxmU37dny5cvVoUOHFBss32nQoEEZnAh4NOvXr9fRo0dT7MXjSKpWraru3btrwIABMgxDX3zxhapUqWJ2LNNk1DWV4sWLa+fOnTp+/LgsFotKlSqllStXUtSAqbp166aiRYvqhx9+UHR0tObPn29d3h6ZFzM1kCHCw8M1fvx4HThwIMUfkyw7ZX9atmxpvRh14MABJSYmyt/f35SLgTt27NCLL75onVZ77Ngxff/996patWqGZ0lvH3zwgXLlyqWOHTum+MPj9nRrwFYqVKigzZs3q0GDBtq/f7+2bNmir7/+Wl9++aXZ0WyqUqVKCg4OTnFHX926dbVlyxaTkzm/ypUra+/evfL397cuF3jnY9iXvXv3qkaNGsqTJ4+OHDmSYkkZZzFs2DCFhoYqODhYnTt31vLly9W4cWPNmTPH7GiwQ++8847Gjx+vl1566a5zhmHoq6++MiEV8PAc/X3PzZs39e6772rjxo2yWCxq3Lixxo4da93DCxmnYMGCTjeLE4DjY6YGMkSvXr1Uq1Yt/fzzz5o2bZpmz54tf39/s2MhFZcuXVK3bt00bdo0Sbc2BTNrY7AaNWro6NGj2rFjhySpZs2aTnmxRZJGjx4t6dbdf4ZhWPfUSEpKMjkZnI27u7ty585tXVu5bt26euONN0xOZXu39wHy9fXVqlWrVKhQIZ07d87kVJmDm5ub7rxnJiIiQsnJySYmwr2sWLFCw4cP19dff63g4GDVq1dPy5YtU6lSpcyOZlMbN27UgQMH5O/vr2nTpmnUqFHq06eP2bEe6M7NzVNj7zNNHNXtvTTmzp1rchLg8dSsWVMdO3ZUp06dUtw05Sizc7Nnz67JkyebHQOSuBcaZqlSpUqqS3Dexo3SmRtFDWSIsLAw/fjjj1q0aJFatWqlpk2bqlmzZmbHQirs6WLU7en/d77xnjp1ql577TVT8qQnLvgho9zeiL5kyZKaOXOmChUqpPDwcLNj2dwrr7yiiIgITZw4UZ06ddK1a9f08ccfmx0rU+jQoYMGDBigqKgozZs3T0FBQerdu7fZsZCKCRMmaMOGDSpRooQ6d+6s1atXq2nTpjp9+rTZ0WzK09NTLi4uMgxDCQkJyps3r86fP292rAfibmRzrFmz5r7nHeWCcHqKjY1VUFDQXUu6OcpeDZnFrl27JEkzZ860thmGYfffw19//fV9zzvKRufO5H4XlYH09OGHH0qSVq9erT///FO9evWSdGtJZUfcLw22xfJTyBBVq1bV7t27VaVKFf3888/KlSuXypQpo+PHj5sdDf8ybdo0/fnnn9q4caPeeustBQUFqVu3bho6dGiGZ6lcubKqVq2qjz/+WDdv3lRgYKCkW7/QnFViYqLi4+Otxyw/BVvbtGmTKlWqpPDwcA0YMEDXrl3TpEmT1KhRI7OjwYksWbJEK1eulMViUevWrdWtWzezIyEVsbGxd621fvbsWT3zzDMmJUofDRo00OrVqzVq1ChdvXpV+fLl07Zt26wX/IA71a9f/57nDMNwyn1nHlZgYKC8vLy0Zs0ajRgxQvPmzVPdunX10UcfmR0NTqBDhw53tRmGob179+rMmTPMZJeUlJSkM2fOpCgqli1b9rHGvNc+QhaLRW+//bauXLnyWOMDj6N+/fratGmTtcCWlJSkRo0a6ddffzU5GcxEUQMZIjAwUJ988okWLFigTz/9VN7e3ipWrJiWLl1qdjSkwl4uRsXHx2v48OHatm2brl+/rv79+z9wKQZHtXv3bvXu3VvHjh1LMVOGN+3Ao9u1a5dCQ0OtS21J3N0H3On8+fN6+eWXdfbsWQUHByskJES//fab023q/vfffyt37txKSkrS9OnTFRERoaFDh6pgwYJmR0uTqKgojR49Whs2bJBhGGrcuLEmTpwoLy8vs6Mhk7q9X1WFChV08OBBRUVFqX379vr555/NjoY7JCUladasWTpx4oRmzpyp0NBQnTlzRg0aNDA72kM5fvy43nzzTe3fv18TJkzI9DdKrF27Vn369NGVK1eUPXt2Xbt2TQULFtSpU6cea9zU9hG6E0vywUwlSpTQwYMHlTVrVklSdHS0nnvuOf31118mJ4OZWH4KGWLBggWSbi0HUqlSJV27do3lp+zUunXr1LlzZ3Xu3DlFW0BAQIZnyZIli4oUKaJVq1YpOTnZKTcIv23o0KH68ssvNWDAAG3ZskUzZsyw/sIGbCGzrc0+cOBA/fzzz/Lz85Orq6ukW3f5UdRIfy+99FKqyxSwua796d+/vzp16qSpU6dKksqVK6fAwECnK2p4e3vL3d1dWbJk0ZgxY5ScnJxiVqS9GzRokLJly6YlS5ZIkj7//HMNGjTI+v4a6eNeGyzXrVs3g5PYn9vvUd3c3BQdHS0vLy+HWNItsxkyZIgSEhK0detWSZKPj486deqkPXv2mJwsbS5duqS3337bOtNu6dKlypIli9mxTDdmzBht375dbdu21f79+7Vw4UIdOnToscelaAF79p///Ec1atTQf/7zH0m3ljvs1KmTyalgNooayHC1a9c2OwLuY/To0XcVMFJrywht2rRRYmKi9u/fr9OnT6tLly7q1q2b3nrrrQzPkt4SEhJUrVo1JSYmysvLS2PGjNHzzz+v4cOHmx0NTuL22uwnTpzQli1b9OKLL0qSvv/+ezVp0sTMaOliw4YNOnr06F1L6yD9Va5c2fo4NjZWK1askL+/v4mJcC+XLl1St27dNG3aNEm3LlC6uTnfnwcNGjTQ2rVr5e3tLenWzIcWLVpYL/TZu4MHD+rAgQPW46CgINaRzgAjRoywPo6NjdXx48dVrlw57du3z8RU9uGJJ55QRESEmjdvrmbNmsnHx0f58+c3Oxb+Zfv27QoJCbH+Ds6VK5dDFHSjoqI0adIkffnll+rXr5/++OMP5cyZ0+xYdsMwDBUqVMg6E7lbt24UW+H0Jk6cqGrVqum3336TxWLRxIkT1aJFC7NjwWTO91cL7ErDhg21ceNGPfXUUynu2rRYLDIMQ5cvXzYxHe504sQJ/fnnn7p+/XqKDRIjIyMVHR1tSqZq1app9OjRkm798bR792716dPHlCzp7fZFJB8fH4WEhMjX11dnzpwxORWcyTvvvCNJatasmfbt2ycfHx9J0tixY6371TiT/PnzU9Awycsvv5zieODAgWrfvr1JaXA/bm5uKZY8jIiIUHJysomJ0kd0dLS1oCHdmrlx8+ZNExM9nKSkJEVFRVmXm7px44ZTfp3szb/vZt+9e7fmz59vUhr78tNPP8nV1VUTJkzQokWLdO3aNWZC2qF/vw9KSkpyiJ8dRYsWVc6cOfX++++rQIECdxWg7X2j8/Tm7u4uSfL19dWqVatUqFAhnTt3zuRUQPpr3ry5ypcvr8KFC5sdBXaCogbS1cKFCyVJe/fuNTkJHmTbtm2aN2+e/v77b+syFJKUM2dO6x2cGe12QePOLMuWLTMlS3rr1KmTrly5otGjR6tu3bpKTEzUu+++a3YsOKGzZ89aCxrSrYKhMxbQatasqY4dO6pTp04p/qjP7H8ImyFr1qw6ffq02TGQig4dOmjAgAGKiorSvHnzFBQUpF69epkdy+aSk5N18+ZN64y1qKgoJSQkmJwq7bp3767q1aura9euMgxDS5cuVY8ePcyOlelUrVpVr7zyitkx7MKdyzpm9v0N7FmFChW0aNEiWSwWnT59WpMmTXKIO/qfffZZGYahRYsW3XXOMIxM/17ulVdeUUREhCZOnKhOnTrp2rVr+vjjj82OBaSr33//XZ07d5aLi4vCwsK0Z88ezZgxg6U4Mzk2CgeQwpw5c9S7d2+zY0i6NdU/KChIISEhio2NtbY7a2HjtoSEBMXGxrIBKNJFhw4d5O3tbf13PnfuXF29elXffvutyclsq379+ne1GYahTZs2mZAmc7lz/5akpCTt3btXTz31lNN9jzmLJUuWaOXKlZKk1q1bq2vXruYGSgeTJ0/Wjz/+qIEDB0qS/vvf/6pt27Z67bXXTE52f9evX9fVq1dVuHBhrV27Vhs3bpTFYlGxYsXUrVs3lmNJZ0ePHrU+TkpK0q5du/Txxx/r8OHDJqYyV2BgoBYsWKAqVaqkunfS7t27TUiFe7lx44ZGjBiR4mf8Rx99pBw5cpgbDA7h77//lmEYypMnj9lRANWoUUMLFy5U+/bttX//fkm3CqBHjhwxORnMRFEDGWLfvn0aPXq0Tp48aV37UZJOnjxpYircy99//60jR46kKCSYcUdMYGCgvLy8tGbNGo0YMULz5s1T3bp19dFHH2V4lvT2+eefq3379nriiSckSVeuXNF3332nvn37mpwMzub69et699139euvv8pisahhw4YaO3YsF8dgE4cPH1bnzp3l5+en4sWLy83NTcWKFVO7du2syyXAfHcWniRZl6C6fZFyypQpGZ4pvc2fP18//fSTpFsX9hzh7vIBAwaocePGateuXYr2BQsWaMeOHQoKCjIpWeZQpEgR62M3NzcVL15cEydOVKVKlUxMZa7g4GBVqlRJmzdvTvV8vXr1MjgRkDnt2rVLoaGhKa6t2GoJuGPHjqljx47WJa2eeeYZLVu2TKVLl7bJ+MCjqFKlivbs2SN/f39rUePOx8icKGogQ5QvX16DBw9WjRo1rNOVpVuVVdiX+fPna9y4cbpy5YpKlCihAwcOqHr16qZsplm+fHkdOnRIFSpU0MGDBxUVFaX27dvr559/zvAs6c3Pz08hISEPbANwf6dOnVKRIkVS3GF7p7Jly2ZwoswjKChIY8aMUcmSJfXHH39o7ty51g3pYV9cXFxUpUoVBQQEyMXF5a7zt/fggbnKli17z59l5cqVy9QzBgDc27Zt21SrVq0U+yTeKbMv3+ToBg4cqJ9//ll+fn4ploKz1WoG9evXV9++fdWlSxdJ0tKlSzV79mz9+uuvNhkfeBR16tTR2rVrVbduXe3bt09HjhxRnz59tGPHDrOjwUTsqYEM4erqqv79+5sdA2kwbdo07du3Tw0aNFBwcLC2bNmir7/+2pQsWbNmlXTr7rjo6Gh5eXnp/PnzpmRJb6nVlx1hIz84juXLl6tDhw73vLN30KBBGZwofQwePFg//fSTWrRoYW0zDEMWi0WGYTBDMB0FBQXp0KFD8vX11aFDhzRw4ECKGnZqw4YNmjt3rhYvXqyOHTuqV69eKlasmNmx0s1LL72U6lI5X331lQlp0u7OG4H+LbXPB7aXlJSkM2fOpJi9THFcOn36tCZPnnzXneIs8Wgf5s2bp1q1aqXYJ/E29qRwfBs2bNDRo0fv2gjeViIiIqwFDenW3o+TJ09Ol+cC0mrs2LFq2rSpLly4oJ49e2rdunXWPXyReVHUQIaoVauW9u/fL39/f7Oj4AHc3d2VO3du6x8odevW1RtvvGFKlieeeEIRERFq3ry5mjVrJh8fH+XPn9+ULOktf/78WrFihXWJiRUrVihfvnwmp4IzOXz4sDp06KA9e/bcdc6ZLo6tXr1a0q0ZG5IUGhqqH3/8UcWLF1erVq3MjOb03N3d5evrK+nWTLubN2+anAj30qBBAzVo0EDXr1/XkiVL1LVrV2XNmlUffPCBqlWrZnY8m6tcubL1cWxsrFasWOEQ70kTExN1/fr1u5YHjIyMdKiNzh3V2rVr1adPH125ckXZs2fXtWvXVLBgQevvl8ysY8eOatiwoQYPHnzf4hvM8cUXX0gSd9Y7qfz586dbQUO6VVA/evSotYB7/PjxVGd1AhmpSZMmKlGihNatWyeLxaK33npLxYsXNzsWTEZRA+nq9iZyCQkJ+vLLL1WqVKkUv4DZTM7+eHh4yGKxqGTJkpo5c6YKFSqk8PBwU7L89NNPcnV11YQJE7Ro0SJdu3bNZmuF2puPPvpIbdu21euvvy5JypIli3744QeTU8GZVKtWTWvWrFGHDh3MjpKumjRpoqlTp8rPz08XLlxQlSpVVK1aNX3++ec6evSo9d8YbC8uLk7Hjh2zzjz79zF3N9ufnDlzqnXr1rp69apmzJihP/74wymLGi+//HKK44EDB6p9+/YmpUm7zp07KzAwUPPmzVPu3Lkl3bqDtnfv3urUqZPJ6ZzfmDFjtH37drVt21b79+/XwoULdejQIbNj2YXY2FhNmjTJ7Bi4h3stW3ebo/w+jo2NVVBQkEJCQlLMlrLVMkuOqmbNmurYsaM6deqU4tqKrWbgvPfee6pXr578/f1lGIZCQkK0YMECm4wNPKy2bdtq5cqVkqR169Zp4MCB5gaCXWFPDaSrH374QVevXlXRokVTtIeGhsrHx0dt2rQxKRnuZdOmTapUqZLCw8M1YMAAXbt2TZMmTVKjRo3Mjub0kpKSdPz4cUlSqVKluPMNNlW/fn3r4+DgYFWuXDnF5sDOsmTEnWvQf/jhh9q2bZu+//57RUREqF69ejp48KDJCZ1X4cKF7znrh6W/7EtSUpJ+/PFHzZkzR6dOnVJgYKB69OjhtLMh/81isejZZ5994IU/syUlJalXr15asWKFSpQoIUn666+/1K5dO3311Ve8T0hnlSpVUnBwsHWPN+nWDOYtW7aYnMx8Xbp00ZQpU6yz82Bf7tzk/t8c6fdxYGCgvLy8tGbNGo0YMULz5s1T3bp19dFHH5kdzVR3vqe/zdbv5f/55x/t2rVLFotFNWrU0JNPPmmzsYGHcedm4BUrVtS+fftMTgR7wkwNpKu1a9eqcePGqlevXor2sLAw/fzzzxQ17FCDBg0kSd7e3lq/fr0pGW7P8LkXZ5zh8+uvv1p/QVesWNFh7qCC47hzCQJ/f3+nKWL82513rG3fvt1611ru3Lnl5sbbnvR0+vRpsyMgjZ5++mkVLFhQvXr1Ut26dSXdmgEQEREhyXHu4n2Qjz76SK+++qpee+016/uKpKQk7d271yE+R1dXV82fP19vv/12ivcIzrz/iT1xd3eXJPn6+mrVqlUqVKiQzp07Z3Iq+3D16lVVqFBBtWvXTvF7N7PfQW8vnGWJtJCQEB06dEgVKlTQkCFD1LNnT4eYZZfe0ntZsVmzZqlbt25q2bJluj4PkBbOtEwybI+ZGkhXd94x+2/lypXT4cOHMzgRHqRPnz6aPHmyfHx8JEnh4eEaM2aMZs+enWEZNm/efN/z/y6SObLr16+rRYsWOn36tCpVqiSLxaJ9+/apUKFCWrNmzV3raAO24Mx3uVSuXFkrV65U7ty5VbBgQe3YsUMlS5aUJJUuXVp//PGHyQkB8905q8YwDN3554Aj3cX7IAEBAYqNjVWRIkVUuHBhSZKbm5uKFSumdu3aWS9aA6lZsmSJAgICdPLkSXXq1EnXrl3Txx9/rK5du5odzXTz589Ptb1Hjx4ZnAQP4sib3VetWlW7d+9WxYoVtXXrVmXLlo1rCP/v77//1pEjR1J8XW21/FTPnj21atUqNWzYUL169VLTpk25sAzTFCtWTLNmzZLFYtHQoUM1Y8aMFOdt9X0Px0RRA+nqzunaD3MO5rlzet9tGX0BtHPnzlqyZEmGPZ+ZBgwYoCxZsmjatGnWiyvx8fEaMWKE4uLi9Pnnn5ucEM7ImYsa3333nQYOHCh3d3dVr15d3377raRbszbeffddrVu3zuSEADLSF198oXfffVfjx49Xr169zI4DOLykpCQFBASYNqMbaefom90HBARoyZIlmjZtmn7//Xf5+PgoKioq03/vzZs3T+PHj9eVK1dUokQJHThwQNWrV9fWrVtt9hw3b97UN998o3nz5unUqVPq3r273nvvPZuND6RVasut3eZMSyjj0VDUQLoqU6aMdu3addfd5pGRkapWrRp3zNqhChUqpFhz3mKxqFy5cjpy5EiGZXDmC67/Vrx4cf35559ycXFJ0Z6YmKhSpUopNDTUpGRwNnfOmmvfvr1WrFiR4u5sR7lrLy3+/vtvXbx4Uc8995z1zrILFy4oMTFRBQsWNDkdgIz2119/qWrVqnJ1dU3x+/by5csmpoIj2LBhg06ePKnExERr26BBg0xMZB8aNWqkX3755a73r7AvFStW1Pfff3/XZveTJ082O1qaJCUlydXVVRaLRYsWLdK1a9fUvXv3TD+TvUKFCtq8ebMaNGig/fv3a8uWLfr666/15Zdf2vy5/v77b73zzjv64osvlJSUZPPxAeBxsLg00lXnzp0VGBioefPmKXfu3JJurdncu3dvderUyeR0SE21atX0yiuvaNSoUbJYLJo6dapq1Khhdiyn5e7unuofhG5ubsqSJYsJieCsWrRokeL4zqm6zrTcjCTlzZtXefPmTdFWoEABk9IAMFNwcLB69OihTp066bXXXmNzbaRZly5ddOTIET333HPW7xuWYLmlevXqatOmjQIDA5UjRw5rO8uA2BfDMFSoUCFrUa5bt27WfZQcwZ3/7rp162ZyGvvh7u6u3LlzW7+udevW1RtvvGGz8RMTE/Xjjz9q7ty52r17tzp06KBdu3bZbHwAsBWKGkhXY8aMUa9evfTMM8+oRIkSkm7dLdeuXTuNHTvW5HRIzbRp0zRs2DD5+/vLMAy1bt1aH330UYZmOHTokPLkyXNXu8VikWEYTnVnpZeXlw4ePKgKFSqkaD9w4ICyZ89uUio4I0dZagAAbOWtt97SokWL9Nlnn6lp06Zmx4GD2bdvn44cOUIhLBXbtm2TJP33v/+1thmGQVHDzjjqZveBgYFasGCBqlSpkmohcffu3Saksh8eHh6yWCwqWbKkZs6cqUKFCik8PNxm4z/99NPy9/dXz5499e2338rDw8NmYwOALbH8FDJEaGiodTmhihUrqlixYiYngj179tlntWbNmnueL1SoUAamSV+rV6/WwIED9dZbb6l69eoyDEPbt2/XxIkT9d///letWrUyOyIAAA6pW7dumjVrlnLlymV2FDigli1baunSpSlmIgCOxFE3uw8ODlalSpW0efPmVM/Xq1cvgxPZl02bNqlSpUoKDw/XgAEDdO3aNU2aNEmNGjWyyfhnz57VM888Y5OxACA9UdQAcJd9+/YpJCREsbGx1raMXD84M+2pIUnr1q3Te++9Z/2cK1WqpDfffFPNmjUzORkAAEDmdPToUXXt2lV16tSRp6entX3KlCkmprIfK1as0IYNG2QYhho3bqwXXnjB7EhAppDaLP/U2h7V9evX9c477+jUqVNauXKljh49qgMHDqhz5842GR8AbIWdvQCkMHnyZPXp00ejRo3Sxo0b9cYbb2j9+vUZmiGz1VoDAgL0+++/6+bNm7p586a2bNlCQQMAAMBEQ4cOla+vr3LlyqXs2bNbPyC9++67eu+991SqVCmVLFlS7733niZOnGh2LPzLO++8oytXrliPw8PDNX78eBMTPZzTp09r4MCBatKkiRo0aGD9yOx69uyZprZHNWDAAPn4+OjEiROSpCJFijjM5vJwXhcvXlTLli2VLVs2Zc+eXa1bt9bFixfNjgWTMVMDQArlypXT3r17Vb16dYWEhOj48eN6++239c0335gdDQAAAMgQZcqU0bFjx8yOYZcqVKignTt3Klu2bJKkmzdvqkaNGjp48KDJyXAnPz8/hYSEpGjz9/fX/v37zQn0kKpWraqGDRuqRo0aKfa2adGihYmpzBMeHq7Lly+rffv2WrFihfVGwMjISPXs2VPHjx+3yfPcXjXhzu+V5557TgcOHLDJ+MCjaNWqlWrUqGFdQeSzzz7Ttm3btGrVKpOTwUxsFA4gBU9PT3l6eio5OVkWi0WlSpXS6dOnzY4FAAAAZBg/Pz9dvHhR+fPnNzuK3bFYLNaChiRlz5490820dgSpfU0SEhJMSPJoYmNjNWnSJLNj2I1Fixbp448/1oULF9S8eXNru7e3t0aNGmWz58mSJUuK45iYGP59w3Rnz55NUcB444035OfnZ14g2AWKGgBSyJYtmxISEuTn56fXX39dvr6+io6ONjsWAAAAkGGuXr2qcuXKqVatWin21Fi2bJmJqexD1apV1b17dw0YMECGYeiLL75QlSpVzI6FfylZsqSmT5+uV199VRaLRR999JFKly5tdqw0K1eunM6dOydfX1+zo9iFV155Ra+88oomTJigsWPHptvz1K9fX++//77i4uL022+/afr06Wrbtm26PR+QFsnJybp06ZLy5csnSbp8+TLFNrD8FICUDh8+rCJFiig6OlqjR49WRESERowYoRo1apgdzeldvnxZx48fV506dZSYmKjk5OS77pQBAABA+ps/f36q7T169MjgJPbn5s2bmjBhgjZs2CCLxaLGjRtr7Nix7DliZy5cuKBu3bpp+/btMgxDtWvX1tdff+0ws48CAgK0e/du1a5dm8Liv9y+wJuYmGhtK1iwoE3GTkxM1NSpU7Vy5UpZLBa1bt1ab7zxhtzcuCca5lmwYIFGjRqlVq1ayTAMrVmzRpMmTVK3bt3MjgYTUdQAIOnWDI1PP/1UL7300l3nbq+rifTz3Xffafjw4ZJubYp34MABvfnmm1qzZo3JyQAAAABpyJAhmjlzphYuXMiFJAdy8+ZNSXK4ohOFxdTNnz9fQ4YMkbu7u1xcXCRJhmHo8uXLJicD0teRI0f066+/ymKxqGHDhipbtqzZkWAyihoAJEm+vr7Kli2bGjdurE8++STFnRiOtKGco6pcubJ+/vlnNWrUyPpaP/vsszpy5IjJyQAAADKf2NhYBQUFKSQkRLGxsdb2zHyX+O2Np7nhyTGsWrVK9erVU86cOfXhhx9q586dGjdunMqVK2d2tAdKSkpSQECA1q9fb3YUu1OsWDH99NNP6baU2Lvvvptq+9tvv50uzwekxcSJE/XWW289sA2Zi4vZAQDYhzx58uj/2rv3oKzL/P/jrw+KoCjqegg3U0hBUzAMK/BrUipZeEqNNgxPrJo5q+tsDa6mtqSmaLltpO2uoaauJ1YztcNqi+mYoQRCKh7ylLNqKASm4q0I9++PfrHdCyqlcn2Q52PmnoHrc8/NkykdvN98ristLU3Hjx9XeHi4cnJySq9ZlmWwrHpwc3NTo0aNXNbYegoAAMCMkSNH6vDhw9q2bZseeeQRHTlyRHfffbfpLKPuueceBQUF6dChQ3rooYfKPGAvL7/8sry9vZWVlaVly5YpIiJCL7zwgumsCqlRo4acTqdKSkpMp9hOkyZNbuvZKOfPny99nD17Vu+9954OHjx4274eUBFr166t0BqqFzbFA1Cqfv362rhxo6ZOnaqQkBAlJycrLCyMA5gqQb169ZSTk1M6QNqyZYsaNmxouAoAAKB6yszM1J49e9ShQweNHTtWw4YN09NPP206y6i1a9cqIyNDMTExmjNnjukc3MCPd95v2rRJo0aN0vPPP6+//e1vhqsqLjQ0VP369dPgwYNVt27d0vXIyEiDVeYNGDBAb7/9tgYNGuRy1kidOnVuyev/75/tP/3pTxo5cuQteW3g59q8ebM2bdqkU6dOKS4urnT93LlzBqtgFww1ALiwLEvTpk1Tp06d1K9fP8XHx3OnRiVISEhQZGSkjh07pkcffVRff/21NmzYYDoLAACgWqpdu7akH94YLiwsVL169XTy5EnDVWa5u7vr4Ycf1vr163XfffeZzsENFBcXKzU1VWvWrNGiRYskSUVFRYarKu7zzz+XJL3zzjula5ZlVfuhxh//+EdJ0rhx42RZlpxOpyzLUnFx8W35eo0aNdKRI0duy2sDN1KrVi3VrVtXlmW5nAvUrFkzTZw40WAZ7IChBgBJKnM3Rr9+/dS2bVsNGDBAhw4dMlRVfXTq1EkpKSnasWOHnE6nOnfurAYNGpjOAgAAqFaio6O1YsUK/epXv1J+fr4iIyP15JNPqlGjRmrWrJnpPKOSk5MVFRWlLVu2aMuWLWWujxkzxkAVrmX69OkaPXq0unfvrvvuu08HDx6Uv7+/6awKK+//Mei2b8k1f/780o+Li4u1c+dONW7c+LZ+TeBawsPDFR4erqeeekr333+/6RzYDAeFA5D0w0Fyffr0KbN+4cIFzZs3TxMmTDBQdecrLCy87vVbdRsxAAAAbqxjx47avXu3iouLS/f1/8c//qGCggINGTJE3t7ephONeeWVVxQfH6/hw4eXuWZZlhYuXGigCneyNWvW6NNPP5VlWYqIiFD//v1NJ93xfvrnu2bNmmrVqpWef/55tkaGET8O0386bPsphunVG0MNADDIzc3tutt73a7biAEAAFDWAw88oIyMDNMZwC2xdu1aZWZmyuFwlK7Nnj3bYFHFvfrqq1q3bp2GDBkiSVq2bJmeeuopTZ482XCZGd27d9e///1vNWnSxOXfjz9uP3XmzBmDdcDtwTAd18NQAwBsYPr06fLw8NCoUaPkdDr17rvvqmbNmho/frzpNAAAgGrD3d39ur+RXJ3fOPzoo4+ue726n3VgN+PHj9eRI0eUnp6u6OhoJScnKyIiQklJSabTKqRDhw5KTU0tvXP94sWLCgsL01dffWW4zIzTp0+rWbNm+uabb8q93rJly5t6/W3btl33eteuXW/q9YFfqri4WOvWrdPAgQNNp8BmGGoAgA383//9X+lheD/q0qWLtm/fbqgIAACg+mnfvv1137y/2TcOq7LHHnvsmtcsy1JKSkol1uBGgoKClJWVpY4dOyorK0s5OTkaMWKENmzYYDqtQoKCgrRnz54bruHWePDBB8usWZalU6dO6fTp0+wgAKPKe78E4KBwALCB7777TocPH1br1q0lSYcPH1Zubq7hKgAAgOrFw8OjWg8uroeDm6sWT0/P0q1ui4qKdNddd+nkyZOmsyrsoYce0pAhQzR69GhZlqUFCxaU+8Z7dePn51fu9sVHjx69qddNS0tz+fy7777T9OnTtWzZMsXHx9/UawM3q1OnTvriiy8UFhZmOgU2wlADAGxgxowZCg0NVUhIiCRp9+7d+vvf/264CgAAoHphI4OKycnJ0b59+1zOamD7KXupV6+eCgsL1aVLFw0dOlQ+Pj5yd3c3nVVhb731lqZNm6Zx48bJ6XQqIiJCU6ZMMZ1l3MaNG0s/djgcWrp06S09xNvhcOjPf/6z3nzzTUVHRys7O1uNGze+Za8P/BLbtm3TvHnzFBAQoLp165au79q1y2AVTGP7KQCwibNnzyo1NVVOp1NhYWFq0qSJ6SQAAADAxeLFixUfH6+8vDz5+/srKytLoaGhbJtqMzk5OWrQoIFKSko0d+5c5efna9y4cWrRooXptOsaO3asEhMTtWzZMsXExJjOqRJ+PET8ZpSUlOjdd9/VtGnTFB4ermnTpsnPz+8WFQI3Z+vWreWuh4eHV3IJ7IShBgAAAAAAqJAOHTpo69at6tatm3bv3q1t27ZpyZIlevfdd02n4Q4QHByszMxMPfDAA8rIyDCdY3v5+fkKCQm56e2n2rVrp8uXLys+Pl4PPPBAudcBUxYuXKjY2NgbrqF6YagBAAAAAAAqJCQkROnp6S6HNnfu3Fk7duwwXIafeuyxx8o9e8HuB7r36dNHx48f17Fjx8p9I726bzfz4IMPlv53LS4u1rFjx/TSSy9p0qRJN/W6vr6+pa9rWZbLVnyWZd300AS4GeUNORl8gjM1AAAAAABAhXh4eMjpdCogIECJiYlq2bKlcnNzTWfhf7z00kulHzscDi1fvlytW7c2WFQxa9euVUZGhmJiYjRnzhzTObbz+uuvl35cs2ZN+fn56de//vVNv+7x48dv+jWAW+3LL7/Uzp07lZubq/nz55eunzt3TleuXDFYBjvgTg0AAAAAAFAhKSkpCgkJUW5urkaPHq2CggLNnDlTPXr0MJ2G67h69aoiIyO1adMm0ykVsn//ft13332mM2zp7Nmzql27tsuBycCd6IMPPtC6deu0fv169e3bt3Td29tbgwcPVqdOnQzWwTSGGgBgA1evXtWaNWt05MgRXb16tXR96tSpBqsAAAAA3AmuXLmi9u3b6+uvvzadcl3JycmKiopy+a3snxozZkwlF9nH/PnzNX36dOXk5EiS2rdvr7lz56pHjx4qKChQgwYNzAYCt8nHH3+sJ5980nQGbIbtpwDABp599ll9++23euihh1SjRg3TOQAAAICLWbNmycvLS2PHjnVZT0hIkGVZiouLM1SG8kRFRbmcvZCVlaWePXsarrqxvXv3KioqSmlpaWWulXdGSHWxYMECvf3220pKSlJYWJgkaceOHXrxxRc1Z84cTZw4Uenp6YYrgdvjxIkTOnfunOrXr6/f/e53Sk1N1dy5c9W1a1fTaTCIOzUAwAbatGmjAwcOVOsf1AEAAGBf999/v1JTU1W7dm2X9cLCQnXu3FmZmZlmwlCu9957r/TjmjVrqlWrVgoNDTVYhJsRFBSkDz/8UC1atHBZP378uAICAvSHP/xBs2bNMlQH3F4dOnTQV199pc8//1yTJk3SpEmTNGXKFO3atct0GgziTg0AsIEWLVqoqKhItWrVMp0CAAAAlOt/BxqSVKdOHfG7kvYzdOhQ0wm/yEcffXTd65GRkZVUYi8lJSVlBhqS5OvrK19fXwYauKPVrPnD29cpKSkaMmSIevbsqYkTJxqugmkMNQDABgICAtStWzcNGDBAnp6epevVec9YAAAA2MeFCxfkdDrL3FlcUlKi8+fPG6rCtTzzzDNl1urXr6+wsDANGzZMbm5uBqpubM6cOde8ZllWtR1qXLlyRQ6Hw+XfipJ06dIllZSUGKoCKoebm5tWrlypVatWaePGjZJ++DOB6o2hBgDYQGFhofz9/bVnz57SNbaiAgAAgF2Eh4dr+vTpmjJlisv6zJkzFR4ebqgK19KkSRNlZGQoOjpakrRq1Sr5+Pho9erVyszM1FtvvWW4sHxbtmwxnWBLAwYM0ODBg7VgwYLSA8Hz8/M1atQoDRw40GwccJu9/fbbmjVrlkaOHClfX18dOnRIjz32mOksGMaZGgAAAAAA4LrOnj2r8PBweXt7lx5UnJqaqoKCAm3dulVNmzY1XIifeuSRR/Tpp5/Kw8NDkuRwONSnTx99+OGHCg4OVnZ2tuHCG8vJydG+ffvkcDhK16rrnRpFRUUaOnSo1q9fL39/f1mWpUOHDqlPnz5asmSJ3N3dTScCQKViqAEANpGRkaHMzEyXH9rZfgoAAAB24XA4tHz5cqWnp0uSQkJCFB0dXe5ZGzCrTZs2OnDgQOnd38XFxQoMDNT+/fvVsWNH7d6923Dh9S1evFjx8fHKy8uTv7+/srKyFBoaqu3bt5tOM+rIkSPKyMiQJHXs2FGtW7c2XATcPn/5y1/0+9//XnFxceVenz17diUXwU7YfgoAbCAhIUGrVq3SiRMnFB4ers2bN6t79+4MNQAAAGAbnp6eio2NVWxsrOkU3EB4eLh69eqlwYMHy7IsLV26VF26dNGFCxdK796ws7lz5yojI0PdunVTenq6tm3bpiVLlpjOMq5Vq1Zq1aqV6QygUvx4hoyXl5fhEtgRd2oAgA0EBgbqyy+/VGhoqDIzM3Xw4EFNnTpVq1atMp0GAAAAoIopKirSX//6V3322WeSpEcffVTNmjXT008/bTasgkJCQpSenq6goKDScwc7d+6sHTt2GC4DANiBm+kAAMAPv4Hg6empkpISOZ1OtWnTRsePHzedBQAAAKAKcnd319ixYzVjxgy1atVKM2bM0MyZM01nVZiHh4ecTqcCAgKUmJio9evXKzc313QWgEqWlpam3/zmNwoMDFRgYKCeffZZpaWlmc6CDbD9FADYQJ06dVRUVKTg4GBNmDBBzZs3V2FhoeksAAAAAFVMYWGhVq9eraSkJB05ckSXLl3S9u3b1b59e9NpPyHkxAAAD75JREFUFTZ9+nR9//33mj17tkaPHq2CggLNnz/fdBaASvTFF18oMjJSY8aMUXR0tJxOp3bt2qWePXvq448/1sMPP2w6EQax/RQA2MDevXvl5+enwsJCTZo0Sfn5+Zo8ebKCg4NNpwEAAAAucnJytG/fPjkcjtK1yMhIg0X40ahRo7RmzRo98sgjio2NVWRkpPz9/XXs2DHTaQDws/Tv31/Dhw9X3759XdY/+OADLVq0SOvWrTMTBltgqAEAAAAAACpk8eLFio+PV15envz9/ZWVlaXQ0FBt377ddBok1atXTyEhIZowYYKeeOIJWZale++9V0ePHjWdViGzZs2Sl5eXxo4d67KekJAgy7IUFxdnqAxAZWvTpo0OHjxY7rWAgAAdOnSokotgJ5ypAQA2EBkZqby8vNLPc3Nz1bt3b4NFAAAAQFlz585VRkaGWrVqpfT0dKWkpKht27ams/D/nT59WjExMXr11VfVokULvfzyyyoqKjKdVWErVqzQiBEjyqyPHTtWy5cvN1AEwJTatWtf81qdOnUqsQR2xFADAGzg1KlTatSoUennjRs31qlTpwwWAQAAAGW5u7urYcOGunr1qiSpa9euys7ONlyFH9WtW1cjRozQF198oU8++UQOh0NXrlxR586dq8yZFOW9kVmnTh2x0QhQvVy5ckX79+9XdnZ2mceVK1dM58EwDgoHABsoKSnR1atXVbPmD38tX7lyRZcvXzZcBQAAALjy8PCQ0+lUQECAEhMT1bJlS+Xm5prOQjnat2+vN954QwkJCVq3bp0WLlyoMWPGmM66rgsXLsjpdMqyLJf1kpISnT9/3lAVABMKCwuveV7T//4dgeqHMzUAwAbi4uJ09OhRjR8/XpL05ptv6t5779Xs2bPNhgEAAAA/kZKSopCQEOXm5mr06NEqKCjQzJkz1aNHD9NpuAPExsbKz89PU6ZMcVmfMWOGDh8+rEWLFhkqAwDYCUMNALCBoqIivfbaa/rwww8lSX379tWECRPk7u5uuAwAAAAAKsfZs2cVHh4ub29vhYWFSZJSU1NVUFCgrVu3qmnTpoYLAQB2wFADAAAAAABcV3JysqKioso9l8GyLDVq1Ei9evWSl5eXgTrcSRwOh5YvX6709HRJUkhIiKKjo697aDAAoHphqAEANrF27VplZmbK4XCUrrH9FAAAAOzglVdeUXx8vIYPH17u9TNnzujChQvaunVrJZcBAIDqhqEGANjA+PHjdeTIEaWnpys6OlrJycmKiIhQUlKS6TQAAACgQiIiIrR582bTGQAA4A7HUAMAbCAoKEhZWVnq2LGjsrKylJOToxEjRmjDhg2m0wAAAAAXGRkZZe4wHjNmjMEiAABQndQ0HQAAkDw9PeXm5ibLslRUVKS77rpLJ0+eNJ0FAAAAuEhISNCqVat04sQJhYeHa/PmzerevTtDDQAAUGkYagCADdSrV0+FhYXq0qWLhg4dKh8fH7m7u5vOAgAAAFwsXbpUX375pUJDQ7VmzRodPHhQU6dONZ2FO1BOTo727dvnckdQZGSkwSIAgF0w1AAAG1ixYoVq1KihOXPmaO7cucrPz1dycrLpLAAAAMCFp6enPD09VVJSIqfTqTZt2uj48eOms3CHWbx4seLj45WXlyd/f39lZWUpNDSUoQYAQBJDDQCwhbvuukvSD7+NNHLkSDVt2tRwEQAAAFBWnTp1VFRUpODgYE2YMEHNmzdXYWGh6SzcYebOnauMjAx169ZN6enp2rZtm5YsWWI6CwBgE26mAwAA0v79+xUUFKS2bduqbdu26tChgw4cOGA6CwAAAHAxf/58XblyRW+88Yby8/O1bds2LV261HQW7jDu7u5q2LChrl69Kknq2rWrsrOzDVcBAOyCOzUAwAbGjBmjiRMnatCgQZKklStX6oUXXtCWLVsMlwEAAAD/FRgYKEny8vLSggULDNfgTuXh4SGn06mAgAAlJiaqZcuWys3NNZ0FALAJy+l0Ok1HAEB1FxwcrMzMTJe1jh07avfu3WaCAAAAgJ+4dOmSFi9erIYNG+qZZ55RXFyc/vWvf6lt27Z68803dffdd5tOxB0kJSVFISEhys3N1ejRo1VQUKCZM2eqR48eptMAADbAUAMAbCAkJERLly5Vu3btJEkHDx7UoEGDlJ6ebrgMAAAAkGJiYnTu3DldvHhRbm5u8vX11cCBA5WSkqIDBw5ow4YNphMBAEA1wVADAGzgk08+0eDBg9WxY0dZlqXMzEwtXbpUjz/+uOk0AAAAQO3atVN2drYcDod8fHz03Xffyc3th2M6AwMDtXfvXsOFuBMkJycrKipK8+fPL3PNsiw1atRIvXr1kpeXl4E6AIBdcKYGANjAE088oezsbO3cuVNOp1NhYWFq3Lix6SwAAABA0g9nHEiSp6en/Pz8SgcaklSrVi1TWbjD7N27V1FRUUpLSyv3+pkzZzRv3jxt3bq1kssAAHbCUAMAbKJJkybq3bu36QwAAACgjMuXL2v//v1yOp0uH0uSw+EwXIc7RXx8vCRp0aJF13xOREREZeUAAGyK7acAwAY++eQTjR8/XkePHlVxcbGcTqcsy1JxcbHpNAAAAEC+vr6yLKvca5Zl6ejRo5VchDtdRkaGMjMzXYZmY8aMMVgEALALhhoAYAMBAQFKTExUWFiYatSoUbrOXrEAAAAAqpuEhAStWrVKJ06cUHh4uDZv3qzu3bvr/fffN50GALABtxs/BQBwu3l7e6tnz57y9vaWl5dX6QMAAAAAqpulS5dqx44dat68udasWaO0tDTObgEAlGKoAQA20KtXL23cuNF0BgAAAAAY5+npKU9PT5WUlMjpdKpNmzY6fvy46SwAgE1wUDgAGNSkSRNZliWn06m8vDzVrVtXnp6epWdqnDlzxnQiAAAAAFSqOnXqqKioSMHBwZowYYKaN2+uwsJC01kAAJvgTA0AMOibb7657vWWLVtWUgkAAAAA2MPevXvl5+enwsJCTZo0Sfn5+Zo8ebKCg4NNpwEAbIChBgDYwIkTJ9S0aVN5enpKkhwOh86ePat77rnHcBkAAAAAAABgH5ypAQA28PTTT7t87nQ6y6wBAAAAwJ3s0qVLeuedd7Ry5UqVlJTopZdeUlBQkKKionTy5EnTeQAAm+BODQCwgeDgYGVmZt5wDQAAAADuVDExMTp37pwuXrwoNzc3+fr6auDAgUpJSdGBAwe0YcMG04kAABvgoHAAsIEfDwVv2rSpJCknJ0fMnAEAAABUJxkZGcrOzpbD4ZCPj482bdokNzc3PfnkkwoMDDSdBwCwCYYaAGAD48aNU5cuXTRkyBBJ0pIlSzR58mTDVQAAAABQeTw8PCRJnp6e8vPzk5vbf3dNr1WrlqksAIDNMNQAABsYPny4/Pz89NFHH0mSkpKS9MgjjxiuAgAAAIDKc/nyZe3fv19Op9PlY0lyOByG6wAAdsGZGgAAAAAAADDO19dXlmWVe82yLB09erSSiwAAdsRQAwAMmjBhghISEhQVFVXuD++rV682UAUAAAAAAADYE9tPAYBBXbp0kST17t3bcAkAAAAAAABgf9ypAQAAAAAAAAAAqgTu1AAAg+Li4q57ffbs2ZVUAgAAAAAAANifm+kAAKjOXn/9dW3dulW1a9eWl5dXmQcAAAAAAACA/2L7KQAwKCUlRYsWLVJqaqqeeeYZxcbGqlWrVqazAAAAAAAAAFtiqAEANvD9999rxYoVWrRokWrXrq1Zs2bp4YcfNp0FAAAAAAAA2ArbTwGADXh7e6tv377q16+fDhw4oAMHDphOAgAAAAAAAGyHoQYAGFRcXKz3339fvXv3Vo8ePWRZljIyMjR06FDTaQAAAAAAAIDtsP0UABjk4+OjFi1aKDY2Vl27di1zvV27dgaqAAAAAAAAAHtiqAEABvn6+sqyLEmSZVn66V/JlmXp6NGjptIAAAAAAAAA22GoAQAAAAAAAAAAqgTO1AAAAAAAAAAAAFUCQw0AAAAAAAAAAFAlMNQAAAAAAAAAAABVAkMNAAAAAAAAAABQJTDUAAAAAAAAAAAAVQJDDQAAAAAAAAAAUCUw1AAAAABga8OGDZNlWZo1a5bL+rp162RZVpnnt2nTRrVq1dLJkyfLXHv00UfLfS1JioyMlGVZ+tOf/lTm+f/7GD169M1/YwAAAAB+NoYaAAAAAGzP09NTCQkJys/Pv+7ztm/fLofDoaioKC1evLjc59xzzz1atGiRy9qpU6eUkpKiZs2alXn+yJEjdfr0aZfH7Nmzf/H3AgAAAOCXY6gBAAAAwPZ69OghHx8fzZw587rPS0pK0qBBgzR48GAtXLhQTqezzHN69+6tvLw8ff7556Vrixcv1uOPP66mTZuWeX6dOnXk4+Pj8vD29r75bwoAAADAz8ZQAwAAAIDt1ahRQ6+99poSExP1n//8p9znnD9/XsnJyYqJiVFERIQuXryozz77rMzzatWqpeeee87lbo3FixcrNjb2duUDAAAAuEUYagAAAACoEvr376/g4GC98sor5V5fuXKl/P391b59e9WoUUPPPvuskpKSyn3ub3/7W61evVoXL17Utm3bdO7cOfXq1avc586fP19169Z1ebz33nu37PsCAAAAUHE1TQcAAAAAQEUlJCSoW7duevHFF8tcS0pKUkxMTOnnMTEx6tq1qwoKCtSgQQOX53bo0EH+/v765z//qS1btmjw4MFyd3cv92s+99xzevnll13WytumCgAAAMDtx1ADAAAAQJXRtWtX9ezZU5MmTdKwYcNK17Ozs7Vz506lpaVpwoQJpevFxcVasWKFXnjhhTKvFRsbq3nz5ik7O1u7du265tesX7++WrdufUu/DwAAAAC/DNtPAQAAAKhSZs2apQ0bNmjHjh2la0lJSeratauysrKUmZlZ+oiLi7vmFlSDBg3Snj17FBgYqHbt2lVWPgAAAICbwJ0aAAAAAKqUoKAgPffcc0pMTJQkFRUVaenSpXr11VcVGBjo8twRI0Zo9uzZysrK0v333+9yrWHDhjp9+vQ1t536UWFhob799luXNQ8PDzVs2PAWfDcAAAAAfg7u1AAAAABQ5UybNk1Op1OStH79euXl5al///5lnufv76+goKBr3q3RoEEDeXl5XfdrLViwQM2aNXN5REdH3/w3AQAAAOBns5w//ksAAAAAAAAAAADAxrhTAwAAAAAAAAAAVAkMNQAAAAAAAAAAQJXAUAMAAAAAAAAAAFQJDDUAAAAAAAAAAECVwFADAAAAAAAAAABUCQw1AAAAAAAAAABAlcBQAwAAAAAAAAAAVAkMNQAAAAAAAAAAQJXAUAMAAAAAAAAAAFQJDDUAAAAAAAAAAECVwFADAAAAAAAAAABUCf8PryYCwdxAQlwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wp = pen(gdf, col, name, weight=weight, figsize=figsize)" + ] + }, + { + "cell_type": "markdown", + "id": "e3241865-bff9-4775-b8b6-ce9324b72f70", + "metadata": {}, + "source": [ + "The weighted Pen's Parade introduces complexity but has some inherent limitations. A key drawback is that it assumes no inequality exists among individuals within each state, as everyone is assigned the same income level. Consequently, this leads to the assumption that in comparing two states with different per capita incomes, the poorest individuals in the wealthier state would still be wealthier than the richest individuals in the poorer state. This assumption conflicts with real-world data ([Rey, 2024](https://github.com/sjsrey/spatial_inequality?tab=readme-ov-file))." + ] + }, + { + "cell_type": "markdown", + "id": "9ba7b96c-c7e1-45d4-9047-8feef02e498e", + "metadata": {}, + "source": [ + "## Pengram\n", + "\n", + "While the Pen's Parade effectively shows where individual states fall within the overall income distribution, it overlooks the geographic dimension of income inequality. The **Pengram** addresses this by extending the Pen's Parade to incorporate a spatial component, combining the income distribution with a choropleth map. This dual approach allows us to visualize not only the statistical distribution of incomes but also how these incomes are geographically distributed across different regions. By blending both perspectives, the Pengram provides a more comprehensive view of inequality, linking spatial and statistical elements in a single visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "bb91fb4f-dc02-45ff-bf34-88dd67fa7987", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pengram(gdf, col, name, figsize=figsize);" + ] + }, + { + "cell_type": "markdown", + "id": "72a006b3-abc6-48ae-b15e-ad57afe08412", + "metadata": {}, + "source": [ + "By using a Pengram, we can identify regions that may be economically lagging and those where income is concentrated. \n", + "we can observe that wealthier regions are primarily concentrated in the northern and central states, while southern states have significantly lower income levels, which suggests regional economic disparity.\n", + "\n", + "This dual analysis of statistical and spatial distribution allows policymakers and researchers to target interventions more effectively." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "5f8b42f7-ea46-4743-ba9b-6b0defee9ff4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left');" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "7f674a6e-54c8-4855-9074-397bae208c51", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks');" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "90dbbadc-f9d6-4290-bc6b-3f6505a2b804", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks',k=3);" + ] + }, + { + "cell_type": "markdown", + "id": "b2744046-2c27-47b4-8922-4a0b892d143e", + "metadata": {}, + "source": [ + "### Queries\n", + "\n", + "The Pengram enables users to search for and highlight specific subsets of areas, both on the map and within the Pengram itself. \n", + "This feature allows users to focus on specific regions of interest, making it easier to analyze economic disparities in targeted areas. For instance, searching for states like Chiapas and Campeche, which appear far apart in the Pen's Parade due to their significant income differences, but are actually contiguous on the map, highlights abrupt spatial disparities. This helps illustrate how neighboring regions can experience vastly different levels of income, underscoring the complexity of geographic inequality.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "6011ccf1-3c44-4892-a6bd-c930371b8750", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks',k=3,\n", + " query=['Chiapas', 'Campeche']);" + ] + }, + { + "cell_type": "markdown", + "id": "4d47f6a0-a6e6-4980-ae85-f8c21b3328b5", + "metadata": {}, + "source": [ + "## Subplotting\n", + "\n", + "Both the Pen's Parade and Pengram are implemented using Matplotlib objects. By combining various visualizations—such as KDE plots, choropleth maps, and the Pen’s Parade—we can examine multiple aspects of inequality in a single view. For example, this approach allows us to compare the distribution of per capita GDP across states while simultaneously observing how it corresponds to their geographic locations. Additionally, these plots can be embedded in a single figure, making them easy to include in reports or papers." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e086b17c-b5f9-44c2-8c39-1ffad3b422f1", + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "20df407d-d5ad-4336-af1a-de2712f256c9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "fig, axes = plt.subplots(2, 2, figsize=(10, 8), gridspec_kw={'height_ratios': [1, 1]})\n", + "ax0, ax1, ax2, ax3 = axes[0,0], axes[0,1], axes[1,0], axes[1,1]\n", + "\n", + "sns.kdeplot(data=gdf, x='PCGDP2000', ax=ax0)\n", + "gdf.plot('PCGDP2000', ax=ax1)\n", + "pen(gdf, col, name, ax=ax2)\n", + "pengram(gdf, col, name, xticks=False, legend=False, ax=ax3);\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2d69e61-dd34-4905-a71f-8624f0b7a7a4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/user-guide/viz/schutz.ipynb b/docs/user-guide/viz/schutz.ipynb new file mode 100644 index 00000000..cb519cc2 --- /dev/null +++ b/docs/user-guide/viz/schutz.ipynb @@ -0,0 +1,1037 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cfa03ecf-6e5d-4cb7-8060-048cd4e1ca6c", + "metadata": {}, + "source": [ + "# Lorenz Curves and Schutz Lines\n", + "\n", + "Lorenz Curves and Schutz diagrams are powerful tools for visualizing economic inequality, particularly in the distribution of income or wealth within a population. The Lorenz Curve plots the cumulative percentage of total income received by the bottom x% of the population, providing a visual representation of how income is distributed. The further the curve bows away from the 45-degree line of equality, the more unequal the distribution. Schutz diagrams complement this by showing the area between the Lorenz Curve and the line of equality, which can be used to calculate the Gini coefficient—a numerical measure of inequality. Both visualizations help highlight disparities in resource allocation, making them useful in policy discussions on equity and social justice.\n", + "\n", + "## Schutz Measures of Inequality\n", + "\n", + "The Schutz class calculates measures of inequality in an income distribution.\n", + "\n", + "It calculates the Schutz distance, which is the maximum distance between the line of perfect equality and the Lorenz curve. Additionally, it computes the intersection point with the line of perfect equality where the Schutz distance occurs and the original Schutz coefficient. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b5841f7c-a8bd-4ecb-bb34-10d51aa36fef", + "metadata": {}, + "outputs": [], + "source": [ + "from inequality.schutz import Schutz" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "471d3791-e3c5-47bc-92fa-9dd5b3e5c2a5", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7879bc81-3d53-40f6-8108-ee2fbc07529e", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9f32cb7a-2210-4a50-bc5c-9cd1bbbd9ee7", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame(data=np.array([1000, 2000, 1500, 3000, 2500]), columns=['GDP'])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f52b60af-f136-46d9-8fb9-91ccdb7b1601", + "metadata": {}, + "outputs": [], + "source": [ + "s = Schutz(df, 'GDP')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8b72184b-86c8-4bed-b946-70d2e472a1cc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.15000000000000008)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.distance" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "acd62bd1-5830-4b2b-ba22-f9dc9381d9c4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.6000000000000001)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.intersection_point" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2d4bdf0a-72c7-4eda-83aa-8b82eb8e3706", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GDPunitupctypctucpctycpctdistanceslopecoefficient
0100010.20.100.20.100.100.50-5.0
1150010.20.150.40.250.150.75-2.5
2200010.20.200.60.450.151.000.0
3250010.20.250.80.700.101.252.5
4300010.20.301.01.000.001.505.0
\n", + "
" + ], + "text/plain": [ + " GDP unit upct ypct ucpct ycpct distance slope coefficient\n", + "0 1000 1 0.2 0.10 0.2 0.10 0.10 0.50 -5.0\n", + "1 1500 1 0.2 0.15 0.4 0.25 0.15 0.75 -2.5\n", + "2 2000 1 0.2 0.20 0.6 0.45 0.15 1.00 0.0\n", + "3 2500 1 0.2 0.25 0.8 0.70 0.10 1.25 2.5\n", + "4 3000 1 0.2 0.30 1.0 1.00 0.00 1.50 5.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.df_processed" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ff41b6d0-f4f2-4dc1-b485-5cac4fb2d29a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(7.499999999999998)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5294f208-5b2e-4e86-aa7f-190b82555a2f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "156b5de7-88b7-4bf8-9fd4-237cb1e72f90", + "metadata": {}, + "source": [ + "### Increase the inequality" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a2ab7983-d0c6-45eb-a393-45464b6d8a7a", + "metadata": {}, + "outputs": [], + "source": [ + "y = np.array([20,50,80,100,100,100,100,120, 150,180])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c2fa9119-df17-4dbb-b6de-71c486355ced", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.DataFrame(data=y, columns=['GDP'])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f4cd0cf8-3458-4a05-87a8-6a387d0f05c4", + "metadata": {}, + "outputs": [], + "source": [ + "s = Schutz(df, 'GDP')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8fdc3fb5-f926-46a2-ae79-15f2b82dd192", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(14.999999999999996)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0a77128b-2b2c-41ab-b479-2cc30339e3d4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GDPunitupctypctucpctycpctdistanceslopecoefficient
02010.10.020.10.028.000000e-020.2-8.0
15010.10.050.20.071.300000e-010.5-5.0
28010.10.080.30.151.500000e-010.8-2.0
310010.10.100.40.251.500000e-011.00.0
410010.10.100.50.351.500000e-011.00.0
510010.10.100.60.451.500000e-011.00.0
610010.10.100.70.551.500000e-011.00.0
712010.10.120.80.671.300000e-011.22.0
815010.10.150.90.828.000000e-021.55.0
918010.10.181.01.00-1.110223e-161.88.0
\n", + "
" + ], + "text/plain": [ + " GDP unit upct ypct ucpct ycpct distance slope coefficient\n", + "0 20 1 0.1 0.02 0.1 0.02 8.000000e-02 0.2 -8.0\n", + "1 50 1 0.1 0.05 0.2 0.07 1.300000e-01 0.5 -5.0\n", + "2 80 1 0.1 0.08 0.3 0.15 1.500000e-01 0.8 -2.0\n", + "3 100 1 0.1 0.10 0.4 0.25 1.500000e-01 1.0 0.0\n", + "4 100 1 0.1 0.10 0.5 0.35 1.500000e-01 1.0 0.0\n", + "5 100 1 0.1 0.10 0.6 0.45 1.500000e-01 1.0 0.0\n", + "6 100 1 0.1 0.10 0.7 0.55 1.500000e-01 1.0 0.0\n", + "7 120 1 0.1 0.12 0.8 0.67 1.300000e-01 1.2 2.0\n", + "8 150 1 0.1 0.15 0.9 0.82 8.000000e-02 1.5 5.0\n", + "9 180 1 0.1 0.18 1.0 1.00 -1.110223e-16 1.8 8.0" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.df_processed" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "191b0379-fa2b-48a8-83e3-4b1513b9ef33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.15000000000000002)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.distance" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "fe18ada3-a3b1-4543-b31f-290236823e24", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.30000000000000004)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s.intersection_point" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "dc17f5bc-9d85-42eb-9cfe-fbc153439e89", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "cb980ad1-a0b0-4d2d-91b9-d0c4d6d42734", + "metadata": {}, + "source": [ + "## Visualizing Mexican State Income Inequality" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0448ec52-ea6a-4db8-9305-25aee1c0e08b", + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "gdf = gpd.read_file('weighted.shp')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "6cb94942-b3a0-4cf2-9034-a836058a29f2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...TESTName_1PopulationNAMEppopulati_1Y2000y2000_1pStategeometry
055.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...5.0Aguascalientes944285Aguascalientes9442852.623413e+1027782.00.009647AguascalientesPOLYGON ((-101.8462 22.01176, -101.9653 21.883...
117.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...1.0Querétaro de Arteaga1404306Baja California Norte14043064.192556e+1029855.00.014347Baja California NorteMULTIPOLYGON (((-113.13972 29.01778, -113.2405...
227.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...2.0Baja California Sur424041Baja California Sur4240411.106874e+1026103.00.004332Baja California SurMULTIPOLYGON (((-111.20612 25.80278, -111.2302...
3155.016584e+10MX04Campeche1575361.1461.239620e+075016583.7233758.04929.05925.0...15.0Campeche690689Campeche6906892.497739e+1036163.00.007056CampecheMULTIPOLYGON (((-91.83446 18.63805, -91.84195 ...
4227.339157e+10MX05Chiapas1477195.1991.813538e+077339157.3762934.04138.05280.0...22.0Chiapas3920892Chiapas39208923.404903e+108684.00.040057ChiapasPOLYGON ((-91.4375 17.24111, -91.35278 17.1763...
\n", + "

5 rows × 43 columns

\n", + "
" + ], + "text/plain": [ + " POLY_ID AREA CODE NAME PERIMETER \\\n", + "0 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", + "1 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", + "2 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", + "3 15 5.016584e+10 MX04 Campeche 1575361.146 \n", + "4 22 7.339157e+10 MX05 Chiapas 1477195.199 \n", + "\n", + " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... TEST \\\n", + "0 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 5.0 \n", + "1 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 1.0 \n", + "2 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 2.0 \n", + "3 1.239620e+07 5016583.723 3758.0 4929.0 5925.0 ... 15.0 \n", + "4 1.813538e+07 7339157.376 2934.0 4138.0 5280.0 ... 22.0 \n", + "\n", + " Name_1 Population NAMEp populati_1 \\\n", + "0 Aguascalientes 944285 Aguascalientes 944285 \n", + "1 Querétaro de Arteaga 1404306 Baja California Norte 1404306 \n", + "2 Baja California Sur 424041 Baja California Sur 424041 \n", + "3 Campeche 690689 Campeche 690689 \n", + "4 Chiapas 3920892 Chiapas 3920892 \n", + "\n", + " Y2000 y2000_1 p State \\\n", + "0 2.623413e+10 27782.0 0.009647 Aguascalientes \n", + "1 4.192556e+10 29855.0 0.014347 Baja California Norte \n", + "2 1.106874e+10 26103.0 0.004332 Baja California Sur \n", + "3 2.497739e+10 36163.0 0.007056 Campeche \n", + "4 3.404903e+10 8684.0 0.040057 Chiapas \n", + "\n", + " geometry \n", + "0 POLYGON ((-101.8462 22.01176, -101.9653 21.883... \n", + "1 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", + "2 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", + "3 MULTIPOLYGON (((-91.83446 18.63805, -91.84195 ... \n", + "4 POLYGON ((-91.4375 17.24111, -91.35278 17.1763... \n", + "\n", + "[5 rows x 43 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "746a1398-6f62-4529-a1f3-fb8eb4d1e73b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['POLY_ID', 'AREA', 'CODE', 'NAME', 'PERIMETER', 'ACRES', 'HECTARES',\n", + " 'PCGDP1940', 'PCGDP1950', 'PCGDP1960', 'PCGDP1970', 'PCGDP1980',\n", + " 'PCGDP1990', 'PCGDP2000', 'HANSON03', 'HANSON98', 'ESQUIVEL99', 'INEGI',\n", + " 'INEGI2', 'MAXP', 'GR4000', 'GR5000', 'GR6000', 'GR7000', 'GR8000',\n", + " 'GR9000', 'LPCGDP40', 'LPCGDP50', 'LPCGDP60', 'LPCGDP70', 'LPCGDP80',\n", + " 'LPCGDP90', 'LPCGDP00', 'TEST', 'Name_1', 'Population', 'NAMEp',\n", + " 'populati_1', 'Y2000', 'y2000_1', 'p', 'State', 'geometry'],\n", + " dtype='object')" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdf.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "098fb817-7b90-44ad-8822-fd967ec6ac98", + "metadata": {}, + "outputs": [], + "source": [ + "s1960 = Schutz(gdf, 'PCGDP1960')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "cd3c70ba-8043-4113-8c3e-146733c1f8fe", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s1960.plot(xlabel='State Percentile Rank 1960')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "45a6bde2-a69a-450a-a9c6-0952b95fa390", + "metadata": {}, + "outputs": [], + "source": [ + "s2000= Schutz(gdf, 'PCGDP2000')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "7270fdba-c040-4816-8dcb-8f9c0e9f84ce", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s2000.plot(xlabel= 'State Percentile Rank 2000')" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "d5165cbe-16ca-4fd9-805a-12c2afa4fd68", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(58.09565999182672)" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s1960.coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "3c5c4bb9-7e0c-43c6-83b7-bd67ac1bc0df", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(62.413744551459686)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s2000.coefficient" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "b627238b-b80a-41af-98f3-0e9437bd3520", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.1815489374744585)" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s1960.calculate_schutz_distance()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "4a45c67d-1bb5-4224-8dd8-38047a37eef3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.1950429517233115)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s2000.calculate_schutz_distance()" + ] + }, + { + "cell_type": "markdown", + "id": "ccd537bf-8c41-4951-a09f-5a104e0fef9a", + "metadata": {}, + "source": [ + "The location and height of the Schutz line (which is derived from the Lorenz curve) offer key insights into the degree of inequality in a distribution. In the case above, the Schutz line for the first distribution in 1960 is positioned to the right and is shorter than that of the second distribution in 2000, this indicates that the first distribution exhibits **less inequality** than the second one.\n", + "\n", + "Here's how to interpret this:\n", + "\n", + "1. **Position of the Schutz line (to the right)**: The more the line shifts to the right, the greater the share of the population that holds a significant portion of the total income or wealth, meaning less inequality. This suggests that in the first distribution, a larger proportion of the population is receiving a more equitable share of the total resources, compared to the second distribution.\n", + "\n", + "2. **Height of the Schutz line (shorter)**: A shorter Schutz line represents a smaller area between the Lorenz curve and the line of perfect equality (the 45-degree line). Since this area is proportional to the Gini coefficient (a measure of inequality), a shorter Schutz line indicates a **lower Gini coefficient** and thus lower inequality in the first distribution compared to the second.\n", + "\n", + "In summary, the first distribution is more equal, with a larger portion of the state's having a fairer share of the total income, while the second distribution has higher inequality, as reflected in its taller and more leftward-shifted Schutz line." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/user-guide/viz/weighted.cpg b/docs/user-guide/viz/weighted.cpg new file mode 100644 index 00000000..3ad133c0 --- /dev/null +++ b/docs/user-guide/viz/weighted.cpg @@ -0,0 +1 @@ +UTF-8 \ No newline at end of file diff --git a/docs/user-guide/viz/weighted.dbf b/docs/user-guide/viz/weighted.dbf new file mode 100644 index 0000000000000000000000000000000000000000..c998af848392b5af853920e5ef09c8a173e3e579 GIT binary patch literal 43746 zcmcJY%Z?mJc7_EQ1K11OfLDfB`2e0m-Y-jFTVI<`>TKb6(1+% z)z{B|`}?n+82zRF`8)e_P#(R0`Y8T)zW&eucyN)gkH3EMG*TYh=d1Xi<>Td}7pvD_ zJ$?Pvi>Gg&zK-`lZvWBa*H7Ps#^n9KeERq;JX#fb{ng`VPhM41TdrU4K5@PO#P#75 z*T+v>pH{EeW$9i2^3lsTU%xCHum9otGFk4=_f8n|;uY%WLhrEw8ofw!HN9w@=@^<(d^azc05xUj4qBuS@xVb@S8x`|aKJ&4(}K zb;F0B=AY~9KgHj3kNN)p6zcB&{x-;l{a^C;XS*I4l-J|E-QT~t+umJ;yGj24zF11v zwf#`m)7Vv;ikp^YGgfUs4KKbetEEzo&qv?iZ$G}j8nJinwf3> z)B}iFR83b-^{^?Yc%dq%aq5dA^mH?g?G(z`mrV&L6@6|uODplyIPB|2(#N4v^r|n1 zQM6N6WnC*e)!{QO+_oNuQPnq=9!hUS`__))|8wZ&rrnMI+!1SpQf_*Kzy_M~E z$Mcd~KBl&<$1ZZ6;UhPHhb#qNYZJGs?#7`^28Wt!5@D66z8$Kro9ec&hl_Dq4Ru!! zUDXU-I(=Yeeb}FKzyI6zkK5ugSovQ!w;!&z#mk%9yQ^~=t;@D-s(RCmJL#K%&uWV9k{bzh!bs(l+R)&3eiS34d?gJlx4pzo%|2KxXLCDyRwO+DNf>l6jL#4PBt zeK5xQO5F9@r>>e^|jE3k6z z=w|4nf`KBy6T+C7_(9TnCJHioVx{RrsW7x|wSHPpD6XP?9-*zmAW*(k_cc~k{WW?o z?rZfQin-o>(JNC>vBoLri4Mk9Qom!xE3Emohl!~;h554kq9;mh0u%SrXWy(c1$ufR zkfAq{Pp~gOYGZS|`mO9Q^=11f z2wMqlgO-BWn{C-&ic@ZYe$|Z)NOFRe?O}h;{r-6S<4;%bemF~&On9iep)-B3YP)Dt zgNY>o+DvGa<7ViFKyO>rz@dm8-3)aUNlxdU-^Y*zI5$n5g}C z%!|~s7@uVt!@$nHD!{~AVwoIIe$!}dHLR5P#gFOG_pY6pp}>#np%N24zo$b#^%Y2x1=dqJ9nW~}g;h31vz&h9`{gu^(13=WTc^sumduXTbFdamF9;}UrS)P99 z(I485;>Tvoqxvu1N%_)l?Nx-f3(w zj@$84oYoyn2#jeuSWM;*tjssibocQMKzaRsTRgccez(2det+|q^I((b`_Q77jm;9* z#<$y|AXfxlfWQ^m9W;!>S(3)?z-C5pWflRZPA1W7bV2F%e5ZVM^Wg zqpaVTQh%&Rd}4|pSoJW`qo>P`j$3~ziqAEAvNmk|=2pz6?oyE3(WUKd`lhl;p-1;} zn45$4O=~zPyY@BR!%FB1v&=`~(2?8267LK4d2~4r)K|WRQy)YTps8#fWAclf_TPHHn}y@$W!|TwaP(Li9u342E`3W7#Tvz5qV&F^$0$gq4dI#Vm*}&Hf)wZsCYe`)j>B4Eam8~~*|s%a1cj}3 zYgK=ZuK2Y29`-$yjt#yHbLhA=PVx0k&o8;Sk>mJRnb9*`6i=={-rZi`-4y?R_1)F& z_Wj{lecty9eRAwJL%Cod`u707o0FHA$zXnkxuBaj_!B};H~5a1(pt=i3&U8Y(?f-s zj#-~fTcD#>$`}r}8C5$(LXTW9p&g*TvYAc__hsTWMsw|W*&^Wo_-2eN(=%k zlWr{v4tk};INy&+c=WIs^Arz5!L0Pgp*rKHvDmk%J9*#M@q0pdFmzD#>SSJCT)+F_ zX8Z1!|M?I(KJ&wJGDtc+vz7hN^ULq9?Z_(9LvBk?0??319re~Ef|Wo=r=}qQRNACn ziqm?)RBd1uXikGWFTM>r*RDrretB|#yZ!L}&6%wn{G238a=)hy9^HtEcM_Gx z%V#96W(6NT=|m*ChJF%njd63L(~m zVH4vv$acWWW%+~!5N>PZ;9;n2A8eKULzmBtlXaC_KFk+iHu>VoAOXP>2c$nqUB|o3hj)%qMOG=CYLnQ{S*x(ZTd<@mLd9%^+ zck(V}`(S8XJ@Lclg@WHx@(;F3tb{JxcQE%zb>iN+<%1{*vYpS3mYcsY%wenps|`;% z!ZWP?Q>P3>XdL+SV{rM?CxE|0JPLQytWY;%QKwr?jbp&g@3j9$?z zrS0rvBL11f68UF6ICP!c%N`;U@Q2?clp%H!gOKN*NA|Hk*zB- zC;5YS5Y=*@qaI>aMeL~MsE7JsW*Ky6j^B{jH*$|;+W4VO?nIMX^_Sw5ZF%f}LB%+E(8h@-?Z}qv)JP}Xsj$XRt}Z)OM;0ycYP%5>2Ot8 zH&_|CJx}*_#I@zib{K=*-&kMivv%pBn420Mflq4(taS88FYi+3)|j5CFv#dik2AWo zd9k%q&@v_|zOC)q&Tia%H^lRo&^*|uV^+}Bv*h$y_-6Z|cz%EVv3PZJck}U=|BdZ_ z_6JFe6I#S)|Ni)g`Q>+ahsY{BjT<(;*)E<$D5$q45w>zHf0}iIvl9L3Vw{rhj>(F# zNkV$UAy}Dp-%iYlU`3E@`}I3^ho7lql3P&Oo#S-E; zMId$*Uw)(yJqca2k;3*Fg;|*M8Y?mLC1&B`Qu-;|zDuRw*p)bob ztWw6<%E>x;e0~4j_B#`f7r*>9gId9XgM=aS`75)_Zx{#r8(Bq~(QnWU(cBK9h#G4W z!AclOMCZ&60z)0g;9QDRJM59ImV!#z|x#;QkG{H)dY+VS;D*Vb106d0#-xmRrP z-E_^`Bqz%q%I#INOj(G#8eyJa}DxhQnhSNiYiddMvwgpS$dm`~lw z&0m z73r7~D>>IwVgybLiE*W!5f?;d_t$0`R9AW&`Iw#3``D~?9H03k@Jc2*{z|qipPpa2CJ`oamYYCwB}dVW zU4JP~@$K1$Ky*pA?<8UlR_0US8IhOwSAV)Go?qQ$+Lu6nYRMTE6?^QK2R-9NSf8Lb zyBpcDSug%dCShud*ip__h{jvR*&D$pYr8s=&a>QMnHfTFJrwvrw}efFaXc8MtxXKC zO9wZ!1J)l6dZcqyv4?#gW_fgp_4Lha-=ljNioa6Y!r0~xU7tw-hDvPmFwvv0fA*tU@Z1@Zw4YE2pvNHF_l~4;#WS#VJYEb&s*%kQbkd)r)WIMVHz2>YOiMZ-3st z%efyMtr2%4=M0fA5Q-%MO*o3#^TgQ`ZQK}49v%mf_eJdJUJt@E()Dw!9}i|SJ0=X) zSCo1k^Fgi!hT`8ml>uvqWBFu#f_~|s$NLhWm-T5%)?cA3OgEMu+KzgbSUY}fM`MuL z0XDq5VvSII+g$3E)c5?A8jI04C00UT9<_m`zz%w!=f~8!L|}B<;axk@_CGQ+xpi*& zu+4ZwpD#R{o4+_d_7PbH+_Aq=AC59|tjdZ+*h;|1#dZ@cN1$@N6sM@I?6GI6nrTQ? z6R&OcAFvM>M|$O#841B7yV$<(#X$lTGB9CbM2lqKbV zBz;}m;GBpev6Zt*6$bI#ll#ZT@p@DA5h$i=J71JXJ>ern2YY&+8&1b z*vBjH4vUQ&1>4-A>zo@fQThQr4E6ks=!qVNN;;V6&{OqsvAwY6o%%ZVb)xV8h682Z z-QNEt4Ac34IXi2d!YfkFZ;Tf5%kPe@$SRI((+zEtTe8}ywEUw^n`OL+16=FDWF$Ox=+eE5j$E%}nR?VkJ` zGFmypnD}EVED1NBLW)FT$%XFQN9uyI?*aUg9rtR*eyDK^#)K+0G97+9= z$f?A{hK=iXKkcVx%A7tREJQ! z(7`O(KK@6?2KV$wFTc`#2U)_-o*$XRbn5TUEg!7iDMT)9n$9n|`8(t&@LJ;~Lo-Bf z(?w3rHHk2-W#pV-JNcVKyX)>!oRU?*{yxizK0eYLtjxM^C(X6JJ{+pg`(BX}L6qhA zJWBEh@LupP*>N$_u*KOCUFYgI#?OL(}SeOw?y&I5zm{IRnRU)QWt3_6P3);H?4q(*Cl` z@4jb|)n-onAwqMs5rc{dwJQ-wBIdVcVDb(}yl?fTIK`2QS~il*c`W8&Wj@C+-F}quM{sf5rQadJA$&6aZmULPhf7!d+jKm% z9n~*u2dq?BU|8w+B~#OR(aTuz=>=%*SCl|06el2OLFKG2(13O~*+o)MWpHD-pIru-hkcm;nHC(J#d* zhwrq!`2Z{-%|8)Curi+lPj}yL|FF$^b_SfI$8ny}PAjnOIW>D3F}W?5d+|%!TOG*_ ziXFvgzhEm#=^=h)uYgNBPm?y6=KoN1W=7hoc4JYWv!ciY-LV5;xZ| zC4S@SiRt7;{;4ndgznY%=!$=u0n6mM--e;mZwQ7;%)tsTjjhDNCDwEPxx{qzO4%>;N>%^VSCd;l$g$ucvwT>Yo4+u>^WVs7&6Z+P zBn|QsVWG~NL{OPbX*;BdX9FRN@=~1gHUyRsSjp)Tsp`1=*4E>FH>Lf*__N*ZuuaXOtxXZRF>TQ%_tfEL{`mH ziHnujR;P=QN^25fdL^+5#G5TYcJTM5IK?AM>dd@L(4M?=A(%_j4Op4)p+tAzzTf`* zZksd1k}ZoR@kEj*118$md-EGic04-z-7aZ`(5m1j4A~A2;dJ^#JJ|T-Fh%B<4~B|eL2{qCtt^GnYjkzrwfYZjAFP!6lz* zQJ7*jxJO^6J&c@nioz=18ya>ckj;-NF%i1NXfSt~k)!s#n2&4YEB;U41DabtNLD1E z9DASPBR7ACECpUIg=KzK_>rPO%{7TIB@~^56MzWn;&^K=#VNWgZ^6cI$6M}FmFUH{ z;mq*EKArP@$sham^Y`07U7gcX{4Gxs9Jw`n9AgY8oaxIuJ6cpq&L3K2W6>)^M|q!L z6mA|u{W#}Ek=CIwg0#z4(ounwo>kTORTTE&=1`bbu~|y#t@uM_+}t{@_*tVXKCQmQ z^cDJv9%PMBe7~f&kr|&<0SnEn#c&kXSbYa8ccHrk;}{2t>Ch#%LYFo>_KLhObcwl6 zJE!NOE<5vn`M*4yfH8eY{K&VRB)j~EiMPLzRZi+97qzN!r6oc{jWvm|6-8)gezCZn z_uE{GQ+sKeC2dzk4^uG&EAtIB-Tm$TyDj;ZHa3|GfXF#(_?6=RoQYG(IU5P5AqlOV zGqeaLXJ`;JFJedcaZ(O$>zmonfKje6jx9jarbg(bU(#OdqcDglp4K1HbfsR2Pe9Ra z+!VGNUESB{$ZA@QNb%}>^mO^sWN5~)Qep)34Ssj^Zu@aJL}z{> z&d2c#1Ls{YQp34SCE1f?0CA`pYdX*?wnCC<&pXTJj`9?W!bg(96mm$(Vof_Av7pD; zP6j2?Z51jy&qax4}JH2erf~h(bETD>O1Z1Ts{Gl1DiIUvOaXBhn_xzbIS*( wE!s<9BYWq6JMw@Lee^O^YOYCyVI@gCBY_=);DlasbNVm;4B+rkl**n+{eS*iceoixsd%Aws$x?c{HMO0Hn)!c zH_@uP(QL{#(b4?>_lp%691HW(L)JI60Xrua7uM1L=I90X`+i+SM;oRN{=#2Gv$5k8 z(ZT;S`v$<)OMV4u^@AZ`mEb(s))`KH*KX$BVjMVfEH!Q}_5ZDc?p0h0)?;_kzQ-!^ zmz%(mbG3U;&^~#1?%ATie#sTgzwWy@KmW%i%wJaod#7iCRh@d&&rJs7TBEP0#YF0- zd(wW$1g1~j80;n(3$~S;Q-As``Q;a2dzow!R0f;x2SaxTX|S3#6l}_8CP#e(R-b1C z%ljK!skn8-Ggtq-DIR_A-9mYq*ywYPe&)fep+*LO(Z6KDUuyi9a_&`vjT#fTqz?X< zXRqz=bMmQRtDQ$F72mO1FMd0$ep`U-`onU2M(sbyfxUgodVW(8`6IGH(<9( zeX!MSY2Up8?QhotoBdVE)vHo>KBxWrS;$W+f_19oV0k^d|3T=gPW%$l*XMWto#|_) z1v^_$Gku2CVDH6I+V?C5whxa}KVOsS+fz3en~}RSf1RoZST))Ydvh>1SRP+z-2vSj zd%tw_`KU5GX`kc~*xs>V)#@hLfBh@Ti6$`Nz<{5Op(cDD_d( znSOQ`uN@Jh}q)js=*1r~F{&RDRmeOaT73jF_Onwm8d-NExEzd<%Ow zGj&~j6xd|s_oQ=<1nb3o-~FGzqyDlC@-rnzg!XNC{FKAM>gfou%EA0i?&-8|I-2?2 z{|W5gx-V*1Z%ug`r2_RcG` zLsa8#V88nt+MDLIuM-=(ZAg35I}YuOA7c7aNx`PwHL&{TZQAF11a@z}L%q~9u&tho z>7Txb^2{CoE?Dm<0(KU@&-8~nvAlbhm0YV2?VIERn`~pj>TnL~d8ble67upT)br(` zz1a@7NvWH6w}Q>|Y|wRvGh{C>^ZWHyn7#m5`7gk_P7!jfH`G5ZMlP0-?Y4EFfpwc~ zU~_`)Jky{U^|0M%hnEA}1My*RE7bryAFbs558Hu`{RQlwt4HBe_{$Rf1wSYMVc6RthdrCQPAb_^q9AJ{*Nod-hY&YTjdee6uSdXQyw*MB|r=q<% z3bt93gLTPUV0pgw`{lg;ZSV1ZC0Q6=|65@7_I$7!a0Tg2;ia^18bxllf_ym<(~JC6 zt^YwcN$c?VDPlFT!F{o{MuFY&kC=YMX!50pDmk|?PXo3KFZf5`uz0jQ)oY%k8^|Vq$6OJCKq}6MsV=0gH50HY;P~g z0#=>oQ7`RKpWuN_;`hM1-{+u^>T{o7bgYlXW{*?q`-dPXS`q6PxJd&`<$G8E73(59J9?w*}Nc;Xnq3czD zg7t$AV6*xhxmQs51|X^oN#fDI2)|dm{ASVU>-G06qaODV*bZLF^i!9UUy@DI$zYY5=~br|K>%|$VmzqGmGt=vWVSaP! zLRZVjP*2;4>F$5B$Oke7H zJ#{_()+f>T&t1}q_Qel@Ra8eF@6i&lp4|*=>Q4gyTR)ZSN&QS?=z3alrvI!t`9yZG zncjiv4<-fMOr62%^H=Q4Ck)T$!7Z@8(;s@IKD09i(>~E(&{dA%!%@;~nPv_Ehk_V&#YFni#<7<`WBWSs{c^1z4MUv{T6`D zv==;H*6rY+EzraU&r#oE{iN%>rha<|^?b3R+dVtMdQr$N&V$|BtZz+{Jz$eKKI~2N zU%~&@&%1V$lZN&AZ$4PP6%Y3I)I+eJjp^0w`1oGEk*u%PsvFRC|HQCYH?M)c`w772 zU{cuY0?c1u&Pi^}_JLkqp5K4iUeH}uk(2QF+Oj+{i^KET^E1B=+xpw+bR zT@h^GTMo9%s?$E>daxJvz4eKGOkbc9bk*rH?Te62-$!86r7HDSPicRKY~Qec^Sjqz z{uPfyS8r9L{eTnXN!0D(gJ2uCChfCrBahZQ-ZUZ-sd-9|CJ zDcJ_Bm;4Id+1iDAUe@oy7$&*pGp7HrAMLZSJ)lw>^0XJ!=L`p{?P=JaxXiw}*_jor zW{qQhEpmeGs|n;&S;!SQ)?+K@1-o`8bmOu;W9Q8Q>)55JU-HOT+Jn_Ui(4y zD)RDCV4d?9@+Wg?UvvZ5v|R``vDbrjuO;LY)YZNJp@cz@OKE!1c8d8kgj9+hS&?VqweYO;jSbN?#Z=NicTYlZFC8bfGbb`Nx0 zBYeK!ZUDPI$3oZP`Pn?-^UlZivGyl1{ggjoZ%R%Cn+o^A&eJhqo0MZm>TTwa{#{UR zs{-NqX9>riDul=H^BC#n*pqCp$5kr!50N>FS()lb*9G3%2A}=0CRWBj~37j|Ft_zswb~KE4F38vRZEjwN@v3RcJVgU!gxfx zcCbG47xk&Xf^F$LU|Wm%>#9-Ue~++MRZ+Jp(J(7Hn>2q7xA_yg9u(?lLw<+H(>AS+o?CrMDDzr ze7+{wO#2CJon7RC^T1~QW!k5kP5q~5Cjb*<6!stG%&vB=<_W=-5wl6`(k6Ddk4mX&4{tgzu5q=`e+!~cKnL@9UDyh zNdv)=^1@tSg!6a5Z%jQbPn5rn`Mq}n<%_vRcI^|elakNZz48pK$DD+{TjcEmxc(%6 zfc>6n$uDn!?Y1;vmHH;wYyW`xZRPu|$CCA`*U0NaBJ!6w;I z^2>B!U7sw=kD%C$qa$UfKa#fLT(K=3xwo(K>*)F2*1_Muzl%JNO(k)jYVv8Y&7Par zz3n*l#bk9Pe9zJ)r2V9Q(9OKqU>kQg?KAw9Pe&gk4c|js^iT3Xyw4^Nb(483kC*ob z^;02#atUl6Y-axLPEzmi3-f>H2-vP)L4LN0oN*ag-CRKX$sw1W0@j_EK)0tR)4t-; z(0&-$WLQl7mm##DN_*vhLw-7+dXD}~|N9)UuKP7u?IoLcJA+N#8MJTFf%cJSF{CN& zZ~Q?0y(Z+hLVI1G_HFqcsr8zA)J)i$%_YFP6Loz)AGrzjpw9s|14F$;da_4dk-W@PlA`Eiu#o zZxz^F3GL%IBEO)nisfedgUSE%?y58e$%%{LcqVZXu&Q03$DflQYz|fft66!;%|E7I zjJlmkdz+EzgE1%S1453|6m0vH;_=oDqu%**=GW&j`Dsh)&xhrWz8|W`H{f6l0Id6y z?fY?gf4ldAZY#f`{oY>W@8Ut%#rlFxpZCb?hfz3LrLOZVroM>m-#x_q^7TV{fA3}LcX@nWKMue5vAwA~A>Sa|KH2!aJMDPAGP%^(wE*ivL#V&o5NxK+q<*9}_0^BS?#-HDdoU=Qg4?OnRR+7`?}7cLrO733 zGyQ1|Ru48aeFo}5y9I0?eoA{g60FM>CV$(OygeV-PH7TynlQg*V84Cp(0&8hITgOI zX%5i772kjN%6_nUPImI2A~$-&@?hlOV0D`9GF#?4c^KJ0avtopc@BHuxytlw*v?TN z**3Tj-Hmqvy6wewk9m79(;uL&67YWL^>=vu-`CTA@GYiKvJk8$lWoVrVBMeX3b$$> zuxl^DUiIevQdKU1O|mbU{xsVu%BxLQ|E)iQX`VRK!+OYTR+-~HIc9QvW5S7sHh9LW z)Be(^hq^@rfA*tHv`zb%ebt|`f%Ue8>^n@($+4j8*}!&l4)WSsV0R<+;JnFqKVp8F zhJ(Es`N4kA8DQr`L9ogfj`a^HM*BzXn?=rD#|iyDCYGf><#Wy}xBHAdi}Ui%$WmZa zv^sRvyeQah9@_8Z`KUTYpxXjjpsNH`$j--LufoqvAC;Z?wcP{uKF{8du0c|&%eCIREwM(3B|L?avgYaadvdoyr8SeFZ)eenP7(CJ|R%og(O zF<`GvKd^Is5bck*0_(D0kvHa|KC=zjaoz)~Z@y&uarAR>@-zbbiT)}TeLVkp1F-q> zJXpP32kgZ^PHy)F`T0q(GomI~7393N-B1neUpoq2`(?p8&1$ecQyOgYtpfWWk^S5Y z$m&z*>g|bOGpz{N?br&eXBPzf&0Mgbx)Ak^4Z+@%kHKEjl3<-T7ubB54eU;$?*5bv z?B}3v_uj<&U>|3Jy?^ou*nIXO)8AV`&Y6b#!|%avx};#|7X7;P@I+ueh3}hpJ2u#R zQycb9v-=HgaG#xy<-jWQJ+S+xBG^wx-T%E9*f#tJy7QFmrHumX!}(~x;xgD9ofWL> z{|R<`rv$qR&VqH(x4=%{Q($#93D|~Zjoa}Jzpu2fpt~3UWO?A;1e+2|QQo)-9+RhU z20KZU;QH+R9W0N^XXf>9Ye>GF4eZ8iOzxJ4di@?u|Ed7fM|A<4*nHkjwt-;(M-APd z{Wa4cu1M}Xocg&+U^9I*`A@#D!I&S|eBGM)_n8V-yV`-(a$b*Lx*OP8xtR7l2a{KE z?9g5wPWz8IwrHJEJF#HD(2T@F4%9e2W-Q-#jM-U z^rOSE?>xWLe&9W(?{NmKhGsrBbOCIQD@RaA1Y-y;#;FEu(9SZ_!UHn-E#{#pXCtnU&8exKdKdeesQs?&t?D*BfP z4WiFQ*SK5~_2zd0gg^P7>wCxX9;=}*`Q9fdo13vp>L87KVn1|$^mFK{8!$ zbpzO$&+k%wxEXA2@w?VTHcR-gK}to&HkJh-qNI)miBN4*K`vUInLT(hP&{ zouj{@Uu7WE&pZx$la2nk`U3NJI`xEZIvk@uss~uD{P8u{Sp1q^cJ$(Hv+m>qa5{OeZlTz4fe(~2m7%KlHVys z&X*tTF31UX4(Fsk=pAyWkHF6RcksSB+p~i0ZTefc>ig-CvS|)z1aN zs!)9LpzPEqzG+~C_sU-37`I#TC0H+b$$I6*6R=bG5ZEvDki2dmIPxufb;B|G3a^>p zy!p_bm5FgYTm2wdMe%&i&UH-RK0WnWZNOf)@P1}$4Yo@PLD$7g(EdgNu-Orx`qX@2 z?|x$Pp^us0yx3rqjn7XPO3CzjGDCMxu-tOfen^h}C(6N~9Sinn?_s&vK0DYg!g@pX zV*dKP2i-Zz^KtU81DjXXXn&FQhN)5pY(L8eUF|9XR>Lwd{ny37-lSw;cO%)k^b+N~ zSFteji+3BWdhvdEUAIy1mYexcnFY3K`F@%$?4x)ybMSbJ$IyNzug}vX$Zz;SA_%Pidatlc`{BYJg3bqhSC0 zI$%|MAJ|D=AFKu9il?j-dp;rB6w?Py&;^r<`-wkM8P!uRI?NPDkBORy)}(UG=Gq@69> zC(*8-XTx@mpOkHAopp5qygO^y#@B0x6+}BHO<)}Pt^Wt-8L@RLE4JVIa{fbo^bXi2 zk6lm)Y0Pu7YL$k(CIfYy8XP&c`)d}kJC6M!|Fs6|ika9Rd{B(`{nLZptChfN7yC=5 zZF#V5{5Ev6wifNny#@A?w*;Fn6H?#Ni+a7dU|ef(zIMq&K8Jp-pnJvs2CE1CXy2dD z&6KZAeKPw;c3w)b4ey!>y;ZGMo0ZsMheYRm*Gp#YxHa!B}Tx&}% zvG4!#3i8lj?_v65eW9xaJHbx9o?!Rb4sZ~k1@>-l1?#5OnO}HrLHrfiuA=T8c#nE) z<`=Zn!FtSZNbhdSNEYWG#OlRy!u#O7*oS9mH`IdvmS4-mJ#?b`Skdz=Eh2Xz_%|xm ze{9V=@A3JM?SZsTkN3eQL3{dw70gciM}5c@bJG68Tpp`mK60@YWS`>=Zu9T|!}egP z*D4Bo)$2FtW^^&I*?b4AVpjz_xe~#bOeyv^-K%ere{IP0Y*dH~QHF~Ajcczc!V6U@WptBFUC8x91juWC2~B)5#uddjK^p>UL(eH$k$>dum1!OoTk(9P!MVE5v4^2E7d|NaZ6Upo=(yL%(O)iMfoP;f1UQIF{Vt4G|sDPU_G6{2564fc1{qGVuwG}C|c>cjqtF8-4B-8uG; zyl(#kyMsQ3y?5s>>$}P9Pnnhpk)Mjq_PVW{9BeOFrhUfu$m42-9G}O}!1lUH!1Qju zM$m(CzR;fI8SbXsVAHQDbk(UY`Ai$I?N|%!e9#db%x{C$sGih6D+0Dx`+&VW)b)*i zv`_<_&`G{#+aEZy@VDZNZUeV}JM(Y}O5jy}90tJd63M z+S9;6IT;>*FWBEV4D2*MM*Awg$hp!Xe%>l8FlFq$^`l7JEb8-(@O>cqp_VWwm8jYF%&Qr8sQiu6RziYv3W|Oc#?)PK- zzIjy=y1Q{3bU!`E5A6I2VCQx==0AThSVzVSUJRwalKoFJdJ$N~W`EbqNOqgDKkK|Z zmFcJ7XZx#0N3h*_FKmxhWBTyh@Uxc$n>8F?u~R;#KJ*pr_1J=7Z>GZeIoa}n?d4ct zohUWa=ZMGaYn}wG6D0uqPj29Osd4O2>p1@dyLUN0r5oG_dnYr(-X6LG*4=nNygRGO z6W@pK-Jc1z+u8s37c^)3(;UC@cGaPNnfd!Ys(|J9o+KzYBK;?4(s#()*jkv&_s$#M ztHKuxpxkKif8~ZQz6+Xjry1J!CT#aQmr8(b{VmY#?t<(O{IQ9g!U5}I>%d-z55em6 zYOuK#n|lAnVCUn|UuyjVPzG@1UN|EXfsHp5x^8fVehSP$}+Fk4lVpOV51>b~BVE*DJ^Szp4UQ`HjKOR+jT-*D$cX&>Xt`WG?Ujv@gLX z+Z?bO#&XR5O1}%$u{-T6`P2`y+}0(ZgZ+3zsb{C3h*#=c=2xA5A(3xE$GQW1+mL!t zF7W*<$Z|dMew#Ucnf_K8=x(XrWL*X9f6RKto%Ag^G0Sb+cRG0m$C;d;W`aE%meVaq zQ1@J(Z~6XU{Z|vPv!Wl^x%~y$`(YH*&nQp(O7ySw*J-e6Hw?O+S^}&x)Bn{g$a-2A z?7{pa^>)cH|D7C{bFcP+?)zaopx~Fx?@4y#=l5s?Hm|aR^|Ln2FH;^Ke>AVhmdOux zMsU19&!Fx`mo?G##wzCT7vB%|MlwI|J?duP2RvTxv$W5|a?@!-e^!58SPp9X3#)Og zC)}j1nBPo}gPNVK!RidlY5P9!kN1@CukFs~;a=kVuUjpl{XeW%ybAMq{P}<5dr)U~ zf%U#i{61DJ1AF&>2isZn54P=&f%WRIncrlNTj<|;f86o=ncoUNPg&juLn5&welhB8 zeyjH46t>B(3`SZnV;i>jYW`ojZ3`~rd4#t1;Zh!_*L0>Wyb$bX-wIaWEC-t%r@_uS zmMePXIogld%=C*7)4mqRL)?u=z;^I9=uYfEX11^awn!=AUm zs()r4KXNZKl_z&+dq5W)3icW?Kfm-+ur9{q>D(K^&caaN7q-uy^L%ZMThPrrr*S+p zEiu{$D(Vc+Cv94=U+X0KAz7U{0oEzlp0lsQ`*SD*>}~Gd)CaRYqCR0cZ$HUFeK*-# zT@I`p^Zu)xRjEH@y{u|~LjCVwke|~eFL@>FVV#J&zh@D2e|BBy{v!{JcP)6${Lyom zK35~=pJy)E{=@c_t?&a__0CRx2J1cl39nCmznieAN-cbe;yaCs(c3y+G$|(&RDSh>@lC$4zgZzlFz&U zH0F2s0`&*H9$Vu8c@6JJ;O7BWQM`V)&3dNKIg{xhZy*<6z~gl?V1Fs?13w3_dCqo^ zcfT?1x6OdPcc&ZJb_?4LO}bJ~I|90C8NQ#-SQhyG7BIiCY;aw+ADyj3cs_dvL-#5% zy`A5M+=lHK-(i2olnC1~jcZchLN?bcfc>RpJM$B;p33`gZWSPZ$o%!?bYL}%&)56m zEWhs@d_KDPa`HFf^WU+a{8890dhsLJ#17km*QbK53Ga83g=A6Q1xs7SeH!+Y-P#;O z^!q(z864@`?B2z7%VzywxheZSR`iQv^qWM#O7^=v(JzzzHY56Vvfn5Bg+}xnWxp~; zzw`Sstbb3`=W}Q^E3BXEfrItczRs1>-L`y=-sz2C_4p&&f3OQ|XQl?bx%Ps+ zjO@pIBlm!VI3PS1cfd}tTjB+uW4j$-Rp$nuThA?E`#Z~VHDNQ@?-E6Q73alFRoa`; zKQq6&k@OrNQr9oT-Wj=)`gqnOHWTOB)R7(3H?4)P{$30APOk<#E2n{dpZS?moHuY@ zErM>eIOjWT ztp;Gzs~qyPd%BayRUrR39_&@D#pA_Z33l>_^A)T3zN;tnAJyrL;(M@pSk{=V?59V{ z9yPTS^$WB&-58H#M$|+8ras#p#;ZYoIT7}z1X(|4xo%tVe4M^(m|vapuy-zT9Kmib z0ru~by^8t4woE+KdtO2M8=CTQSTCv^)W4#=DarXvX9U|Z-i?gVO}nsOte7&)Zyk>B z%}4=un_nb%qyMLA@tiy{8SMw<#_`;Zq5o$_*7M%TS9qV*^2*S4-&iP~;U6({xBXu}lY}0N6n_Bmn-^=-6XUh}v?nzAF z@DW&jJ^<`bcna2ud(nOx?cG#)$vwjP?6FMm=DNlF_DrPSxC8c@XQjUK zHrTn80qmdSd~UFQ7TE24nfb-fM1B7m=69wx^?c{S+H?i0Gt`}dgK6LYAoZrapZ4k@ zuy>$3?Z>hHFr~QerJp-2?@sdkypyay{Pd}LyeRrTsO8V_e4U*v51rvJz+SO)$lpeB zT~BZ3MRMA6v`>CDWWFEXOdssJTbTYP**P%{Z02zO+{@SttRFka)FE?o++BanWk#@2kas%mAmVD6l)+^+-1;`V_`u3lsVAGHH zM=9ES1zEr9!PTLAleZ#$FkcCF6R%7W!VC6coa-CDBXb+s9y%~q^Q=}~yj#DQO`pa)c z=10P@gveNc3H!V@y3ZFq&t59}gXPc9w*>8D_aN(iJCFV6h<}0IMcvlOiF!b_r0(T< z!+N;%YNU4(J|#BF9-`jKj!r8ZnL|$9b$62a@ANavaHC4#$!9-No~9 zbA5>S$ZUB*&X(a^9^3b4^U5<;~ZCYvXuh=JJu79PqV`X91? zBKt40f8&V$PmKPN>_7GVZ~rPr|4a1GV)Wlc|IUd1pX?vT=s$}7r6c;EvVW>X|20Pc zR`h?3=pW1evz*seV&2yg^TKl8Sk5cUd1pBbPpp_YxXyY!vVP5aw*P~AhW1a`pVF!3k|T9X z=$jnFKUVn9O8;6b{BLFblOm{-BJ=o>HrfBp&9hAkpV{bo?EmctE!wLlHf^1if8o6S zrK{NfZGMQ?F*$7CR$K$Nuc_M<8^PuQbz7+$c@XE1ywn}Ry7OA*w{ajj5&Z;A$qr=U zS0LxXl$a-z^JsFOEpjhRI1gt<`!z=UR>s2I`Xx=m z_J{4Zlw%g*7|y?A9??Fs(fc!03jU&hL2#c6eWLC5#T?hzIG+8uFb^|-4cPCy5W3YH z*pItSKUIBxHCQE|%W;fLvuOXw0|(kd+1NInfAJT59XI|4v+WC5U|e0 zI8ODO0Xz35Q-9o>_A);)j^!?)->@39o9*AV^b@wPEm)sz$^0Ju2KH_@1?zKM7f82a zdfSilJ;54$(9MLmaeOuqjX7CTPg>n?yh6$o2Wzs`GgHhC}ynaNNy)M^;gd zdHiWJq3bivnSYK;g_z3-?|ol?b7dE`o&AXc{vVf_WgI9 z(8L%=495w>aYi`~`R_Lyj#J8U%oyXGVjR?yYlE6`=c$Krhw2;7>j&%PF#Xhv(Czy@$-hz8mm86b zb6mx3-h}-3QP?{pxE88g`ykkqB%6wiTXFwp+?2n^LU+GPgY;(acJli7!0JoR<9l6S zBR;_9W8D%_9b<_h<*r8llNio9oUQW58_6dem?zO{Onxo)@BOXi38mX zIs|)LiEHaR0}ha9?WMo=gk!uPe;fuo1NgkmTE_92dVJpgoCWm%zI&ba-!2Awzw>=j zwMT+&*4xnin)DwxS@?d~%7dW$OX)`v%nvZXoPWXIS@{Y1=ndxob1JauatW-PzGgXk zn(vFZ>l!(Vx|`%WxeU_>@gn5qp^s12?O;=w<3uL?D6n__DUaWzIrZ;jv3;7LJ@uJ! z!NL0o)>~tPy*o9*&Qgv`xtmH-Zy%0xnbPFLsbL@aw)J89;kvCqf$n9d|COgJGQSqo zgSC0V?j!1M^I7Cy(jh;m39rW;kPU2hK4SV8nZdeXX52q-YgQh=M-{M)3pFBcRK}HB z5qBCRE>*;>%D7hN1+OQF2g3X4h`3l8H)};)t&F>sak(;X*Dsd=*K5PLUN1)6@5j(1 zaltZf*b{NZo{T#damg{_mPK51jJRhJ7cJwa9T8V8>EUnN`@bwv)AORI;Y|7El03d^Y= zZIDbqOUrU)#Ax!__rR(@{XR{#w`squ3Uohfa_4LGgdrGdyC)VrJay>t}-k(?x zP|5WIw~ylar!59QZj*To&%Z+f`gz}&NUl{BtjA6R8@DPs=S;9}T@h^O{Xo5bL8fms zf!yFj@}E<{!TOQx5HxU$;(iGvw-ObGKNB}T}ECKuE+V^ z&rJX7Gv;r9Vfvbt!M5)j+CQ%Y);TxOzFWBdXEnZ0s!j#kZ=tRSaXnAlZ5{1@2-kBg zM%LrQ<9S<{|KgI&|5$juk)MK9_tntt+Wh1Nzk$^mJ|A0gKRFlI1J!Adkn3i_$PYxDXjPBI8O#+=+}!@xmCMNZg8yYtbU^MaIQM z;%FjqGZBu&)yTLTCE{|-3HtM@Y8-b}N5LKsTS%0Q-I0gLR(z)T^`wd#S5} zZIVzA)7xE5pxYW@+{n`UA*X}AiTwrGB=`udi&dlkPj2RysXW+gpPBlclC&S4jl8`m zSS>CI_SzHx2Ywo0XFwkExRzj9f4>{_zrC;>5Qz~8_QJ!xh@>^|9HC#sS3yM@{$xH8 zTQ@w8JP$3-Q;X{ed?#?8|6ZrK5Ar_w;y%jzET4lC&nd=p6wg`9_dvWS@;%b>JrnPt zd{5nKYg)v&#fX0s@o~P0pOf)*k#Xoq{9WW-h|B?KInFM|;f)xlm*e}RANtj|dMbpxO~jXkhlZ@})R*`v%L``KX}MQ*Zc^ci%&7VXWuj4QYGBlScs=*r>oZ1wcCf8-)RC)WGqjLn#Tvy!xL z*$C`AWx-zi24FjsY?@W3{pzgH^>3BH=ABGTf220;%UtL4F2i~!@I)c+q3)(y1=g$T z!CozzL;WMxW9k`W#PsY?KlUwj+qN!`x1&v%Ukz{&SIqqUs^Gw%5NxKE1qc3{;zj30~01 zPx^1Ir2kjMPeJ-ISP_ry$#`uM&#gtgw~Pmu@!~R`T*jNrcyuG;)nz=pjCWTe9zI6A zyojfl@%CE80uoHVM=g-nz=W`p@iSuPm!*Te;p&xGlGth%|exTcz zCz!r5=R-}sV_>(42VEUL#QdV4W$+C3oIOlGl78k^#LGpV{lD>aBHm8Mlv81Z}} z-cQB@8WArj;|XQFp^QgVB3@DY3rc@N>2E0gYElR7%kJTK5!v&^%;z3TI?<}SHn@j& z;@rYIdJm33?_TiIJd1FAG+x}knh?Dm%w@l-&NJ&DD?|nslTiPf>3+hTP~J^%Pt?BiJJdY_E@?p8O2hw42Q1 z6+X`N`^SNG!F{xkexA|yyNIQIQrg>$o5AXCXQq#{j(WB(v`@O0>7(+1RTaJ;dIw`W zZN{Ie*LsWTkJDZiWXy>zvXS}EKFvDsi{0R0&nec41CB8LYsN|jdlu3DX%XnA(4Vxo zj6t(oLcJ{OO!p|+t??)77}ek+?eCo>e;TIWu@`JMlGV+VU}qlfy^-g^wlrC7zX{f{ z_`Fr8d*n`k@O&$UzP`0C^LWh;Gkv$~h=@1p@ThO%{kIwK3Sa18A`Gso$sI}qqd9V!Sk)F!(#LQ?9R&O4{-cID$gem!$ z=X;($XL?b{)mT2Nx1Leo#IXW%nYwvZi}|g1%KU0p2HQL@XrCqY#rim2JsW)2ku@N6 zN=5FR+j+9nJD!&L--E#)EB=usm88>S6s9>`}+` zD_Fkh>5a(Zcxi&VE=Q!Udo%&_Ymqp3KjT!kE27s>kM?C~8T^GmId^K-#pB#vR3^-2 z+C|}9>;wnwXMB#l%mf8iQ7_0vqu_I+GlVe$JLse1rC@q{@Gx}ykZTTj-DZ<(TtWI^ z&la%Cd4c)mU~HK#a29O;;o6Pffg@mDs5|VP${Wdf82hIG{)zV0J2Jm6i^0x^oN*$)}aE086=~cedVC(YuHqCjkcYYR+SNb=wo)g;l+DQAj%+K$! z`9JIo3Vr5^hWFzfee86)r95AsK40#5<`=B-jPx*_2}}r1MUFe&1zU^ZWUrHp_~7J^8&vkxhbc$*KXSYorgNx|;#xmJ>?+vS=?q;x`x@+Q=?%6e2ZHtCZ@}(FruPaD2Rj3IK=(3pt)gHJ zY^Gm14tk`#vEAtl?cdFS^2d#obt~!1p;}QlZR@hUsz(mye8JAjp~x>78({hM3(rqg z`=0s5>k3_cL|+eeu_M^dUjyCS%Gd<&27O(ecdA0yakwwMIa7+9xXu5kuZQ#nafGjk z^d)hnuZi$QafGjm^ktF0E?WA+2wxdlAEXWD>Tibiir2ge_w9)IcZU9y*w-VvUil$X zs|5cFUrQr=F{Q7j6~3HW`g#gqQ0XfweMzOSsS>`Z(pS~b*oD5TpE1VRw&NPSw$>=V zhn0I$Pp}khlX8t+bLSXXKOG2NZ94}x=LXY$_wUr7jUneqg7-)lpHBWHFWBapNiLd) z+>O4@YE>I@{a>J)oeRO<@0-b8|0KWQo-X$NLU`{?vvbUEL1}Oh%NW`Z1p7Dcf%S`_ zVDHo=a^m`6xAs-0Z`cB?S5h}_W3cM@Cv-KY71++WO#6JpY5(T}3`#v5d1p!@B^ z{3p^U&8)czU3*+3)m**>HWzumruRQ!yMXrImIutQ4%f~%CtgtBGoR-dMcwon!Sge3 zsOMYA^E(rV?{c1faeGPlFYd2V};2t>kr@J`E}4!#guN4kZR!_1-bZhd zA3f#qdXd$bxXiC-BIcKe`J2oMX+J3$bla8Zqdod4dM|iAI&&=OdIPV=e)b;ilZN?k zpbw;48|J?>J#>{Iyq@8?z-HWgIG#G16YTFHo1}$k@9=u{{=8tPa(Mj*OEP_l)I9(C zWobW@dj_d7S!kc1tk;D3JxTu`dow)`SU+e4dwV!5&!=Dmu-?Z#==AeeJ;QWxr($?7Qg67WWT%HwSq$NX}04?KNtFzqjMk3F-i zCs++D5!!Pv4gH%22k$@auW*mOV67dnep-R{t44sGg=NWSCeeO>Y4W}av|q(N`PA3k zn?vU!+v`)I+alrlP5TM#zb?e%H$TMu7V~<{?KR|j<*4@w)9Dt^@18>w{JQU0`Pl z)9XzusDIdq={xLX`bb??gL`VJ<)L2uB6Rz0W9I*J9QYjDc07MGxH^51%kcQBc6PAd zR*m+**P}j}*Qd+ZroOK-kAJ-a^`hbZ*1I!nDgt=l5F}cT> zBlaNEVvjPphnd{tOs**}*PNGY()(h~dS9+-FV?)5YvNn6X1-igUx_vM<(m9*&3?J2 zzc1GOH|H2j^Y5MjV$T4%r-0mZK<-H(+hgg1cHOP8UFR>}*~A7-Hk+^Rf8Uh}T4QYd zhp=52EYuzS(@#^v-pt=oLI-TpX94T;K3IM5KJ|=`$w$aRd}7IHd#_YR=ypL~u#-Op zSpBBK?#;K!bF$L@d=lnY{RQ%~cc|1?#HKz~;g#usXuJKowX^y|D}3{>uF^ZKf9BVEt6)SFRQH!&|`q z1lp@bE1BO%?P&k^FU)U!C-S8*UdQXf^h3EHrT;_!kY6(YUVUhv;vP8g3kB;3=@?&> zbQsu-O2c@fER(6*>|lTN4`i<_*qiHt)zr_aPnbo0e+_Uj1_d?^T2k-+BlUNhft`B` zz;^j4uvxQ&{CF`qh|gjAgDb#x@FJ$)L^kIZlGAUb{n`0ob?;Z&_X+L0Y^NS;G4q>u z0<7Me2e$eQIC4Ga;2%sskLj&*mFW{Pz0Glv`usIK{^eU>Rc1Ze{zdyUzwmgQ?@;eZ z-45kGcRIx;+Sk3#{9cCXpI-x;avP!B8>g7x%I#pa@(Jzx>}CGuAF!%&l-xBL%d=vC z(EdzqmVehSkW;h(t6_J@PkVvA^LNR!r;_Ks1e=#T!RE>{uwBmb(v*KfuDl((v-L6U zHy@&X?AKsb_7qqpPr&kd70Y*jbRw{Q^c1?CM^*zqMEPwiB%^&3miK<&q~y=5QSZb0 z#Gb6n@_yvI%x}*ZV6%y=A5;PB6ltNGc6Gq2Ogh>(Y(e`hX}~&*AwOsRq-L)N+des& zzRwM?9-Eixf4xO+m5+Mc!lh7OG%rN`dIhjb^9fkht_aq53xl<-4>tR$o55Ykh09aF z^)uL-isV7Zz$yoIo9qGD|2fphrzjnLeBHPlkEaw^tt|t#Lq8_xt3d8voc8G|gH1fL zcYwP3yC8JCxf1OivZ_*p_75vFzb|Wnb-i-T?`}2fT}zP*)TF+tB-pHJ2UcG<1lz1_ zX(Iey|MSfDr!6RPAPQs^N6&U z)C>n~)@`MIp1joWZvp$?m!RHtE!al4r-Jl$bjS@$ft|Q@p}Ujf(SGKc#x~lndlwwv zjNc9RuGa;7cf#_yLp`u;-=q)X@*{q=&I!gm=uIW_M;}}H+c=MPauMTeYDND~{_Muq z^=nLgGku)5I;>|Wgnw)K01z5i{e z{=qk38?}x4L&i6#(nV2(Y=99UQrKcXVN} z9?s+I#ns5$`@mkM_>6qCJJ=>G3%1pHJ;7KqITP=X$`!5?Kd2Scw`xcI)z@IXzXn*n zp{}cS0_$UyY2TT1nl@fl+IMNr^xswloBCfey;F($j(SW#r##cwZcF>C)YYOcU{k(0 z^$)w#K3#sMFF6{l-pUO&eWy@AniFjQ=nS?M$f_9q%*=~i)F;iM{j5yPFZ$gH-V^&W z9l8Ec^1*~)lZ>p>CIScRSu_2r*Y%>`FFhtMIH+gHV;}JOroIXG+LP_e8{lAFS=ieo ze}Mg-X~BBTNw8bwZLpK_5c$e8zCXA4uDkXL^N+my@15ZL^ECVx#(zd#T}1kSzm?Nx z!NGnr)T>+o2kRt)U3-ao@3zdZzYlh+_M!dcTVUI9FxU(!5- z+jkp+&9s@!e_adeg@#ZUu_CKm}goIB7}nOScN{zqaeZ=6N4-^_kQ=g#OdJ!u4q1 z@Otz}&b8$|~T37-S$lOTN-q)&tNd5}I4 zR`^Uvp9<-7A$>BW&xZ8rkUk&(zWbq1h@2yo@%WyI*EcerU&i~3^#GJuFF?ul1mt=H zVm$)6UV#?t8ECQIfm{zku9qO!Q;_Q|Xt5rHT(3c{=itX!@8JO6r(nNXe&1rf2)Ukw z73)pN^(f?e6>>cbE7rU4<$4%my$rdYMvV0~#CjZZy$-pahg|PNt_Kohy%4dUh+J<( zi}gsfT(3l~XCl@+k?Wzz^-|<|DssIQE7oI?>$S-BT;zH$ay=NiUW_N!lhI9$64;qPfcgRYWa&w@z-r$g)KixSyU*#P z<-INdw(nCnbrXQ~hv#7LUVP2*t=DJC_3ndJ1^T(G{uelYHH+`R*JCo+J4p7|eg`%K z_aeO?X8`q+WVcO6u*&!=bXBl5*v+*WY)Wyx8mCXVo=jYq_FvLR%zaW4?6+P7duK%% za#@z=?(~ApFYavU-k73HKWjSq9_N1CqV%uRb8|5LOV$tme`?sNHOT=$lc{-9wF``_0ahS2m!1d$QA#?C-b*-T#L1 zJo@vyV7(-a?@9RtEZavJgEr3Hu$}eqnzvyrTqIV_MDL*z-OfrM{6&5uZcN6N$+$Bm z;?iW?nh|krO2oa%xHu!?<|60%Z(LpM4ty?=xVso}d2H82;`WS;>l1N*GA>ZY4aSHo zlyQe*{osG^b-2E;Tz^>ZM|Zx(Jog`JG9%~jn$D>i*+V~ICZw`!*wX+Iu&vq3oX{UP;wm%u}+2->uAVzHsm@S za-9yjj)z?5L#_jˬtRrH@IwNu&5-rv#(PAAFxz0(9bx_1QDO#+fBG*}w>#!)X zPK%6Rlksga;@?DkoR;x(BEHUw_&XV&C*${wi0{)f{!hdQ%J@Mo;tSQD8Z0lv_(K_= zDB~BEjBk|jk0L%&$@obTUn%1+WqhWL-&7*L(--ldzK9Q%@uM=nG)DZXh)JWN@0u3-vdMkhjM&%Bh<)F*+!s#l8z=Xbll#tDu`ivL`_|1E!}daCUpukyo!l2s z?wcp~)w5#Xy%_uQiGBOzzJAiDUHZIBpLivF=56R>AMvS=aKz_c`s7QWed*J$gwKDB zm;ezoAY%#~5py785@gJRjA@WD4>Be~#!SfZjTqw}Vtho7pJ*|@BFA51jL(Si8#%tC z!||ZV_>cON<3p-d4vyz+=lGdQ`y4S1X4;o{A9Wk9Yip|20jti8yH#)1rEa;-uU*y% zY}%G*OvPZ1*O{!0g|xfa{?*6(P!HD!QQN*H{~Wfr;~(Jh&#^sj^WGrG?#|<{dXMM3 ztuxqG{s+3c!FHrQ{1aF=W_w+Qv6nV$bJ`#NhW7vP{Ol*(Z%Up1ocX6b#@M5$Rlw%m z6^tdSl8anA2iPphK>Mi|3+kX5W;UguK7p}gdQ~E@9#M>Xmju*HeG0a1)HA-WAKkpOQOUr1+cWYfmkLB5Pv5-{YDoV4L(QImHfgw#Upr&jzNS!sFRV+sIR|QIESEtZqbsgYi9;E$t z+N+geesd1fKJj{{ud)lQ?#%+5!aJD%#j(t<{x9U6T*pqQUr62*iKUwZw%=uC`W>Ue z>TCh9oaZuP9!$=YDKU>G=h>{7hf{K%PR`?rc|JK0Xv93Bk@JXRo>8{<-w)O|$QSk- zRMgCR(eF+q&N&jtY^n$GOVRy?%)wvybFWW>t=sx6-|N*=z`?%WU~l_$u=kStyhZX3 z{K%l|v_JeuH*09Ge}dkYy1G#W&a1ZEyHrleL~J2#%Nc*3s#-N813GFQJ*-7$8#97YQy!#_1!S0 zv^HbOBG1YTW6otvx{O)(_cY@9USCu&`h4AEgTdaUfw=$bqhVm%@hd)$5o5u+8P`$K z#m3P7z*s)d0(^e<;25xcKb&B`ClW&$SzFtNdzAgVX6uRUpW;0m5}Z)vC-&=-`+3Rz zzEl)rpw#CXIbSe~F-fL;X0Z8wa6=p9?F`ajdpV4WN)WEI{*-KAegWN0Fc$Wc-5k#YE`AdOl$P++?udmoZx2=~>k4)T90*_e%@b!zGto0o|$lF4#-Ho}4X; z@68ah-E#u$i2c;$erulCk4^5^Ciiob`@PBi;N*UBaz8mO_M3~bAD!5*&Wio)g%_`}N8F{G1s3{rz`8K)GL_+)vOI`whzd2<3i-O6+GS_dE2( zeu#3vL|5#m=*#^U<$jD}zeY#w=NMzZN3kDdjQt|Tev*#ZZ&L0@X~lk(az9JC-=*9S z)5`ra<$juCzfDK($0_#fl>2!`%A&}ApK>1n|NFNaMVA-B`eOWE|4ah5Dc;6>u6r>N z^)Xq%CR=>4|3Lw;_a-hlSg#)J-+#gKVC}>(J@*ea6X$}REf1iZ&C9|1!DE&OOMYeg zgxv2_4ZBGDuc@oGDLJ3rjr&8o8}pD0a(_=Vx&qi{I*$C@D_pl$)fKvvocrAb zs_!?}k$EUuB zF`?$#U&!C|YYp9BdI78xwFRqV`@uFXb(MJsc~BGPcWWouNzNEtUFZbZ|Go~>*WL%# zrUvc190jXArNRD_sZ4+36R>?a1N?8@6dm6moWG1gl`*O^hE>M6x-te<#K_7RT3^K2 z${1W3qbp;09TDRzV}NChu#6#=F~%|mS&10s7%|Ku##xCNXh+0I%NS}aVyyoYgZ=*i D^@9lZ literal 0 HcmV?d00001 diff --git a/docs/user-guide/viz/weighted.shx b/docs/user-guide/viz/weighted.shx new file mode 100644 index 0000000000000000000000000000000000000000..82ebeaac1fda052229f6a7caafd6dd68a323929e GIT binary patch literal 356 zcmaiwzbnLH9LHbZ@0~kcN*S(0$&Wf$x;herI$x1nEOd%GI*VBb^9=?WjFJrU50DH- zqtQZE+hvdplF92Sqw-l^&-;15-=Cfy7|rqbT(?uu@#{U-HtswoFTLd?Fn75cbZfqm z1pVJk7RM{%KT!t*U Date: Thu, 3 Oct 2024 16:12:24 -0700 Subject: [PATCH 11/32] Contributing docs --- README.md | 2 ++ contributing.md | 61 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+) create mode 100644 contributing.md diff --git a/README.md b/README.md index e099d00b..7a6550e3 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,8 @@ Contribute PySAL-inequality is under active development and contributors are welcome. +Please see the [Contributing](contributing.md) instructions. + If you have any suggestion, feature request, or bug report, please open a new [issue](https://github.com/pysal/inequality/issues) on GitHub. To submit patches, please follow the PySAL development [guidelines](http://pysal.org/docs/devs/) and open a [pull request](https://github.com/pysal/inequality). Once your changes get merged, you’ll automatically be added to the [Contributors List](https://github.com/pysal/inequality/graphs/contributors). Support diff --git a/contributing.md b/contributing.md new file mode 100644 index 00000000..f7278413 --- /dev/null +++ b/contributing.md @@ -0,0 +1,61 @@ +# Contributing to inequality + +Contributions to inequality are much appreciated. + +## Steps to Contribute + +1. Fork the inequality git repository +2. Create a development environment +3. Activate the new environment +4. Install project dependencies +5. Verify installation and run tests +6. Build documentation +7. Submitting a Pull Request + +## 1. Fork the inequality git repository + +- On github, fork the repository at: +- From your new fork, grab the clone url: +``` +git clone git@github.com:your-user-name/inequality.git inequality-yourname +cd inequality-yourname +git remote add upstream git://github.com/pysal/inequality.git +``` + +## 2. Create a development environment + +- Install either [Anaconda](http://docs.continuum.io/anaconda/) or [miniconda](http://conda.pydata.org/miniconda.html) +- `cd` into the `inequality-yourname` source directory that you cloned in step 1 + +``` +conda create --name inequality python=3.10 +``` + +## 3. Activate the new environment +``` +conda activate inequality +``` +## 4. Install project dependencies +``` +pip install .[dev,docs,tests] +``` + +## 5. Verify installation and run tests +``` +python -c "import libpysal; print('libpysal version:', libpysal.__version__)" +pytest +``` + + +## 6. Build documentation +``` +cd docs +make html +``` + +## 7. Submitting a Pull Request + +If you have made changes that you have pushed to your forked repository, you can +submit a pull request to have them integrated into the `inequality` code base. + +See the [GitHUB tutorial](https://help.github.com/articles/using-pull-requests/). From a4e7f9c245ad8c43f10b906fc3c04a7fccb43494 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Fri, 4 Oct 2024 10:40:20 -0700 Subject: [PATCH 12/32] DOC: Mac OSX and proj instructions --- contributing.md | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/contributing.md b/contributing.md index f7278413..fbf45f4f 100644 --- a/contributing.md +++ b/contributing.md @@ -40,6 +40,29 @@ conda activate inequality pip install .[dev,docs,tests] ``` +Note, if you are on zsh use: + +``` +pip install '.[dev,docs,tests]' +``` +If this fails on MacOS you have to have `proj` installed: +``` +brew install proj +``` + +Set this variable in your shell configuration (e.g., ~/.zshrc or ~/.bashrc): +``` +export PROJ_DIR="/opt/homebrew/opt/proj" +``` +Then, reload your shell configuration: +``` +source ~/.zshrc +``` +and check that `proj` is correctly installed: +``` +proj +``` + ## 5. Verify installation and run tests ``` python -c "import libpysal; print('libpysal version:', libpysal.__version__)" From 3354455ace4e5b9f7ac206d4e5548157174ee4c8 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Fri, 4 Oct 2024 16:03:45 -0700 Subject: [PATCH 13/32] DOC: update test dependencies and instructions --- contributing.md | 2 +- pyproject.toml | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/contributing.md b/contributing.md index fbf45f4f..12a5cf80 100644 --- a/contributing.md +++ b/contributing.md @@ -66,7 +66,7 @@ proj ## 5. Verify installation and run tests ``` python -c "import libpysal; print('libpysal version:', libpysal.__version__)" -pytest +pytest inequality ``` diff --git a/pyproject.toml b/pyproject.toml index edf86bdd..77f17ad5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -52,7 +52,9 @@ docs = [ ] tests = [ "codecov", + "mapclassify", "pytest", + "seaborn", "pytest-cov", "pytest-xdist", ] @@ -88,3 +90,4 @@ exclude_lines = [ ] ignore_errors = true omit = ["inequality/tests/*", "docs/conf.py"] + \ No newline at end of file From aba6ff8c38dabc338375c6117adaeb3239def608 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 16 Oct 2024 10:57:14 -0700 Subject: [PATCH 14/32] New interface for Wolfson --- inequality/tests/test_interface.py | 77 ++++++++++++++++++++++++++ inequality/utils.py | 36 +++++++++++++ inequality/wolfson.py | 86 ++++++++++++++++++------------ 3 files changed, 164 insertions(+), 35 deletions(-) create mode 100644 inequality/tests/test_interface.py create mode 100644 inequality/utils.py diff --git a/inequality/tests/test_interface.py b/inequality/tests/test_interface.py new file mode 100644 index 00000000..cd7150f3 --- /dev/null +++ b/inequality/tests/test_interface.py @@ -0,0 +1,77 @@ +import pytest +import numpy as np +import pandas as pd +from inequality.wolfson import lorenz_curve, wolfson + + +def test_lorenz_curve_with_array(): + income = np.array([20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000]) + population, cumulative_income = lorenz_curve(income) + + # Check that both returned arrays have the correct length (n+1) + assert len(population) == len(income) + 1 + assert len(cumulative_income) == len(income) + 1 + + # Ensure that the Lorenz curve starts at zero + assert cumulative_income[0] == 0.0 + assert population[0] == 0.0 + +def test_lorenz_curve_with_list(): + income = [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] + population, cumulative_income = lorenz_curve(income) + + # Check that both returned arrays have the correct length (n+1) + assert len(population) == len(income) + 1 + assert len(cumulative_income) == len(income) + 1 + + # Ensure that the Lorenz curve starts at zero + assert cumulative_income[0] == 0.0 + assert population[0] == 0.0 + +def test_lorenz_curve_with_dataframe(): + df = pd.DataFrame({'income': [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000]}) + population, cumulative_income = lorenz_curve(df, column='income') + + # Check that both returned arrays have the correct length (n+1) + assert len(population) == len(df['income']) + 1 + assert len(cumulative_income) == len(df['income']) + 1 + + # Ensure that the Lorenz curve starts at zero + assert cumulative_income[0] == 0.0 + assert population[0] == 0.0 + +def test_wolfson_with_array(): + income = np.array([20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000]) + wolfson_index = wolfson(income) + + # Compare the result to an expected value (based on the example) + assert np.isclose(wolfson_index, 0.2013, atol=1e-4) + +def test_wolfson_with_list(): + income = [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] + wolfson_index = wolfson(income) + + # Compare the result to an expected value (based on the example) + assert np.isclose(wolfson_index, 0.2013, atol=1e-4) + +def test_wolfson_with_dataframe(): + df = pd.DataFrame({'income': [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000]}) + wolfson_index = wolfson(df, column='income') + + # Compare the result to an expected value (based on the example) + assert np.isclose(wolfson_index, 0.2013, atol=1e-4) + +def test_wolfson_with_small_dataset(): + income = [6, 6, 8, 8, 10, 10, 12, 12] + wolfson_index = wolfson(income) + + # Compare the result to an expected value (based on the example) + assert np.isclose(wolfson_index, 0.0833, atol=1e-4) + +def test_wolfson_with_even_distribution(): + income = [2, 4, 6, 8, 10, 12, 14, 16] + wolfson_index = wolfson(income) + + # Compare the result to an expected value (based on the example) + assert np.isclose(wolfson_index, 0.1528, atol=1e-4) + diff --git a/inequality/utils.py b/inequality/utils.py new file mode 100644 index 00000000..c7d20f55 --- /dev/null +++ b/inequality/utils.py @@ -0,0 +1,36 @@ +import numpy as np +import pandas as pd +from functools import wraps + +def consistent_input(func): + @wraps(func) + def wrapper(data, *args, column=None, **kwargs): + # If input is a DataFrame, extract the specified column + if isinstance(data, pd.DataFrame): + if column is None: + raise ValueError("For DataFrame input, 'column' argument must be provided.") + data = data[column].values + # If input is a series, numpy array, or list, no transformation needed + elif isinstance(data, (pd.Series, np.ndarray, list)): + data = np.asarray(data) + else: + raise TypeError("Input should be a sequence, numpy array, or pandas DataFrame.") + + return func(data, *args, **kwargs) + + return wrapper + +# Example function using the decorator +@consistent_input +def compute_mean(data): + return np.mean(data) + +# Usage +df = pd.DataFrame({'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8]}) +print(compute_mean(df, column='a')) # Output: 2.5 + +arr = np.array([1, 2, 3, 4]) +print(compute_mean(arr)) # Output: 2.5 + +lst = [1, 2, 3, 4] +print(compute_mean(lst)) # Output: 2.5 diff --git a/inequality/wolfson.py b/inequality/wolfson.py index 9c77fb92..aeffac14 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -7,64 +7,84 @@ Author: Serge Rey """ - import numpy as np from .gini import Gini +from .utils import consistent_input __all__ = ["wolfson", "lorenz_curve"] - -def lorenz_curve(y): +@consistent_input +def lorenz_curve(data, column=None): """ Calculate the Lorenz curve for a given distribution. - Parameters: - y (array-like): A list or array of income or wealth values. + This function takes an income or wealth distribution as input. The input + can be a sequence, a NumPy array, or a Pandas DataFrame. If a DataFrame + is provided, the `column` parameter must be used to specify which column + contains the income or wealth values. + + Parameters + ---------- + data : array-like, numpy array, or pandas.DataFrame + A sequence, NumPy array, or DataFrame representing the income or + wealth distribution. + column : str, optional + The column name to be used when `data` is a pandas DataFrame. Required + if `data` is a DataFrame. - Returns: - tuple: Two numpy arrays representing the cumulative share of the population - and the cumulative share of the income/wealth. + Returns + ------- + tuple + Two numpy arrays: the first represents the cumulative share of the + population, and the second represents the cumulative share of + the income/wealth. + + Example + ------- + >>> income = [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] + >>> population, income_share = lorenz_curve(income) + >>> print(population, income_share) """ - sorted_y = np.sort(y) + sorted_y = np.sort(data) cumulative_y = np.cumsum(sorted_y) - # Add zero for the starting point cumulative_y = np.insert(cumulative_y, 0, 0) cumulative_y = cumulative_y / cumulative_y[-1] - cumulative_population = np.linspace(0, 1, len(y) + 1) + cumulative_population = np.linspace(0, 1, len(data) + 1) return cumulative_population, cumulative_y - -def wolfson(income_distribution): +@consistent_input +def wolfson(data, column=None): """ Calculate the Wolfson Bipolarization Index for a given income distribution. + This function takes an income distribution and calculates the Wolfson + Bipolarization Index. The input can be a sequence, a NumPy array, or a + Pandas DataFrame. If a DataFrame is provided, the `column` parameter must + be used to specify which column contains the income values. - The Wolfson index is constructed from the polarization curve, - which is a rotation and rescaling of the Lorenz curve by the - median income: + The Wolfson index is constructed from the polarization curve, which is + a rotation and rescaling of the Lorenz curve by the median income: .. math:: W = (2D_{50} - G)\\frac{\\mu}{m} - Where :math:`D_{50} =0.5 - L(0.5)`, :math:`L(0.5)` is the - value of the Lorenz curve at the median, :math:`G` is the Gini - index, :math:`\mu` is the mean, and :math:`m` is the median. - - - See :cite:t:`wolfson1994WhenInequalities,hoffmann2024MeasuringMismeasuring`. - - + Where :math:`D_{50} =0.5 - L(0.5)`, :math:`L(0.5)` is the value of the + Lorenz curve at the median, :math:`G` is the Gini index, :math:`\mu` + is the mean, and :math:`m` is the median. Parameters ---------- - income_distribution : list of int or float - A list representing the income distribution. + data : array-like, numpy array, or pandas.DataFrame + A sequence, NumPy array, or DataFrame representing the income distribution. + column : str, optional + The column name to be used when `data` is a pandas DataFrame. Required + if `data` is a DataFrame. Returns ------- - w: float + float The Wolfson Bipolarization Index value. Example @@ -74,17 +94,13 @@ def wolfson(income_distribution): >>> wolfson_index = wolfson(income_distribution) >>> print(f"Wolfson Bipolarization Index: {wolfson_index:.4f}") Wolfson Bipolarization Index: 0.2013 - >>> income_distribution = [6, 6, 8, 8, 10, 10, 12, 12] - >>> wolfson_index = wolfson(income_distribution) + + >>> df = pd.DataFrame({'income': [6, 6, 8, 8, 10, 10, 12, 12]}) + >>> wolfson_index = wolfson(df, column='income') >>> print(f"Wolfson Bipolarization Index: {wolfson_index:.4f}") Wolfson Bipolarization Index: 0.0833 - >>> income_distribution = [2, 4, 6, 8, 10, 12, 14, 16] - >>> wolfson_index = wolfson(income_distribution) - >>> print(f"Wolfson Bipolarization Index: {wolfson_index:.4f}") - Wolfson Bipolarization Index: 0.1528 - """ - y = np.array(income_distribution) + y = np.array(data) y_med = np.median(y) ordinate, lc = lorenz_curve(y) l50 = np.interp(.5, ordinate, lc) From ff62ba40c8c0bb55b1ebfb57f52e5b0ec2247cf3 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Wed, 16 Oct 2024 11:54:00 -0700 Subject: [PATCH 15/32] Support dataframes or sequence args in Theil --- inequality/__init__.py | 34 +++++++++------------------------- 1 file changed, 9 insertions(+), 25 deletions(-) diff --git a/inequality/__init__.py b/inequality/__init__.py index 662e40a0..484e1592 100644 --- a/inequality/__init__.py +++ b/inequality/__init__.py @@ -4,35 +4,19 @@ """ + import contextlib from importlib.metadata import PackageNotFoundError, version from . import atkinson, gini, schutz, theil, wolfson -from ._indices import ( - abundance, - ellison_glaeser_egg, - ellison_glaeser_egg_pop, - fractionalization_gs, - gini_gi, - gini_gi_m, - gini_gig, - herfindahl_hd, - hoover_hi, - isolation_ii, - isolation_isg, - margalev_md, - maurel_sedillot_msg, - maurel_sedillot_msg_pop, - menhinick_mi, - modified_segregation_msg, - polarization, - segregation_gsg, - shannon_se, - similarity_w_wd, - simpson_sd, - simpson_so, - theil_th, -) +from ._indices import (abundance, ellison_glaeser_egg, ellison_glaeser_egg_pop, + fractionalization_gs, gini_gi, gini_gi_m, gini_gig, + herfindahl_hd, hoover_hi, isolation_ii, isolation_isg, + margalev_md, maurel_sedillot_msg, + maurel_sedillot_msg_pop, menhinick_mi, + modified_segregation_msg, polarization, segregation_gsg, + shannon_se, similarity_w_wd, simpson_sd, simpson_so, + theil_th) with contextlib.suppress(PackageNotFoundError): __version__ = version("inequality") From b07a7341a688e71fe216a8e90863cbce5a4b5d99 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 7 Nov 2024 14:22:46 -0800 Subject: [PATCH 16/32] Trimmed wolfson nb --- docs/user-guide/measure/wolfson.ipynb | 252 +++++++++++++++++++++++++- 1 file changed, 250 insertions(+), 2 deletions(-) diff --git a/docs/user-guide/measure/wolfson.ipynb b/docs/user-guide/measure/wolfson.ipynb index 29f2d17c..885d66bd 100644 --- a/docs/user-guide/measure/wolfson.ipynb +++ b/docs/user-guide/measure/wolfson.ipynb @@ -7,6 +7,16 @@ "source": [ "# Demonstrating the Wolfson Bipolarization Coefficient:\n", "\n", + "The Wolfson Polarization Index, introduced by Wolfson (1994), is a measure used to quantify the degree of bipolarization within a distribution, particularly income distributions. Unlike traditional inequality measures, such as the Gini coefficient, which capture the overall level of inequality within a distribution, the Wolfson index specifically focuses on the extent to which a distribution exhibits characteristics of bipolarization. This means it is sensitive to the presence of two distinct groups or \"poles\" in the distribution, which can signal social or economic divisions.\n", + "\n", + "Bipolarization occurs when the population tends to cluster around two income poles, resulting in a “hollowing out” of the middle class. This phenomenon has been observed in many advanced economies where growing income inequality is not just due to the rich getting richer and the poor getting poorer, but also due to the diminishing size of the middle-income group.\n", + "\n", + "The Wolfson index is defined mathematically in terms of the Lorenz curve, but it differs from traditional Lorenz-based indices (like the Gini coefficient) by its focus on the distance between the poles of a distribution. The index increases as the distribution becomes more polarized, which happens when the middle of the distribution thins out while the lower and upper ends of the distribution expand.\n", + "\n", + "Wolfson’s work (1994) has been foundational in the field of inequality measurement, offering new insights into the nature of economic divisions beyond what is captured by measures like variance or Gini. By applying the Wolfson index to different income distributions, analysts can better understand the dynamics of income segmentation and social stratification within a population.\n", + "\n", + "\n", + "Wolfson, M. C. (1994). When Inequalities Diverge. The American Economic Review, 84(2), 353-358.\n", "\n", "-------------------------\n", "\n", @@ -31,7 +41,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABxYklEQVR4nO3deXgUVdr38V+bpbOQRBIgTQRC0IBAAFkcJKgB2WQJKs6ggCyKjyiIRGFQRIeASAQVGHFkXBhAGEBHxUdUlE2jPKAiiAI6yIzIZkIUQ8KaQHLeP3xT2CSBrNVJ5/u5rrou+tTpqnOqq1M3d5+q4zDGGAEAAAAAAAA2usTTDQAAAAAAAEDNQ1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbEdSCtXWokWL5HA49OWXX3q6KW4K2lWw+Pr6qkGDBrrzzjt16NChUm+vS5cu6tKlS4W3s3HjxhoxYkSFb1eSTp48qeTkZH388ceF1hUcnx9//LFS9n0hXbp0UVxcnO37rWrOP0cDAgLkcrnUtWtXpaSkKCMjo9B7kpOT5XA4SrWfC50HF1LUvho3bqx+/fqVajsXs2zZMs2dO7fIdQ6HQ8nJyRW6PwDwpIvFTf369VPjxo3dysoTK5T3mtu4cWO3a1WtWrXUsWNHvfrqq6Xe1scffyyHw1Hq69HFVHZM8/777xd7LarMOO5CCo7lG2+8Yfu+q5rfn6OXXHKJwsLC1Lx5cw0bNkxr1qwp8j1liS8udB5cyPn7qoz/O/30009KTk7W9u3bC60rS+yImsnX0w0AvNXChQt15ZVX6tSpU/rkk0+UkpKi1NRU7dixQ8HBwZ5unlauXKnQ0NBK2fbJkyc1depUSSqUUOvbt682b96s+vXrV8q+UXIF5+iZM2eUkZGhjRs3aubMmXrmmWf02muvqXv37lbdu+++WzfeeGOptn+h8+BCyrKvsli2bJl27typpKSkQus2b96sBg0aVHobAKAqq8xYoSQ6d+6sZ555RpJ08OBBPfPMMxo+fLhOnDih++67z2PtKlDZMc3777+vv/3tb0UmJDz92eA3vz9Hjx8/rt27d2vFihXq1auXbr31Vi1fvlx+fn5W/bLEFxc6Dy7Ejljmp59+0tSpU9W4cWNdddVVbuvsiudQ/ZGUAipJXFycOnToIEnq2rWr8vLy9MQTT+jtt9/WkCFDPNauU6dOKTAwUG3btvXI/uvWrau6det6ZN9w9/tzVJJuvfVWPfjgg7r22ms1YMAA7dmzR5GRkZKkBg0aVHpgc/LkSQUFBdmyr4u55pprPLp/AKgKPBUrFLj00kvd/h53795d0dHRmj17tkeTUqdOnVJAQIBHYxpPfzb4TVHn6JgxY5ScnKypU6fqscce08yZM631lR1fGGN0+vRpBQYGejyWqQrxHKoHbt+D19u4caO6deumkJAQBQUFKT4+Xu+99561Pjs7W76+vnr66aetsl9++cUahnv27Fmr/IEHHlDdunVljCl1OwouDPv27ZMknT59WpMmTVJMTIz8/f112WWXacyYMTp69OhFtzV16lR17NhR4eHhCg0NVbt27bRgwYJC7Sq45emtt95S27ZtFRAQYI1cOX/Yd5cuXdyGyf9+WbRokSTp559/1ujRo9WiRQvVqlVL9erV0w033KBPP/3U2s6PP/5oBWhTp061tlGwr+KGuv/jH/9QmzZtFBAQoPDwcN1yyy367rvv3OqMGDFCtWrV0n/+8x/16dNHtWrVUsOGDTV+/Hjl5ORc9LgVxeFw6P7779eSJUvUvHlzBQUFqU2bNnr33XcL1f33v/+tQYMGKTIyUk6nU40aNdKwYcPc9r1z507ddNNNql27tgICAnTVVVdp8eLFbtspGPq+bNkyPfzww6pfv75q1aqlxMREHT58WMeOHdM999yjOnXqqE6dOrrzzjt1/Phxt20YY/TCCy/oqquuUmBgoGrXrq0//vGP+uGHH8p0HAo0atRIzz77rI4dO6YXX3zRKi9qCPaGDRvUpUsXRUREKDAwUI0aNdKtt96qkydPXvQ8KNjetm3b9Mc//lG1a9fW5ZdfXuy+CqxcuVKtW7dWQECAmjRpoueee85tfXHn1/m3bnTp0kXvvfee9u3b53auFyhqeH1pPtvly5dr8uTJioqKUmhoqLp3767du3cXf+ABoAoq6haxXbt2qWfPngoKClLdunU1ZswYvffee8XeHrdlyxZdd911CgoKUpMmTfTUU08pPz+/TO259NJL1axZMyuWki4e5xXnyy+/1O23367GjRsrMDBQjRs31qBBg9y2LZ27rqxZs0Z33XWX6tatq6CgIOXk5BS65hRcA4pafn9r5GuvvaaePXuqfv36CgwMVPPmzfXII4/oxIkTVp0RI0bob3/7myS5badgX0V9Nvv379cdd9yhevXqyel0qnnz5nr22WfdjvePP/4oh8OhZ555RrNnz1ZMTIxq1aqlTp066bPPPivJx1BIwXV7165dGjRokMLCwhQZGam77rpLWVlZbnXz8/M1b948K34pSOq88847bnVmzZqlK6+8Uk6nU/Xq1dOwYcN08OBBt20V3CK6efNmxcfHW5/jwoULJUnvvfee2rVrp6CgILVq1UoffPBBobbv2bNHgwcPdjtmBce9PJKTk9WyZUs9//zzOn36tFV+fnxx8uRJTZgwQTExMVYM3KFDBy1fvlzSxc+Dgjj273//u5o3by6n02nFJsXdKpiZmak777xT4eHhCg4OVmJiYqH4sbjbQ3//WJGPP/5YV199tSTpzjvvtNpWsM+i4rnSfrYV+fcDVRcjpeDVUlNT1aNHD7Vu3VoLFiyQ0+nUCy+8oMTERC1fvly33XabQkNDdfXVV2vdunX685//LElav369nE6njh07pi+++ELx8fGSpHXr1umGG24o0/3R//nPfyTJSmrdfPPNWr9+vSZNmqTrrrtO33zzjaZMmaLNmzdr8+bNcjqdxW7rxx9/1KhRo9SoUSNJ0meffaaxY8fq0KFD+stf/uJWd9u2bfruu+/02GOPKSYmpthbB1944QVlZ2e7lT3++OP66KOP1KxZM0nSr7/+KkmaMmWKXC6Xjh8/rpUrV6pLly5av369unTpovr16+uDDz7QjTfeqJEjR+ruu++2+l2clJQUPfrooxo0aJBSUlJ05MgRJScnq1OnTtqyZYtiY2OtumfOnFH//v01cuRIjR8/Xp988omeeOIJhYWFFep7Sb333nvasmWLpk2bplq1amnWrFm65ZZbtHv3bjVp0kSS9PXXX+vaa69VnTp1NG3aNMXGxiotLU3vvPOOcnNz5XQ6tXv3bsXHx6tevXp67rnnFBERoaVLl2rEiBE6fPiwJk6c6LbfRx99VF27dtWiRYv0448/asKECRo0aJB8fX3Vpk0bLV++XF999ZUeffRRhYSEuCVgRo0apUWLFumBBx7QzJkz9euvv2ratGmKj4/X119/bY1wKos+ffrIx8dHn3zySbF1fvzxR/Xt21fXXXed/vGPf+jSSy/VoUOH9MEHHyg3N7fE58GAAQN0++23695773ULxouyfft2JSUlKTk5WS6XS//85z81btw45ebmasKECaXq4wsvvKB77rlH//3vf7Vy5cqL1i/LZ9u5c2e98sorys7O1sMPP6zExER999138vHxKVVbAaAi5eXluf3gVqAkP7ilpaUpISFBwcHBmj9/vurVq6fly5fr/vvvL7J+enq6hgwZovHjx2vKlClauXKlJk2apKioKA0bNqzUbT9z5oz27dtnXUtKEucV58cff1SzZs10++23Kzw8XGlpaZo/f76uvvpqffvtt6pTp45b/bvuukt9+/bVkiVLdOLECbdbsgq0a9dOmzdvdivbs2ePRo4cqZYtW7qV9enTR0lJSQoODta///1vzZw5U1988YU2bNgg6bcY7MSJE3rjjTfctlncrYI///yz4uPjlZubqyeeeEKNGzfWu+++qwkTJui///2vXnjhBbf6f/vb33TllVdaz1Z8/PHH1adPH+3du1dhYWHFHrcLufXWW3Xbbbdp5MiR2rFjhyZNmiTptx8eC4wYMUJLly7VyJEjNW3aNPn7+2vbtm1uPybdd999eumll3T//ferX79++vHHH/X444/r448/1rZt29w+m/T0dN15552aOHGiGjRooHnz5umuu+7SgQMH9MYbb+jRRx9VWFiYpk2bpptvvlk//PCDoqKiJEnffvut4uPjrR/kXC6XPvzwQz3wwAP65ZdfNGXKlDIdhwKJiYl66qmn9OWXX+raa68tss5DDz2kJUuWaPr06Wrbtq1OnDihnTt36siRI5JKdh68/fbb+vTTT/WXv/xFLpdL9erVu2C7Ro4cqR49emjZsmU6cOCAHnvsMXXp0kXffPONLr300hL3r127dlq4cKHuvPNOPfbYY+rbt68kXXB0VGk/24r8+4EqzADV1MKFC40ks2XLlmLrXHPNNaZevXrm2LFjVtnZs2dNXFycadCggcnPzzfGGPPYY4+ZwMBAc/r0aWOMMXfffbe58cYbTevWrc3UqVONMcYcOnTISDIvvfRSidr12WefmTNnzphjx46Zd99919StW9eEhISY9PR088EHHxhJZtasWW7vfe211wrtIyEhwSQkJBS7v7y8PHPmzBkzbdo0ExERYfXJGGOio6ONj4+P2b17d6H3RUdHm+HDhxe73aeffvqi/T179qw5c+aM6datm7nlllus8p9//tlIMlOmTCn0noLjs3fvXmOMMZmZmSYwMND06dPHrd7+/fuN0+k0gwcPtsqGDx9uJJnXX3/drW6fPn1Ms2bNim1ngYSEBNOyZUu3MkkmMjLSZGdnW2Xp6enmkksuMSkpKVbZDTfcYC699FKTkZFR7PZvv/1243Q6zf79+93Ke/fubYKCgszRo0eNMcZ89NFHRpJJTEx0q5eUlGQkmQceeMCt/Oabbzbh4eHW682bNxtJ5tlnn3Wrd+DAARMYGGgmTpx4ocNQou9OZGSkad68ufV6ypQp5veXjDfeeMNIMtu3by92Gxc6Dwq295e//KXYdb8XHR1tHA5Hof316NHDhIaGmhMnTrj1reD8KlBwzD/66COrrG/fviY6OrrItp/f7tJ+tuefz6+//rqRZDZv3lzk/gCgshX8fbzQcv7fxPNjhT//+c/G4XCYXbt2udXr1atXob+xCQkJRpL5/PPP3eq2aNHC9OrV66LtjY6ONn369DFnzpwxZ86cMXv37rXigD//+c/GmJLHeUVdA8539uxZc/z4cRMcHGz++te/Fjpuw4YNK/Se4q45BQ4fPmyaNGliWrZsaTIzM4usk5+fb86cOWNSU1ONJPP1119b68aMGVPoevj74/P7z+aRRx4p8njfd999xuFwWLHg3r17jSTTqlUrc/bsWaveF198YSSZ5cuXF7m/AgXH8l//+pdVVnDdPj+uHT16tAkICLA+h08++cRIMpMnTy52+999952RZEaPHu1W/vnnnxtJ5tFHH7XKCs6xL7/80io7cuSI8fHxMYGBgebQoUNW+fbt240k89xzz1llvXr1Mg0aNDBZWVlu+7r//vtNQECA+fXXXy94LKKjo03fvn2LXT9//nwjybz22mtW2fnxRVxcnLn55psvuJ8LnQeSTFhYWJFtPX9fBefr72N2Y4z5v//7PyPJTJ8+3a1vRf0/4fz/l2zZssVIMgsXLixU9/x4riyfbVn/fqB64fY9eK0TJ07o888/1x//+EfVqlXLKvfx8dHQoUN18OBB63aabt266dSpU9q0aZOk30ZE9ejRQ927d9fatWutMkluD3++kGuuuUZ+fn4KCQlRv3795HK5tHr1akVGRlq/gp0/LPZPf/qTgoODtX79+gtue8OGDerevbvCwsLk4+MjPz8//eUvf9GRI0cKzZzWunVrNW3atERtLrB8+XJNnDhRjz32mP7nf/7Hbd3f//53tWvXTgEBAfL19ZWfn5/Wr19f6Fa7ktq8ebNOnTpV6Fg0bNhQN9xwQ6Fj4XA4lJiY6FbWunXrQsPtS6Nr164KCQmxXkdGRqpevXrWNk+ePKnU1FQNHDjwgiO+NmzYoG7duqlhw4Zu5SNGjNDJkycL/Xp6/mxyzZs3lyTrl6bfl//666/WLXzvvvuuHA6H7rjjDp09e9ZaXC6X2rRpUyGzC5mL/GJ+1VVXyd/fX/fcc48WL15c5tsGb7311hLXbdmypdq0aeNWNnjwYGVnZ2vbtm1l2n9Jlfaz7d+/v9vr1q1bS1K5zlMAqAivvvqqtmzZUmgpbiTH76WmpiouLk4tWrRwKx80aFCR9V0ul/7whz+4lZXmmv3+++/Lz89Pfn5+iomJ0euvv66xY8dq+vTppYrzinL8+HE9/PDDuuKKK+Tr6ytfX1/VqlVLJ06cKDKmKc31SvotDu3bt69Onz6t1atXu41A+eGHHzR48GC5XC4rjktISJCkMsdTGzZsUIsWLQod7xEjRsgYY8WeBfr27es2crcirlNFXftOnz5txaarV6+WJI0ZM6bYbXz00UdWu3/vD3/4g5o3b14oLqxfv77at29vvQ4PD1e9evV01VVXWSOipHMx1u8fo7F+/XrdcsstCgoKcoun+vTpo9OnT5f5dsYCF4ulCvq1evVqPfLII/r444916tSpUu/nhhtuUO3atUtc//xn28bHxys6Oto69pWltJ9tef9+oPrg9j14rczMTBljihzmXHCRKhgaGx8fr6CgIK1bt04NGzbUjz/+qB49eujgwYOaN2+ejh8/rnXr1qlJkyaKiYkp0f5fffVVNW/eXL6+voqMjHRrx5EjR+Tr61soweFwOORyuax2FeWLL75Qz5491aVLF7388stq0KCB/P399fbbb+vJJ58sdDEr7YwwH330kUaMGKFhw4bpiSeecFs3e/ZsjR8/Xvfee6+eeOIJ1alTRz4+Pnr88cfLHEQV9LW4z6kgKVggKChIAQEBbmVOp9Ptfv3SioiIKFTmdDqtY5mZmam8vLyLPqzxyJEjJTrfCoSHh7u99vf3v2D56dOnVatWLR0+fFjGmGJv0Su45bCsTpw4oSNHjqhVq1bF1rn88su1bt06zZo1S2PGjNGJEyfUpEkTPfDAAxo3blyJ91Wa89PlchVbdqHvTEUo7Wd7/jlVcDtuWYJNAKhIzZs3d5vkokBYWJgOHDhwwfceOXKkyDiouOvRxa6vF3Pttddqzpw5cjgcCgoK0uWXX25dEzMyMkoc5xVl8ODBWr9+vR5//HFdffXVCg0NlcPhUJ8+fYpsX2muV2fPntUf//hHff/99/rkk0/cftA4fvy4rrvuOgUEBGj69Olq2rSpgoKCdODAAQ0YMKDM14kjR464PbeqgJ3XqYtt8+eff5aPj0+R1/MCF4sLz09InB8zSb/FTReKpQr2c/bsWc2bN0/z5s0rsi2//PJLse0siYK2/j45dr7nnntODRo00GuvvaaZM2cqICBAvXr10tNPP+32+IoLKW2sX1w8ZUcsJZX8sy3v3w9UHySl4LVq166tSy65RGlpaYXW/fTTT5Jk3bfs7++va6+9VuvWrVODBg3kcrnUqlUr6z/3H3/8sdavX19oZMuFFBf0Sb/9kT179qx+/vlnt8SUMUbp6enWQwOLsmLFCvn5+endd991S868/fbbRdYvzfOvvvnmG918881KSEjQyy+/XGj90qVL1aVLF82fP9+t/NixYyXex/kKLjjFfU7nP9PBE8LDw+Xj41PoIYzni4iIKNH5Vl516tSRw+HQp59+WuSzxy70PLKSeO+995SXl2c9yLI41113na677jrl5eXpyy+/1Lx585SUlKTIyEjdfvvtJdpXac7P9PT0YssKzqOC78T5D74vb2Bp12cLAFVZRESEDh8+XKi8qL/PFSEsLKzYWKo0cd75srKy9O6772rKlCl65JFHrPKcnBzr+ZnnK8316p577tH69ev1/vvvFxrhu2HDBv3000/6+OOPrdFRkko00c2FVIfrVN26dZWXl6f09PRiEym/jwvP/zGwIuPC2rVrW6Pqihu5VdIfootijNGqVasUHBxc7DksScHBwZo6daqmTp2qw4cPW6OmEhMT9e9//7tE+yrts26Li6euuOIK63VAQECRkwj98ssvZf4M7PpsUf1w+x68VnBwsDp27Ki33nrLLaOen5+vpUuXqkGDBm63tXXv3l1bt27Vm2++ad2iFxwcrGuuuUbz5s3TTz/9VOJb9y6mW7dukn5L8vzem2++qRMnTljri+JwOOTr6+s25PrUqVNasmRJudq0f/9+9e7dW02aNNGbb75Z5AM8HQ5HoYTHN998U+jWpdL82tapUycFBgYWOhYHDx60bpnytMDAQCUkJOhf//rXBZMb3bp1s4LN33v11VcVFBRUYVPz9uvXT8YYHTp0SB06dCi0XGiE08Xs379fEyZMUFhYmEaNGlWi9/j4+Khjx47W7DAFt9JV9OigXbt26euvv3YrW7ZsmUJCQtSuXTtJsn4l/uabb9zq/X5WnwKl+bXNrs8WAKqyhIQE7dy5U99++61b+YoVK2xvS2njvN9zOBwyxhSKaV555RXl5eWVq12PPfaYFi5cqFdeeaXIuLEggXD+vn8/422B0lxHu3Xrpm+//bbQ7eyvvvqqHA6HunbtWuI+VJbevXtLUqEfN3/vhhtukFQ4Rt6yZYu+++67CosLg4KC1LVrV3311Vdq3bp1kfFUUSN1Smrq1Kn69ttvNW7cuEIj/IsTGRmpESNGaNCgQdq9e7dOnjwpqeLjqX/+859urzdt2qR9+/a5/RjZuHHjQrHU999/X+iW2NK0za7PFtUPI6VQ7W3YsKHQ9O/SbzOIpaSkqEePHuratasmTJggf39/vfDCC9q5c6eWL1/u9stCt27dlJeXp/Xr17tN8969e3dNmTJFDofD+mNaXj169FCvXr308MMPKzs7W507d7Zm32vbtq2GDh1a7Hv79u2r2bNna/Dgwbrnnnt05MgRPfPMM+UeHdO7d28dPXpUzz//vHbt2uW27vLLL1fdunXVr18/PfHEE5oyZYoSEhK0e/duTZs2TTExMW4z+YSEhCg6Olr/+7//q27duik8PFx16tQpclj5pZdeqscff1yPPvqohg0bpkGDBunIkSOaOnWqAgICyj3zSUWZPXu2rr32WnXs2FGPPPKIrrjiCh0+fFjvvPOOXnzxRYWEhGjKlCl699131bVrV/3lL39ReHi4/vnPf+q9997TrFmzyjybzfk6d+6se+65R3feeae+/PJLXX/99QoODlZaWpo2btyoVq1a6b777rvodnbu3Gk9PyEjI0OffvqpFi5cKB8fH61cufKCz8/6+9//rg0bNqhv375q1KiRTp8+bc2uUxCEl+Y8KImoqCj1799fycnJql+/vpYuXaq1a9dq5syZCgoKkiRdffXVatasmSZMmKCzZ8+qdu3aWrlypTZu3Fhoe61atdJbb72l+fPnq3379rrkkkuK/TXTrs8WAKqypKQk/eMf/1Dv3r01bdo0RUZGatmyZdaIjksusff37tLEeb8XGhqq66+/Xk8//bR1XUpNTdWCBQtKNfvY+f71r3/pySef1B//+Ec1bdrU7ZlETqdTbdu2VXx8vGrXrq17771XU6ZMkZ+fn/75z38W+tFFkvUj08yZM9W7d2/5+PiodevW1q1ov/fggw/q1VdfVd++fTVt2jRFR0frvffe0wsvvKD77ruv1M8XrQzXXXedhg4dqunTp+vw4cPq16+fnE6nvvrqKwUFBWns2LFq1qyZ7rnnHs2bN0+XXHKJevfubc3Q1rBhQz344IMV1p6//vWvuvbaa3XdddfpvvvuU+PGjXXs2DH95z//0apVqwo9h6soR48etT7nEydOaPfu3VqxYoU+/fRTDRw4UFOnTr3g+zt27Kh+/fqpdevWql27tr777jstWbJEnTp1smKb0pwHJfHll1/q7rvv1p/+9CcdOHBAkydP1mWXXabRo0dbdYYOHao77rhDo0eP1q233qp9+/Zp1qxZhWLDyy+/XIGBgfrnP/+p5s2bq1atWoqKiirylkU7P1tUM556wjpQXhebRaZgJpRPP/3U3HDDDSY4ONgEBgaaa665xqxatarQ9vLz802dOnWMJLfZOgpmpGjXrl2p2nWhmc2MMebUqVPm4YcfNtHR0cbPz8/Ur1/f3HfffYVmZylq9r1//OMfplmzZsbpdJomTZqYlJQUs2DBgkIzwFxoVpDzZ9W40LEsmFEjJyfHTJgwwVx22WUmICDAtGvXzrz99ttm+PDhhWbsWbdunWnbtq1xOp1GkrWv4maqeeWVV0zr1q2Nv7+/CQsLMzfddFOh2X2GDx9ugoODC/WlqNnailLc7Htjxoy56PExxphvv/3W/OlPfzIRERHG39/fNGrUyIwYMcKatdEYY3bs2GESExNNWFiY8ff3N23atCk0I0lRM9cYU/y5U9C/n3/+2a38H//4h+nYsaN1bl9++eVm2LBhbrPQFOX8746/v7+pV6+eSUhIMDNmzChyhsHzj/HmzZvNLbfcYqKjo43T6TQREREmISHBvPPOO27vK+48KK5PRe3LmHPn8htvvGFatmxp/P39TePGjc3s2bMLvf/77783PXv2NKGhoaZu3bpm7Nix5r333is089Kvv/5q/vjHP5pLL73UOBwOt32qiFkDy/PZFsx2VNTsNABgh4vFJ0XNSFrUtXDnzp2me/fuJiAgwISHh5uRI0eaxYsXF5o5rqhrrjGmyJihKBeb2axASeK8ombfO3jwoLn11ltN7dq1TUhIiLnxxhvNzp07C/X5Qsft/Jim4PpV1PL7Pm/atMl06tTJBAUFmbp165q7777bbNu2rdB1Iicnx9x9992mbt261nWqYF9FfTb79u0zgwcPNhEREcbPz880a9bMPP300yYvL8+qU3A9evrppwv1p6hr3/kuNPve+df0omK+vLw8M2fOHBMXF2fFfJ06dXL7zPLy8szMmTNN06ZNjZ+fn6lTp4654447zIEDB9y2X9w5Vty5U1TMt3fvXnPXXXeZyy67zPj5+Zm6deua+Ph4t5noihMdHW19vg6Hw9SqVcs0a9bMDB061Hz44YdFvuf8Y/zII4+YDh06mNq1a1tx/YMPPmh++eUXq86FzoPi4tii9lXweaxZs8YMHTrUXHrppdYM2Hv27HF7b35+vpk1a5Zp0qSJCQgIMB06dDAbNmwo8v8ly5cvN1deeaXx8/Nz22dR8Vx5P9uS/v1A9eIwpgTTAgAAAABAEe655x4tX75cR44cKfPoDQBAzcTtewAAAABKZNq0aYqKilKTJk10/Phxvfvuu3rllVf02GOPkZACAJQaSSkAAAAAJeLn56enn35aBw8e1NmzZxUbG6vZs2dr3Lhxnm4aAKAa4vY9AAAAAAAA2M7eKTIAAAAAAAAAkZQCAAAAAACAB5CUAgAAAAAAgO140Lmk/Px8/fTTTwoJCZHD4fB0cwAAQBVijNGxY8cUFRWlSy7h97wCxE8AAKA4JY2fSEpJ+umnn9SwYUNPNwMAAFRhBw4cUIMGDTzdjCqD+AkAAFzMxeInklKSQkJCJP12sEJDQz3cGgAAUJVkZ2erYcOGVryA3xA/AQCA4pQ0fiIpJVlDzkNDQwmqAABAkbhFzR3xEwAAuJiLxU88GAEAAAAAAAC2IykFAAAAAAAA25GUAgAAAAAAgO1ISgEAAAAAAMB2JKUAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7X083AADslJhYsnqrVlVuOwAAqNJKcsHkYgkAKCdGSgEAAAAAAMB2JKUAAAAAAABgO27fA+A1SnprHgAAAFAjcWsuqhiSUgBQRjyfCgAAAADKjtv3AAAAAAAAYDuSUgAAAAAAALAdt+8BQBF4PhUAAAAAVC5GSgEAAAAAAMB2JKUAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANjO40mpQ4cO6Y477lBERISCgoJ01VVXaevWrdZ6Y4ySk5MVFRWlwMBAdenSRbt27XLbRk5OjsaOHas6deooODhY/fv318GDB+3uCgAAAAAAAErIo0mpzMxMde7cWX5+flq9erW+/fZbPfvss7r00kutOrNmzdLs2bP1/PPPa8uWLXK5XOrRo4eOHTtm1UlKStLKlSu1YsUKbdy4UcePH1e/fv2Ul5fngV4BAAAAAADgYnw9ufOZM2eqYcOGWrhwoVXWuHFj69/GGM2dO1eTJ0/WgAEDJEmLFy9WZGSkli1bplGjRikrK0sLFizQkiVL1L17d0nS0qVL1bBhQ61bt069evWytU8AAAAAAAC4OI+OlHrnnXfUoUMH/elPf1K9evXUtm1bvfzyy9b6vXv3Kj09XT179rTKnE6nEhIStGnTJknS1q1bdebMGbc6UVFRiouLs+oAAAAAAACgavHoSKkffvhB8+fP10MPPaRHH31UX3zxhR544AE5nU4NGzZM6enpkqTIyEi390VGRmrfvn2SpPT0dPn7+6t27dqF6hS8/3w5OTnKycmxXmdnZ1dktwAAAAAAsE9ioqdbAJSJR5NS+fn56tChg2bMmCFJatu2rXbt2qX58+dr2LBhVj2Hw+H2PmNMobLzXahOSkqKpk6dWs7WAwAAAAAAoKw8evte/fr11aJFC7ey5s2ba//+/ZIkl8slSYVGPGVkZFijp1wul3Jzc5WZmVlsnfNNmjRJWVlZ1nLgwIEK6Q8AAAAAAABKxqNJqc6dO2v37t1uZd9//72io6MlSTExMXK5XFq7dq21Pjc3V6mpqYqPj5cktW/fXn5+fm510tLStHPnTqvO+ZxOp0JDQ90WAAAAAAAA2Mejt+89+OCDio+P14wZMzRw4EB98cUXeumll/TSSy9J+u22vaSkJM2YMUOxsbGKjY3VjBkzFBQUpMGDB0uSwsLCNHLkSI0fP14REREKDw/XhAkT1KpVK2s2PgAAAAAAAFQtHk1KXX311Vq5cqUmTZqkadOmKSYmRnPnztWQIUOsOhMnTtSpU6c0evRoZWZmqmPHjlqzZo1CQkKsOnPmzJGvr68GDhyoU6dOqVu3blq0aJF8fHw80S0AAAAAAABchMMYYzzdCE/Lzs5WWFiYsrKyuJUPqMaq6qQjq1Z5ugUAyoM4oWgcFy9XkosqFzig6qjIQJjvNipASeMEjz5TCgAAAAAAADUTSSkAAAAAAADYjqQUAAAAAAAAbOfRB50DQE3AYzkAAAAAoDBGSgEAAFQzhw4d0h133KGIiAgFBQXpqquu0tatW631xhglJycrKipKgYGB6tKli3bt2uW2jZycHI0dO1Z16tRRcHCw+vfvr4MHD9rdFQAAUIORlAIAAKhGMjMz1blzZ/n5+Wn16tX69ttv9eyzz+rSSy+16syaNUuzZ8/W888/ry1btsjlcqlHjx46duyYVScpKUkrV67UihUrtHHjRh0/flz9+vVTXl6eB3oFAABqIm7fAwAAqEZmzpyphg0bauHChVZZ48aNrX8bYzR37lxNnjxZAwYMkCQtXrxYkZGRWrZsmUaNGqWsrCwtWLBAS5YsUffu3SVJS5cuVcOGDbVu3Tr16tXL1j4BAICaiZFSAAAA1cg777yjDh066E9/+pPq1auntm3b6uWXX7bW7927V+np6erZs6dV5nQ6lZCQoE2bNkmStm7dqjNnzrjViYqKUlxcnFXnfDk5OcrOznZbAAAAyoOkFAAAQDXyww8/aP78+YqNjdWHH36oe++9Vw888IBeffVVSVJ6erokKTIy0u19kZGR1rr09HT5+/urdu3axdY5X0pKisLCwqylYcOGFd01AABQw5CUAgAAqEby8/PVrl07zZgxQ23bttWoUaP0P//zP5o/f75bPYfD4fbaGFOo7HwXqjNp0iRlZWVZy4EDB8rXEQAAUOORlAIAAKhG6tevrxYtWriVNW/eXPv375ckuVwuSSo04ikjI8MaPeVyuZSbm6vMzMxi65zP6XQqNDTUbQEAACgPklIAAADVSOfOnbV79263su+//17R0dGSpJiYGLlcLq1du9Zan5ubq9TUVMXHx0uS2rdvLz8/P7c6aWlp2rlzp1UHAACgsjH7HgAAQDXy4IMPKj4+XjNmzNDAgQP1xRdf6KWXXtJLL70k6bfb9pKSkjRjxgzFxsYqNjZWM2bMUFBQkAYPHixJCgsL08iRIzV+/HhFREQoPDxcEyZMUKtWrazZ+AAAACobSSkAAIBq5Oqrr9bKlSs1adIkTZs2TTExMZo7d66GDBli1Zk4caJOnTql0aNHKzMzUx07dtSaNWsUEhJi1ZkzZ458fX01cOBAnTp1St26ddOiRYvk4+PjiW4BAIAayGGMMZ5uhKdlZ2crLCxMWVlZPB8BqMYSEz3dgrJbtcrTLQBQHOKEonFcvFxJLqpcvICqoyIDYb7bqAAljRN4phQAAAAAAABsx+17AKq86jwCCgAAAABQNEZKAQAAAAAAwHYkpQAAAAAAAGA7bt8DAAAAUHolvb+ehyYDAIrBSCkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2I6kFAAAAAAAAGzn6+kGAKjZEhM93QIAAAAAgCcwUgoAAAAAAAC2Y6QUAAAAAABVFbcWwIsxUgoAAAAAAAC2Y6QUAAAAUFMw4gIAUIUwUgoAAAAAAAC2IykFAAAAAAAA25GUAgAAAAAAgO1ISgEAAAAAAMB2JKUAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABs5+vpBgAApMTEktVbtapy2wEAAAAAdmGkFAAAAAAAAGzHSCkAAADAG5R02C0AAFUEI6UAAAAAAABgO5JSAAAAAAAAsB237wEAAACoPCW5rZCZPACgRmKkFAAAAAAAAGxHUgoAAAAAAAC2IykFAAAAAAAA25GUAgAAAAAAgO1ISgEAAAAAAMB2JKUAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALbzaFIqOTlZDofDbXG5XNZ6Y4ySk5MVFRWlwMBAdenSRbt27XLbRk5OjsaOHas6deooODhY/fv318GDB+3uCgAAAAAAAErB4yOlWrZsqbS0NGvZsWOHtW7WrFmaPXu2nn/+eW3ZskUul0s9evTQsWPHrDpJSUlauXKlVqxYoY0bN+r48ePq16+f8vLyPNEdAAAAAAAAlICvxxvg6+s2OqqAMUZz587V5MmTNWDAAEnS4sWLFRkZqWXLlmnUqFHKysrSggULtGTJEnXv3l2StHTpUjVs2FDr1q1Tr169bO0LAAAAAAAASsbjI6X27NmjqKgoxcTE6Pbbb9cPP/wgSdq7d6/S09PVs2dPq67T6VRCQoI2bdokSdq6davOnDnjVicqKkpxcXFWnaLk5OQoOzvbbQEAAAAAAIB9PJqU6tixo1599VV9+OGHevnll5Wenq74+HgdOXJE6enpkqTIyEi390RGRlrr0tPT5e/vr9q1axdbpygpKSkKCwuzloYNG1ZwzwAAAAAAAHAhHk1K9e7dW7feeqtatWql7t2767333pP02216BRwOh9t7jDGFys53sTqTJk1SVlaWtRw4cKAcvQAAAAAAAEBpefz2vd8LDg5Wq1attGfPHus5U+ePeMrIyLBGT7lcLuXm5iozM7PYOkVxOp0KDQ11WwAAAAAAAGCfKpWUysnJ0Xfffaf69esrJiZGLpdLa9eutdbn5uYqNTVV8fHxkqT27dvLz8/PrU5aWpp27txp1QEAAAAAAEDV49HZ9yZMmKDExEQ1atRIGRkZmj59urKzszV8+HA5HA4lJSVpxowZio2NVWxsrGbMmKGgoCANHjxYkhQWFqaRI0dq/PjxioiIUHh4uCZMmGDdDggAAAAAAICqyaNJqYMHD2rQoEH65ZdfVLduXV1zzTX67LPPFB0dLUmaOHGiTp06pdGjRyszM1MdO3bUmjVrFBISYm1jzpw58vX11cCBA3Xq1Cl169ZNixYtko+Pj6e6BQAAAABA9ZSYePE6q1ZVfjtQIziMMcbTjfC07OxshYWFKSsri+dLATYryTUP53D9B+xHnFA0jksVVJ0vqlzggOJVxe8231lcREnjBI+OlAIAlA4/XAEAAADwFlXqQecAAAC4sOTkZDkcDrelYNZiSTLGKDk5WVFRUQoMDFSXLl20a9cut23k5ORo7NixqlOnjoKDg9W/f38dPHjQ7q4AAIAajqQUAABANdOyZUulpaVZy44dO6x1s2bN0uzZs/X8889ry5Ytcrlc6tGjh44dO2bVSUpK0sqVK7VixQpt3LhRx48fV79+/ZSXl+eJ7gAAgBqK2/cAAACqGV9fX7fRUQWMMZo7d64mT56sAQMGSJIWL16syMhILVu2TKNGjVJWVpYWLFigJUuWWLMVL126VA0bNtS6devUq1cvW/sCAABqLkZKAQAAVDN79uxRVFSUYmJidPvtt+uHH36QJO3du1fp6enq2bOnVdfpdCohIUGbNm2SJG3dulVnzpxxqxMVFaW4uDirDgAAgB0YKQUAAFCNdOzYUa+++qqaNm2qw4cPa/r06YqPj9euXbuUnp4uSYqMjHR7T2RkpPbt2ydJSk9Pl7+/v2rXrl2oTsH7i5KTk6OcnBzrdXZ2dkV1CQAA1FAkpQAAAKqR3r17W/9u1aqVOnXqpMsvv1yLFy/WNddcI0lyOBxu7zHGFCo738XqpKSkaOrUqeVoOQDATUmmVQa8HLfvAQAAVGPBwcFq1aqV9uzZYz1n6vwRTxkZGdboKZfLpdzcXGVmZhZbpyiTJk1SVlaWtRw4cKCCewIAAGoaklIAAADVWE5Ojr777jvVr19fMTExcrlcWrt2rbU+NzdXqampio+PlyS1b99efn5+bnXS0tK0c+dOq05RnE6nQkND3RYAAIDy4PY9AACAamTChAlKTExUo0aNlJGRoenTpys7O1vDhw+Xw+FQUlKSZsyYodjYWMXGxmrGjBkKCgrS4MGDJUlhYWEaOXKkxo8fr4iICIWHh2vChAlq1aqVNRsfAACAHUhKAQAAVCMHDx7UoEGD9Msvv6hu3bq65ppr9Nlnnyk6OlqSNHHiRJ06dUqjR49WZmamOnbsqDVr1igkJMTaxpw5c+Tr66uBAwfq1KlT6tatmxYtWiQfHx9PdQsAANRADmOM8XQjPC07O1thYWHKyspiKDpgM57vWPFWrfJ0CwDvQpxQNI5LFVSdL6pcvFAT8Z2FFytpnMAzpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2I6kFAAAAAAAAGxHUgoAAAAAAAC2IykFAAAAAAAA2/l6ugEAvFN1nuEWAAAAAFD5GCkFAAAAAAAA25GUAgAAAAAAgO1ISgEAAAAAAMB2PFMKAAAAAACUXEkfILtqVeW2A9UeI6UAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADb+Xq6AQCqn8RET7cAAAAAAFDdMVIKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2I6kFAAAAAAAAGxHUgoAAAAAAAC2IykFAAAAAAAA25GUAgAAAAAAgO1ISgEAAAAAAMB2JKUAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYLsqk5RKSUmRw+FQUlKSVWaMUXJysqKiohQYGKguXbpo165dbu/LycnR2LFjVadOHQUHB6t///46ePCgza0HAAAAAABAaVSJpNSWLVv00ksvqXXr1m7ls2bN0uzZs/X8889ry5Ytcrlc6tGjh44dO2bVSUpK0sqVK7VixQpt3LhRx48fV79+/ZSXl2d3NwAAAAAAAFBCHk9KHT9+XEOGDNHLL7+s2rVrW+XGGM2dO1eTJ0/WgAEDFBcXp8WLF+vkyZNatmyZJCkrK0sLFizQs88+q+7du6tt27ZaunSpduzYoXXr1nmqSwAAAAAAALgIjyelxowZo759+6p79+5u5Xv37lV6erp69uxplTmdTiUkJGjTpk2SpK1bt+rMmTNudaKiohQXF2fVKUpOTo6ys7PdFgAAAAAAANjH15M7X7FihbZt26YtW7YUWpeeni5JioyMdCuPjIzUvn37rDr+/v5uI6wK6hS8vygpKSmaOnVqeZsPAAAAAACAMvLYSKkDBw5o3LhxWrp0qQICAoqt53A43F4bYwqVne9idSZNmqSsrCxrOXDgQOkaDwAAAAAAgHLxWFJq69atysjIUPv27eXr6ytfX1+lpqbqueeek6+vrzVC6vwRTxkZGdY6l8ul3NxcZWZmFlunKE6nU6GhoW4LAAAAAAAA7OOxpFS3bt20Y8cObd++3Vo6dOigIUOGaPv27WrSpIlcLpfWrl1rvSc3N1epqamKj4+XJLVv315+fn5uddLS0rRz506rDgAAAAAAAKoejz1TKiQkRHFxcW5lwcHBioiIsMqTkpI0Y8YMxcbGKjY2VjNmzFBQUJAGDx4sSQoLC9PIkSM1fvx4RUREKDw8XBMmTFCrVq0KPTgdAAAAAAAAVYfHZ9+7kIkTJyopKUmjR49Whw4ddOjQIa1Zs0YhISFWnTlz5ujmm2/WwIED1blzZwUFBWnVqlXy8fHxYMsBAADskZKSIofDoaSkJKvMGKPk5GRFRUUpMDBQXbp00a5du9zel5OTo7Fjx6pOnToKDg5W//79dfDgQZtbD/x/iYklWwAAXsVhjDGeboSnZWdnKywsTFlZWTxfCigBYkLvsGqVp1sAVA9VOU7YsmWLBg4cqNDQUHXt2lVz586VJM2cOVNPPvmkFi1apKZNm2r69On65JNPtHv3buvHvfvuu0+rVq3SokWLFBERofHjx+vXX3/V1q1bS/TjXlU+LjVWTbhAc/GCN+E7Cy9W0jihSo+UAgAAQNGOHz+uIUOG6OWXX1bt2rWtcmOM5s6dq8mTJ2vAgAGKi4vT4sWLdfLkSS1btkySlJWVpQULFujZZ59V9+7d1bZtWy1dulQ7duzQunXrPNUlAABQw5CUAgAAqIbGjBmjvn37FnqO5t69e5Wenq6ePXtaZU6nUwkJCdq0aZOk32ZBPnPmjFudqKgoxcXFWXUAAAAqm8cedA4AAICyWbFihbZt26YtW7YUWpeeni5JioyMdCuPjIzUvn37rDr+/v5uI6wK6hS8/3w5OTnKycmxXmdnZ5erDwAAAIyUAgAAqEYOHDigcePGaenSpQoICCi2nsPhcHttjClUdr4L1UlJSVFYWJi1NGzYsPSNBwAA+B2SUgAAANXI1q1blZGRofbt28vX11e+vr5KTU3Vc889J19fX2uE1PkjnjIyMqx1LpdLubm5yszMLLbO+SZNmqSsrCxrOXDgQCX0DgAA1CQkpQAAAKqRbt26aceOHdq+fbu1dOjQQUOGDNH27dvVpEkTuVwurV271npPbm6uUlNTFR8fL0lq3769/Pz83OqkpaVp586dVp3zOZ1OhYaGui0AAADlwTOlAAAAqpGQkBDFxcW5lQUHBysiIsIqT0pK0owZMxQbG6vY2FjNmDFDQUFBGjx4sCQpLCxMI0eO1Pjx4xUREaHw8HBNmDBBrVq1KvTgdAAAgMpCUgoAAMDLTJw4UadOndLo0aOVmZmpjh07as2aNQoJCbHqzJkzR76+vho4cKBOnTqlbt26adGiRfLx8fFgywEAQE3iMMYYTzfC07KzsxUWFqasrCyGogMlkJjo6RagIqxa5ekWANUDcULROC5VUE24QHPxgjfhOwsvVtI4gZFSACw14boIAAAAAKgaSEoBQA1VkiQkP24BAAAAqCzMvgcAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2K5MSam9e/dWdDsAAAC8HjEUAADAOWVKSl1xxRXq2rWrli5dqtOnT1d0mwAAALwSMRQAAMA5ZUpKff3112rbtq3Gjx8vl8ulUaNG6YsvvqjotgEAAHgVYigAAIBzHMYYU9Y3nz17VqtWrdKiRYu0evVqxcbGauTIkRo6dKjq1q1bke2sVNnZ2QoLC1NWVpZCQ0M93RzAYxITPd0CVDWrVnm6BYDnVUac4A0xFPGTjbhAn8OFCd6kJny3+c7WWCWNE8r1oHNfX1/dcsstev311zVz5kz997//1YQJE9SgQQMNGzZMaWlp5dk8AACAVyKGAgAAKGdS6ssvv9To0aNVv359zZ49WxMmTNB///tfbdiwQYcOHdJNN91UUe0EAADwGsRQAAAAkm9Z3jR79mwtXLhQu3fvVp8+ffTqq6+qT58+uuSS33JcMTExevHFF3XllVdWaGMBAACqM2IoAACAc8qUlJo/f77uuusu3XnnnXK5XEXWadSokRYsWFCuxgEAAHgTYigAAIBzypSU2rNnz0Xr+Pv7a/jw4WXZPAAAgFcihgIAADinTM+UWrhwof71r38VKv/Xv/6lxYsXl7tRAAAA3ogYCgAA4JwyJaWeeuop1alTp1B5vXr1NGPGjHI3CgAAwBsRQwEAAJxTpqTUvn37FBMTU6g8Ojpa+/fvL3ejAAAAvBExFAAAwDllSkrVq1dP33zzTaHyr7/+WhEREeVuFAAAgDcihgIAADinTEmp22+/XQ888IA++ugj5eXlKS8vTxs2bNC4ceN0++23V3QbAQAAvAIxFAAAwDllmn1v+vTp2rdvn7p16yZf3982kZ+fr2HDhvE8BAAAgGIQQwEAAJxTpqSUv7+/XnvtNT3xxBP6+uuvFRgYqFatWik6Orqi2wcAAOA1iKEAAADOKVNSqkDTpk3VtGnTimoLAABAjUAMBQAAUMakVF5enhYtWqT169crIyND+fn5bus3bNhQIY0DAADwJsRQAAAA55QpKTVu3DgtWrRIffv2VVxcnBwOR0W3CwAAwOsQQwEAAJxTpqTUihUr9Prrr6tPnz4V3R4AAACvRQwFAABwziVleZO/v7+uuOKKim4LAACAVyOGAgAAOKdMSanx48frr3/9q4wxFd0eAAAAr0UMBQAAcE6Zbt/buHGjPvroI61evVotW7aUn5+f2/q33nqrQhoHAADgTYihAAAAzilTUurSSy/VLbfcUtFtAQAA8GrEUAAAAOeUKSm1cOHCim4HAACA1yOGAgAAOKdMz5SSpLNnz2rdunV68cUXdezYMUnSTz/9pOPHj1dY4wAAALwNMRQAAMBvyjRSat++fbrxxhu1f/9+5eTkqEePHgoJCdGsWbN0+vRp/f3vf6/odgIAAFR7xFAAAADnlGmk1Lhx49ShQwdlZmYqMDDQKr/lllu0fv36CmscAACANyGGAgAAOKfMs+/93//9n/z9/d3Ko6OjdejQoQppGAAAgLchhgIAADinTEmp/Px85eXlFSo/ePCgQkJCyt0oAAAAb0QMBQA1RGKip1sAVAtlun2vR48emjt3rvXa4XDo+PHjmjJlivr06VNRbQMAAPAqxFAAAADnlGmk1Jw5c9S1a1e1aNFCp0+f1uDBg7Vnzx7VqVNHy5cvr+g2AgAAeAViKAAAgHPKlJSKiorS9u3btXz5cm3btk35+fkaOXKkhgwZ4vbQTgAAAJxDDAUAAHBOmZJSkhQYGKi77rpLd911V0W2BwAAwKsRQwEAAPymTEmpV1999YLrhw0bVqbGAAAAeDNiKAAAgHPKlJQaN26c2+szZ87o5MmT8vf3V1BQEAEVAABAEYihAAAAzinT7HuZmZluy/Hjx7V7925de+21PKQTAACgGMRQAAAA55T5mVLni42N1VNPPaU77rhD//73vytqswAAD0pMLFm9Vasqtx2ANyOGAgAANVWZRkoVx8fHRz/99FNFbhIAAMDrEUMBAICaqEwjpd555x2318YYpaWl6fnnn1fnzp0rpGEAAADehhgKAADgnDIlpW6++Wa31w6HQ3Xr1tUNN9ygZ599tiLaBQAA4HWIoQAANUpJngXBcyBqtDIlpfLz8yu6HQAAAF6PGAoAAOCcCn2mFAAAAAAAAFASZRop9dBDD5W47uzZs8uyCwAAAK9DDAUAAHBOmZJSX331lbZt26azZ8+qWbNmkqTvv/9ePj4+ateunVXP4XBUTCsBAAC8ADEUUE48nwYAvEqZklKJiYkKCQnR4sWLVbt2bUlSZmam7rzzTl133XUaP358hTYSAADAGxBDAQAAnFOmZ0o9++yzSklJsYIpSapdu7amT5/OzDEAAADFIIYCAAA4p0xJqezsbB0+fLhQeUZGho4dO1buRgEAAHgjYigAAIBzypSUuuWWW3TnnXfqjTfe0MGDB3Xw4EG98cYbGjlypAYMGFDRbQQAAPAKxFAAAADnlCkp9fe//119+/bVHXfcoejoaEVHR2vIkCHq3bu3XnjhhRJvZ/78+WrdurVCQ0MVGhqqTp06afXq1dZ6Y4ySk5MVFRWlwMBAdenSRbt27XLbRk5OjsaOHas6deooODhY/fv318GDB8vSLQAAgEpVUTEUAACAN3AYY0xZ33zixAn997//lTFGV1xxhYKDg0v1/lWrVsnHx0dXXHGFJGnx4sV6+umn9dVXX6lly5aaOXOmnnzySS1atEhNmzbV9OnT9cknn2j37t0KCQmRJN13331atWqVFi1apIiICI0fP16//vqrtm7dKh8fnxK1Izs7W2FhYcrKylJoaGjpDgJQTZRkshqgrJjoCN6sMuKE8sZQVQHxk424iJcOFyVUBXxvS47vrFcqaZxQppFSBdLS0pSWlqamTZsqODhYpc1vJSYmqk+fPmratKmaNm2qJ598UrVq1dJnn30mY4zmzp2ryZMna8CAAYqLi9PixYt18uRJLVu2TJKUlZWlBQsW6Nlnn1X37t3Vtm1bLV26VDt27NC6devK0zUAAIBKU94YCgAAwBuUKSl15MgRdevWTU2bNlWfPn2UlpYmSbr77rvLPJVxXl6eVqxYoRMnTqhTp07au3ev0tPT1bNnT6uO0+lUQkKCNm3aJEnaunWrzpw541YnKipKcXFxVh0AAICqojJiKAAAgOqqTEmpBx98UH5+ftq/f7+CgoKs8ttuu00ffPBBqba1Y8cO1apVS06nU/fee69WrlypFi1aKD09XZIUGRnpVj8yMtJal56eLn9/f7dplc+vU5ScnBxlZ2e7LQAAAJWtImMoAACA6s63LG9as2aNPvzwQzVo0MCtPDY2Vvv27SvVtpo1a6bt27fr6NGjevPNNzV8+HClpqZa6x0Oh1t9Y0yhsvNdrE5KSoqmTp1aqnYCAACUV0XGUAAAANVdmUZKnThxwu3XvQK//PKLnE5nqbbl7++vK664Qh06dFBKSoratGmjv/71r3K5XJJUaMRTRkaGNXrK5XIpNzdXmZmZxdYpyqRJk5SVlWUtBw4cKFWbAQAAyqIiYygAAIDqrkxJqeuvv16vvvqq9drhcCg/P19PP/20unbtWq4GGWOUk5OjmJgYuVwurV271lqXm5ur1NRUxcfHS5Lat28vPz8/tzppaWnauXOnVacoTqdToaGhbgsAAEBlq8wYCgAAoLopU1Lq6aef1osvvqjevXsrNzdXEydOVFxcnD755BPNnDmzxNt59NFH9emnn+rHH3/Ujh07NHnyZH388ccaMmSIHA6HkpKSNGPGDK1cuVI7d+7UiBEjFBQUpMGDB0uSwsLCNHLkSI0fP17r16/XV199pTvuuEOtWrVS9+7dy9I1AACASlMRMdT8+fPVunVr64e1Tp06afXq1dZ6Y4ySk5MVFRWlwMBAdenSRbt27XLbRk5OjsaOHas6deooODhY/fv318GDByu0rwAAABdTpqRUixYt9M033+gPf/iDevTooRMnTmjAgAH66quvdPnll5d4O4cPH9bQoUPVrFkzdevWTZ9//rk++OAD9ejRQ5I0ceJEJSUlafTo0erQoYMOHTqkNWvWKCQkxNrGnDlzdPPNN2vgwIHq3LmzgoKCtGrVKvn4+JSlawAAAJWmImKoBg0a6KmnntKXX36pL7/8UjfccINuuukmK/E0a9YszZ49W88//7y2bNkil8ulHj166NixY9Y2kpKStHLlSq1YsUIbN27U8ePH1a9fP+Xl5VVKvwEAAIriMMaY0rzhzJkz6tmzp1588UU1bdq0stplq+zsbIWFhSkrK4tb+eC1EhM93QJ4s1WrPN0CoPJUVJxQmTFUeHi4nn76ad11112KiopSUlKSHn74YUm/jYqKjIzUzJkzNWrUKGVlZalu3bpasmSJbrvtNknSTz/9pIYNG+r9999Xr169SrRP4icbcREvHS5KqAr43pYc31mvVNI4odQjpfz8/LRz586LzoAHAACAcyojhsrLy9OKFSt04sQJderUSXv37lV6erp69uxp1XE6nUpISNCmTZskSVu3brUSZAWioqIUFxdn1SlKTk6OsrOz3RYAAIDyKNPte8OGDdOCBQsqui0AAABeraJiqB07dqhWrVpyOp269957tXLlSrVo0cKatfj8WYgjIyOtdenp6fL391ft2rWLrVOUlJQUhYWFWUvDhg3L3Q8AAFCz+ZblTbm5uXrllVe0du1adejQQcHBwW7rZ8+eXSGNAwAA8CYVFUM1a9ZM27dv19GjR/Xmm29q+PDhSk1NtdafPxrLGHPREVoXqzNp0iQ99NBD1uvs7GwSUwAAoFxKlZT64Ycf1LhxY+3cuVPt2rWTJH3//fdudbitDwAAwF1Fx1D+/v664oorJEkdOnTQli1b9Ne//tV6jlR6errq169v1c/IyLBGT7lcLuXm5iozM9NttFRGRobi4+OL3afT6ZTT6SxxGwEAAC6mVEmp2NhYpaWl6aOPPpIk3XbbbXruuecKDREHAADAOZUdQxljlJOTo5iYGLlcLq1du1Zt27aV9NvorNTUVM2cOVOS1L59e/n5+Wnt2rUaOHCgJCktLU07d+7UrFmzKqQ9AAAAJVGqpNT5E/WtXr1aJ06cqNAGAQAAeJuKjKEeffRR9e7dWw0bNtSxY8e0YsUKffzxx/rggw/kcDiUlJSkGTNmKDY2VrGxsZoxY4aCgoI0ePBgSVJYWJhGjhyp8ePHKyIiQuHh4ZowYYJatWql7t27l7uvAAAAJVWmZ0oVOD/AAgAAwMWVJ4Y6fPiwhg4dqrS0NIWFhal169b64IMP1KNHD0nSxIkTderUKY0ePVqZmZnq2LGj1qxZo5CQEGsbc+bMka+vrwYOHKhTp06pW7duWrRokXx8fMrdNwAAgJIqVVLK4XAUet4Bz5ACAAC4sIqMoS42e5/D4VBycrKSk5OLrRMQEKB58+Zp3rx5ZWoDAABARSj17XsjRoywHnJ5+vRp3XvvvYVmjnnrrbcqroUAAADVHDEUAABAYaVKSg0fPtzt9R133FGhjQEAAPBGxFAAAACFlSoptXDhwspqBwAAgNcihgIAACjsEk83AAAAAAAAADUPSSkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2I6kFAAAAAAAAGzn6+kGACifxERPtwAAAAAAgNJjpBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbOfr6QYAAKq/xMSL11m1qvLbAQAAAKD6YKQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2M7X0w0AAAAAaqzERE+3AAAAj2GkFAAAAAAAAGxHUgoAAAAAAAC2IykFAAAAAAAA25GUAgAAAAAAgO1ISgEAAAAAAMB2JKUAAAAAAABgO19PNwAAAAAAgGohMdHTLQC8CiOlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2I6kFAAAAAAAAGzn6+kGACheYqKnWwAAAAAAQOVgpBQAAAAAAABsx0gpAAAAAADgGSW9PWTVqsptBzyCkVIAAAAAAACwHUkpAAAAAAAA2I6kFAAAAAAAAGzn0aRUSkqKrr76aoWEhKhevXq6+eabtXv3brc6xhglJycrKipKgYGB6tKli3bt2uVWJycnR2PHjlWdOnUUHBys/v376+DBg3Z2BQAAAAAAAKXg0aRUamqqxowZo88++0xr167V2bNn1bNnT504ccKqM2vWLM2ePVvPP/+8tmzZIpfLpR49eujYsWNWnaSkJK1cuVIrVqzQxo0bdfz4cfXr1095eXme6BYAAAAAAAAuwqOz733wwQdurxcuXKh69epp69atuv7662WM0dy5czV58mQNGDBAkrR48WJFRkZq2bJlGjVqlLKysrRgwQItWbJE3bt3lyQtXbpUDRs21Lp169SrVy/b+wUAAAAAAIALq1LPlMrKypIkhYeHS5L27t2r9PR09ezZ06rjdDqVkJCgTZs2SZK2bt2qM2fOuNWJiopSXFycVed8OTk5ys7OdlsAAAAAAABgnyqTlDLG6KGHHtK1116ruLg4SVJ6erokKTIy0q1uZGSktS49PV3+/v6qXbt2sXXOl5KSorCwMGtp2LBhRXcHAAAAAAAAF1BlklL333+/vvnmGy1fvrzQOofD4fbaGFOo7HwXqjNp0iRlZWVZy4EDB8recABAiSQmlmwBcGFMFAMAALxFlUhKjR07Vu+8844++ugjNWjQwCp3uVySVGjEU0ZGhjV6yuVyKTc3V5mZmcXWOZ/T6VRoaKjbAgAAUB0wUQwAAPAWHk1KGWN0//3366233tKGDRsUExPjtj4mJkYul0tr1661ynJzc5Wamqr4+HhJUvv27eXn5+dWJy0tTTt37rTqAAAAeIsPPvhAI0aMUMuWLdWmTRstXLhQ+/fv19atWyWp0EQxcXFxWrx4sU6ePKlly5ZJkjVRzLPPPqvu3burbdu2Wrp0qXbs2KF169Z5snsAAKAG8ejse2PGjNGyZcv0v//7vwoJCbFGRIWFhSkwMFAOh0NJSUmaMWOGYmNjFRsbqxkzZigoKEiDBw+26o4cOVLjx49XRESEwsPDNWHCBLVq1cqajQ8AAMBblXaimFGjRl10opiiZi/OyclRTk6O9ZqJYlBllfRe8FWrKrcdAICL8mhSav78+ZKkLl26uJUvXLhQI0aMkCRNnDhRp06d0ujRo5WZmamOHTtqzZo1CgkJserPmTNHvr6+GjhwoE6dOqVu3bpp0aJF8vHxsasrAAAAtivtRDH79u2z6pRlopipU6dWdBcAAEAN5tGklDHmonUcDoeSk5OVnJxcbJ2AgADNmzdP8+bNq8DWAQAAVG0FE8Vs3Lix0LrKmCjmoYcesl5nZ2czgzEAACiXKvGgcwAAAJQOE8UAAIDqjqQUAABANcJEMQAAwFt49PY9AAAAlA4TxQAAAG9BUgoAAKAaYaIYAADgLUhKAQAAVCNMFAMAALwFz5QCAAAAAACA7UhKAQAAAAAAwHbcvgcAqFISEy9eZ9Wqym8HAAAAgMrFSCkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2I6kFAAAAAAAAGxHUgoAAAAAAAC2IykFAAAAAAAA25GUAgAAAAAAgO1ISgEAAAAAAMB2JKUAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALbz9XQDAAAAAK+UmOjpFgAAUKUxUgoAAAAAAAC2IykFAAAAAAAA25GUAgAAAAAAgO14phTgATxiAgAAAABQ05GUAgAAAAAAVVtJftlftary24EKxe17AAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsxzOlgArGQ8wBAAAAALg4RkoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjgedAwAAAADAjEWA7RgpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALYjKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwna+nGwAAQGklJpas3qpVldsOAAAAAGXHSCkAAAAAAADYjqQUAAAAAAAAbEdSCgAAAAAAALbzaFLqk08+UWJioqKiouRwOPT222+7rTfGKDk5WVFRUQoMDFSXLl20a9cutzo5OTkaO3as6tSpo+DgYPXv318HDx60sRcAAAAAqp3ExIsvAIBK5dGk1IkTJ9SmTRs9//zzRa6fNWuWZs+ereeff15btmyRy+VSjx49dOzYMatOUlKSVq5cqRUrVmjjxo06fvy4+vXrp7y8PLu6AQAAAAAAgFLyaFKqd+/emj59ugYMGFBonTFGc+fO1eTJkzVgwADFxcVp8eLFOnnypJYtWyZJysrK0oIFC/Tss8+qe/fuatu2rZYuXaodO3Zo3bp1dncHAADAFow2BwAA3qDKPlNq7969Sk9PV8+ePa0yp9OphIQEbdq0SZK0detWnTlzxq1OVFSU4uLirDpFycnJUXZ2ttsCAABQXTDaHAAAeANfTzegOOnp6ZKkyMhIt/LIyEjt27fPquPv76/atWsXqlPw/qKkpKRo6tSpFdxiAAAAe/Tu3Vu9e/cuct35o80lafHixYqMjNSyZcs0atQoa7T5kiVL1L17d0nS0qVL1bBhQ61bt069evWyrS8AAKDmqrIjpQo4HA6318aYQmXnu1idSZMmKSsry1oOHDhQIW0FAADwtMoabc5IcwAAUNGqbFLK5XJJUqERTxkZGdboKZfLpdzcXGVmZhZbpyhOp1OhoaFuCwAAgDe40GjzgnVlGW2ekpKisLAwa2nYsGEltB4AANQkVTYpFRMTI5fLpbVr11plubm5Sk1NVXx8vCSpffv28vPzc6uTlpamnTt3WnUAAABqoooebc5IcwAAUNE8+kyp48eP6z//+Y/1eu/evdq+fbvCw8PVqFEjJSUlacaMGYqNjVVsbKxmzJihoKAgDR48WJIUFhamkSNHavz48YqIiFB4eLgmTJigVq1aWc9HAAAAqEl+P9q8fv36Vnlxo81/P1oqIyOj2B/2nE6nnE5nJbYcAADUNB5NSn355Zfq2rWr9fqhhx6SJA0fPlyLFi3SxIkTderUKY0ePVqZmZnq2LGj1qxZo5CQEOs9c+bMka+vrwYOHKhTp06pW7duWrRokXx8fGzvD7xbYqKnWwAAwMX9frR527ZtJZ0bbT5z5kxJ7qPNBw4cKOncaPNZs2Z5rO0AAKBm8WhSqkuXLjLGFLve4XAoOTlZycnJxdYJCAjQvHnzNG/evEpoIQAAQNXDaHMAAOANPJqUAgAAQOkx2hwAAHgDh7nQUKUaIjs7W2FhYcrKymImPhSL2/eA6mfVKk+3AN6AOKFoHJcSIHio/riQ1Cx8Z6s/vrNVRknjBEZKAQAAAKXBf1wBAKgQl3i6AQAAAAAAAKh5GCkFAPBaJRnMwChvAAAAwDMYKQUAAAAAAADbkZQCAAAAAACA7UhKAQAAAAAAwHY8UwoAUKPx3CkAAADAMxgpBQAAAAAAANuRlAIAAAAAAIDtuH0PAAAAAABUfyV5LoPEsxmqEJJSgEr+twsAAAAAAFQMbt8DAAAAAACA7UhKAQAAAAAAwHYkpQAAAAAAAGA7klIAAAAAAACwHUkpAAAAAAAA2I7Z9wAAAAAA3ouptoEqi5FSAAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALAdSSkAAAAAAADYztfTDQAAAACAKikxsWT1Vq2q3HYAgJdipBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDteNA5AAAAUKCkD7YGAADlxkgpAAAAAAAA2I6kFAAAAAAAAGxHUgoAAAAAAAC2IykFAAAAAAAA2/GgcwAAAABA9cTkBEC1RlIKXo1rFICKUNK/JatWVW47AAAAAG/C7XsAAAAAAACwHUkpAAAAAAAA2I6kFAAAAAAAAGzHM6VQbfG8KAAAAFQJJQlMefAgABTCSCkAAAAAAADYjqQUAAAAAAAAbMftewAAVBDu3gAAAABKjpFSAAAAAAAAsB1JKQAAAAAAANiO2/cAAAAAAEDNwTMXqgySUgAA2KgkMZBEHAQAAADvx+17AAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsxzOlUOWU9HkrAAAAALwU/ykAagSSUgAAAPB+/AcXAFAazE5jC5JSqDDMqgkAAAAAAEqKpBQAAACqN0ZBAQBQLZGUAgCgCmL0KQAAALwds+8BAAAAAADAdoyUgq0YXQ8AAAAAACSSUgAAAAAAO/FLNYD/j6QUAAAAAFQ2ppcHgEJISgEA4OV4aDoAAACqIpJSAABUU9z9AAAAgOrMa5JSL7zwgp5++mmlpaWpZcuWmjt3rq677jpPN6vK49dzAABqtiodQ5F5BQBUdfynuly8Iin12muvKSkpSS+88II6d+6sF198Ub1799a3336rRo0aebp5AAAAVRIxFFAFVWQylv8IA6jiHMYY4+lGlFfHjh3Vrl07zZ8/3ypr3ry5br75ZqWkpFz0/dnZ2QoLC1NWVpZCQ0Mrs6lVDj9AAgBKoyb+/8ab44TyxFC2HBcCFaB87P6jzXcWKFoNDKBKGidU+5FSubm52rp1qx555BG38p49e2rTpk0ealVhjOgDAKD0mKyq8lSXGAoAAHivap+U+uWXX5SXl6fIyEi38sjISKWnpxf5npycHOXk5Fivs7KyJP2WyassZ85cvM6NN1bc/l5/vWT1StIuAAAK2H2tKul1qhIv4VZ84AWDy92UNobyRPxEoAKUU0m+nwMHVn47gJquIq+VFfmdLWnioAxKGj9V+6RUAYfD4fbaGFOorEBKSoqmTp1aqLxhw4aV0jZPCAvzdAsAALiwirxW2XHdO3bsmMK88AJb0hiqJsRPgNfxwr9ZQLVUVb+LNrTrYvFTtU9K1alTRz4+PoV+0cvIyCj0y1+BSZMm6aGHHrJe5+fn69dff1VERESxiSxvkZ2drYYNG+rAgQNe91wMu3AMy4fjV34cw/Lh+JVfTTuGxhgdO3ZMUVFRnm5KhSptDFWS+KmmnRv017vRX+9Wk/pbk/oq0d+qoqTxU7VPSvn7+6t9+/Zau3atbrnlFqt87dq1uummm4p8j9PplNPpdCu79NJLK7OZVU5oaGiVOmGrI45h+XD8yo9jWD4cv/KrScfQG0dIlTaGKk38VJPODYn+ejv6691qUn9rUl8l+lsVlCR+qvZJKUl66KGHNHToUHXo0EGdOnXSSy+9pP379+vee+/1dNMAAACqLGIoAADgSV6RlLrtttt05MgRTZs2TWlpaYqLi9P777+v6OhoTzcNAACgyiKGAgAAnuQVSSlJGj16tEaPHu3pZlR5TqdTU6ZMKTT8HiXHMSwfjl/5cQzLh+NXfhxD71KRMVRNOzfor3ejv96tJvW3JvVVor/VjcN42/zGAAAAAAAAqPIu8XQDAAAAAAAAUPOQlAIAAAAAAIDtSEoBAAAAAADAdiSlapgXXnhBMTExCggIUPv27fXpp596ukmVLiUlRVdffbVCQkJUr1493Xzzzdq9e7dbHWOMkpOTFRUVpcDAQHXp0kW7du1yq5OTk6OxY8eqTp06Cg4OVv/+/XXw4EG3OpmZmRo6dKjCwsIUFhamoUOH6ujRo2519u/fr8TERAUHB6tOnTp64IEHlJubWyl9rwwpKSlyOBxKSkqyyjh+F3fo0CHdcccdioiIUFBQkK666ipt3brVWs8xLN7Zs2f12GOPKSYmRoGBgWrSpImmTZum/Px8qw7Hz90nn3yixMRERUVFyeFw6O2333ZbX9WO144dO5SQkKDAwEBddtllmjZtmnjkpX2q2/lSHjUtJpg/f75at26t0NBQhYaGqlOnTlq9erVX9vV8NSFeSU5OlsPhcFtcLpfX9rcmxVKNGzcu9Nk6HA6NGTPG6/oq1cxY79ixY0pKSlJ0dLQCAwMVHx+vLVu2eG1/L8igxlixYoXx8/MzL7/8svn222/NuHHjTHBwsNm3b5+nm1apevXqZRYuXGh27txptm/fbvr27WsaNWpkjh8/btV56qmnTEhIiHnzzTfNjh07zG233Wbq169vsrOzrTr33nuvueyyy8zatWvNtm3bTNeuXU2bNm3M2bNnrTo33nijiYuLM5s2bTKbNm0ycXFxpl+/ftb6s2fPmri4ONO1a1ezbds2s3btWhMVFWXuv/9+ew5GOX3xxRemcePGpnXr1mbcuHFWOcfvwn799VcTHR1tRowYYT7//HOzd+9es27dOvOf//zHqsMxLN706dNNRESEeffdd83evXvNv/71L1OrVi0zd+5cqw7Hz937779vJk+ebN58800jyaxcudJtfVU6XllZWSYyMtLcfvvtZseOHebNN980ISEh5plnnqm8AwQ31el8Ka+aFhO888475r333jO7d+82u3fvNo8++qjx8/MzO3fu9Lq+/l5NiVemTJliWrZsadLS0qwlIyPDK/tb02KpjIwMt8917dq1RpL56KOPvK6vxtTMWG/gwIGmRYsWJjU11ezZs8dMmTLFhIaGmoMHD3plfy+EpFQN8oc//MHce++9bmVXXnmleeSRRzzUIs/IyMgwkkxqaqoxxpj8/HzjcrnMU089ZdU5ffq0CQsLM3//+9+NMcYcPXrU+Pn5mRUrVlh1Dh06ZC655BLzwQcfGGOM+fbbb40k89lnn1l1Nm/ebCSZf//738aY3wL/Sy65xBw6dMiqs3z5cuN0Ok1WVlbldboCHDt2zMTGxpq1a9eahIQEK8jj+F3cww8/bK699tpi13MML6xv377mrrvucisbMGCAueOOO4wxHL+LOT/JUNWO1wsvvGDCwsLM6dOnrTopKSkmKirK5OfnV+CRQElU9fOlotXEmKB27drmlVde8dq+1qR4ZcqUKaZNmzZFrvO2/tb0WGrcuHHm8ssvN/n5+V7Z15oW6508edL4+PiYd9991628TZs2ZvLkyV7X34vh9r0aIjc3V1u3blXPnj3dynv27KlNmzZ5qFWekZWVJUkKDw+XJO3du1fp6elux8bpdCohIcE6Nlu3btWZM2fc6kRFRSkuLs6qs3nzZoWFhaljx45WnWuuuUZhYWFudeLi4hQVFWXV6dWrl3JyctyGH1dFY8aMUd++fdW9e3e3co7fxb3zzjvq0KGD/vSnP6levXpq27atXn75ZWs9x/DCrr32Wq1fv17ff/+9JOnrr7/Wxo0b1adPH0kcv9Kqasdr8+bNSkhIkNPpdKvz008/6ccff6z4A4BSqWrnS0WrSTFBXl6eVqxYoRMnTqhTp05e29eaFq/s2bNHUVFRiomJ0e23364ffvjBK/tbk2Op3NxcLV26VHfddZccDodX9rWmxXpnz55VXl6eAgIC3MoDAwO1ceNGr+vvxfjashd43C+//KK8vDxFRka6lUdGRio9Pd1DrbKfMUYPPfSQrr32WsXFxUmS1f+ijs2+ffusOv7+/qpdu3ahOgXvT09PV7169Qrts169em51zt9P7dq15e/vX6U/hxUrVmjbtm1u9zkX4Phd3A8//KD58+froYce0qOPPqovvvhCDzzwgJxOp4YNG8YxvIiHH35YWVlZuvLKK+Xj46O8vDw9+eSTGjRokCTOwdKqascrPT1djRs3LrSfgnUxMTFl6SYqSFU7XypSTYkJduzYoU6dOun06dOqVauWVq5cqRYtWlj/IfGmvta0eKVjx4569dVX1bRpUx0+fFjTp09XfHy8du3a5XX9rcmx1Ntvv62jR49qxIgR1v4L2v171bmvNS3WCwkJUadOnfTEE0+oefPmioyM1PLly/X5558rNjbW6/p7MSSlahiHw+H22hhTqMyb3X///frmm2+0cePGQuvKcmzOr1NU/bLUqUoOHDigcePGac2aNYWy+b/H8Stefn6+OnTooBkzZkiS2rZtq127dmn+/PkaNmyYVY9jWLTXXntNS5cu1bJly9SyZUtt375dSUlJioqK0vDhw616HL/SqUrHq6i2FPdeeEZVOl8qSk2JCZo1a6bt27fr6NGjevPNNzV8+HClpqYW24bq2teaGK/07t3b+nerVq3UqVMnXX755Vq8eLGuueaaIttRXftbk2OpBQsWqHfv3m4jWYpqQ3Xua02M9ZYsWaK77rpLl112mXx8fNSuXTsNHjxY27ZtK7Yd1bm/F8LtezVEnTp15OPjUyjbmZGRUSgz6q3Gjh2rd955Rx999JEaNGhglRfMUnKhY+NyuZSbm6vMzMwL1jl8+HCh/f78889udc7fT2Zmps6cOVNlP4etW7cqIyND7du3l6+vr3x9fZWamqrnnntOvr6+biMafo/jd079+vXVokULt7LmzZtr//79kjgHL+bPf/6zHnnkEd1+++1q1aqVhg4dqgcffFApKSmSOH6lVdWOV1F1MjIyJBX+hRD2q2rnS0WpSTGBv7+/rrjiCnXo0EEpKSlq06aN/vrXv3pdX4lXpODgYLVq1Up79uzxus+3psZS+/bt07p163T33XdbZd7Y15oY611++eVKTU3V8ePHdeDAAX3xxRc6c+aMYmJivLK/F0JSqobw9/dX+/bttXbtWrfytWvXKj4+3kOtsocxRvfff7/eeustbdiwodCtIAVf/N8fm9zcXKWmplrHpn379vLz83Ork5aWpp07d1p1OnXqpKysLH3xxRdWnc8//1xZWVludXbu3Km0tDSrzpo1a+R0OtW+ffuK73wF6Natm3bs2KHt27dbS4cOHTRkyBBt375dTZo04fhdROfOnQtNOf79998rOjpaEufgxZw8eVKXXOJ+ufLx8bGmCeb4lU5VO16dOnXSJ5984jb18Jo1axQVFVXotj7Yr6qdL+VFTPDbMcjJyfG6vhKv/DY9/Hfffaf69et73edbU2OphQsXql69eurbt69V5o19rcmxXnBwsOrXr6/MzEx9+OGHuummm7y6v0WqgIelo5pYsWKF8fPzMwsWLDDffvutSUpKMsHBwebHH3/0dNMq1X333WfCwsLMxx9/7Da16smTJ606Tz31lAkLCzNvvfWW2bFjhxk0aFCRU242aNDArFu3zmzbts3ccMMNRU652bp1a7N582azefNm06pVqyKn3OzWrZvZtm2bWbdunWnQoEGVm07+Yn4/m40xHL+L+eKLL4yvr6958sknzZ49e8w///lPExQUZJYuXWrV4RgWb/jw4eayyy6zpgl+6623TJ06dczEiROtOhw/d8eOHTNfffWV+eqrr4wkM3v2bPPVV1+Zffv2GWOq1vE6evSoiYyMNIMGDTI7duwwb731lgkNDTXPPPOMDUcKxlSv86W8alpMMGnSJPPJJ5+YvXv3mm+++cY8+uij5pJLLjFr1qzxur4WxdvjlfHjx5uPP/7Y/PDDD+azzz4z/fr1MyEhIVZs7039rYmxVF5enmnUqJF5+OGHC63ztr7WxFjvgw8+MKtXrzY//PCDWbNmjWnTpo35wx/+YHJzc72yvxdCUqqG+dvf/maio6ONv7+/adeunTUFsjeTVOSycOFCq05+fr6ZMmWKcblcxul0muuvv97s2LHDbTunTp0y999/vwkPDzeBgYGmX79+Zv/+/W51jhw5YoYMGWJCQkJMSEiIGTJkiMnMzHSrs2/fPtO3b18TGBhowsPDzf333+82FXp1cH6Qx/G7uFWrVpm4uDjjdDrNlVdeaV566SW39RzD4mVnZ5tx48aZRo0amYCAANOkSRMzefJkk5OTY9Xh+Ln76KOPivy7N3z4cGNM1Tte33zzjbnuuuuM0+k0LpfLJCcnm/z8/Ao/LihadTtfyqOmxQR33XWXFffVrVvXdOvWzUpIeVtfi+Lt8cptt91m6tevb/z8/ExUVJQZMGCA2bVrl9f2t6bFUh9++KGRZHbv3l1onbf1tSbGeq+99ppp0qSJ8ff3Ny6Xy4wZM8YcPXrUa/t7IQ5j/v/TRAEAAAAAAACb8EwpAAAAAAAA2I6kFAAAAAAAAGxHUgoAAAAAAAC2IykFAAAAAAAA25GUAgAAAAAAgO1ISgEAAAAAAMB2JKUAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANiOpBSAamnEiBG6+eabPd0MAACAaoP4CUBVQ1IKAAAAAAAAtiMpBaDa69Klix544AFNnDhR4eHhcrlcSk5Odqtz9OhR3XPPPYqMjFRAQIDi4uL07rvvWuvffPNNtWzZUk6nU40bN9azzz7r9v7GjRtr+vTpGjZsmGrVqqXo6Gj97//+r37++WfddNNNqlWrllq1aqUvv/zS7X2bNm3S9ddfr8DAQDVs2FAPPPCATpw4UWnHAgAAoCSInwBUBSSlAHiFxYsXKzg4WJ9//rlmzZqladOmae3atZKk/Px89e7dW5s2bdLSpUv17bff6qmnnpKPj48kaevWrRo4cKBuv/127dixQ8nJyXr88ce1aNEit33MmTNHnTt31ldffaW+fftq6NChGjZsmO644w5t27ZNV1xxhYYNGyZjjCRpx44d6tWrlwYMGKBvvvlGr732mjZu3Kj777/f1mMDAABQFOInAJ7mMAXffgCoRkaMGKGjR4/q7bffVpcuXZSXl6dPP/3UWv+HP/xBN9xwg5566imtWbNGvXv31nfffaemTZsW2taQIUP0888/a82aNVbZxIkT9d5772nXrl2Sfvul77rrrtOSJUskSenp6apfv74ef/xxTZs2TZL02WefqVOnTkpLS5PL5dKwYcMUGBioF1980druxo0blZCQoBMnTiggIKBSjg0AAEBRiJ8AVDWMlALgFVq3bu32un79+srIyJAkbd++XQ0aNCgyoJKk7777Tp07d3Yr69y5s/bs2aO8vLwi9xEZGSlJatWqVaGygv1u3bpVixYtUq1ataylV69eys/P1969e8vaVQAAgApB/ATA03w93QAAqAh+fn5urx0Oh/Lz8yVJgYGBF3yvMUYOh6NQ2YX2UVC/qLKC/ebn52vUqFF64IEHCm2rUaNGF2wTAABAZSN+AuBpJKUAeL3WrVvr4MGD+v7774v8ta9FixbauHGjW9mmTZvUtGlT67kJZdGuXTvt2rVLV1xxRZm3AQAA4AnETwDswO17ALxeQkKCrr/+et16661au3at9u7dq9WrV+uDDz6QJI0fP17r16/XE088oe+//16LFy/W888/rwkTJpRrvw8//LA2b96sMWPGaPv27dqzZ4/eeecdjR07tiK6BQAAUGmInwDYgaQUgBrhzTff1NVXX61BgwapRYsWmjhxovW8g3bt2un111/XihUrFBcXp7/85S+aNm2aRowYUa59tm7dWqmpqdqzZ4+uu+46tW3bVo8//rjq169fAT0CAACoXMRPACobs+8BAAAAAADAdoyUAgAAAAAAgO1ISgEAAAAAAMB2JKUAAAAAAABgO5JSAAAAAAAAsB1JKQAAAAAAANiOpBQAAAAAAABsR1IKAAAAAAAAtiMpBQAAAAAAANuRlAIAAAAAAIDtSEoBAAAAAADAdiSlAAAAAAAAYDuSUgAAAAAAALDd/wMTK9IH5yqBIwAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByIElEQVR4nO3de1xU1f7/8Td3UATUBDQVtbzhNbVw8nqUJCW/mZxK84Lp6eLBSu1qWXkpLSs1y0t1TC3zWHa0Ust7WSpeMi2VUisLSwFTAbEEhfX7ox+jI6CAsAeG1/PxmEftvdfs/Vl7ZpiPn1l7bTdjjBEAAAAAAABgIXdnBwAAAAAAAICKh6IUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFFAOdO3aVV27di3Rff7yyy9yc3PT/PnzS3S/ZfW4uDLz58+Xm5ubfvnll1I/1pAhQ1SvXj37cu575uWXXy71Y0vSuHHj5ObmZsmxAKCsq1evnoYMGVLs595yyy0lG1Axldb3WGnkaGX5uLgybm5uGjduXKkf54svvpCbm5u++OIL+7quXbuqefPmpX5siXwfRUNRCuVaboLx9ddfOzsUB7lx5T58fX3VqFEjjRgxQsnJyc4OzxKLFi3S9OnTnR2GgyFDhsjf39/ZYThdbqKS+/Dx8VFISIi6du2qSZMm6dixYyVynD///FPjxo1zSIjKirIcGwCUlsvlTVb+o7UwLvyucnd3V61atdSjR48K87c7ISFB48aNs+QHocLKzSE+/PBDZ4fidPXq1XN4fwYFBalFixa69957tW3bthI7TlnMqXOV5dhQfng6OwDAlU2YMEH169fXmTNntGnTJs2ePVuffvqp9u7dq0qVKjk1trCwMP3111/y8vIqlf0vWrRIe/fu1ciRIy09LgrvwQcf1PXXX6/s7GwdO3ZMW7Zs0bPPPqupU6fqgw8+ULdu3extBw0apH79+snHx6fQ+//zzz81fvx4SSrSr7lvvfWWcnJyCt2+OC4V29ixY/XEE0+U6vEBoLzYv3+/3N2d9zv2TTfdpMGDB8sYo0OHDmnWrFnq1q2bVq5cqZ49ezotrlxr1qwptX0nJCRo/Pjx6tq1q8MI4tI+LgqvdevWevjhhyVJp06d0vfff68lS5borbfe0qhRozR16lSH9n/99Zc8PYv2T/CCcupL6dy5s/766y95e3sX6VhFRb6PkkBRCihFPXv2VLt27SRJ//rXv1S9enVNnTpVH3/8sfr37++UmM6dO6ecnBx5e3vL19fX8uPnjhyD83Xq1En//Oc/HdZ9++236tGjh2JiYpSQkKCaNWtKkjw8POTh4VGq8Zw+fVqVK1d2egLj6elZ5IQRAFxVUX6MKA2NGjXSwIED7cu33XabWrZsqenTpzu1KPXnn3+qUqVKpf6P/oI467hwdPXVVzu8PyXpxRdf1F133aVp06apYcOGGj58uH1baefAZ86ckbe3t9zd3Z2ab5Pvoyi4fA8Vwq5du9SzZ08FBATI399f3bt319atW+3bU1NT5eHhoRkzZtjX/fHHH3J3d1f16tVljLGvHz58uEJDQ4sVR+7Ik0OHDkn6u0A0ceJEXXPNNfLx8VG9evX05JNPKjMz85L7ycrK0jPPPKO2bdsqMDBQlStXVqdOnfT55587tLtwLp7p06fbj5OQkJDnWu+LL+m68HHhr3Mff/yxoqOjVatWLfn4+Oiaa67RxIkTlZ2dbW/TtWtXrVy5Ur/++muefRR0jfmGDRvUqVMnVa5cWUFBQbr11lv1/fffO7TJnevnxx9/1JAhQxQUFKTAwEDdfffd+vPPPwv7MjjIne9i06ZNuuGGG+Tr66sGDRronXfeydM2NTVVo0aNUr169eTj46PatWtr8ODB+uOPP+xtUlJSNGzYMIWEhMjX11etWrXSggULHPZz4esyc+ZMNWjQQJUqVVKPHj10+PBhGWM0ceJE1a5dW35+frr11lt14sSJPPF89tln9nNWpUoVRUdHa9++fcU6D7latWql6dOnKzU1Va+//rp9fX5zcXz99deKiorSVVddJT8/P9WvX19Dhw6197FGjRqSpPHjx9vfB7nzKOReSvnTTz+pV69eqlKligYMGGDfdvEvwrmmTZumsLAw+fn5qUuXLtq7d6/D9oLm2Lhwn5eLLb85pQr7WS3K+wkAyoP85pT67rvv1KVLF/n5+al27dp67rnnNG/evALnbCrJv4ktWrTQVVddZc+lpMLlEPkpTE4jnb+scefOnercubMqVaqkJ5980r7twu+dCy/puviRe9nhr7/+qn//+99q3Lix/Pz8VL16dd1+++0O527+/Pm6/fbbJUn/+Mc/8uwjv++7ouYgb775pv177frrr9eOHTsue87yU9T8bOHChbrhhhtUqVIlVa1aVZ07d84z8mvWrFlq1qyZfHx8VKtWLcXFxSk1NdWhTe7rkvt+rFSpkq699lr7pYUbN25URESE/Pz81LhxY61bty5PLL///ruGDh2qkJAQ+fj4qFmzZnr77beLdR5y+fn56d1331W1atX0/PPPO/w74uI5pU6dOqWRI0fac8vg4GDddNNN+uabb+x9LCinzs3dFy9erLFjx+rqq69WpUqVlJ6enu+cUrl27typG2+80Z67zZkzx2F7QfOvXbzP8pTvo2zjp2C4vH379qlTp04KCAjQY489Ji8vL73xxhvq2rWr/csqKChIzZs315dffqkHH3xQ0t8JlJubm06cOKGEhAQ1a9ZMkvTVV1+pU6dOxYrlp59+kiRVr15d0t+jpxYsWKB//vOfevjhh7Vt2zZNnjxZ33//vZYtW1bgftLT0/Wf//xH/fv31z333KNTp05p7ty5ioqK0vbt29W6dWuH9vPmzdOZM2d07733ysfHR9WqVctzeVTTpk317rvvOqxLTU3V6NGjFRwcbF83f/58+fv7a/To0fL399eGDRv0zDPPKD09XS+99JIk6amnnlJaWpp+++03TZs2TZIuOZfTunXr1LNnTzVo0EDjxo3TX3/9pddee00dOnTQN998k6dAcccdd6h+/fqaPHmyvvnmG/3nP/9RcHCwXnzxxQKPcSk//vij/vnPf2rYsGGKjY3V22+/rSFDhqht27b21z0jI0OdOnXS999/r6FDh6pNmzb6448/9Mknn+i3337TVVddpb/++ktdu3bVjz/+qBEjRqh+/fpasmSJhgwZotTUVD300EMOx33vvfeUlZWlBx54QCdOnNCUKVN0xx13qFu3bvriiy/0+OOP68cff9Rrr72mRx55xCFJevfddxUbG6uoqCi9+OKL+vPPPzV79mx17NhRu3btKrCoUxi552LNmjV6/vnn822TkpKiHj16qEaNGnriiScUFBSkX375RUuXLpUk1ahRQ7Nnz9bw4cN12223qW/fvpKkli1b2vdx7tw5RUVFqWPHjnr55Zcve0nrO++8o1OnTikuLk5nzpzRq6++qm7dumnPnj0KCQkpdP8KE9vFivJZLcz7CQCcKS0tzeEHlVxnz5697HN///13e5FkzJgxqly5sv7zn/8UOKKqpP8mnjx5UidPntS1114rqeg5xIUKk9PkOn78uHr27Kl+/fpp4MCBBX7vTJ8+XRkZGQ7rpk2bpt27d9vzvx07dmjLli3q16+fateurV9++UWzZ89W165dlZCQoEqVKqlz58568MEHNWPGDD355JNq2rSpJNn/e7Gi5iCLFi3SqVOndN9998nNzU1TpkxR37599fPPPxd7xHJh8rPx48dr3LhxuvHGGzVhwgR5e3tr27Zt2rBhg3r06CHp76LE+PHjFRkZqeHDh2v//v2aPXu2duzYoc2bNzvEd/LkSd1yyy3q16+fbr/9ds2ePVv9+vXTe++9p5EjR+r+++/XXXfdpZdeekn//Oc/dfjwYVWpUkWSlJycrPbt28vNzU0jRoxQjRo19Nlnn2nYsGFKT08v0uVyF/P399dtt92muXPnOvw74mL333+/PvzwQ40YMULh4eE6fvy4Nm3apO+//15t2rQpVE49ceJEeXt765FHHlFmZuYlR9GdPHlSvXr10h133KH+/fvrgw8+0PDhw+Xt7W3/YbGwylu+jzLMAOXYvHnzjCSzY8eOAtv06dPHeHt7m59++sm+7siRI6ZKlSqmc+fO9nVxcXEmJCTEvjx69GjTuXNnExwcbGbPnm2MMeb48ePGzc3NvPrqq4WKa926debYsWPm8OHDZvHixaZ69erGz8/P/Pbbb2b37t1GkvnXv/7l8NxHHnnESDIbNmywr+vSpYvp0qWLffncuXMmMzPT4XknT540ISEhZujQofZ1hw4dMpJMQECASUlJcWifu23evHn59iEnJ8fccsstxt/f3+zbt8++/s8//8zT9r777jOVKlUyZ86csa+Ljo42YWFhedrmd9zWrVub4OBgc/z4cfu6b7/91ri7u5vBgwfb1z377LNGkkMfjTHmtttuM9WrV8+3HxeKjY01lStXdlgXFhZmJJkvv/zSvi4lJcX4+PiYhx9+2L7umWeeMZLM0qVL8+w3JyfHGGPM9OnTjSSzcOFC+7asrCxjs9mMv7+/SU9PdzgHNWrUMKmpqfa2Y8aMMZJMq1atzNmzZ+3r+/fvb7y9ve3n99SpUyYoKMjcc889DnEkJSWZwMDAPOsv9vnnnxtJZsmSJQW2adWqlalatap9Ofc9fejQIWOMMcuWLbvsZ+/YsWNGknn22WfzbIuNjTWSzBNPPJHvtgvfO7nnK/ezk2vbtm1Gkhk1apR93cWflYL2eanYct9nuYryWS3s+wkAnCH3b/mlHs2aNXN4TlhYmImNjbUvP/DAA8bNzc3s2rXLvu748eOmWrVqDt8Tuc+9kr+JksywYcPMsWPHTEpKitm2bZvp3r27kWReeeUVY0zhc4iLv8eMKXxO06VLFyPJzJkzJ0/7gr53cn3wwQdGkpkwYcIljxsfH28kmXfeece+bsmSJUaS+fzzzy973KLmINWrVzcnTpywt/3444+NJLN8+fIC+2JM/jlEYfOzgwcPGnd3d3PbbbeZ7Oxsh7a5uVRKSorx9vY2PXr0cGjz+uuvG0nm7bffdjgHksyiRYvs63744Qcjybi7u5utW7fa169evTpP/jls2DBTs2ZN88cffzjE0q9fPxMYGJjv63ShsLAwEx0dXeD2adOmGUnm448/tq+7OPcIDAw0cXFxlzxOQTl17mvRoEGDPLHmbrvwvZN7vnI/O8YYk5mZaf8MZWVlGWPy/6wUtM+ymO+j/OHyPbi07OxsrVmzRn369FGDBg3s62vWrKm77rpLmzZtUnp6uqS/59dJTk7W/v37Jf09Iqpz587q1KmTvvrqK0l/j54yxhR6pFRkZKRq1KihOnXqqF+/fvL399eyZct09dVX69NPP5UkjR492uE5uZMlrly5ssD9enh42H8FycnJ0YkTJ3Tu3Dm1a9fOPtz3QjExMfbLlQpr4sSJWrFihebPn6/w8HD7ej8/P/v/nzp1Sn/88Yc6deqkP//8Uz/88EORjiFJR48e1e7duzVkyBBVq1bNvr5ly5a66aab7OfpQvfff7/DcqdOnXT8+HH7a1lU4eHhDq9pjRo11LhxY/3888/2df/73//UqlUr3XbbbXmen3up16effqrQ0FCH+cK8vLz04IMPKiMjQxs3bnR43u23367AwED7ckREhCRp4MCBDnMaRUREKCsrS7///rskae3atUpNTVX//v31xx9/2B8eHh6KiIjIcxlncfj7++vUqVMFbg8KCpIkrVixolC/rBfkwnkWLqdPnz66+uqr7cs33HCDIiIi8n2PlKSiflYL834CAGeaOXOm1q5dm+dxqRGjuVatWiWbzeYwKrtatWr2S7AvdqV/E+fOnasaNWooODhYERER2rx5s0aPHq2RI0cWK4e4UFFyGh8fH919992FijlXQkKChg4dqltvvVVjx47N97hnz57V8ePHde211yooKCjfPK4wipqD3Hnnnapatap9Ofc1upLvqsvlZx999JFycnL0zDPP5Jk8PzeXWrdunbKysjRy5EiHNvfcc48CAgLyfOf6+/urX79+9uXGjRsrKChITZs2tedV0vkcK7d/xhj973//U+/evWWMccinoqKilJaWVuzX4sLYJF02n9q2bZuOHDlS7OPExsY6vKcuxdPTU/fdd5992dvbW/fdd59SUlK0c+fOYsdwOWUh30fZxeV7cGnHjh3Tn3/+qcaNG+fZ1rRpU+Xk5Ojw4cNq1qyZ/cv4q6++Uu3atbVr1y4999xzqlGjhl5++WX7toCAALVq1apQx585c6YaNWokT09PhYSEqHHjxvYv2F9//VXu7u724ee5QkNDFRQUpF9//fWS+16wYIFeeeUV/fDDDw5Fgfr16+dpm9+6S1m1apXGjx+vMWPGKCYmxmHbvn37NHbsWG3YsCHPl0JaWlqRjiPJ3s+CXqPVq1fbJ8DOVbduXYd2uUnVyZMnFRAQUOQYLt5f7j5PnjxpX/7pp5/ynIuL/frrr2rYsGGeRCt3qP3Fr+nFx80tUNWpUyff9bnxHDx4UJIc7o53oeKcg4tlZGTYh7fnp0uXLoqJidH48eM1bdo0de3aVX369NFdd91V6ElxPT09Vbt27ULH1LBhwzzrGjVqpA8++KDQ+yiOon5WC/N+AgBnuuGGG+w3YrlQ1apV872s70K//vqrbDZbnvUX/43MdaV/E2+99VaNGDFCbm5uqlKlipo1a2bPCYqTQ1yoKDnN1VdfXaTJxdPT09W3b19dffXVeueddxzmKvzrr780efJkzZs3T7///rvDnEPFyaWkK89BLsyliuty+dlPP/0kd3d3hx87L1bQa+rt7a0GDRrk6Uft2rXzzAMZGBh42Vzq2LFjSk1N1Ztvvqk333wz31hSUlIKjLMwci/jvFQ+NWXKFMXGxqpOnTpq27atevXqpcGDBzv8mH45Rcnza9Wqlefz0KhRI0l/zwPVvn37Qu+rKMpCvo+yi6IU8P/VqlVL9evX15dffql69erJGCObzaYaNWrooYce0q+//qqvvvpKN954Y6FvjVxQ0nehi79IC2PhwoUaMmSI+vTpo0cffVTBwcHy8PDQ5MmT7fNWXaiwv55If0/CPmDAAN1000167rnnHLalpqaqS5cuCggI0IQJE3TNNdfI19dX33zzjR5//PE881SVloLuAndhUufM/V3pcS8XT+55fvfdd/OddP9K7xx39uxZHThwQM2bNy+wjZubmz788ENt3bpVy5cv1+rVqzV06FC98sor2rp16yXnFMjl4+NT4rcZd3Nzy/d1u3jS2uLuuzCc9X4CgLLoSv8m1q5dW5GRkSUZkqSi5zRFyaWkv2+wceTIEW3fvj3PP6AfeOABzZs3TyNHjpTNZlNgYKDc3NzUr1+/cptLldY+i3vMwuZSAwcOVGxsbL5tCzNy8FJyb8ZSUMFW+nvepE6dOmnZsmVas2aNXnrpJb344otaunRpoe8uWdT35uUUlO+URC5VFORTFQdFKbi0GjVqqFKlSvZL8i70ww8/yN3d3eGXlE6dOunLL79U/fr11bp1a1WpUkWtWrVSYGCgVq1apW+++Ubjx48vkdjCwsKUk5OjgwcPOkxamZycrNTUVIWFhRX43A8//FANGjTQ0qVLHb44nn322SuK6a+//lLfvn0VFBSk//73v3kKBl988YWOHz+upUuXqnPnzvb1F94BJ1dh/wGf28+CXqOrrrqqwF84rXTNNdfkudPbxcLCwvTdd98pJyfH4dzlXgJwqde0qLFIUnBwcKkk6h9++KH++usvRUVFXbZt+/bt1b59ez3//PNatGiRBgwYoMWLF+tf//pXsQqul5I7QuxCBw4ccJgYs2rVqvleenDxL6tFie1KPqsA4GrCwsL0448/5lmf3zorYpGKl0MUJacpqhdeeEEfffSRli5dqiZNmuTZ/uGHHyo2NlavvPKKfd2ZM2fy3F2uqN9VVuQgV+Kaa65RTk6OEhIS8tyUJ9eFr+mFo4WysrJ06NChEst7atSooSpVqig7O7tUcqmMjAwtW7ZMderUKXBy+lw1a9bUv//9b/373/9WSkqK2rRpo+eff95elCrJfOrIkSN5RiQdOHBAkuz5VO6IpIvfj/ldxeFq+T6cgzml4NI8PDzUo0cPffzxxw63NU1OTtaiRYvUsWNHh1+vOnXqpF9++UXvv/++/XI+d3d33XjjjZo6darOnj1b7DvvXaxXr16S/r5Ly4WmTp0qSYqOjr5kvyTHXwq2bdum+Pj4K4rp/vvv14EDB7Rs2TKHeQYuddysrCzNmjUrT9vKlSsXagh6zZo11bp1ay1YsMDhy2/v3r1as2aN/Tw5W0xMjL799tt874qYez569eqlpKQkvf/++/Zt586d02uvvSZ/f3916dKlRGKJiopSQECAJk2alO98TseOHSv2vr/99luNHDlSVatWVVxcXIHtTp48meeXqtwEMzMzU5Lsd9O7OKkpro8++sg+r5Ykbd++Xdu2bXP4JfGaa67RDz/84HAOvv32W23evNlhX0WJ7Uo+qwDgaqKiohQfH6/du3fb1504cULvvfee5bFcSQ5RlJymKNatW6exY8fqqaeeUp8+fQo89sXfoa+99lqekSi5/0gv7HeVFTnIlejTp4/c3d01YcKEPCPCcs9HZGSkvL29NWPGDIdzNHfuXKWlpZXYd66Hh4diYmL0v//9L98fHa8kl/rrr780aNAgnThxQk899dQlRx5dnCsHBwerVq1a9lxKKnxOXRjnzp3TG2+8YV/OysrSG2+8oRo1aqht27aSzv/4+eWXXzrEmt9ljq6W78M5GCkFl/D2229r1apVedY/9NBDeu6557R27Vp17NhR//73v+Xp6ak33nhDmZmZmjJlikP73ILT/v37NWnSJPv6zp0767PPPpOPj4+uv/76Eom5VatWio2N1ZtvvmkfQr59+3YtWLBAffr00T/+8Y8Cn3vLLbdo6dKluu222xQdHa1Dhw5pzpw5Cg8Pz3Mb4sJauXKl3nnnHcXExOi7777Td999Z9/m7++vPn366MYbb1TVqlUVGxurBx98UG5ubnr33XfzHUbbtm1bvf/++xo9erSuv/56+fv7q3fv3vke+6WXXlLPnj1ls9k0bNgw+y1iAwMDNW7cuGL1p6Q9+uij+vDDD3X77bdr6NChatu2rU6cOKFPPvlEc+bMUatWrXTvvffqjTfe0JAhQ7Rz507Vq1dPH374oTZv3qzp06dfck6BoggICNDs2bM1aNAgtWnTRv369VONGjWUmJiolStXqkOHDnr99dcvu5+vvvpKZ86cUXZ2to4fP67Nmzfrk08+UWBgoJYtW5bvpYG5FixYoFmzZum2227TNddco1OnTumtt95SQECAPbHw8/NTeHi43n//fTVq1EjVqlVT8+bNL3lZ4KVce+216tixo4YPH67MzExNnz5d1atX12OPPWZvM3ToUE2dOlVRUVEaNmyYUlJSNGfOHDVr1sxhvpCixHYln1UAcDWPPfaYFi5cqJtuukkPPPCAKleurP/85z+qW7euTpw4UeKjZC+nuDlEUXKaoujfv79q1Kihhg0bauHChQ7bbrrpJoWEhOiWW27Ru+++q8DAQIWHhys+Pl7r1q1T9erVHdq3bt1aHh4eevHFF5WWliYfHx9169ZNwcHBeY5rVQ5yJa699lo99dRTmjhxojp16qS+ffvKx8dHO3bsUK1atTR58mTVqFFDY8aM0fjx43XzzTfr//7v/7R//37NmjVL119/vQYOHFhi8bzwwgv6/PPPFRERoXvuuUfh4eE6ceKEvvnmG61bt04nTpy47D5+//13++uckZGhhIQELVmyRElJSXr44YcdJhW/2KlTp1S7dm3985//VKtWreTv769169Zpx44dDqPoipJTX06tWrX04osv6pdfflGjRo30/vvva/fu3XrzzTfl5eUlSWrWrJnat2+vMWPG6MSJE6pWrZoWL16sc+fO5dmfq+X7cBLL7vMHlILL3dr48OHDxhhjvvnmGxMVFWX8/f1NpUqVzD/+8Q+zZcuWfPcZHBxsJJnk5GT7uk2bNhlJplOnTkWKa8eOHZdsd/bsWTN+/HhTv3594+XlZerUqWPGjBnjcBtiY/Le9jcnJ8dMmjTJhIWFGR8fH3PdddeZFStW5Lntfe7tWF966aU8x774Vq2XOpcX7nPz5s2mffv2xs/Pz9SqVcs89thj9tvsXniL2IyMDHPXXXeZoKAgh33kd4tYY4xZt26d6dChg/Hz8zMBAQGmd+/eJiEhwaFN7i1ijx07lu/5vvjWtReLjY01lStXdlhX0O1887vF8/Hjx82IESPM1Vdfbby9vU3t2rVNbGysw62Ek5OTzd13322uuuoq4+3tbVq0aJGnrwW9LvndZvnC/l38fvr8889NVFSUCQwMNL6+vuaaa64xQ4YMMV9//fUlz0PucXIfXl5epkaNGqZz587m+eefNykpKXmec/E5/uabb0z//v1N3bp1jY+PjwkODja33HJLnmNv2bLFtG3b1nh7ezvcBjm/1yLXpd7Hr7zyiqlTp47x8fExnTp1Mt9++22e5y9cuNA0aNDAeHt7m9atW5vVq1fn2eelYst9n12osJ/VoryfAMBql8tPunTpYpo1a+awLiwszMTGxjqs27Vrl+nUqZPx8fExtWvXNpMnTzYzZswwkkxSUpLDc6/kb6IkExcXd9l2hckh8ssVCpvT5HdeCurLpfLS3H2ePHnSniv4+/ubqKgo88MPP+R7rt966y3ToEED4+Hh4bCP/M7hleQgubHnfhcWJL9cpaj52dtvv22uu+464+PjY6pWrWq6dOli1q5d69Dm9ddfN02aNDFeXl4mJCTEDB8+3Jw8edKhTUGvS0Hvu/zeT8nJySYuLs7UqVPHeHl5mdDQUNO9e3fz5ptvXvI85B4n97V1c3MzAQEBplmzZuaee+4x27Zty/c5F57jzMxM8+ijj5pWrVqZKlWqmMqVK5tWrVqZWbNmOTynoJy6oLzxwm35vY+//vprY7PZjK+vrwkLCzOvv/56nuf/9NNPJjIy0vj4+JiQkBDz5JNPmrVr15aLfB/lj5sxzBQGAAAAoPhGjhypN954QxkZGQVOUAwAwMWYUwoAAABAof31118Oy8ePH9e7776rjh07UpACABQJc0oBAAAAKDSbzaauXbuqadOmSk5O1ty5c5Wenq6nn37a2aEBAMoZilIAAAAACq1Xr1768MMP9eabb8rNzU1t2rTR3Llz1blzZ2eHBgAoZ5hTCgAAAAAAAJZjTikAAAAAAABYjqIUAAAAAAAALMecUpJycnJ05MgRValSRW5ubs4OBwAAlCHGGJ06dUq1atWSuzu/5+UifwIAAAUpbP5EUUrSkSNHVKdOHWeHAQAAyrDDhw+rdu3azg6jzCB/AgAAl3O5/ImilKQqVapI+vtkBQQEODkaAABQlqSnp6tOnTr2fAF/I38CAAAFKWz+RFFKsg85DwgIIKkCAAD54hI1R+RPAADgci6XPzExAgAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBxFKQAAAAAAAFiOohQAAAAAAAAsR1EKAAAAAAAAlqMoBQAAAAAAAMtRlAIAAAAAAIDlKEoBAAAAAADAchSlAAAAAAAAYDmKUgAAAAAAALAcRSkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHKezg4AAKzUu3fh2i1fXrpxAABQphXmC5MvSwDAFWKkFAAAAAAAACxHUQoAAAAAAACW4/I9AC6jsJfmAQAAABUO81igDKIoBQDFxPc6AAAAABQfl+8BAAAAAADAchSlAAAAAAAAYDku3wOAfDA/FQAAAACULkZKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWM7pRanff/9dAwcOVPXq1eXn56cWLVro66+/tm83xuiZZ55RzZo15efnp8jISB08eNBhHydOnNCAAQMUEBCgoKAgDRs2TBkZGVZ3BQAAAAAAAIXk1KLUyZMn1aFDB3l5eemzzz5TQkKCXnnlFVWtWtXeZsqUKZoxY4bmzJmjbdu2qXLlyoqKitKZM2fsbQYMGKB9+/Zp7dq1WrFihb788kvde++9zugSAAAAAAAACsHTmQd/8cUXVadOHc2bN8++rn79+vb/N8Zo+vTpGjt2rG699VZJ0jvvvKOQkBB99NFH6tevn77//nutWrVKO3bsULt27SRJr732mnr16qWXX35ZtWrVsrZTAAAAAAAAuCynjpT65JNP1K5dO91+++0KDg7Wddddp7feesu+/dChQ0pKSlJkZKR9XWBgoCIiIhQfHy9Jio+PV1BQkL0gJUmRkZFyd3fXtm3brOsMAAAAAAAACs2pI6V+/vlnzZ49W6NHj9aTTz6pHTt26MEHH5S3t7diY2OVlJQkSQoJCXF4XkhIiH1bUlKSgoODHbZ7enqqWrVq9jYXy8zMVGZmpn05PT29JLsFAAAAAIB1evd2dgRAsTi1KJWTk6N27dpp0qRJkqTrrrtOe/fu1Zw5cxQbG1tqx508ebLGjx9favsHAAAAAADApTn18r2aNWsqPDzcYV3Tpk2VmJgoSQoNDZUkJScnO7RJTk62bwsNDVVKSorD9nPnzunEiRP2NhcbM2aM0tLS7I/Dhw+XSH8AAAAAAABQOE4tSnXo0EH79+93WHfgwAGFhYVJ+nvS89DQUK1fv96+PT09Xdu2bZPNZpMk2Ww2paamaufOnfY2GzZsUE5OjiIiIvI9ro+PjwICAhweAAAAAAAAsI5TL98bNWqUbrzxRk2aNEl33HGHtm/frjfffFNvvvmmJMnNzU0jR47Uc889p4YNG6p+/fp6+umnVatWLfXp00fS3yOrbr75Zt1zzz2aM2eOzp49qxEjRqhfv37ceQ8AAAAAAKCMcmpR6vrrr9eyZcs0ZswYTZgwQfXr19f06dM1YMAAe5vHHntMp0+f1r333qvU1FR17NhRq1atkq+vr73Ne++9pxEjRqh79+5yd3dXTEyMZsyY4YwuAQAAAAAAoBCcWpSSpFtuuUW33HJLgdvd3Nw0YcIETZgwocA21apV06JFi0ojPAAAAAAAAJQCp84pBQAAAAAAgIqJohQAAAAAAAAsR1EKAAAAAAAAlnP6nFIA4Op69758m+XLSz8OAAAAAChLGCkFAABQzvz+++8aOHCgqlevLj8/P7Vo0UJff/21fbsxRs8884xq1qwpPz8/RUZG6uDBgw77OHHihAYMGKCAgAAFBQVp2LBhysjIsLorAACgAqMoBQAAUI6cPHlSHTp0kJeXlz777DMlJCTolVdeUdWqVe1tpkyZohkzZmjOnDnatm2bKleurKioKJ05c8beZsCAAdq3b5/Wrl2rFStW6Msvv9S9997rjC4BAIAKisv3AAAAypEXX3xRderU0bx58+zr6tevb/9/Y4ymT5+usWPH6tZbb5UkvfPOOwoJCdFHH32kfv366fvvv9eqVau0Y8cOtWvXTpL02muvqVevXnr55ZdVq1YtazsFAAAqJEZKAQAAlCOffPKJ2rVrp9tvv13BwcG67rrr9NZbb9m3Hzp0SElJSYqMjLSvCwwMVEREhOLj4yVJ8fHxCgoKshekJCkyMlLu7u7atm1bvsfNzMxUenq6wwMAAOBKUJQCAAAoR37++WfNnj1bDRs21OrVqzV8+HA9+OCDWrBggSQpKSlJkhQSEuLwvJCQEPu2pKQkBQcHO2z39PRUtWrV7G0uNnnyZAUGBtofderUKemuAQCACoaiFAAAQDmSk5OjNm3aaNKkSbruuut077336p577tGcOXNK9bhjxoxRWlqa/XH48OFSPR4AAHB9FKUAAADKkZo1ayo8PNxhXdOmTZWYmChJCg0NlSQlJyc7tElOTrZvCw0NVUpKisP2c+fO6cSJE/Y2F/Px8VFAQIDDAwAA4EpQlAIAAChHOnTooP379zusO3DggMLCwiT9Pel5aGio1q9fb9+enp6ubdu2yWazSZJsNptSU1O1c+dOe5sNGzYoJydHERERFvQCAACAu+8BAACUK6NGjdKNN96oSZMm6Y477tD27dv15ptv6s0335Qkubm5aeTIkXruuefUsGFD1a9fX08//bRq1aqlPn36SPp7ZNXNN99sv+zv7NmzGjFihPr168ed9wAAgGUoSgEAAJQj119/vZYtW6YxY8ZowoQJql+/vqZPn64BAwbY2zz22GM6ffq07r33XqWmpqpjx45atWqVfH197W3ee+89jRgxQt27d5e7u7tiYmI0Y8YMZ3QJAABUUBSlAAAAyplbbrlFt9xyS4Hb3dzcNGHCBE2YMKHANtWqVdOiRYtKIzwAAIBCYU4pAAAAAAAAWI6RUgDKvN69nR0BAAAAAKCkMVIKAAAAAAAAlqMoBQAAAAAAAMtx+R4AAACAoivs9fXLl5duHACAcouRUgAAAAAAALAcRSkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWM7T2QEAqNh693Z2BAAAAAAAZ2CkFAAAAAAAACzHSCkAAAAAAMoiLiuAi2OkFAAAAAAAACzHSCkAAACgomDUBQCgDGGkFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBxFKQAAAAAAAFjO09kBAACk3r0L12758tKNAwAAAACswkgpAAAAAAAAWI6RUgAAAIArKOywWwAAyghGSgEAAAAAAMByFKUAAAAAAABgOS7fAwAAAFB6CnNZIXfyAIAKiZFSAAAAAAAAsBxFKQAAAAAAAFiOohQAAAAAAAAsR1EKAAAAAAAAlqMoBQAAAAAAAMtRlAIAAAAAAIDlKEoBAAAAAADAchSlAAAAAAAAYDmKUgAAAAAAALAcRSkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwnFOLUuPGjZObm5vDo0mTJvbtZ86cUVxcnKpXry5/f3/FxMQoOTnZYR+JiYmKjo5WpUqVFBwcrEcffVTnzp2zuisAAAAAAAAoAk9nB9CsWTOtW7fOvuzpeT6kUaNGaeXKlVqyZIkCAwM1YsQI9e3bV5s3b5YkZWdnKzo6WqGhodqyZYuOHj2qwYMHy8vLS5MmTbK8LwAAAAAAACgcpxelPD09FRoammd9Wlqa5s6dq0WLFqlbt26SpHnz5qlp06baunWr2rdvrzVr1ighIUHr1q1TSEiIWrdurYkTJ+rxxx/XuHHj5O3tbXV3AAAAAAAAUAhOn1Pq4MGDqlWrlho0aKABAwYoMTFRkrRz506dPXtWkZGR9rZNmjRR3bp1FR8fL0mKj49XixYtFBISYm8TFRWl9PR07du3z9qOAAAAAAAAoNCcOlIqIiJC8+fPV+PGjXX06FGNHz9enTp10t69e5WUlCRvb28FBQU5PCckJERJSUmSpKSkJIeCVO723G0FyczMVGZmpn05PT29hHoEAAAAAACAwnBqUapnz572/2/ZsqUiIiIUFhamDz74QH5+fqV23MmTJ2v8+PGltn8AAAAAAABcmtMv37tQUFCQGjVqpB9//FGhoaHKyspSamqqQ5vk5GT7HFShoaF57saXu5zfPFW5xowZo7S0NPvj8OHDJdsRAAAAAAAAXFKZKkplZGTop59+Us2aNdW2bVt5eXlp/fr19u379+9XYmKibDabJMlms2nPnj1KSUmxt1m7dq0CAgIUHh5e4HF8fHwUEBDg8AAAAAAAAIB1nHr53iOPPKLevXsrLCxMR44c0bPPPisPDw/1799fgYGBGjZsmEaPHq1q1aopICBADzzwgGw2m9q3by9J6tGjh8LDwzVo0CBNmTJFSUlJGjt2rOLi4uTj4+PMrgEAAAAAAOASnFqU+u2339S/f38dP35cNWrUUMeOHbV161bVqFFDkjRt2jS5u7srJiZGmZmZioqK0qxZs+zP9/Dw0IoVKzR8+HDZbDZVrlxZsbGxmjBhgrO6BAAAAAAAgEJwalFq8eLFl9zu6+urmTNnaubMmQW2CQsL06efflrSoQEAAAAAUPH07n35NsuXl34cqBCcWpQCABQNOQIAAAAAV1GmJjoHAAAAAABAxUBRCgAAoBwZN26c3NzcHB5NmjSxbz9z5ozi4uJUvXp1+fv7KyYmRsnJyQ77SExMVHR0tCpVqqTg4GA9+uijOnfunNVdAQAAFRyX7wEAAJQzzZo107p16+zLnp7nU7pRo0Zp5cqVWrJkiQIDAzVixAj17dtXmzdvliRlZ2crOjpaoaGh2rJli44eParBgwfLy8tLkyZNsrwvAACg4qIoBQAAUM54enoqNDQ0z/q0tDTNnTtXixYtUrdu3SRJ8+bNU9OmTbV161a1b99ea9asUUJCgtatW6eQkBC1bt1aEydO1OOPP65x48bJ29vb6u4AAIAKisv3AAAAypmDBw+qVq1aatCggQYMGKDExERJ0s6dO3X27FlFRkba2zZp0kR169ZVfHy8JCk+Pl4tWrRQSEiIvU1UVJTS09O1b9++Ao+ZmZmp9PR0hwcAAMCVYKQUAABAORIREaH58+ercePGOnr0qMaPH69OnTpp7969SkpKkre3t4KCghyeExISoqSkJElSUlKSQ0Eqd3vutoJMnjxZ48ePL9nOAEBFVpjbKgMujqIUAABAOdKzZ0/7/7ds2VIREREKCwvTBx98ID8/v1I77pgxYzR69Gj7cnp6uurUqVNqxwMAAK6Py/cAAADKsaCgIDVq1Eg//vijQkNDlZWVpdTUVIc2ycnJ9jmoQkND89yNL3c5v3mqcvn4+CggIMDhAQAAcCUoSgEAAJRjGRkZ+umnn1SzZk21bdtWXl5eWr9+vX37/v37lZiYKJvNJkmy2Wzas2ePUlJS7G3Wrl2rgIAAhYeHWx4/AACouLh8DwAAoBx55JFH1Lt3b4WFhenIkSN69tln5eHhof79+yswMFDDhg3T6NGjVa1aNQUEBOiBBx6QzWZT+/btJUk9evRQeHi4Bg0apClTpigpKUljx45VXFycfHx8nNw7AABQkVCUAgAAKEd+++039e/fX8ePH1eNGjXUsWNHbd26VTVq1JAkTZs2Te7u7oqJiVFmZqaioqI0a9Ys+/M9PDy0YsUKDR8+XDabTZUrV1ZsbKwmTJjgrC4BAIAKiqIUAABAObJ48eJLbvf19dXMmTM1c+bMAtuEhYXp008/LenQAAAAioQ5pQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy3k6OwAArql3b2dHAAAAAAAoyxgpBQAAAAAAAMtRlAIAAAAAAIDlKEoBAAAAAADAcswpBQAAAAAACq+wE8guX166caDcY6QUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByns4OAED507u3syMAAAAAAJR3jJQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBxFKQAAAAAAAFiOohQAAAAAAAAsR1EKAAAAAAAAlqMoBQAAAAAAAMtRlAIAAAAAAIDlKEoBAAAAAADAchSlAAAAAAAAYDmKUgAAAAAAALAcRSkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWK7MFKVeeOEFubm5aeTIkfZ1Z86cUVxcnKpXry5/f3/FxMQoOTnZ4XmJiYmKjo5WpUqVFBwcrEcffVTnzp2zOHoAAAAAAAAURZkoSu3YsUNvvPGGWrZs6bB+1KhRWr58uZYsWaKNGzfqyJEj6tu3r317dna2oqOjlZWVpS1btmjBggWaP3++nnnmGau7AAAAAAAAgCJwelEqIyNDAwYM0FtvvaWqVava16elpWnu3LmaOnWqunXrprZt22revHnasmWLtm7dKklas2aNEhIStHDhQrVu3Vo9e/bUxIkTNXPmTGVlZTmrSwAAAAAAALgMpxel4uLiFB0drcjISIf1O3fu1NmzZx3WN2nSRHXr1lV8fLwkKT4+Xi1atFBISIi9TVRUlNLT07Vv374Cj5mZman09HSHBwAAAAAAAKzj6cyDL168WN9884127NiRZ1tSUpK8vb0VFBTksD4kJERJSUn2NhcWpHK3524ryOTJkzV+/PgrjB4AAAAAAADF5bSRUocPH9ZDDz2k9957T76+vpYee8yYMUpLS7M/Dh8+bOnxAQAAAAAAKjqnFaV27typlJQUtWnTRp6envL09NTGjRs1Y8YMeXp6KiQkRFlZWUpNTXV4XnJyskJDQyVJoaGhee7Gl7uc2yY/Pj4+CggIcHgAAAAAAADAOk4rSnXv3l179uzR7t277Y927dppwIAB9v/38vLS+vXr7c/Zv3+/EhMTZbPZJEk2m0179uxRSkqKvc3atWsVEBCg8PBwy/sEAAAAAACAwnHanFJVqlRR8+bNHdZVrlxZ1atXt68fNmyYRo8erWrVqikgIEAPPPCAbDab2rdvL0nq0aOHwsPDNWjQIE2ZMkVJSUkaO3as4uLi5OPjY3mfAAAAAAAAUDhOv/vepUybNk233HKLYmJi1LlzZ4WGhmrp0qX27R4eHlqxYoU8PDxks9k0cOBADR48WBMmTHBi1AAAANZ54YUX5ObmppEjR9rXnTlzRnFxcapevbr8/f0VExOTZ8qDxMRERUdHq1KlSgoODtajjz6qc+fOWRw98P/17l24BwDApTj17nsX++KLLxyWfX19NXPmTM2cObPA54SFhenTTz8t5cgAoPwobM6+fHnpxgGg9O3YsUNvvPGGWrZs6bB+1KhRWrlypZYsWaLAwECNGDFCffv21ebNmyVJ2dnZio6OVmhoqLZs2aKjR49q8ODB8vLy0qRJk5zRFQAAUAGV6ZFSAAAAyF9GRoYGDBigt956S1WrVrWvT0tL09y5czV16lR169ZNbdu21bx587RlyxZt3bpVkrRmzRolJCRo4cKFat26tXr27KmJEydq5syZysrKclaXAABABUNRCgAAoByKi4tTdHS0IiMjHdbv3LlTZ8+edVjfpEkT1a1bV/Hx8ZKk+Ph4tWjRQiEhIfY2UVFRSk9P1759+6zpAAAAqPDK1OV7AAAAuLzFixfrm2++0Y4dO/JsS0pKkre3t4KCghzWh4SEKCkpyd7mwoJU7vbcbfnJzMxUZmamfTk9Pf1KugAAAMBIKQAAgPLk8OHDeuihh/Tee+/J19fXsuNOnjxZgYGB9kedOnUsOzYAAHBNFKUAAADKkZ07dyolJUVt2rSRp6enPD09tXHjRs2YMUOenp4KCQlRVlaWUlNTHZ6XnJys0NBQSVJoaGieu/HlLue2udiYMWOUlpZmfxw+fLjkOwcAACoUilIAAADlSPfu3bVnzx7t3r3b/mjXrp0GDBhg/38vLy+tX7/e/pz9+/crMTFRNptNkmSz2bRnzx6lpKTY26xdu1YBAQEKDw/P97g+Pj4KCAhweAAAAFwJ5pQCAAAoR6pUqaLmzZs7rKtcubKqV69uXz9s2DCNHj1a1apVU0BAgB544AHZbDa1b99ektSjRw+Fh4dr0KBBmjJlipKSkjR27FjFxcXJx8fH8j4BAICKiaIUAACAi5k2bZrc3d0VExOjzMxMRUVFadasWfbtHh4eWrFihYYPHy6bzabKlSsrNjZWEyZMcGLUAACgoqEoBQAAUM598cUXDsu+vr6aOXOmZs6cWeBzwsLC9Omnn5ZyZAAAAAVjTikAAAAAAABYjpFSAOx693Z2BLBSYV7v5ctLPw4AAAAAFRMjpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAyxWrKPXzzz+XdBwAAAAujxwKAADgvGIVpa699lr94x//0MKFC3XmzJmSjgkAAMAlkUMBAACcV6yi1DfffKOWLVtq9OjRCg0N1X333aft27eXdGwAAAAuhRwKAADgPDdjjCnuk8+dO6dPPvlE8+fP16pVq9SoUSMNHTpUgwYNUo0aNUoyzlKVnp6uwMBApaWlKSAgwNnhAE7Tu7ezI0BZs3y5syMAnK808gRXyKHInyzEF/R5fDHBlVSEzzaf2QqrsHnCFU107unpqb59+2rJkiV68cUX9eOPP+qRRx5RnTp1NHjwYB09evRKdg8AAOCSyKEAAACusCj19ddf69///rdq1qypqVOn6pFHHtFPP/2ktWvX6siRI7r11ltLKk4AAACXQQ4FAAAgeRbnSVOnTtW8efO0f/9+9erVS++884569eold/e/a1z169fX/PnzVa9evZKMFQAAoFwjhwIAADivWEWp2bNna+jQoRoyZIhq1qyZb5vg4GDNnTv3ioIDAABwJeRQAAAA5xWrKHXw4MHLtvH29lZsbGxxdg8AAOCSyKEAAADOK9acUvPmzdOSJUvyrF+yZIkWLFhwxUEBAAC4InIoAACA84pVlJo8ebKuuuqqPOuDg4M1adKkKw4KAADAFZFDAQAAnFesolRiYqLq16+fZ31YWJgSExOvOCgAAABXRA4FAABwXrGKUsHBwfruu+/yrP/2229VvXr1Kw4KAADAFZFDAQAAnFesolT//v314IMP6vPPP1d2drays7O1YcMGPfTQQ+rXr19JxwgAAOASyKEAAADOK9bd9yZOnKhffvlF3bt3l6fn37vIycnR4MGDmQ8BAACgAORQAAAA5xWrKOXt7a33339fEydO1Lfffis/Pz+1aNFCYWFhJR0fAACAyyCHAgAAOK9YRalcjRo1UqNGjUoqFgAAgAqBHAoAAKCYRans7GzNnz9f69evV0pKinJychy2b9iwoUSCAwAAcCXkUAAAAOcVqyj10EMPaf78+YqOjlbz5s3l5uZW0nEBAAC4HHIoAACA84pVlFq8eLE++OAD9erVq6TjAQAAcFnkUAAAAOe5F+dJ3t7euvbaa0s6FgAAAJdGDgUAAHBesYpSDz/8sF599VUZY0o6HgAAAJdFDgUAAHBesS7f27Rpkz7//HN99tlnatasmby8vBy2L126tESCAwAAcCXkUAAAAOcVqygVFBSk2267raRjAQAAcGnkUAAAAOcVqyg1b968ko4DAADA5ZFDAQAAnFesOaUk6dy5c1q3bp3eeOMNnTp1SpJ05MgRZWRklFhwAAAAroYcCgAA4G/FGin166+/6uabb1ZiYqIyMzN10003qUqVKnrxxReVmZmpOXPmlHScAAAA5R45FAAAwHnFGin10EMPqV27djp58qT8/Pzs62+77TatX7++xIIDAABwJeRQAAAA5xVrpNRXX32lLVu2yNvb22F9vXr19Pvvv5dIYAAAAK6GHAoAAOC8YhWlcnJylJ2dnWf9b7/9pipVqlxxUAAAAK6IHAoAKoDevZ0dAVBuFOvyvR49emj69On2ZTc3N2VkZOjZZ59Vr169Sio2AAAAl0IOBQAAcF6xRkq98sorioqKUnh4uM6cOaO77rpLBw8e1FVXXaX//ve/JR0jAACASyCHAgAAOK9YRanatWvr22+/1eLFi/Xdd98pIyNDw4YN04ABAxwm7QQAAMB55FAAAADnFasoJUmenp4aOHBgScYCAADg8sihAAAA/lasotQ777xzye2DBw8uVjAAAACujBwKAADgvGIVpR566CGH5bNnz+rPP/+Ut7e3KlWqREIFAACQD3IoAACA84p1972TJ086PDIyMrR//3517NiRSToBAAAKQA4FAABwXrHnlLpYw4YN9cILL2jgwIH64YcfSmq3AAAn6t378m2WLy/9OABXRg4FAAAqqmKNlCqIp6enjhw5UpK7BAAAcHnkUAAAoCIq1kipTz75xGHZGKOjR4/q9ddfV4cOHUokMAAAAFdDDgUAAHBesYpSffr0cVh2c3NTjRo11K1bN73yyislERcAAIDLIYcCAFQozAWByyhWUSonJ6ek4wAAAHB55FAAAADnleicUgAAAAAAAEBhFGuk1OjRowvddurUqcU5BAAAgMshhwIAADivWEWpXbt2adeuXTp79qwaN24sSTpw4IA8PDzUpk0bezs3N7eSiRIAAMAFkEMBV4j5aQDApRSrKNW7d29VqVJFCxYsUNWqVSVJJ0+e1N13361OnTrp4YcfLtEgAQAAXAE5FAAAwHnFmlPqlVde0eTJk+3JlCRVrVpVzz33HHeOAQAAKAA5FAAAwHnFKkqlp6fr2LFjedYfO3ZMp06duuKgAAAAXBE5FAAAwHnFKkrddtttuvvuu7V06VL99ttv+u233/S///1Pw4YNU9++fUs6RgAAAJdADgUAAHBesYpSc+bMUc+ePXXXXXcpLCxMYWFhuuuuu3TzzTdr1qxZhd7P7Nmz1bJlSwUEBCggIEA2m02fffaZffuZM2cUFxen6tWry9/fXzExMUpOTnbYR2JioqKjo1WpUiUFBwfr0Ucf1blz54rTLQAAgFJVUjkUAACAKyjWROeVKlXSrFmz9NJLL+mnn36SJF1zzTWqXLlykfZTu3ZtvfDCC2rYsKGMMVqwYIFuvfVW7dq1S82aNdOoUaO0cuVKLVmyRIGBgRoxYoT69u2rzZs3S5Kys7MVHR2t0NBQbdmyRUePHtXgwYPl5eWlSZMmFadrgMsqzM1qAAClq6RyKAAAAFdQrJFSuY4ePaqjR4+qYcOGqly5sowxRXp+79691atXLzVs2FCNGjXS888/L39/f23dulVpaWmaO3eupk6dqm7duqlt27aaN2+etmzZoq1bt0qS1qxZo4SEBC1cuFCtW7dWz549NXHiRM2cOVNZWVlX0jUAAIBSc6U5FAAAgCsoVlHq+PHj6t69uxo1aqRevXrp6NGjkqRhw4YV+1bG2dnZWrx4sU6fPi2bzaadO3fq7NmzioyMtLdp0qSJ6tatq/j4eElSfHy8WrRooZCQEHubqKgopaena9++fcWKAwAAoLSURg4FAABQXhWrKDVq1Ch5eXkpMTFRlSpVsq+/8847tWrVqiLta8+ePfL395ePj4/uv/9+LVu2TOHh4UpKSpK3t7eCgoIc2oeEhCgpKUmSlJSU5FCQyt2eu60gmZmZSk9Pd3gAAACUtpLMoQAAAMq7Ys0ptWbNGq1evVq1a9d2WN+wYUP9+uuvRdpX48aNtXv3bqWlpenDDz9UbGysNm7cWJywCm3y5MkaP358qR4DAADgYiWZQwEAAJR3xRopdfr0aYdf93KdOHFCPj4+RdqXt7e3rr32WrVt21aTJ09Wq1at9Oqrryo0NFRZWVlKTU11aJ+cnKzQ0FBJUmhoaJ678eUu57bJz5gxY5SWlmZ/HD58uEgxAwAAFEdJ5lAAAADlXbGKUp06ddI777xjX3Zzc1NOTo6mTJmif/zjH1cUUE5OjjIzM9W2bVt5eXlp/fr19m379+9XYmKibDabJMlms2nPnj1KSUmxt1m7dq0CAgIUHh5e4DF8fHwUEBDg8AAAAChtJZFDzZ49Wy1btrTnMDabTZ999pl9+5kzZxQXF6fq1avL399fMTExeX7ES0xMVHR0tCpVqqTg4GA9+uijOnfuXMl0EgAAoJCKdfnelClT1L17d3399dfKysrSY489pn379unEiRPavHlzofczZswY9ezZU3Xr1tWpU6e0aNEiffHFF1q9erUCAwM1bNgwjR49WtWqVVNAQIAeeOAB2Ww2tW/fXpLUo0cPhYeHa9CgQZoyZYqSkpI0duxYxcXF8WsjAAAoc0oih6pdu7ZeeOEFNWzYUMYYLViwQLfeeqt27dqlZs2aadSoUVq5cqWWLFmiwMBAjRgxQn379rXvPzs7W9HR0QoNDdWWLVt09OhRDR48WF5eXpo0aVJpdh8AAMBBsYpSzZs314EDB/T666+rSpUqysjIUN++fRUXF6eaNWsWej8pKSkaPHiwjh49qsDAQLVs2VKrV6/WTTfdJEmaNm2a3N3dFRMTo8zMTEVFRWnWrFn253t4eGjFihUaPny4bDabKleurNjYWE2YMKE43QIAAChVJZFD9e7d22H5+eef1+zZs7V161bVrl1bc+fO1aJFi9StWzdJ0rx589S0aVNt3bpV7du315o1a5SQkKB169YpJCRErVu31sSJE/X4449r3Lhx8vb2LvF+AwAA5KfIRamzZ8/q5ptv1pw5c/TUU09d0cHnzp17ye2+vr6aOXOmZs6cWWCbsLAwffrpp1cUBwAAQGkryRwqV3Z2tpYsWaLTp0/LZrNp586dOnv2rCIjI+1tmjRporp16yo+Pl7t27dXfHy8WrRo4XAH46ioKA0fPlz79u3TddddVyKxAQAAXE6Ri1JeXl767rvvSiMWAAAAl1WSOdSePXtks9l05swZ+fv7a9myZQoPD9fu3bvl7e2toKAgh/YhISFKSkqSJCUlJTkUpHK3524rSGZmpjIzM+3L6enpJdIXAABQcRVrovOBAwdedpQTAAAAHJVUDtW4cWPt3r1b27Zt0/DhwxUbG6uEhIQSiLBgkydPVmBgoP1Rp06dUj0eAABwfcWaU+rcuXN6++23tW7dOrVt21aVK1d22D516tQSCQ4AAMCVlFQO5e3trWuvvVaS1LZtW+3YsUOvvvqq7rzzTmVlZSk1NdVhtFRycrJCQ0MlSaGhodq+fbvD/nLvzpfbJj9jxozR6NGj7cvp6ekUpgAAwBUpUlHq559/Vr169bR37161adNGknTgwAGHNm5ubiUXHQAAgAso7RwqJydHmZmZatu2rby8vLR+/XrFxMRIkvbv36/ExETZbDZJks1m0/PPP6+UlBQFBwdLktauXauAgACFh4cXeAwfHx/ubgwAAEpUkYpSDRs21NGjR/X5559Lku68807NmDEjz7wEAAAAOK8kc6gxY8aoZ8+eqlu3rk6dOqVFixbpiy++0OrVqxUYGKhhw4Zp9OjRqlatmgICAvTAAw/IZrOpffv2kqQePXooPDxcgwYN0pQpU5SUlKSxY8cqLi6OohMAALBUkYpSxhiH5c8++0ynT58u0YAAAABcTUnmUCkpKRo8eLCOHj2qwMBAtWzZUqtXr9ZNN90kSZo2bZrc3d0VExOjzMxMRUVFadasWfbne3h4aMWKFRo+fLhsNpsqV66s2NhYTZgwofgdBAAAKIZizSmV6+IECwAAAJd3JTnU5SZK9/X11cyZMzVz5swC24SFhenTTz8tdgwAAAAloUh333Nzc8sz3wFzSAEAAFwaORQAAEBeRb58b8iQIfb5Bs6cOaP7778/z51jli5dWnIRAgAAlHPkUAAAAHkVqSgVGxvrsDxw4MASDQYAAMAVkUMBAADkVaSi1Lx580orDgAAAJdFDgUAAJBXkeaUAgAAAAAAAEoCRSkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACzn6ewAAFyZ3r2dHQEAAAAAAEXHSCkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWM7T2QEAAMq33r0L12758tKNAwAAAED5wkgpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsJynswMAAAAAKqzevZ0dAQAATsNIKQAAAAAAAFiOohQAAAAAAAAsR1EKAAAAAAAAlqMoBQAAAAAAAMtRlAIAAAAAAIDluPseAAAAAACFwR0zgRLFSCkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOU8nR0AgIL17u3sCAAAAAAAKB2MlAIAAAAAAIDlGCkFAAAAAACco7CXhyxfXrpxwCkYKQUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHJOLUpNnjxZ119/vapUqaLg4GD16dNH+/fvd2hz5swZxcXFqXr16vL391dMTIySk5Md2iQmJio6OlqVKlVScHCwHn30UZ07d87KrgAAAAAAAKAInFqU2rhxo+Li4rR161atXbtWZ8+eVY8ePXT69Gl7m1GjRmn58uVasmSJNm7cqCNHjqhv37727dnZ2YqOjlZWVpa2bNmiBQsWaP78+XrmmWec0SUAAAAAAAAUglPvvrdq1SqH5fnz5ys4OFg7d+5U586dlZaWprlz52rRokXq1q2bJGnevHlq2rSptm7dqvbt22vNmjVKSEjQunXrFBISotatW2vixIl6/PHHNW7cOHl7ezujawAAAAAAALiEMjWnVFpamiSpWrVqkqSdO3fq7NmzioyMtLdp0qSJ6tatq/j4eElSfHy8WrRooZCQEHubqKgopaena9++ffkeJzMzU+np6Q4PAAAAAAAAWKfMFKVycnI0cuRIdejQQc2bN5ckJSUlydvbW0FBQQ5tQ0JClJSUZG9zYUEqd3vutvxMnjxZgYGB9kedOnVKuDcAAAClgzk5AQCAq3Dq5XsXiouL0969e7Vp06ZSP9aYMWM0evRo+3J6ejqFKQAoZb17X77N8uWlHwdQ3uXOyXn99dfr3LlzevLJJ9WjRw8lJCSocuXKkv6ek3PlypVasmSJAgMDNWLECPXt21ebN2+WdH5OztDQUG3ZskVHjx7V4MGD5eXlpUmTJjmzewAAoAIpE0WpESNGaMWKFfryyy9Vu3Zt+/rQ0FBlZWUpNTXVYbRUcnKyQkND7W22b9/usL/cXwJz21zMx8dHPj4+JdwLAACA0secnAAAwFU4tShljNEDDzygZcuW6YsvvlD9+vUdtrdt21ZeXl5av369YmJiJEn79+9XYmKibDabJMlms+n5559XSkqKgoODJUlr165VQECAwsPDre0QAACAxYo6J2f79u0LnJNz+PDh2rdvn6677jprOwGUpMIMzZUYngsAZYBTi1JxcXFatGiRPv74Y1WpUsU+B1RgYKD8/PwUGBioYcOGafTo0apWrZoCAgL0wAMPyGazqX379pKkHj16KDw8XIMGDdKUKVOUlJSksWPHKi4ujtFQAADApVk5J2dmZqYyMzPty9woBgAAXCmnTnQ+e/ZspaWlqWvXrqpZs6b98f7779vbTJs2TbfccotiYmLUuXNnhYaGaunSpfbtHh4eWrFihTw8PGSz2TRw4EANHjxYEyZMcEaXAAAALJM7J+fixYtL/VjcKAYAAJQ0p1++dzm+vr6aOXOmZs6cWWCbsLAwffrppyUZGgAAQJlm9Zyc3CgGAACUNKeOlAIAAEDRGGM0YsQILVu2TBs2bLjknJy58puTc8+ePUpJSbG3udycnD4+PgoICHB4AAAAXIkycfc9AAAAFA5zcgIAAFdBUQoAAKAcmT17tiSpa9euDuvnzZunIUOGSPp7Tk53d3fFxMQoMzNTUVFRmjVrlr1t7pycw4cPl81mU+XKlRUbG8ucnAAAwFIUpQAAAMoR5uQEAACugjmlAAAAAAAAYDmKUgAAAAAAALAcRSkAAAAAAABYjjmlAABlRu/ehWu3fHnpxgEAAACg9DFSCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBxFKQAAAAAAAFiOohQAAAAAAAAsR1EKAAAAAAAAlqMoBQAAAAAAAMtRlAIAAAAAAIDlKEoBAAAAAADAchSlAAAAAAAAYDmKUgAAAAAAALAcRSkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJajKAUAAAAAAADLUZQCAAAAAACA5TydHQAAAADgcnr3dnYEAACUeYyUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOeaUApyAaSYAAAAAABUdRSkAAAAAAFC2FeaX/eXLSz8OlCgu3wMAAAAAAIDlKEoBAAAAAADAcly+B5Qw5osCAAAAAODyGCkFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOSY6BwAAAACAOxYBlmOkFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBxFKQAAAAAAAFiOohQAAAAAAAAsR1EKAAAAAAAAlqMoBQAAAAAAAMtRlAIAAAAAAIDlKEoBAAAAAADAchSlAAAAAAAAYDlPZwcAAEBR9e59+TbLl5d+HAAAAACKj5FSAAAAAAAAsBxFKQAAAAAAAFjOqUWpL7/8Ur1791atWrXk5uamjz76yGG7MUbPPPOMatasKT8/P0VGRurgwYMObU6cOKEBAwYoICBAQUFBGjZsmDIyMizsBQAAAAAAAIrKqXNKnT59Wq1atdLQoUPVt2/fPNunTJmiGTNmaMGCBapfv76efvppRUVFKSEhQb6+vpKkAQMG6OjRo1q7dq3Onj2ru+++W/fee68WLVpkdXcAAAAAlBdMUAgATufUkVI9e/bUc889p9tuuy3PNmOMpk+frrFjx+rWW29Vy5Yt9c477+jIkSP2EVXff/+9Vq1apf/85z+KiIhQx44d9dprr2nx4sU6cuSIxb0BAACwBqPNAQCAKyizc0odOnRISUlJioyMtK8LDAxURESE4uPjJUnx8fEKCgpSu3bt7G0iIyPl7u6ubdu2FbjvzMxMpaenOzwAAADKi9zR5jNnzsx3e+5o8zlz5mjbtm2qXLmyoqKidObMGXubAQMGaN++fVq7dq1WrFihL7/8Uvfee69VXQAAAHDu5XuXkpSUJEkKCQlxWB8SEmLflpSUpODgYIftnp6eqlatmr1NfiZPnqzx48eXcMQAAADW6Nmzp3r27JnvtotHm0vSO++8o5CQEH300Ufq16+ffbT5jh077D/uvfbaa+rVq5defvll1apVy7K+AACAiqvMjpQqTWPGjFFaWpr9cfjwYWeHBAAAUCJKc7Q5AABASSqzI6VCQ0MlScnJyapZs6Z9fXJyslq3bm1vk5KS4vC8c+fO6cSJE/bn58fHx0c+Pj4lHzQAAICTldZo88zMTGVmZtqXmf4AAABcqTI7Uqp+/foKDQ3V+vXr7evS09O1bds22Ww2SZLNZlNqaqp27txpb7Nhwwbl5OQoIiLC8pgBAABc1eTJkxUYGGh/1KlTx9khAQCAcs6pRamMjAzt3r1bu3fvlvT3cPPdu3crMTFRbm5uGjlypJ577jl98skn2rNnjwYPHqxatWqpT58+kqSmTZvq5ptv1j333KPt27dr8+bNGjFihPr168dcCAAAoEK6cLT5hZKTk+3bijPanOkPAABASXPq5Xtff/21/vGPf9iXR48eLUmKjY3V/Pnz9dhjj+n06dO69957lZqaqo4dO2rVqlXy9fW1P+e9997TiBEj1L17d7m7uysmJkYzZsywvC9wfb17OzsCAAAu78LR5rlTHuSONh8+fLgkx9Hmbdu2lXT50eZMfwAAAEqaU4tSXbt2lTGmwO1ubm6aMGGCJkyYUGCbatWqadGiRaURHgAAQJmUkZGhH3/80b6cO9q8WrVqqlu3rn20ecOGDVW/fn09/fTTBY42nzNnjs6ePctocwAAYLkyO9E5AAAA8sdocwAA4AooSgEAAJQzjDYHAACugKIUAAAAUBRMNAkAQIlw6t33AAAAAAAAUDExUgoA4JIKO5Bh+fLSjQMAAABA/hgpBQAAAAAAAMtRlAIAAAAAAIDlKEoBAAAAAADAcswpBQCo0Aoz9xTzTgEAAAAlj5FSAAAAAAAAsBxFKQAAAAAAAFiOohQAAAAAAAAsx5xSgAo3pwwAAAAAoAwr7D/smDC0zGCkFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMBy3H0PAAAAAOC6uNU2UGYxUgoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBxFKQAAAAAAAFiOohQAAAAAAAAsR1EKAAAAAAAAlqMoBQAAAAAAAMt5OjsAAAAAACiTevcuXLvly0s3DgBwUYyUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBwTnQMAAABS4Se1BgAAJYKRUgAAAAAAALAcRSkAAAAAAABYjqIUAAAAAAAALEdRCgAAAAAAAJZjonMAAAAAQPnEDQqAco2RUgAAAAAAALAcI6Xg0vjhBEBJKOzfkuXLSzcOAAAAwJUwUgoAAAAAAACWoygFAAAAAAAAy3H5HsotLs0DAABAmVCYxJRrvAEgD0ZKAQAAAAAAwHIUpQAAAAAAAGA5Lt8DAKCEcPUGAAAAUHiMlAIAAAAAAIDlKEoBAAAAAADAcly+BwAAAAAAKg7mXCgzKEoBAGChwuRAEnkQAAAAXB+X7wEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBxzSqHMKex8KwAAAABcFP8oACoEilIAAABwffwDFwBQFNydxhIUpVAi+LwCAAAAAICioCgFAACA8osRUAAAlFsUpQAAKIMK8+9sRp8CAACgPOPuewAAAAAAALAcI6VgKUbYAwAAAAAAiaIUAAAAAMBK/FIN4P+jKAUAAAAApY3bVQNAHhSlAABwcUyaDgAAgLKIohQAAOUUVz8AAACgPHOZotTMmTP10ksvKSkpSa1atdJrr72mG264wdlhlWmMIAYAAGU6h6LyCgAo6xiSfkVcoij1/vvva/To0ZozZ44iIiI0ffp0RUVFaf/+/QoODnZ2eAAAAGUSORRQBpVkMZZ/CAMo49yMMcbZQVypiIgIXX/99Xr99dclSTk5OapTp44eeOABPfHEE5d9fnp6ugIDA5WWlqaAgIDSDrfM4MdHAEBRVcR/37hynnAlOZQl54VkBbgyVv/R5jML5K8CJlCFzRPK/UiprKws7dy5U2PGjLGvc3d3V2RkpOLj450Y2XlcJgcAQPHwHVp6ykMOBQAAXFu5L0r98ccfys7OVkhIiMP6kJAQ/fDDD/k+JzMzU5mZmfbltLQ0SX9X8krD2bOFa3fzzSV3zA8+uHybwsYFAECusvpdVUpf4f9/33/v3AUGlzsoag5ldf4kiWQFuFKF+XzecUfpxwFUdCX5XVmSn9nCJGPFVNj8qdwXpYpj8uTJGj9+fJ71derUcUI0pSMw0NkRAABwaSX5XWXF996pU6cUWIG/YCtC/gS4nAr8NwsoU8rqZ9GCuC6XP5X7otRVV10lDw8PJScnO6xPTk5WaGhovs8ZM2aMRo8ebV/OycnRiRMnVL16dbm5uZVqvM6Wnp6uOnXq6PDhwy43L4ZVOIdXhvN35TiHV4bzd+Uq2jk0xujUqVOqVauWs0MpUUXNoQqTP1W09wb9dW3013VVpL5K9NfVldX+FjZ/KvdFKW9vb7Vt21br169Xnz59JP2dJK1fv14jRozI9zk+Pj7y8fFxWBcUFFTKkZYtAQEBZeoNWx5xDq8M5+/KcQ6vDOfvylWkc+iKI6SKmkMVJX+qSO8Nif66OvrruipSXyX66+rKYn8Lkz+V+6KUJI0ePVqxsbFq166dbrjhBk2fPl2nT5/W3Xff7ezQAAAAyixyKAAA4EwuUZS68847dezYMT3zzDNKSkpS69attWrVqjwTdwIAAOA8cigAAOBMLlGUkqQRI0YUeLkezvPx8dGzzz6bZ/g9Co9zeGU4f1eOc3hlOH9XjnPoWkoyh6po7w3669ror+uqSH2V6K+rK+/9dTOudn9jAAAAAAAAlHnuzg4AAAAAAAAAFQ9FKQAAAAAAAFiOohQAAAAAAAAsR1GqApk5c6bq1asnX19fRUREaPv27c4OyRKTJ0/W9ddfrypVqig4OFh9+vTR/v37HdqcOXNGcXFxql69uvz9/RUTE6Pk5GSHNomJiYqOjlalSpUUHBysRx99VOfOnXNo88UXX6hNmzby8fHRtddeq/nz5+eJp7y/Di+88ILc3Nw0cuRI+zrO3+X9/vvvGjhwoKpXry4/Pz+1aNFCX3/9tX27MUbPPPOMatasKT8/P0VGRurgwYMO+zhx4oQGDBiggIAABQUFadiwYcrIyHBo891336lTp07y9fVVnTp1NGXKlDyxLFmyRE2aNJGvr69atGihTz/9tHQ6XUKys7P19NNPq379+vLz89M111yjiRMn6sIpETl/jr788kv17t1btWrVkpubmz766COH7WXpfBUmFpSu8vR+uVIVLSeYPXu2WrZsqYCAAAUEBMhms+mzzz5zyb7mx9VzlnHjxsnNzc3h0aRJE5fsq1Txcql69erleX3d3NwUFxcnybVe34qY6506dUojR45UWFiY/Pz8dOONN2rHjh0u299LMqgQFi9ebLy9vc3bb79t9u3bZ+655x4TFBRkkpOTnR1aqYuKijLz5s0ze/fuNbt37za9evUydevWNRkZGfY2999/v6lTp45Zv369+frrr0379u3NjTfeaN9+7tw507x5cxMZGWl27dplPv30U3PVVVeZMWPG2Nv8/PPPplKlSmb06NEmISHBvPbaa8bDw8OsWrXK3qa8vw7bt2839erVMy1btjQPPfSQfT3n79JOnDhhwsLCzJAhQ8y2bdvMzz//bFavXm1+/PFHe5sXXnjBBAYGmo8++sh8++235v/+7/9M/fr1zV9//WVvc/PNN5tWrVqZrVu3mq+++spce+21pn///vbtaWlpJiQkxAwYMMDs3bvX/Pe//zV+fn7mjTfesLfZvHmz8fDwMFOmTDEJCQlm7NixxsvLy+zZs8eak1EMzz//vKlevbpZsWKFOXTokFmyZInx9/c3r776qr0N58/Rp59+ap566imzdOlSI8ksW7bMYXtZOl+FiQWlqzy9X65URcsJPvnkE7Ny5Upz4MABs3//fvPkk08aLy8vs3fvXpfr68UqQs7y7LPPmmbNmpmjR4/aH8eOHXPJvlbEXColJcXhtV27dq2RZD7//HNjjGu9vhUx17vjjjtMeHi42bhxozl48KB59tlnTUBAgPntt99csr+XQlGqgrjhhhtMXFycfTk7O9vUqlXLTJ482YlROUdKSoqRZDZu3GiMMSY1NdV4eXmZJUuW2Nt8//33RpKJj483xvydsLu7u5ukpCR7m9mzZ5uAgACTmZlpjDHmscceM82aNXM41p133mmioqLsy+X5dTh16pRp2LChWbt2renSpYs9weP8Xd7jjz9uOnbsWOD2nJwcExoaal566SX7utTUVOPj42P++9//GmOMSUhIMJLMjh077G0+++wz4+bmZn7//XdjjDGzZs0yVatWtZ/T3GM3btzYvnzHHXeY6Ohoh+NHRESY++6778o6WYqio6PN0KFDHdb17dvXDBgwwBjD+buci4sMZel8FSYWWKssv19KQ0XMCapWrWr+85//uHRfK0rO8uyzz5pWrVrlu83V+kouZcxDDz1krrnmGpOTk+Nyr29Fy/X+/PNP4+HhYVasWOGwvk2bNuapp55yuf5eDpfvVQBZWVnauXOnIiMj7evc3d0VGRmp+Ph4J0bmHGlpaZKkatWqSZJ27typs2fPOpyfJk2aqG7duvbzEx8frxYtWigkJMTeJioqSunp6dq3b5+9zYX7yG2Tu4/y/jrExcUpOjo6Tx85f5f3ySefqF27drr99tsVHBys6667Tm+99ZZ9+6FDh5SUlOTQt8DAQEVERDicw6CgILVr187eJjIyUu7u7tq2bZu9TefOneXt7W1vExUVpf379+vkyZP2Npc6z2XRjTfeqPXr1+vAgQOSpG+//VabNm1Sz549JXH+iqosna/CxALnKkvvl9JQkXKC7OxsLV68WKdPn5bNZnPpvlaknOXgwYOqVauWGjRooAEDBigxMdEl+1rRc6msrCwtXLhQQ4cOlZubm8u9vhUt1zt37pyys7Pl6+vrsN7Pz0+bNm1yuf5eDkWpCuCPP/5Qdna2wx8kSQoJCVFSUpKTonKOnJwcjRw5Uh06dFDz5s0lSUlJSfL29lZQUJBD2wvPT1JSUr7nL3fbpdqkp6frr7/+Ktevw+LFi/XNN99o8uTJebZx/i7v559/1uzZs9WwYUOtXr1aw4cP14MPPqgFCxZIOn8OLtW3pKQkBQcHO2z39PRUtWrVSuQ8l+Vz+MQTT6hfv35q0qSJvLy8dN1112nkyJEaMGCAJM5fUZWl81WYWOBcZen9UtIqSk6wZ88e+fv7y8fHR/fff7+WLVum8PBwl+yrVLFyloiICM2fP1+rVq3S7NmzdejQIXXq1EmnTp1yub5W9Fzqo48+UmpqqoYMGWKPwZVe34qW61WpUkU2m00TJ07UkSNHlJ2drYULFyo+Pl5Hjx51uf5ejqdlRwLKgLi4OO3du1ebNm1ydijlxuHDh/XQQw9p7dq1ear5KJycnBy1a9dOkyZNkiRdd9112rt3r+bMmaPY2FgnR1f2ffDBB3rvvfe0aNEiNWvWTLt379bIkSNVq1Ytzh+AYqsoOUHjxo21e/dupaWl6cMPP1RsbKw2btzo7LBKRUXLWXJHkUhSy5YtFRERobCwMH3wwQfy8/NzYmQlr6LnUnPnzlXPnj1Vq1YtZ4dSKipirvfuu+9q6NChuvrqq+Xh4aE2bdqof//+2rlzp7NDsxwjpSqAq666Sh4eHnnuxpCcnKzQ0FAnRWW9ESNGaMWKFfr8889Vu3Zt+/rQ0FBlZWUpNTXVof2F5yc0NDTf85e77VJtAgIC5OfnV25fh507dyolJUVt2rSRp6enPD09tXHjRs2YMUOenp4KCQnh/F1GzZo1FR4e7rCuadOm9iH2ufFfqm+hoaFKSUlx2H7u3DmdOHGiRM5zWT6Hjz76qP0XtBYtWmjQoEEaNWqU/Vdwzl/RlKXzVZhY4Fxl6f1SkipSTuDt7a1rr71Wbdu21eTJk9WqVSu9+uqrLtnXip6zBAUFqVGjRvrxxx9d7vWtyLnUr7/+qnXr1ulf//qXfZ2rvb4VMde75pprtHHjRmVkZOjw4cPavn27zp49qwYNGrhkfy+FolQF4O3trbZt22r9+vX2dTk5OVq/fr1sNpsTI7OGMUYjRozQsmXLtGHDBtWvX99he9u2beXl5eVwfvbv36/ExET7+bHZbNqzZ4/DB3/t2rUKCAiwf0HabDaHfeS2yd1HeX0dunfvrj179mj37t32R7t27TRgwAD7/3P+Lq1Dhw55bjl+4MABhYWFSZLq16+v0NBQh76lp6dr27ZtDucwNTXV4deTDRs2KCcnRxEREfY2X375pc6ePWtvs3btWjVu3FhVq1a1t7nUeS6L/vzzT7m7O35deXh4KCcnRxLnr6jK0vkqTCxwrrL0fikJ5AR/HyczM9Ml+1rRc5aMjAz99NNPqlmzpsu9vhU5l5o3b56Cg4MVHR1tX+dqr29FzvUqV66smjVr6uTJk1q9erVuvfVWl+5vviybUh1OtXjxYuPj42Pmz59vEhISzL333muCgoIc7sbgqoYPH24CAwPNF1984XBb1T///NPe5v777zd169Y1GzZsMF9//bWx2WzGZrPZt+feUrVHjx5m9+7dZtWqVaZGjRr53lL10UcfNd9//72ZOXNmvrdUdYXX4cI72RjD+buc7du3G09PT/P888+bgwcPmvfee89UqlTJLFy40N7mhRdeMEFBQebjjz823333nbn11lvzve3rddddZ7Zt22Y2bdpkGjZs6HDb19TUVBMSEmIGDRpk9u7daxYvXmwqVaqU57avnp6e5uWXXzbff/+9efbZZy2/7WtRxcbGmquvvtp+m+ClS5eaq666yjz22GP2Npw/R6dOnTK7du0yu3btMpLM1KlTza5du8yvv/5qjClb56swsaB0laf3y5WqaDnBE088YTZu3GgOHTpkvvvuO/PEE08YNzc3s2bNGpfra0FcOWd5+OGHzRdffGEOHTpkNm/ebCIjI81VV11lUlJSXK6vFTWXys7ONnXr1jWPP/54nm2u9PpWxFxv1apV5rPPPjM///yzWbNmjWnVqpWJiIgwWVlZLtnfS6EoVYG89tprpm7dusbb29vccMMNZuvWrc4OyRKS8n3MmzfP3uavv/4y//73v03VqlVNpUqVzG233WaOHj3qsJ9ffvnF9OzZ0/j5+ZmrrrrKPPzww+bs2bMObT7//HPTunVr4+3tbRo0aOBwjFyu8DpcnOBx/i5v+fLlpnnz5sbHx8c0adLEvPnmmw7bc3JyzNNPP21CQkKMj4+P6d69u9m/f79Dm+PHj5v+/fsbf39/ExAQYO6++25z6tQphzbffvut6dixo/Hx8TFXX321eeGFF/LE8sEHH5hGjRoZb29v06xZM7Ny5cqS73AJSk9PNw899JCpW7eu8fX1NQ0aNDBPPfWUw+1tOX+OPv/883z/7sXGxhpjytb5KkwsKF3l6f1ypSpaTjB06FATFhZmvL29TY0aNUz37t3tBSlX62tBXDlnufPOO03NmjWNt7e3ufrqq82dd95pfvzxR5fsqzEVM5davXq1kZTv96Irvb4VMdd7//33TYMGDYy3t7cJDQ01cXFxJjU11WX7eyluxhhj2bAsAAAAAAAAQMwpBQAAAAAAACegKAUAAAAAAADLUZQCAAAAAACA5ShKAQAAAAAAwHIUpQAAAAAAAGA5ilIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFoFwaMmSI+vTp4+wwAAAAyg3yJwBlDUUpAAAAAAAAWI6iFIByr2vXrnrwwQf12GOPqVq1agoNDdW4ceMc2qSmpuq+++5TSEiIfH191bx5c61YscK+/X//+5+aNWsmHx8f1atXT6+88orD8+vVq6fnnntOgwcPlr+/v8LCwvTJJ5/o2LFjuvXWW+Xv76+WLVvq66+/dnjepk2b1KlTJ/n5+alOnTp68MEHdfr06VI7FwAAAIVB/gSgLKAoBcAlLFiwQJUrV9a2bds0ZcoUTZgwQWvXrpUk5eTkqGfPntq8ebMWLlyohIQEvfDCC/Lw8JAk7dy5U3fccYf69eunPXv2aNy4cXr66ac1f/58h2NMmzZNHTp00K5duxQdHa1BgwZp8ODBGjhwoL755htdc801Gjx4sIwxkqSffvpJN998s2JiYvTdd9/p/fff16ZNmzRixAhLzw0AAEB+yJ8AOJubyf30A0A5MmTIEKWmpuqjjz5S165dlZ2dra+++sq+/YYbblC3bt30wgsvaM2aNerZs6e+//57NWrUKM++BgwYoGPHjmnNmjX2dY899phWrlypffv2Sfr7l75OnTrp3XfflSQlJSWpZs2aevrppzVhwgRJ0tatW2Wz2XT06FGFhobqX//6lzw8PPTGG2/Y97tp0yZ16dJFp0+flq+vb6mcGwAAgPyQPwEoaxgpBcAltGzZ0mG5Zs2aSklJkSTt3r1btWvXzjehkqTvv/9eHTp0cFjXoUMHHTx4UNnZ2fkeIyQkRJLUokWLPOtyj/vtt99q/vz58vf3tz+ioqKUk5OjQ4cOFberAAAAJYL8CYCzeTo7AAAoCV5eXg7Lbm5uysnJkST5+fmV+DHc3NwKXJd73IyMDN1333168MEH8+yrbt26JRITAABAcZE/AXA2ilIAXF7Lli3122+/6cCBA/n+2te0aVNt3rzZYd3mzZvVqFEj+7wJxdGmTRslJCTo2muvLfY+AAAAnIH8CYAVuHwPgMvr0qWLOnfurJiYGK1du1aHDh3SZ599plWrVkmSHn74Ya1fv14TJ07UgQMHtGDBAr3++ut65JFHrui4jz/+uLZs2aIRI0Zo9+7dOnjwoD7++GMm6gQAAGUe+RMAK1CUAlAh/O9//9P111+v/v37Kzw8XI899ph9voM2bdrogw8+0OLFi9W8eXM988wzmjBhgoYMGXJFx2zZsqU2btyoAwcOqFOnTrruuuv0zDPPqFatWiXQIwAAgNJF/gSgtHH3PQAAAAAAAFiOkVIAAAAAAACwHEUpAAAAAAAAWI6iFAAAAAAAACxHUQoAAAAAAACWoygFAAAAAAAAy1GUAgAAAAAAgOUoSgEAAAAAAMByFKUAAAAAAABgOYpSAAAAAAAAsBxFKQAAAAAAAFiOohQAAAAAAAAsR1EKAAAAAAAAlvt/O7jw6WCqrh0AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -119,6 +129,244 @@ "source": [ "wolfson(income_low_polarization)" ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c5f3b133-6dd2-4335-ac88-3ef1db83c30f", + "metadata": {}, + "outputs": [], + "source": [ + "import libpysal\n", + "import geopandas\n", + "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", + "gdf = geopandas.read_file(pth)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "178e52f8-00a7-4b0e-af5f-82c5ce9a869b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gdf.plot(column='PCGDP1960', legend=True);" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8c7ad1b2-9dd8-46a1-b962-7a8000e295c2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([8., 6., 7., 4., 2., 0., 2., 1., 1., 1.]),\n", + " array([ 4140. , 6043.4, 7946.8, 9850.2, 11753.6, 13657. , 15560.4,\n", + " 17463.8, 19367.2, 21270.6, 23174. ]),\n", + " )" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(gdf.PCGDP1960)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d589094f-d127-4ab3-9f70-924c35f9e8d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.11070986960431652)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(gdf.PCGDP1960)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4870ffd2-8ec3-4ce4-98a1-48078fbac019", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gdf.plot(column='PCGDP2000', legend=True);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "33421fc3-1853-4836-8d21-f07ddcdf50a2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([9., 8., 3., 4., 4., 1., 2., 0., 0., 1.]),\n", + " array([ 8684. , 13250.5, 17817. , 22383.5, 26950. , 31516.5, 36083. ,\n", + " 40649.5, 45216. , 49782.5, 54349. ]),\n", + " )" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(gdf.PCGDP2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e266c662-9e61-45ae-8861-a57feacdf87c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.13617347834498972)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wolfson(gdf.PCGDP2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "02000879-c5c2-467d-89cc-dd8ade7b0560", + "metadata": {}, + "outputs": [], + "source": [ + "years = range(1940, 2010, 10)\n", + "w = [wolfson(gdf[f\"PCGDP{year}\"]) for year in years]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b1056738-51e3-4611-8db1-fda8d551cb91", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f01a6c1d-1ebd-416b-a28d-35c6dd7e5245", + "metadata": {}, + "outputs": [], + "source": [ + "ts = pandas.DataFrame(data=years, columns=['year'])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8ddeebbb-ec87-47db-9f98-ca665413adf7", + "metadata": {}, + "outputs": [], + "source": [ + "ts['wolfson'] = w\n", + "ts = ts.set_index('year')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "21fa7d6f-16fb-4cbf-813d-2e2f377dbaa0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ts.plot()" + ] } ], "metadata": { @@ -137,7 +385,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.10.15" } }, "nbformat": 4, From bf197c69b6c0ce6e9b66ae04fe5a82b85fa6dc73 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 7 Nov 2024 14:26:09 -0800 Subject: [PATCH 17/32] prune docs --- docs/user-guide/measure/wolfson_spatial.ipynb | 3079 ----------------- 1 file changed, 3079 deletions(-) delete mode 100644 docs/user-guide/measure/wolfson_spatial.ipynb diff --git a/docs/user-guide/measure/wolfson_spatial.ipynb b/docs/user-guide/measure/wolfson_spatial.ipynb deleted file mode 100644 index afca7b0b..00000000 --- a/docs/user-guide/measure/wolfson_spatial.ipynb +++ /dev/null @@ -1,3079 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "55aba049-984e-4563-9bb6-8292f2c92a22", - "metadata": {}, - "source": [ - "# Demonstrating the Wolfson Bipolarization Coefficient:\n", - "\n", - "\n", - "-------------------------\n", - "\n", - "### 1. Imports & Input Data" - ] - }, - { - "cell_type": "code", - "execution_count": 159, - "id": "64243a0a-7c9b-424d-940b-86004ab8c0d1", - "metadata": {}, - "outputs": [], - "source": [ - "from inequality.wolfson import wolfson\n" - ] - }, - { - "cell_type": "code", - "execution_count": 160, - "id": "76fe1f4d-ba15-468f-8334-23777b611cac", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Set random seed for reproducibility\n", - "np.random.seed(42)\n", - "\n", - "# Distribution 1: Low polarization (normal distribution)\n", - "income_low_polarization = np.random.normal(loc=50000, scale=15000, size=10000)\n", - "\n", - "# Distribution 2: High polarization (bimodal distribution)\n", - "income_high_polarization = np.concatenate([\n", - " np.random.normal(loc=30000, scale=5000, size=5000),\n", - " np.random.normal(loc=70000, scale=5000, size=5000)\n", - "])\n", - "\n", - "# Plotting the distributions\n", - "plt.figure(figsize=(12, 6))\n", - "\n", - "# Plot for low polarization\n", - "plt.subplot(1, 2, 1)\n", - "plt.hist(income_low_polarization, bins=50, color='blue', alpha=0.7)\n", - "plt.title('Low Polarization Income Distribution')\n", - "plt.xlabel('Income')\n", - "plt.ylabel('Frequency')\n", - "\n", - "# Plot for high polarization\n", - "plt.subplot(1, 2, 2)\n", - "plt.hist(income_high_polarization, bins=50, color='red', alpha=0.7)\n", - "plt.title('High Polarization Income Distribution')\n", - "plt.xlabel('Income')\n", - "plt.ylabel('Frequency')\n", - "\n", - "# Show plots\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 161, - "id": "4020946f-6f78-45e6-9d72-895de8807bc3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.17571224182763848)" - ] - }, - "execution_count": 161, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wolfson(income_high_polarization)" - ] - }, - { - "cell_type": "code", - "execution_count": 162, - "id": "6d105e2b-5549-425c-a594-37372d5fc75c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.07016937981819878)" - ] - }, - "execution_count": 162, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wolfson(income_low_polarization)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3241b6ae-dd3a-4e76-a773-95c6f5b846ef", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 163, - "id": "b3184d08-5e44-4983-a271-3e26f0f616bd", - "metadata": {}, - "outputs": [], - "source": [ - "import geopandas\n", - "import inequality\n", - "import libpysal\n" - ] - }, - { - "cell_type": "code", - "execution_count": 164, - "id": "2d86fcfd-55eb-4380-a6ab-b1bcceceaaf1", - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.962407Z", - "start_time": "2023-01-17T02:01:01.779047Z" - } - }, - "outputs": [], - "source": [ - "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", - "gdf = geopandas.read_file(pth)" - ] - }, - { - "cell_type": "code", - "execution_count": 165, - "id": "d08c11c1-f788-41a5-98d8-1f9b5977bd81", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.11070986960431652)" - ] - }, - "execution_count": 165, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wolfson(gdf.PCGDP1960)" - ] - }, - { - "cell_type": "code", - "execution_count": 166, - "id": "f4d889b2-36cc-49f3-bd72-8bb4d7da8c3e", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_2534197/4115592875.py:1: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", - " w = libpysal.weights.Queen.from_dataframe(gdf)\n" - ] - } - ], - "source": [ - "\n", - "w = libpysal.weights.Queen.from_dataframe(gdf)\n", - "w.transform = 'r'" - ] - }, - { - "cell_type": "code", - "execution_count": 167, - "id": "f49c6c0b-19a7-4cac-819e-1b50d7f033a4", - "metadata": {}, - "outputs": [], - "source": [ - "l60 = libpysal.weights.lag_spatial(w, gdf.PCGDP1960)" - ] - }, - { - "cell_type": "code", - "execution_count": 168, - "id": "108d9217-c01d-4d02-837d-6de9a34f53c9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.07039175526018514)" - ] - }, - "execution_count": 168, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wolfson(l60)" - ] - }, - { - "cell_type": "code", - "execution_count": 169, - "id": "6f3967c4-8cc4-4b60-8b1f-1e17e5d516ad", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 170, - "id": "e5e772f1-e5a7-4bb4-99e4-1654a8f5c8db", - "metadata": {}, - "outputs": [], - "source": [ - "r60 = np.random.permutation(gdf.PCGDP1960)" - ] - }, - { - "cell_type": "code", - "execution_count": 171, - "id": "31ba5fa8-52cb-4afe-a71a-76934cd671aa", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.05767316232696517)" - ] - }, - "execution_count": 171, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "lr60 = libpysal.weights.lag_spatial(w, r60)\n", - "wolfson(lr60)" - ] - }, - { - "cell_type": "code", - "execution_count": 172, - "id": "4332eb63-a418-4542-b61e-5d520659cf75", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKIAAAJOCAYAAACEMq9JAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXgElEQVR4nO3dd5hU5d0//s/SlgWWVUAEpFpRimKJIkTshmaNigVQozGxIZYgJhZs2EN8/AVrEB+jolERu6ioMYIFxII+iEoAFcRYFkRZgT2/P/wycdwFYVnO7C6v13XNdTFn7jnnc99nZ+fmvafkJUmSBAAAAACsZ7VyXQAAAAAAGwZBFAAAAACpEEQBAAAAkApBFAAAAACpEEQBAAAAkApBFAAAAACpEEQBAAAAkApBFAAAAACpEEQBAAAAkApBFFQTd9xxR+Tl5cXrr7+e61JyLi8vL/OoXbt2bLzxxrH99tvHySefHFOmTCnT/t///nfk5eXFHXfcsVbbufvuu2PUqFFr9Z7ytnXxxRdHXl5e/Oc//1mrda3Ou+++GxdffHH8+9//LvPacccdF+3bt6+0bQGw4XjllVfikEMOibZt20Z+fn5suumm0b179zj77LPX+7avuOKKGD9+fJnlzz//fOTl5cXzzz+/1utc0/eubPePf/xjrbexPuTl5cVpp52W6zJy7rjjjsua9zVs2DDat28fBx54YIwZMyZKSkrKvGfPPfeMPffcc622s7p51er8dFsr54HXXnvtWq3n56yPzwbkkiAKqJZ+/etfx+TJk+Oll16Ke++9NwYNGhRTpkyJ7t27x5AhQ7LatmzZMiZPnhx9+/Zdq21UJIiq6LbW1rvvvhsjRowod8J0wQUXxEMPPbRetw9AzfPYY4/F7rvvHosWLYqrr746nn766fjLX/4SPXr0iHHjxq337a/qP9s77rhjTJ48OXbcccf1XgNVT0FBQUyePDkmT54cjz76aFxyySXRsGHDOOmkk2KnnXaKjz/+OKv9X//61/jrX/+6VttY3bxqdSqyrYrw2aCmqZPrAgAqYtNNN43ddtst8/yAAw6IM888M37729/GDTfcEB07dozf//73ERGRn5+f1XZ9WLFiRSxfvjyVbf2cLbbYIqfbB6B6uvrqq6NDhw7x1FNPRZ06//1vwoABA+Lqq6/OWV2NGzfO+XcruVOrVq0y+3/QoEFx/PHHR79+/eLXv/511hHx22233Xqv6dtvv40GDRqksq3V8dmgunJEFFRjxx13XDRq1Cg++OCD6NOnTzRq1CjatGkTZ599dplDlUtKSuKSSy6JbbfdNurXrx9NmzaNvfbaK15++eVMm6VLl8bw4cOjQ4cOUa9evdhss83i1FNPja+//jprXe3bt49+/frFo48+Gt26dYuCgoLYdttt49FHH42IH04j3HbbbaNhw4bxi1/8otzTCV9//fU48MADo0mTJlG/fv3o1q1b3Hfffes0HrVr144bb7wxmjVrFtdcc01meXmny33++efx29/+Ntq0aRP5+fmxySabRI8ePeKZZ56JiB8OtX7sscdizpw5WYeE/3h9V199dVx22WXRoUOHyM/Pj0mTJq32NMB58+bFoYceGo0bN46ioqI49thj4/PPP89qk5eXFxdffHGZ97Zv3z6OO+64iPhhfA8//PCIiNhrr70yta3cZnmn5q3tvn3yySdjxx13jIKCgujYsWP87W9/+5nRB6C6++KLL6JZs2ZZIdRKtWpl/7dh5ffFQw89FF27do369evH5ptvHjfccENWu6VLl8bZZ58dO+ywQxQVFUWTJk2ie/fu8fDDD2e1y8vLiyVLlsTYsWMz32srT3kq7/Sj119/PQYMGBDt27ePgoKCaN++fRx11FExZ86cyhmMVRgxYkTsuuuu0aRJk2jcuHHsuOOOcfvtt0eSJFntSkpK4uyzz44WLVpEgwYNYo899oipU6dmfZ+vjZVjcM8998Qf//jHaNWqVTRu3Dj23XffmDlzZpn2Tz75ZOyzzz5RVFQUDRo0iG233TZGjhyZ1WbChAnRvXv3aNCgQRQWFsZ+++0XkydPzmqz8vICb731Vhx++OGZfXjWWWfF8uXLY+bMmfGrX/0qCgsLo3379uUGlosWLYpzzjknaw5y5plnxpIlS9Z6HH5s//33j5NOOileeeWVePHFFzPLyzs1b/To0bH99ttHo0aNorCwMDp27Bjnn39+RPz8vGrPPfeMzp07x4svvhi77757NGjQIE444YRVbisiorS0NC6//PJo27Zt1K9fP3beeed49tlns9qs6lIKK8d8pbX9bESs3b6dMWNGHHXUUVFUVBSbbrppnHDCCVFcXFzumENlEURBNbds2bI48MADY5999omHH344TjjhhPjzn/8cV111VabN8uXLo3fv3nHppZdmJo133HFH7L777jF37tyIiEiSJA4++OC49tprY+DAgfHYY4/FWWedFWPHjo299967TLD15ptvxvDhw2PYsGHx4IMPRlFRURx66KFx0UUXxW233RZXXHFF/P3vf4/i4uLo169ffPfdd5n3Tpo0KXr06BFff/113HTTTfHwww/HDjvsEEceeeRaX8fppwoKCmLfffeN2bNnlzlU+8cGDhwY48ePjwsvvDCefvrpuO2222LfffeNL774IiJ+ONS6R48e0aJFi8zh4D/9Ar/hhhviueeei2uvvTaeeOKJ6Nix42prO+SQQ2LLLbeMf/zjH3HxxRfH+PHj44ADDohly5atVR/79u0bV1xxRURE/H//3/+XqW1VpwNWZN+effbZMXTo0Hj44Yeja9eu8Zvf/CZrkgdAzdO9e/d45ZVX4owzzohXXnnlZ7+fpk+fHmeeeWYMHTo0Hnroodh9991jyJAhWdfHKSkpiS+//DLOOeecGD9+fNxzzz3Rs2fPOPTQQ+POO+/MtJs8eXIUFBREnz59Mt9rqzvl6d///ndss802MWrUqHjqqafiqquuivnz58cuu+xSqddkLG+7J598ctx3333x4IMPxqGHHhqnn356XHrppVntjj/++Bg1alQcf/zx8fDDD8dhhx0WhxxySJk/AK2t888/P+bMmRO33XZb3HLLLTFr1qzo379/rFixItPm9ttvjz59+kRpaWncdNNN8cgjj8QZZ5yRNS+6++6746CDDorGjRvHPffcE7fffnt89dVXseeee8ZLL71UZrtHHHFEbL/99vHAAw/ESSedFH/+859j6NChcfDBB0ffvn3joYceir333jszL1zp22+/jV69esXYsWPjjDPOiCeeeCKGDRsWd9xxRxx44IFlAry1deCBB0ZErHaOcu+998Ypp5wSvXr1ioceeijGjx8fQ4cOzQRhazKvmj9/fhx77LFx9NFHx+OPPx6nnHLKauu68cYb48knn4xRo0bFXXfdFbVq1YrevXuXmUuuibX9bKztvj3ssMNi6623jgceeCDOO++8uPvuu2Po0KFrXSeslQSoFsaMGZNERPLaa69llg0ePDiJiOS+++7LatunT59km222yTy/8847k4hIbr311lWu/8knn0wiIrn66quzlo8bNy6JiOSWW27JLGvXrl1SUFCQfPzxx5ll06dPTyIiadmyZbJkyZLM8vHjxycRkUyYMCGzrGPHjkm3bt2SZcuWZW2rX79+ScuWLZMVK1asdiwiIjn11FNX+fqwYcOSiEheeeWVJEmSZPbs2UlEJGPGjMm0adSoUXLmmWeudjt9+/ZN2rVrV2b5yvVtscUWyffff1/uaz/e1kUXXZRERDJ06NCstn//+9+TiEjuuuuurL5ddNFFZbbZrl27ZPDgwZnn999/fxIRyaRJk8q0HTx4cFbda7tv69evn8yZMyez7LvvvkuaNGmSnHzyyWW2BUDN8Z///Cfp2bNnEhFJRCR169ZNdt9992TkyJHJ4sWLs9q2a9cuycvLS6ZPn561fL/99ksaN26cNRf4seXLlyfLli1LfvOb3yTdunXLeq1hw4ZZ33UrTZo0aZXfeT9e7zfffJM0bNgw+ctf/rJW7/1xu/vvv3+17X5sxYoVybJly5JLLrkkadq0aVJaWpokSZLMmDEjiYhk2LBhWe3vueeeJCLK7eNP/XSus7K+Pn36ZLW77777kohIJk+enCRJkixevDhp3Lhx0rNnz0w95dXdqlWrpEuXLllzrsWLFyfNmzdPdt9998yylXOY6667LmsdO+ywQxIRyYMPPphZtmzZsmSTTTZJDj300MyykSNHJrVq1cqavyZJkvzjH/9IIiJ5/PHHVzsOgwcPTho2bLjK1997770kIpLf//73mWW9evVKevXqlXl+2mmnJRtttNFqt7O6eVWvXr2SiEieffbZcl/78bZWzgNbtWqVfPfdd5nlixYtSpo0aZLsu+++WX0rb565csx/bE0/GxXZtz+dH55yyilJ/fr1V/nzA5XBEVFQzeXl5UX//v2zlnXt2jXr0PQnnngi6tevnzmMuDzPPfdcRESZw8UPP/zwaNiwYZnDiXfYYYfYbLPNMs+33XbbiPjhEOUGDRqUWb6yng8++CD+7//+L4455piI+OForZWPPn36xPz588s9xHxtJGvw17Vf/OIXcccdd8Rll10WU6ZMWeujkiJ++Ctc3bp117j9yj6vdMQRR0SdOnVi0qRJa73ttVGRfdu2bdvM8/r168fWW2+93k93ACC3mjZtGv/85z/jtddeiyuvvDIOOuigeP/992P48OHRpUuXMkcaderUKbbffvusZUcffXQsWrQopk2blll2//33R48ePaJRo0ZRp06dqFu3btx+++3x3nvvVbjWb775JoYNGxZbbrll1KlTJ+rUqRONGjWKJUuWrNN6f85zzz0X++67bxQVFUXt2rWjbt26ceGFF8YXX3wRCxcujIiIF154ISJ++J7/sV//+tflnva4NlYeAbRS165dI+K/86yXX345Fi1aFKecckrW6V0/NnPmzPj0009j4MCBWadcNmrUKA477LCYMmVKfPvtt1nv6devX9bzbbfdNvLy8qJ3796ZZXXq1Iktt9wya77w6KOPRufOnWOHHXbImvMdcMABlXK3tzWd83399ddx1FFHxcMPP1yhI+Y23njj2Hvvvde4/aGHHhr169fPPC8sLIz+/fvHiy++mHX0WmWryL4t72dq6dKlmZ9nWB8EUVDNNWjQIOuLLuKHi3MvXbo08/zzzz+PVq1albm+w4998cUXUadOndhkk02ylufl5UWLFi0yp6yt1KRJk6zn9erVW+3ylfV89tlnERFxzjnnRN26dbMeKw9zXtdD6ldOgFq1arXKNuPGjYvBgwfHbbfdFt27d48mTZrEoEGDYsGCBWu8nZYtW65VXS1atMh6XqdOnWjatGmZsa1sa7tvmzZtWmYd+fn5WadXAlBz7bzzzjFs2LC4//7749NPP42hQ4fGv//97zLX//np99qPl638bnnwwQfjiCOOiM022yzuuuuumDx5crz22mtxwgknZM1V1tbRRx8dN954Y5x44onx1FNPxauvvhqvvfZabLLJJuvt++rVV1+N/fffPyIibr311vjXv/4Vr732Wvzxj3+MiMhsd2XfN91006z3r/zeXxc/fX9+fn7Wtldee7J169arXMfK+sqbx7Rq1SpKS0vjq6++ylpe3vyuvDlovXr1svbrZ599Fm+99VaZOV9hYWEkSZLKnG/gwIHxt7/9LebMmROHHXZYNG/ePHbdddeYOHHiGm9nXed8K5d9//338c0336zVutZGRfbtz/1MwfrgrnmwAdhkk03ipZdeitLS0lWGUU2bNo3ly5fH559/nhVYJEkSCxYsiF122aVSamnWrFlERAwfPjwOPfTQcttss802FV7/d999F88880xsscUWq52ENWvWLEaNGhWjRo2KuXPnxoQJE+K8886LhQsXxpNPPrlG21rVXxpXZcGCBVlHkS1fvjy++OKLrAlAfn5+mWs2RcQ6hVVp7VsAap66devGRRddFH/+85/jnXfeyXqtvD/erFy28rvtrrvuig4dOsS4ceOyvjfL+65bU8XFxfHoo4/GRRddFOedd17WOr/88ssKr/fn3HvvvVG3bt149NFHswKY8ePHZ7Vb2ffPPvus3O/99Wnl9/zqrpO5sr758+eXee3TTz+NWrVqxcYbb1wp9TRr1iwKCgpWedOTlfPCipowYUJERLkXDP+x448/Po4//vhYsmRJvPjii3HRRRdFv3794v3334927dr97HYqMucrb1m9evWiUaNGEfHDEeflfQ7WJZxLc9/CunBEFGwAevfuHUuXLl3thcD32WefiPhhwvhjDzzwQCxZsiTz+rraZpttYquttoo333wzdt5553IfhYWFFVr3ihUr4rTTTosvvvgihg0btsbva9u2bZx22mmx3377ZZ1KUNlHAf3973/Pen7ffffF8uXLsyZP7du3j7feeiur3XPPPVfmr2dr89eqtPYtANVbef95jYjMqW4/PepkxowZ8eabb2Ytu/vuu6OwsDB23HHHiPjhP/D16tXL+o/8ggULytw1L2LNv3fz8vIiSZLMd+FKt91223o97SkvLy/q1KkTtWvXziz77rvv4n//93+z2u2xxx4R8cPR1z/2j3/8I5YvX77e6ouI2H333aOoqChuuummVZ62ts0228Rmm20Wd999d1abJUuWxAMPPJC521pl6NevX3z44YfRtGnTcud85d01bk1NnDgxbrvttth9992jZ8+ea/Sehg0bRu/eveOPf/xjfP/99zFjxoyIqPyjgB588MGsI8MWL14cjzzySPzyl7/M/Py0b98+Fi5cmDlbICLi+++/j6eeeqrM+tb0s5HmvoV14Ygo2AAcddRRMWbMmPjd734XM2fOjL322itKS0vjlVdeiW233TYGDBgQ++23XxxwwAExbNiwWLRoUfTo0SPeeuutuOiii6Jbt24xcODASqvn5ptvjt69e8cBBxwQxx13XGy22Wbx5ZdfxnvvvRfTpk2L+++//2fX8dlnn8WUKVMiSZJYvHhxvPPOO3HnnXfGm2++GUOHDo2TTjpple8tLi6OvfbaK44++ujo2LFjFBYWxmuvvRZPPvlk1lFaXbp0iQcffDBGjx4dO+20U9SqVSt23nnnCvf7wQcfjDp16sR+++0XM2bMiAsuuCC23377rGtIDBw4MC644IK48MILo1evXvHuu+/GjTfeGEVFRVnr6ty5c0RE3HLLLVFYWBj169ePDh06lHvIf5r7FoDq64ADDojWrVtH//79o2PHjlFaWhrTp0+P6667Lho1ahRDhgzJat+qVas48MAD4+KLL46WLVvGXXfdFRMnToyrrroq85/dfv36xYMPPhinnHJK/PrXv4558+bFpZdeGi1btoxZs2Zlra9Lly7x/PPPxyOPPBItW7aMwsLCco+Sbty4ceyxxx5xzTXXRLNmzaJ9+/bxwgsvxO233x4bbbTROo3BlClTyl3eq1ev6Nu3b1x//fVx9NFHx29/+9v44osv4tprry0TiHXq1CmOOuqouO6666J27dqx9957x4wZM+K6666LoqKi1V4qYV01atQorrvuujjxxBNj3333jZNOOik23XTT+OCDD+LNN9+MG2+8MWrVqhVXX311HHPMMdGvX784+eSTo6SkJK655pr4+uuv48orr6y0es4888x44IEHYo899oihQ4dG165do7S0NObOnRtPP/10nH322bHrrruudh2lpaWZ/VJSUhJz586NJ554Iu67777Ydttt47777lvt+0866aQoKCiIHj16RMuWLWPBggUxcuTIKCoqyhwVvjbzqjVRu3bt2G+//eKss86K0tLSuOqqq2LRokUxYsSITJsjjzwyLrzwwhgwYECce+65sXTp0rjhhhvKDVPX9LOR5r6FdZKrq6QDa2dVd80r704i5d1t47vvvksuvPDCZKuttkrq1auXNG3aNNl7772Tl19+OavNsGHDknbt2iV169ZNWrZsmfz+979Pvvrqq6x1tWvXLunbt2+Z7UY5d7NbefeQa665Jmv5m2++mRxxxBFJ8+bNk7p16yYtWrRI9t577+Smm2762bGI/3c3n4hIatWqlTRu3Djp0qVL8tvf/jZz15jyalh5J7ulS5cmv/vd75KuXbsmjRs3TgoKCpJtttkmueiii7Lu8vPll18mv/71r5ONNtooycvLy4zpqvpU3raS5L/7Y+rUqUn//v2TRo0aJYWFhclRRx2VfPbZZ1nvLykpSf7whz8kbdq0SQoKCpJevXol06dPL3PXvCRJklGjRiUdOnRIateunbXN8u7Csq779qd3hQGg5hk3blxy9NFHJ1tttVXSqFGjpG7duknbtm2TgQMHJu+++25W25XfF//4xz+STp06JfXq1Uvat2+fXH/99WXWe+WVVybt27dP8vPzk2233Ta59dZby52rTJ8+PenRo0fSoEGDJCIy3zvl3fnu448/Tg477LBk4403TgoLC5Nf/epXyTvvvFPm+3Jt75q3qsfK9//tb39LttlmmyQ/Pz/ZfPPNk5EjRya33357EhHJ7NmzM+tbunRpctZZZyXNmzdP6tevn+y2227J5MmTk6KiojJ30S3PT+dUq7qrX3nzjiRJkscffzzp1atX0rBhw6RBgwbJdtttl1x11VVZbcaPH5/suuuuSf369ZOGDRsm++yzT/Kvf/0rq83K/fT5559nLV/VHLRXr15Jp06dspZ98803yZ/+9Kdkm222SerVq5cUFRUlXbp0SYYOHZosWLBgteOw8g7RKx8FBQVJ27Ztk/79+yd/+9vfkpKSknJr+PGcZezYsclee+2VbLrppkm9evWSVq1aJUcccUTy1ltvZb1vVfOq8vq0qm2t3B9XXXVVMmLEiKR169ZJvXr1km7duiVPPfVUmfc//vjjyQ477JAUFBQkm2++eXLjjTeu82cjSdZt3678P8ePf56hsuUlyRrcagAAAOD/ad++fXTu3DkeffTRXJdSbbz88svRo0eP+Pvf/x5HH310rssByBmn5gEAAFSiiRMnxuTJk2OnnXaKgoKCePPNN+PKK6+MrbbaapU3awHYUAiiAAAAKlHjxo3j6aefjlGjRsXixYujWbNm0bt37xg5cmTWHfcANkROzQMAAAAgFevvlg0AAAAA8COCKAAAAABSIYgCAAAAIBXV+mLlpaWl8emnn0ZhYWHk5eXluhwAoAZIkiQWL14crVq1ilq1asbf7MyZAIDKVtE5U7UOoj799NNo06ZNrssAAGqgefPmRevWrXNdRqUwZwIA1pe1nTNV6yCqsLAwIn7odOPGjXNcDQBQEyxatCjatGmTmWfUBOZMAEBlq+icqVoHUSsPLW/cuLFJFQBQqWrSKWzmTADA+rK2c6aaceEDAAAAAKo8QRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJCKnAZRy5cvjz/96U/RoUOHKCgoiM033zwuueSSKC0tzWVZAAAAAKwHdXK58auuuipuuummGDt2bHTq1Clef/31OP7446OoqCiGDBmSy9IAAAAAqGQ5DaImT54cBx10UPTt2zciItq3bx/33HNPvP7667ksCwAAAID1IKen5vXs2TOeffbZeP/99yMi4s0334yXXnop+vTpU277kpKSWLRoUdYDAAAAgOohp0dEDRs2LIqLi6Njx45Ru3btWLFiRVx++eVx1FFHldt+5MiRMWLEiFRr7N8/1c2tF488kusKAIAaryZMmmoCEz8AqricHhE1bty4uOuuu+Luu++OadOmxdixY+Paa6+NsWPHltt++PDhUVxcnHnMmzcv5YoBAAAAqKicHhF17rnnxnnnnRcDBgyIiIguXbrEnDlzYuTIkTF48OAy7fPz8yM/Pz/tMgEAAACoBDk9Iurbb7+NWrWyS6hdu3aUlpbmqCIAAAAA1pecHhHVv3//uPzyy6Nt27bRqVOneOONN+L666+PE044IZdlAQAAALAe5DSI+p//+Z+44IIL4pRTTomFCxdGq1at4uSTT44LL7wwl2UBAAAAsB7kNIgqLCyMUaNGxahRo3JZBgAAAAApyOk1ogAAAADYcAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAACqsOXLl8ef/vSn6NChQxQUFMTmm28el1xySZSWlua6NACAtVYn1wUAALBqV111Vdx0000xduzY6NSpU7z++utx/PHHR1FRUQwZMiTX5QEArBVBFABAFTZ58uQ46KCDom/fvhER0b59+7jnnnvi9ddfz3FlAABrz6l5AABVWM+ePePZZ5+N999/PyIi3nzzzXjppZeiT58+q3xPSUlJLFq0KOsBAFAVOCIKAKAKGzZsWBQXF0fHjh2jdu3asWLFirj88svjqKOOWuV7Ro4cGSNGjEixSgCANeOIKACAKmzcuHFx1113xd133x3Tpk2LsWPHxrXXXhtjx45d5XuGDx8excXFmce8efNSrBgAYNVyGkS1b98+8vLyyjxOPfXUXJYFAFBlnHvuuXHeeefFgAEDokuXLjFw4MAYOnRojBw5cpXvyc/Pj8aNG2c9AACqgpyemvfaa6/FihUrMs/feeed2G+//eLwww/PYVUAAFXHt99+G7VqZf/tsHbt2lFaWpqjigAAKi6nQdQmm2yS9fzKK6+MLbbYInr16pWjigAAqpb+/fvH5ZdfHm3bto1OnTrFG2+8Eddff32ccMIJuS4NAGCtVZmLlX///fdx1113xVlnnRV5eXm5LgcAoEr4n//5n7jgggvilFNOiYULF0arVq3i5JNPjgsvvDDXpQEArLUqE0SNHz8+vv766zjuuONW2aakpCRKSkoyz92KGACo6QoLC2PUqFExatSoXJcCALDOqkwQdfvtt0fv3r2jVatWq2zjVsQbrv79c13BunvkkVxXAAAAALmV07vmrTRnzpx45pln4sQTT1xtO7ciBgAAAKi+qsQRUWPGjInmzZtH3759V9suPz8/8vPzU6oKAAAAgMqU8yOiSktLY8yYMTF48OCoU6dK5GIAAAAArAc5D6KeeeaZmDt3rlsQAwAAANRwOT8Eaf/9948kSXJdBgAAAADrWc6PiAIAAABgwyCIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVOQ+iPvnkkzj22GOjadOm0aBBg9hhhx1i6tSpuS4LAAAAgEpWJ5cb/+qrr6JHjx6x1157xRNPPBHNmzePDz/8MDbaaKNclgUAAADAepDTIOqqq66KNm3axJgxYzLL2rdvn7uCAAAAAFhvcnpq3oQJE2LnnXeOww8/PJo3bx7dunWLW2+9dZXtS0pKYtGiRVkPAAAAAKqHnB4R9dFHH8Xo0aPjrLPOivPPPz9effXVOOOMMyI/Pz8GDRpUpv3IkSNjxIgROai0euvfP9cVAAAAAOT4iKjS0tLYcccd44orrohu3brFySefHCeddFKMHj263PbDhw+P4uLizGPevHkpVwwAAABAReU0iGrZsmVst912Wcu23XbbmDt3brnt8/Pzo3HjxlkPAAAAAKqHnAZRPXr0iJkzZ2Yte//996Ndu3Y5qggAAACA9SWnQdTQoUNjypQpccUVV8QHH3wQd999d9xyyy1x6qmn5rIsAAAAANaDnAZRu+yySzz00ENxzz33ROfOnePSSy+NUaNGxTHHHJPLsgAAAABYD3J617yIiH79+kW/fv1yXQYAAAAA61lOj4gCAAAAYMMhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAAAAgFYIoAAAAAFIhiAIAqOI++eSTOPbYY6Np06bRoEGD2GGHHWLq1Km5LgsAYK3VyXUBAACs2ldffRU9evSIvfbaK5544olo3rx5fPjhh7HRRhvlujQAgLUmiAIAqMKuuuqqaNOmTYwZMyazrH379rkrCABgHTg1DwCgCpswYULsvPPOcfjhh0fz5s2jW7duceutt672PSUlJbFo0aKsBwBAVSCIAgCowj766KMYPXp0bLXVVvHUU0/F7373uzjjjDPizjvvXOV7Ro4cGUVFRZlHmzZtUqwYAGDVBFEAAFVYaWlp7LjjjnHFFVdEt27d4uSTT46TTjopRo8evcr3DB8+PIqLizOPefPmpVgxAMCqCaIAAKqwli1bxnbbbZe1bNttt425c+eu8j35+fnRuHHjrAcAQFUgiAIAqMJ69OgRM2fOzFr2/vvvR7t27XJUEQBAxQmiAACqsKFDh8aUKVPiiiuuiA8++CDuvvvuuOWWW+LUU0/NdWkAAGtNEAUAUIXtsssu8dBDD8U999wTnTt3jksvvTRGjRoVxxxzTK5LAwBYa3VyXQAAAKvXr1+/6NevX67LAABYZ46IAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVOQ2iLr744sjLy8t6tGjRIpclAQAAALCe1Ml1AZ06dYpnnnkm87x27do5rAYAAACA9SXnQVSdOnUcBQUAAACwAcj5NaJmzZoVrVq1ig4dOsSAAQPio48+WmXbkpKSWLRoUdYDAAAAgOohp0HUrrvuGnfeeWc89dRTceutt8aCBQti9913jy+++KLc9iNHjoyioqLMo02bNilXDAAAAEBF5TSI6t27dxx22GHRpUuX2HfffeOxxx6LiIixY8eW23748OFRXFycecybNy/NcgEAAABYBzm/RtSPNWzYMLp06RKzZs0q9/X8/PzIz89PuSoAAAAAKkPOrxH1YyUlJfHee+9Fy5Ytc10KAAAAAJUsp0HUOeecEy+88ELMnj07Xnnllfj1r38dixYtisGDB+eyLAAAAADWg5yemvfxxx/HUUcdFf/5z39ik002id122y2mTJkS7dq1y2VZAAAAAKwHOQ2i7r333lxuHgAAAIAUValrRAEAAABQcwmiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEhFhYKo2bNnV3YdAAA1jjkTAEC2CgVRW265Zey1115x1113xdKlSyu7JgCAGsGcCQAgW4WCqDfffDO6desWZ599drRo0SJOPvnkePXVVyu7NgCAas2cCQAgW4WCqM6dO8f1118fn3zySYwZMyYWLFgQPXv2jE6dOsX1118fn3/+eWXXCQBQ7ZgzAQBkW6eLldepUycOOeSQuO++++Kqq66KDz/8MM4555xo3bp1DBo0KObPn19ZdQIAVFvmTAAAP1inIOr111+PU045JVq2bBnXX399nHPOOfHhhx/Gc889F5988kkcdNBBlVUnAEC1Zc4EAPCDOhV50/XXXx9jxoyJmTNnRp8+feLOO++MPn36RK1aP+RaHTp0iJtvvjk6duxYqcUCAFQn5kwAANkqFESNHj06TjjhhDj++OOjRYsW5bZp27Zt3H777etUHABAdWbOBACQrUJB1KxZs362Tb169WLw4MEVWT0AQI1gzgQAkK1C14gaM2ZM3H///WWW33///TF27Nh1LgoAoCYwZwIAyFahIOrKK6+MZs2alVnevHnzuOKKK9a5KACAmsCcCQAgW4WCqDlz5kSHDh3KLG/Xrl3MnTt3nYsCAKgJzJkAALJVKIhq3rx5vPXWW2WWv/nmm9G0adN1LgoAoCYwZwIAyFahIGrAgAFxxhlnxKRJk2LFihWxYsWKeO6552LIkCExYMCAyq4RAKBaMmcCAMhWobvmXXbZZTFnzpzYZ599ok6dH1ZRWloagwYNcr0DAID/x5wJACBbhYKoevXqxbhx4+LSSy+NN998MwoKCqJLly7Rrl27yq4PAKDaMmcCAMhWoSBqpa233jq23nrryqoFAKBGMmcCAPhBhYKoFStWxB133BHPPvtsLFy4MEpLS7Nef+655yqlOACA6sycCQAgW4WCqCFDhsQdd9wRffv2jc6dO0deXl5l1wUAUO2ZMwEAZKtQEHXvvffGfffdF3369KnsegAAagxzJlhL/fvnuoJ198gjua4AoEqrVZE31atXL7bccsvKrgUAoEYxZwIAyFahIOrss8+Ov/zlL5EkSWXXAwBQY5gzAQBkq9CpeS+99FJMmjQpnnjiiejUqVPUrVs36/UHH3ywUooDAKjOzJkAALJVKIjaaKON4pBDDqnsWgAAahRzJgCAbBUKosaMGVPZdQAA1DjmTAAA2Sp0jaiIiOXLl8czzzwTN998cyxevDgiIj799NP45ptvKq04AIDqzpwJAOC/KnRE1Jw5c+JXv/pVzJ07N0pKSmK//faLwsLCuPrqq2Pp0qVx0003VXadAADVjjkTAEC2Ch0RNWTIkNh5553jq6++ioKCgszyQw45JJ599tlKKw4AoDozZwIAyFbhu+b961//inr16mUtb9euXXzyySeVUhgAQHVnzgQAkK1CR0SVlpbGihUryiz/+OOPo7CwcJ2LAgCoCcyZAACyVSiI2m+//WLUqFGZ53l5efHNN9/ERRddFH369Kms2gAAqjVzJgCAbBU6Ne/Pf/5z7LXXXrHddtvF0qVL4+ijj45Zs2ZFs2bN4p577qnsGgEAqiVzJgCAbBUKolq1ahXTp0+Pe+65J6ZNmxalpaXxm9/8Jo455pisC3ECAGzIzJkAALJVKIiKiCgoKIgTTjghTjjhhMqsBwCgRjFnAgD4rwoFUXfeeedqXx80aFCFigEAqEnMmQAAslUoiBoyZEjW82XLlsW3334b9erViwYNGphUAQCEORMAwE9V6K55X331Vdbjm2++iZkzZ0bPnj1deBMA4P8xZwIAyFahIKo8W221VVx55ZVl/vIHAMB/mTMBABuySguiIiJq164dn376aWWuEgCgxjFnAgA2VBW6RtSECROynidJEvPnz48bb7wxevToUSmFAQBUd+ZMAADZKhREHXzwwVnP8/LyYpNNNom99947rrvuusqoCwCg2jNnAgDIVqEgqrS0tLLriJEjR8b5558fQ4YMiVGjRlX6+gEA0rY+5kwAANVZpV4jqqJee+21uOWWW6Jr1665LgUAAACA9aRCR0SdddZZa9z2+uuvX+3r33zzTRxzzDFx6623xmWXXVaRcgAAqqTKnDMBANQEFQqi3njjjZg2bVosX748ttlmm4iIeP/996N27dqx4447Ztrl5eX97LpOPfXU6Nu3b+y7776CKACgRqnMORMAQE1QoSCqf//+UVhYGGPHjo2NN944IiK++uqrOP744+OXv/xlnH322Wu0nnvvvTemTZsWr7322hq1LykpiZKSkszzRYsWrX3xAAApqaw5EwBATVGhIOq6666Lp59+OjOhiojYeOON47LLLov9999/jSZV8+bNiyFDhsTTTz8d9evXX6Ptjhw5MkaMGFGRkiHn+vfPdQXr5pFHcl0BQPVTGXMmAICapEIXK1+0aFF89tlnZZYvXLgwFi9evEbrmDp1aixcuDB22mmnqFOnTtSpUydeeOGFuOGGG6JOnTqxYsWKMu8ZPnx4FBcXZx7z5s2rSPkAAKmojDkTAEBNUqEjog455JA4/vjj47rrrovddtstIiKmTJkS5557bhx66KFrtI599tkn3n777axlxx9/fHTs2DGGDRsWtWvXLvOe/Pz8yM/Pr0jJAACpq4w5EwBATVKhIOqmm26Kc845J4499thYtmzZDyuqUyd+85vfxDXXXLNG6ygsLIzOnTtnLWvYsGE0bdq0zHIAgOqoMuZMAAA1SYWCqAYNGsRf//rXuOaaa+LDDz+MJEliyy23jIYNG1Z2fQAA1ZY5EwBAtgoFUSvNnz8/5s+fH3vssUcUFBREkiTrdPvh559/fl3KAQCokip7zgQAUF1V6GLlX3zxReyzzz6x9dZbR58+fWL+/PkREXHiiSe6+wsAwP9jzgQAkK1CQdTQoUOjbt26MXfu3GjQoEFm+ZFHHhlPPvlkpRUHAFCdmTMBAGSr0Kl5Tz/9dDz11FPRunXrrOVbbbVVzJkzp1IKAwCo7syZAACyVeiIqCVLlmT9VW+l//znP5Gfn7/ORQEA1ATmTAAA2SoURO2xxx5x5513Zp7n5eVFaWlpXHPNNbHXXntVWnEAANWZORMAQLYKnZp3zTXXxJ577hmvv/56fP/99/GHP/whZsyYEV9++WX861//quwaAQCqJXMmAIBsFToiarvttou33norfvGLX8R+++0XS5YsiUMPPTTeeOON2GKLLSq7RgCAasmcCQAg21ofEbVs2bLYf//94+abb44RI0asj5oAAKo9cyYAgLLW+oiounXrxjvvvBN5eXnrox4AgBrBnAkAoKwKnZo3aNCguP322yu7FgCAGsWcCQAgW4UuVv7999/HbbfdFhMnToydd945GjZsmPX69ddfXynFAQBUZ+ZMAADZ1iqI+uijj6J9+/bxzjvvxI477hgREe+//35WG4efAwAbOnMmAIDyrVUQtdVWW8X8+fNj0qRJERFx5JFHxg033BCbbrrpeikOAKA6MmcCACjfWl0jKkmSrOdPPPFELFmypFILAgCo7syZAADKV6GLla/000kWAABlmTMBAPxgrYKovLy8MtczcH0DAIBs5kwAAOVbq2tEJUkSxx13XOTn50dExNKlS+N3v/tdmTvAPPjgg5VXIQBANbM+50wjR46M888/P4YMGRKjRo2qjHIBAFKzVkHU4MGDs54fe+yxlVoMAEBNsL7mTK+99lrccsst0bVr10pZHwBA2tYqiBozZsz6qgMAoMZYH3Omb775Jo455pi49dZb47LLLqv09QMApGGdLlYOAEA6Tj311Ojbt2/su+++P9u2pKQkFi1alPUAAKgK1uqIKAAA0nfvvffGtGnT4rXXXluj9iNHjowRI0as56oAANaeI6IAAKqwefPmxZAhQ+Kuu+6K+vXrr9F7hg8fHsXFxZnHvHnz1nOVAABrxhFRAABV2NSpU2PhwoWx0047ZZatWLEiXnzxxbjxxhujpKQkateunfWe/Pz8zB37AACqEkEUAEAVts8++8Tbb7+dtez444+Pjh07xrBhw8qEUAAAVZkgCgCgCissLIzOnTtnLWvYsGE0bdq0zHIAgKrONaIAAAAASIUjogAAqpnnn38+1yUAAFSII6IAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBUCKIAAAAASIUgCgAAAIBU5DSIGj16dHTt2jUaN24cjRs3ju7du8cTTzyRy5IAAAAAWE9yGkS1bt06rrzyynj99dfj9ddfj7333jsOOuigmDFjRi7LAgAAAGA9qJPLjffv3z/r+eWXXx6jR4+OKVOmRKdOnXJUFQAAAADrQ06DqB9bsWJF3H///bFkyZLo3r17rssBAAAAoJLlPIh6++23o3v37rF06dJo1KhRPPTQQ7HddtuV27akpCRKSkoyzxctWpRWmQAAAACso5zfNW+bbbaJ6dOnx5QpU+L3v/99DB48ON59991y244cOTKKiooyjzZt2qRcLQAAAAAVlfMgql69erHlllvGzjvvHCNHjoztt98+/vKXv5Tbdvjw4VFcXJx5zJs3L+VqAQAAAKionJ+a91NJkmSdfvdj+fn5kZ+fn3JFAAAAAFSGnAZR559/fvTu3TvatGkTixcvjnvvvTeef/75ePLJJ3NZFgAAAADrQU6DqM8++ywGDhwY8+fPj6KioujatWs8+eSTsd9+++WyLAAAAADWg5wGUbfffnsuNw8AAABAinJ+sXIAAAAANgyCKAAAAABSIYgCAAAAIBWCKAAAAABSIYgCAAAAIBWCKAAAAABSIYgCAAAAIBWCKAAAAABSIYgCAAAAIBWCKAAAAABSIYgCAAAAIBWCKAAAAABSIYgCAAAAIBWCKAAAAABSUSfXBQAAANQY/fvnuoJ198gjua4AqMEcEQUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKgRRAAAAAKRCEAUAAABAKnIaRI0cOTJ22WWXKCwsjObNm8fBBx8cM2fOzGVJAAAAAKwnOQ2iXnjhhTj11FNjypQpMXHixFi+fHnsv//+sWTJklyWBQAAAMB6UCeXG3/yySezno8ZMyaaN28eU6dOjT322CNHVQEAAACwPuQ0iPqp4uLiiIho0qRJua+XlJRESUlJ5vmiRYtSqQsAAACAdVdlgqgkSeKss86Knj17RufOncttM3LkyBgxYkTKlQEREf3757qCdffII7muYN1V9/1QE/YBAABQcVXmrnmnnXZavPXWW3HPPfesss3w4cOjuLg485g3b16KFQIAAACwLqrEEVGnn356TJgwIV588cVo3br1Ktvl5+dHfn5+ipUBAAAAUFlyGkQlSRKnn356PPTQQ/H8889Hhw4dclkOAAAAAOtRToOoU089Ne6+++54+OGHo7CwMBYsWBAREUVFRVFQUJDL0gAAAACoZDm9RtTo0aOjuLg49txzz2jZsmXmMW7cuFyWBQAAAMB6kPNT8wAAAADYMFSZu+YBAAAAULMJogAAAABIhSAKAKAKGzlyZOyyyy5RWFgYzZs3j4MPPjhmzpyZ67IAACpEEAUAUIW98MILceqpp8aUKVNi4sSJsXz58th///1jyZIluS4NAGCt5fRi5QAArN6TTz6Z9XzMmDHRvHnzmDp1auyxxx45qgoAoGIcEQUAUI0UFxdHRESTJk1yXAkAwNpzRBQAQDWRJEmcddZZ0bNnz+jcufMq25WUlERJSUnm+aJFi9IoDwDgZwmiAACqidNOOy3eeuuteOmll1bbbuTIkTFixIiUqqJK6d8/1xUAlaEmfJYfeSTXFVBFOTUPAKAaOP3002PChAkxadKkaN269WrbDh8+PIqLizOPefPmpVQlAMDqOSIKAKAKS5IkTj/99HjooYfi+eefjw4dOvzse/Lz8yM/Pz+F6gAA1o4gCgCgCjv11FPj7rvvjocffjgKCwtjwYIFERFRVFQUBQUFOa4OAGDtODUPAKAKGz16dBQXF8eee+4ZLVu2zDzGjRuX69IAANaaI6IAAKqwJElyXQIAQKVxRBQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJAKQRQAAAAAqRBEAQAAAJCKnAZRL774YvTv3z9atWoVeXl5MX78+FyWAwAAAMB6lNMgasmSJbH99tvHjTfemMsyAAAAAEhBnVxuvHfv3tG7d+9clgAAAABASnIaRK2tkpKSKCkpyTxftGhRDqsBAAAAYG1UqyBq5MiRMWLEiFyXAUAF9e+f6wqoCR55JNcVAABQUdXqrnnDhw+P4uLizGPevHm5LgkAAACANVStjojKz8+P/Pz8XJcBAAAAQAVUqyOiAAAAAKi+cnpE1DfffBMffPBB5vns2bNj+vTp0aRJk2jbtm0OKwMAAACgsuU0iHr99ddjr732yjw/66yzIiJi8ODBcccdd+SoKgAAAADWh5wGUXvuuWckSZLLEgAAAABISbW6WDkAAADrWf/+ua5g3TzySK4roKbwWVgvXKwcAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIhSAKAAAAgFQIogAAAABIRc6DqL/+9a/RoUOHqF+/fuy0007xz3/+M9clAQBUOeZMAEBNkNMgaty4cXHmmWfGH//4x3jjjTfil7/8ZfTu3Tvmzp2by7IAAKoUcyYAoKbIaRB1/fXXx29+85s48cQTY9ttt41Ro0ZFmzZtYvTo0bksCwCgSjFnAgBqipwFUd9//31MnTo19t9//6zl+++/f7z88ss5qgoAoGoxZwIAapI6udrwf/7zn1ixYkVsuummWcs33XTTWLBgQbnvKSkpiZKSkszz4uLiiIhYtGjReqtz2bL1tmogZevxV0Vq/E6C9f9ZXjmvSJJk/W5oDVWXOZNfUECVYdJXNdgPubee90FF50w5C6JWysvLy3qeJEmZZSuNHDkyRowYUWZ5mzZt1kttQM1SVJTrCoDKkNZnefHixVFUhX5xmDMBrKEq9Lt7g2Y/5F5K+2Bt50w5C6KaNWsWtWvXLvOXvIULF5b5i99Kw4cPj7POOivzvLS0NL788sto2rTpKidiVdWiRYuiTZs2MW/evGjcuHGuy0nVhtz3CP3Xf/3Xf/2v6v1PkiQWL14crVq1ynUpEZHbOVN12WfVhfGsXMazchnPymMsK5fxrFyVOZ4VnTPlLIiqV69e7LTTTjFx4sQ45JBDMssnTpwYBx10ULnvyc/Pj/z8/KxlG2200fosc71r3LjxBvth2pD7HqH/+q//+q//VVlVOhKqKsyZqsM+q06MZ+UynpXLeFYeY1m5jGflqqzxrMicKaen5p111lkxcODA2HnnnaN79+5xyy23xNy5c+N3v/tdLssCAKhSzJkAgJoip0HUkUceGV988UVccsklMX/+/OjcuXM8/vjj0a5du1yWBQBQpZgzAQA1Rc4vVn7KKafEKaeckusyUpefnx8XXXRRmcPmNwQbct8j9F//9V//9X9D7f+6ysWcyT6rXMazchnPymU8K4+xrFzGs3JVhfHMS6rKvYkBAAAAqNFq5boAAAAAADYMgigAAAAAUiGIAgAAACAVgqgKuvjiiyMvLy/r0aJFi8zrSZLExRdfHK1atYqCgoLYc889Y8aMGVnrKCkpidNPPz2aNWsWDRs2jAMPPDA+/vjjrDZfffVVDBw4MIqKiqKoqCgGDhwYX3/9dRpdXK327duX6X9eXl6ceuqpERFx3HHHlXltt912y1pHder/iy++GP37949WrVpFXl5ejB8/Puv1NPf33Llzo3///tGwYcNo1qxZnHHGGfH999+vj25nrK7/y5Yti2HDhkWXLl2iYcOG0apVqxg0aFB8+umnWevYc889y/xMDBgwIKtNdex/RLo/71Wx/+X9LsjLy4trrrkm06a67v+RI0fGLrvsEoWFhdG8efM4+OCDY+bMmVltavLn/+f6vyF8/muCTz75JI499tho2rRpNGjQIHbYYYeYOnVq5vWaPmepTMuXL48//elP0aFDhygoKIjNN988LrnkkigtLc20MZ6rtqHPpypbZczPjOd//dzP54+dfPLJkZeXF6NGjcpabjx/sCZj+d5778WBBx4YRUVFUVhYGLvttlvMnTs387qx/K+fG89vvvkmTjvttGjdunUUFBTEtttuG6NHj85qU+XGM6FCLrrooqRTp07J/PnzM4+FCxdmXr/yyiuTwsLC5IEHHkjefvvt5Mgjj0xatmyZLFq0KNPmd7/7XbLZZpslEydOTKZNm5bstddeyfbbb58sX7480+ZXv/pV0rlz5+Tll19OXn755aRz585Jv379Uu1reRYuXJjV94kTJyYRkUyaNClJkiQZPHhw8qtf/SqrzRdffJG1jurU/8cffzz54x//mDzwwANJRCQPPfRQ1utp7e/ly5cnnTt3Tvbaa69k2rRpycSJE5NWrVolp512Ws76//XXXyf77rtvMm7cuOT//u//ksmTJye77rprstNOO2Wto1evXslJJ52U9TPx9ddfZ7Wpjv1PkvR+3qtq/3/c7/nz5yd/+9vfkry8vOTDDz/MtKmu+/+AAw5IxowZk7zzzjvJ9OnTk759+yZt27ZNvvnmm0ybmvz5/7n+bwif/+ruyy+/TNq1a5ccd9xxySuvvJLMnj07eeaZZ5IPPvgg06amz1kq02WXXZY0bdo0efTRR5PZs2cn999/f9KoUaNk1KhRmTbGc9U29PlUZauM+Znx/K+f+/lc6aGHHkq23377pFWrVsmf//znrNeM5w9+biw/+OCDpEmTJsm5556bTJs2Lfnwww+TRx99NPnss88ybYzlf/3ceJ544onJFltskUyaNCmZPXt2cvPNNye1a9dOxo8fn2lT1cZTEFVBF110UbL99tuX+1ppaWnSokWL5Morr8wsW7p0aVJUVJTcdNNNSZL88OVQt27d5N577820+eSTT5JatWolTz75ZJIkSfLuu+8mEZFMmTIl02by5MlJRCT/93//tx56VXFDhgxJtthii6S0tDRJkh/+Y37QQQetsn117v9PP/xp7u/HH388qVWrVvLJJ59k2txzzz1Jfn5+UlxcvF76+1Or+2Je6dVXX00iIpkzZ05mWa9evZIhQ4as8j3Vuf9p/bxX1f7/1EEHHZTsvffeWctqyv5fuHBhEhHJCy+8kCTJhvf5/2n/y1OTP//V0bBhw5KePXuu8vUNcc6yLvr27ZuccMIJWcsOPfTQ5Nhjj02SxHiujQ19PlXZKjI/M56rtqrx/Pjjj5PNNtsseeedd5J27dplBVHGs3zljeWRRx6Z+b1ZHmO5auWNZ6dOnZJLLrkka9mOO+6Y/OlPf0qSpGqOp1Pz1sGsWbOiVatW0aFDhxgwYEB89NFHERExe/bsWLBgQey///6Ztvn5+dGrV694+eWXIyJi6tSpsWzZsqw2rVq1is6dO2faTJ48OYqKimLXXXfNtNltt92iqKgo06Yq+P777+Ouu+6KE044IfLy8jLLn3/++WjevHlsvfXWcdJJJ8XChQszr9Wk/qe5vydPnhydO3eOVq1aZdoccMABUVJSknWaRa4VFxdHXl5ebLTRRlnL//73v0ezZs2iU6dOcc4558TixYszr1X3/qfx816V+7/SZ599Fo899lj85je/KfNaTdj/xcXFERHRpEmTiNjwPv8/7f+q2mxon/+qbMKECbHzzjvH4YcfHs2bN49u3brFrbfemnl9Q5uzrKuePXvGs88+G++//35ERLz55pvx0ksvRZ8+fSLCeK6LDe33aS789Pez8Vw7paWlMXDgwDj33HOjU6dOZV43nmumtLQ0Hnvssdh6663jgAMOiObNm8euu+6adbqZsVw7PXv2jAkTJsQnn3wSSZLEpEmT4v33348DDjggIqrmeNapcG83cLvuumvceeedsfXWW8dnn30Wl112Wey+++4xY8aMWLBgQUREbLrpplnv2XTTTWPOnDkREbFgwYKoV69ebLzxxmXarHz/ggULonnz5mW23bx580ybqmD8+PHx9ddfx3HHHZdZ1rt37zj88MOjXbt2MXv27Ljgggti7733jqlTp0Z+fn6N6n+a+3vBggVltrPxxhtHvXr1qsyYLF26NM4777w4+uijo3HjxpnlxxxzTHTo0CFatGgR77zzTgwfPjzefPPNmDhxYkRU7/6n9fNeVfv/Y2PHjo3CwsI49NBDs5bXhP2fJEmcddZZ0bNnz+jcuXOmpogN4/NfXv9/akP8/Fd1H330UYwePTrOOuusOP/88+PVV1+NM844I/Lz82PQoEEb3JxlXQ0bNiyKi4ujY8eOUbt27VixYkVcfvnlcdRRR0VEur8TapoN6fdpLpT3+9l4rp2rrroq6tSpE2eccUa5rxvPNbNw4cL45ptv4sorr4zLLrssrrrqqnjyySfj0EMPjUmTJkWvXr2M5Vq64YYb4qSTTorWrVtHnTp1olatWnHbbbdFz549I6Jq/mwKoiqod+/emX936dIlunfvHltssUWMHTs2c5HiHx8dFPHDJP6ny37qp23Ka78m60nT7bffHr17985KRo888sjMvzt37hw777xztGvXLh577LEy/0H9serY/5XS2t9VeUyWLVsWAwYMiNLS0vjrX/+a9dpJJ52U+Xfnzp1jq622ip133jmmTZsWO+64Y0RU3/6n+fNeFfv/Y3/729/imGOOifr162ctrwn7/7TTTou33norXnrppTKvbQif/9X1P2LD/fxXdaWlpbHzzjvHFVdcERER3bp1ixkzZsTo0aNj0KBBmXYbypxlXY0bNy7uuuuuuPvuu6NTp04xffr0OPPMM6NVq1YxePDgTDvjWXEbwu/TtK3u93N5jGdZU6dOjb/85S8xbdq0te6T8cy28uYOBx10UAwdOjQiInbYYYd4+eWX46abbopevXqt8r3Gsnw33HBDTJkyJSZMmBDt2rWLF198MU455ZRo2bJl7Lvvvqt8Xy7H06l5laRhw4bRpUuXmDVrVubueT9NBRcuXJhJEFu0aBHff/99fPXVV6tt89lnn5XZ1ueff14micyVOXPmxDPPPBMnnnjiatu1bNky2rVrF7NmzYqImtP/iEh1f7do0aLMdr766qtYtmxZzsdk2bJlccQRR8Ts2bNj4sSJWUdDlGfHHXeMunXrZv1MVOf+/9j6+nmv6v3/5z//GTNnzvzZ3wcR1W//n3766TFhwoSYNGlStG7dOrN8Q/n8r6r/K/n8V10tW7aM7bbbLmvZtttum7kz0YY0Z6kM5557bpx33nkxYMCA6NKlSwwcODCGDh0aI0eOjAjjuS42lN+naVvd72fjueb++c9/xsKFC6Nt27ZRp06dqFOnTsyZMyfOPvvsaN++fUQYzzXVrFmzqFOnzs9+NxnLNfPdd9/F+eefH9dff330798/unbtGqeddloceeSRce2110ZE1RxPQVQlKSkpiffeey9atmyZOf1g5SkHET9cR+mFF16I3XffPSIidtppp6hbt25Wm/nz58c777yTadO9e/coLi6OV199NdPmlVdeieLi4kybXBszZkw0b948+vbtu9p2X3zxRcybNy9atmwZETWn/xGR6v7u3r17vPPOOzF//vxMm6effjry8/Njp512Wq/9XJ2Vk5xZs2bFM888E02bNv3Z98yYMSOWLVuW+Zmozv3/qfX1817V+3/77bfHTjvtFNtvv/3Ptq0u+z9JkjjttNPiwQcfjOeeey46dOiQ9XpN//z/XP8jfP6ruh49esTMmTOzlr3//vvRrl27iEj3Z7gm+Pbbb6NWrezpc+3atTN/4TeeFVfTf5/mws/9fjaea27gwIHx1ltvxfTp0zOPVq1axbnnnhtPPfVURBjPNVWvXr3YZZddVvvdZCzX3LJly2LZsmWr/W6qkuO5Vpc2J+Pss89Onn/++eSjjz5KpkyZkvTr1y8pLCxM/v3vfydJ8sPtZ4uKipIHH3wwefvtt5Ojjjqq3NvPtm7dOnnmmWeSadOmJXvvvXe5t1Ds2rVrMnny5GTy5MlJly5dqsyte1esWJG0bds2GTZsWNbyxYsXJ2effXby8ssvJ7Nnz04mTZqUdO/ePdlss82qbf8XL16cvPHGG8kbb7yRRERy/fXXJ2+88UbmriNp7e+Vt8zcZ599kmnTpiXPPPNM0rp16/V+C9LV9X/ZsmXJgQcemLRu3TqZPn161u3ZS0pKkiT54RatI0aMSF577bVk9uzZyWOPPZZ07Ngx6datW7Xvf5o/71Wx/ysVFxcnDRo0SEaPHl3m/dV5///+979PioqKkueffz7rZ/vbb7/NtKnJn/+f6/+G8Pmv7l599dWkTp06yeWXX57MmjUr+fvf/540aNAgueuuuzJtNoQ5S2UZPHhwstlmmyWPPvpoMnv27OTBBx9MmjVrlvzhD3/ItDGeq7ahz6cq27rOz5LEeP7Ymsx3fuynd81LEuO50s+N5YMPPpjUrVs3ueWWW5JZs2Yl//M//5PUrl07+ec//5lZh7H8r58bz169eiWdOnVKJk2alHz00UfJmDFjkvr16yd//etfM+uoauMpiKqgI488MmnZsmVSt27dpFWrVsmhhx6azJgxI/N6aWlpctFFFyUtWrRI8vPzkz322CN5++23s9bx3XffJaeddlrSpEmTpKCgIOnXr18yd+7crDZffPFFcswxxySFhYVJYWFhcswxxyRfffVVGl38WU899VQSEcnMmTOzln/77bfJ/vvvn2yyySZJ3bp1k7Zt2yaDBw8u07fq1P9JkyYlEVHmMXjw4CRJ0t3fc+bMSfr27ZsUFBQkTZo0SU477bRk6dKl67P7q+3/7Nmzy30tIpJJkyYlSZIkc+fOTfbYY4+kSZMmSb169ZItttgiOeOMM5Ivvvii2vc/7Z/3qtb/lW6++eakoKAg+frrr8u8vzrv/1X9bI8ZMybTpiZ//n+u/xvC578meOSRR5LOnTsn+fn5SceOHZNbbrkl6/UNYc5SWRYtWpQMGTIkadu2bVK/fv1k8803T/74xz9m/cfeeK7ahj6fqmzrOj9LEuP5Y2sy3/mx8oIo4/mDNRnL22+/Pdlyyy2T+vXrJ9tvv30yfvz4rHUYy//6ufGcP39+ctxxxyWtWrVK6tevn2yzzTbJddddl5SWlmbWUdXGMy9JkmStDqECAAAAgApwjSgAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAgAAACAVgigAAAAAUiGIAqqM4447Lg4++OBclwEAUKWZMwHVmSAKAAAAgFQIooAqac8994wzzjgj/vCHP0STJk2iRYsWcfHFF2e1+frrr+O3v/1tbLrpplG/fv3o3LlzPProo5nXH3jggejUqVPk5+dH+/bt47rrrst6f/v27eOyyy6LQYMGRaNGjaJdu3bx8MMPx+effx4HHXRQNGrUKLp06RKvv/561vtefvnl2GOPPaKgoCDatGkTZ5xxRixZsmS9jQUAwKqYMwHVjSAKqLLGjh0bDRs2jFdeeSWuvvrquOSSS2LixIkREVFaWhq9e/eOl19+Oe666654991348orr4zatWtHRMTUqVPjiCOOiAEDBsTbb78dF198cVxwwQVxxx13ZG3jz3/+c/To0SPeeOON6Nu3bwwcODAGDRoUxx57bEybNi223HLLGDRoUCRJEhERb7/9dhxwwAFx6KGHxltvvRXjxo2Ll156KU477bRUxwYAYCVzJqA6yUtW/qYAyLHjjjsuvv766xg/fnzsueeesWLFivjnP/+Zef0Xv/hF7L333nHllVfG008/Hb1794733nsvtt566zLrOuaYY+Lzzz+Pp59+OrPsD3/4Qzz22GMxY8aMiPjhr3u//OUv43//938jImLBggXRsmXLuOCCC+KSSy6JiIgpU6ZE9+7dY/78+dGiRYsYNGhQFBQUxM0335xZ70svvRS9evWKJUuWRP369dfL2AAArGTOBFRnjogCqqyuXbtmPW/ZsmUsXLgwIiKmT58erVu3LndCFRHx3nvvRY8ePbKW9ejRI2bNmhUrVqwodxubbrppRER06dKlzLKV2506dWrccccd0ahRo8zjgAMOiNLS0pg9e3ZFuwoAUGHmTEB1UifXBQCsSt26dbOe5+XlRWlpaUREFBQUrPa9SZJEXl5emWWr28bK9uUtW7nd0tLSOPnkk+OMM84os662bduutiYAgPXBnAmoTgRRQLXUtWvX+Pjjj+P9998v9y982223Xbz00ktZy15++eXYeuutM9dEqIgdd9wxZsyYEVtuuWWF1wEAkBZzJqCqcWoeUC316tUr9thjjzjssMNi4sSJMXv27HjiiSfiySefjIiIs88+O5599tm49NJL4/3334+xY8fGjTfeGOecc846bXfYsGExefLkOPXUU2P69Okxa9asmDBhQpx++umV0S0AgEplzgRUNYIooNp64IEHYpdddomjjjoqtttuu/jDH/6QuZbBjjvuGPfdd1/ce++90blz57jwwgvjkksuieOOO26dttm1a9d44YUXYtasWfHLX/4yunXrFhdccEG0bNmyEnoEAFD5zJmAqsRd8wAAAABIhSOiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVAiiAAAAAEiFIAoAAACAVPz/OiICdskxrVMAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Set random seed for reproducibility\n", - "np.random.seed(42)\n", - "\n", - "bins=10\n", - "\n", - "# Plotting the distributions\n", - "plt.figure(figsize=(12, 6))\n", - "\n", - "# Plot for low polarization\n", - "plt.subplot(1, 2, 1)\n", - "plt.hist(gdf.PCGDP1960, bins=bins, color='blue', alpha=0.7)\n", - "plt.title('Income Distribution')\n", - "plt.xlabel('Income')\n", - "plt.ylabel('Frequency')\n", - "\n", - "# Plot for high polarization\n", - "plt.subplot(1, 2, 2)\n", - "plt.hist(l60, bins=bins, color='red', alpha=0.7)\n", - "plt.title('Spatial Lag Income Distribution')\n", - "plt.xlabel('Income')\n", - "plt.ylabel('Frequency')\n", - "\n", - "# Show plots\n", - "plt.tight_layout()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 173, - "id": "90baa6a7-1110-4475-bfcc-b33a64d031d6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Generate two sets of random data\n", - "data1 = np.random.normal(0, 1, size=1000)\n", - "data2 = np.random.normal(2, 0.5, size=1000)\n", - "\n", - "# Set the same range for both KDE plots\n", - "common_range = (-3, 5)\n", - "\n", - "# Create the plot\n", - "plt.figure(figsize=(8, 6))\n", - "\n", - "# Plot the first KDE\n", - "sns.kdeplot(data1, label='Data 1', bw_adjust=0.5, clip=common_range)\n", - "\n", - "# Plot the second KDE\n", - "sns.kdeplot(data2, label='Data 2', bw_adjust=0.5, clip=common_range)\n", - "\n", - "# Add labels and title\n", - "plt.xlabel('Value')\n", - "plt.ylabel('Density')\n", - "plt.title('KDE of Two Distributions Over the Same Range')\n", - "plt.legend()\n", - "\n", - "# Show the plot\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 175, - "id": "51852c08-e7a5-46be-bf47-5fe6fbaa76fa", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Generate two sets of random data\n", - "data1 = np.random.normal(0, 1, size=1000)\n", - "data2 = np.random.normal(2, 0.5, size=1000)\n", - "\n", - "# Set the same range for both KDE plots\n", - "y = gdf.PCGDP1960\n", - "common_range = (y.min() *.5, y.max())\n", - "\n", - "# Create the plot\n", - "plt.figure(figsize=(8, 6))\n", - "\n", - "# Plot the first KDE\n", - "sns.kdeplot(y, label='Observed', bw_adjust=0.5, clip=common_range)\n", - "\n", - "# Plot the second KDE\n", - "sns.kdeplot(l60, label='Spatial Lag', bw_adjust=0.5, clip=common_range)\n", - "\n", - "# Plot the random lag\n", - "sns.kdeplot(lr60, label='Spatial Lag (Random)', bw_adjust=0.5, clip=common_range)\n", - "\n", - "# Add labels and title\n", - "plt.xlabel('Value')\n", - "plt.ylabel('Density')\n", - "plt.title('KDE of Three Distributions Over the Same Range')\n", - "plt.legend()\n", - "\n", - "# Show the plot\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 182, - "id": "78aef533-2ad6-4b46-9bf3-9fd0c64bb076", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statistic: 0.196044921875, p-value: 0.2800978640494538\n" - ] - } - ], - "source": [ - "from scipy.stats import cramervonmises_2samp\n", - "\n", - "# Perform the Cramér-von Mises test\n", - "result = cramervonmises_2samp(l60, lr60)\n", - "print(f\"Statistic: {result.statistic}, p-value: {result.pvalue}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 176, - "id": "cffaf80d-02df-49dd-9cda-1901d7aded1d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statistic: -0.05261469967768734, p-value: 0.25\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_2534197/3482703562.py:4: UserWarning: p-value capped: true value larger than 0.25. Consider specifying `method` (e.g. `method=stats.PermutationMethod()`.)\n", - " result = anderson_ksamp([l60, lr60])\n" - ] - } - ], - "source": [ - "from scipy.stats import anderson_ksamp\n", - "\n", - "# Perform the Anderson-Darling test\n", - "result = anderson_ksamp([l60, lr60])\n", - "print(f\"Statistic: {result.statistic}, p-value: {result.significance_level}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 188, - "id": "0bae35f6-865f-4416-b61f-008bf5a63526", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_2534197/725806687.py:1: UserWarning: p-value capped: true value larger than 0.25. Consider specifying `method` (e.g. `method=stats.PermutationMethod()`.)\n", - " results = [anderson_ksamp([l60, libpysal.weights.lag_spatial(w, np.random.permutation(gdf.PCGDP1960))]) for i in range(99)]\n" - ] - } - ], - "source": [ - "results = [anderson_ksamp([l60, libpysal.weights.lag_spatial(w, np.random.permutation(gdf.PCGDP1960))]) for i in range(99)]" - ] - }, - { - "cell_type": "code", - "execution_count": 189, - "id": "aaf9c29e-1797-472a-9116-e5a8c5de5509", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[Anderson_ksampResult(statistic=np.float64(0.6589920653729476), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.17652713244839607),\n", - " Anderson_ksampResult(statistic=np.float64(-0.34697170363520224), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.7007267012841933), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.16942821297845637),\n", - " Anderson_ksampResult(statistic=np.float64(0.4035584032053961), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.22725447554330247),\n", - " Anderson_ksampResult(statistic=np.float64(0.2780484965634238), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(1.8683704810168367), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.055134205150877004),\n", - " Anderson_ksampResult(statistic=np.float64(1.2469655114478362), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.09958961390750354),\n", - " Anderson_ksampResult(statistic=np.float64(0.7067324861420466), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1684312996840937),\n", - " Anderson_ksampResult(statistic=np.float64(0.11592853083147192), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(2.0333865163064724), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.04723398451863168),\n", - " Anderson_ksampResult(statistic=np.float64(-0.20903121842789757), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(1.085054660506413), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.11644621318761145),\n", - " Anderson_ksampResult(statistic=np.float64(0.7593864347578005), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1599475065483019),\n", - " Anderson_ksampResult(statistic=np.float64(0.5833021834141229), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.19019996927764632),\n", - " Anderson_ksampResult(statistic=np.float64(3.1742107372015806), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.016660129096606503),\n", - " Anderson_ksampResult(statistic=np.float64(0.36647777432413087), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.235788798880333),\n", - " Anderson_ksampResult(statistic=np.float64(0.6110174890064242), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1850701708742307),\n", - " Anderson_ksampResult(statistic=np.float64(1.2176360813517806), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.10244367505054722),\n", - " Anderson_ksampResult(statistic=np.float64(-0.6018524519181122), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(1.0636927180924765), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.11888205135355742),\n", - " Anderson_ksampResult(statistic=np.float64(-0.1960624985804575), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(2.861832014678324), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.022057525462241476),\n", - " Anderson_ksampResult(statistic=np.float64(1.2152615000589706), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.10267843551015848),\n", - " Anderson_ksampResult(statistic=np.float64(0.5724431239900444), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.19224988094003514),\n", - " Anderson_ksampResult(statistic=np.float64(-0.6476569345904948), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(1.4832296479641838), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.07940717524015867),\n", - " Anderson_ksampResult(statistic=np.float64(1.1884054212362711), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.10537278422420467),\n", - " Anderson_ksampResult(statistic=np.float64(1.3253739239381608), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.09235823423276689),\n", - " Anderson_ksampResult(statistic=np.float64(-0.7790760267649309), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.5326350540730636), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.20578211806890973), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.5597971873163465), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1946660241786323),\n", - " Anderson_ksampResult(statistic=np.float64(0.22543423025002296), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.48043578122094976), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.7977518563804589), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.13996800002570875), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(1.5535144405015517), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.07426277991400779),\n", - " Anderson_ksampResult(statistic=np.float64(1.3844842980708991), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.0872688165845278),\n", - " Anderson_ksampResult(statistic=np.float64(-0.28123025275724345), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.2550329852639916), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(2.0073728056876083), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.048396546760625984),\n", - " Anderson_ksampResult(statistic=np.float64(-0.2750600121179492), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.010850295765853488), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.13274487939863963), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.9512090762324987), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.13261051225873643),\n", - " Anderson_ksampResult(statistic=np.float64(-0.28636581408686024), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.3690838545026225), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.3984297392729227), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.2284155211233201),\n", - " Anderson_ksampResult(statistic=np.float64(-0.6260277299031528), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.8541439594398893), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.14577888769400463),\n", - " Anderson_ksampResult(statistic=np.float64(-0.8467974536037051), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.1705605761274296), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.4448369626593231), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.21812964636396412),\n", - " Anderson_ksampResult(statistic=np.float64(0.6723402530641444), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.17422367951475473),\n", - " Anderson_ksampResult(statistic=np.float64(-0.9852196721139579), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.5916393714077337), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.18864151678856184),\n", - " Anderson_ksampResult(statistic=np.float64(0.3687163477796152), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.2352642723040588),\n", - " Anderson_ksampResult(statistic=np.float64(0.7935148577646094), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1546865727777048),\n", - " Anderson_ksampResult(statistic=np.float64(0.36225911524755317), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.23678058301119323),\n", - " Anderson_ksampResult(statistic=np.float64(0.05211697031946774), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.44625767463085647), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.21782243948841373),\n", - " Anderson_ksampResult(statistic=np.float64(0.8494735126856523), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.14644575376587035),\n", - " Anderson_ksampResult(statistic=np.float64(0.05390367245731991), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.141833691382348), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.46873719592473606), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.2130208594913156),\n", - " Anderson_ksampResult(statistic=np.float64(-0.2890511480742549), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.2971292941433096), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.6969563041852672), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.39875697333723115), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.22834125731330776),\n", - " Anderson_ksampResult(statistic=np.float64(-0.23968496539063935), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(1.8685176053343069), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.0551265789876067),\n", - " Anderson_ksampResult(statistic=np.float64(-0.06057229957419835), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.3617881403799545), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.23689157473972228),\n", - " Anderson_ksampResult(statistic=np.float64(-0.42038155652396053), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.6044322197563446), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(1.2955828869945099), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.09503925863382233),\n", - " Anderson_ksampResult(statistic=np.float64(2.791401053066109), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.02350982454498939),\n", - " Anderson_ksampResult(statistic=np.float64(0.06968101490507873), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.5555633367888577), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.5908798173850676), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.8354076523933401), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.9778231143201137), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.12922016441401524),\n", - " Anderson_ksampResult(statistic=np.float64(0.004199594528309553), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.4760468347297224), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.3250924936882813), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.2457073955757966),\n", - " Anderson_ksampResult(statistic=np.float64(2.0083290909255993), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.048353286592078784),\n", - " Anderson_ksampResult(statistic=np.float64(0.7912081121389084), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.15503643544817583),\n", - " Anderson_ksampResult(statistic=np.float64(0.767511600731924), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.15867838853780442),\n", - " Anderson_ksampResult(statistic=np.float64(-0.7160810220571034), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.6938017145731582), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.6909435225161504), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1710652750792323),\n", - " Anderson_ksampResult(statistic=np.float64(1.1228235007862648), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.11226559521036106),\n", - " Anderson_ksampResult(statistic=np.float64(-0.31242288592769335), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(-0.4063418357707226), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(0.8896983931178999), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.1408044977403145),\n", - " Anderson_ksampResult(statistic=np.float64(1.8097574385906525), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.05826154520775699),\n", - " Anderson_ksampResult(statistic=np.float64(2.65730159253264), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.026557820745559617),\n", - " Anderson_ksampResult(statistic=np.float64(-0.05180271475731241), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=np.float64(0.25)),\n", - " Anderson_ksampResult(statistic=np.float64(1.4996392384643258), critical_values=array([0.325, 1.226, 1.961, 2.718, 3.752, 4.592, 6.546]), pvalue=0.07817382723730883)]" - ] - }, - "execution_count": 189, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "results" - ] - }, - { - "cell_type": "code", - "execution_count": 179, - "id": "b0a61d38-e133-428c-8d3c-ee4ad93c1af2", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 17865.0\n", - "1 16707.0\n", - "2 7621.0\n", - "3 9953.0\n", - "4 8714.0\n", - "5 8209.0\n", - "6 7110.0\n", - "7 6399.0\n", - "8 5244.0\n", - "9 9053.0\n", - "10 23174.0\n", - "11 6036.0\n", - "12 10499.0\n", - "13 10067.0\n", - "14 5925.0\n", - "15 6542.0\n", - "16 9677.0\n", - "17 4357.0\n", - "18 4991.0\n", - "19 4140.0\n", - "20 6494.0\n", - "21 5280.0\n", - "22 12134.0\n", - "23 16265.0\n", - "24 12318.0\n", - "25 9613.0\n", - "26 9323.0\n", - "27 5821.0\n", - "28 6440.0\n", - "29 20117.0\n", - "30 8383.0\n", - "31 11404.0\n", - "Name: PCGDP1960, dtype: float64" - ] - }, - "execution_count": 179, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d82ce31d-aa0f-45cf-896e-f7926827d2c1", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "58be93a2-5cdb-4999-80e8-38617c45183a", - "metadata": {}, - "outputs": [], - "source": [ - "def spatial_wolfson(y, w, permutations=99):\n", - " observed = wolfson(libpysal.weights.lag_spatial(w,y))\n", - " sim = [ wolfson(libpysal.weights.lag_spatial(w, np.random.permutation(y))) for i in range(permutations)]\n", - " pvalue = (sim >= observed).sum()\n", - " pvalue = (pvalue+1) / (permutations+1)\n", - " return np.array(sim), pvalue, observed\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "f4ba6f0b-4099-4031-8dac-878f86a47c5c", - "metadata": {}, - "outputs": [], - "source": [ - "res = spatial_wolfson(y, w)" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "5b1374b6-3afc-4fa6-8f80-0e209ffaa342", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([0.06539695, 0.06713867, 0.04803813, 0.04857902, 0.04507344,\n", - " 0.06627576, 0.07870363, 0.04253836, 0.03973175, 0.06051153,\n", - " 0.05608921, 0.06021101, 0.07564086, 0.03975564, 0.05635009,\n", - " 0.06511387, 0.04174943, 0.06306224, 0.0730056 , 0.05791516,\n", - " 0.05286226, 0.07373472, 0.04765563, 0.04857054, 0.06190831,\n", - " 0.05162562, 0.06172844, 0.04583417, 0.07501084, 0.11193408,\n", - " 0.04552564, 0.04283921, 0.04329658, 0.05832185, 0.07772928,\n", - " 0.04047874, 0.04841504, 0.04501951, 0.05523765, 0.0475723 ,\n", - " 0.06828713, 0.04525536, 0.06769643, 0.0558426 , 0.0506755 ,\n", - " 0.06199921, 0.05579397, 0.05585677, 0.09021329, 0.0544272 ,\n", - " 0.0406228 , 0.08515166, 0.0740715 , 0.05776597, 0.05415043,\n", - " 0.06458409, 0.04897898, 0.04006921, 0.05886143, 0.07962785,\n", - " 0.04940512, 0.07872911, 0.05386425, 0.08311664, 0.05348995,\n", - " 0.04765452, 0.06376714, 0.05855543, 0.04082106, 0.04745616,\n", - " 0.06442704, 0.06553425, 0.04288452, 0.04812785, 0.04894455,\n", - " 0.06905272, 0.0602209 , 0.04586896, 0.0698854 , 0.05729252,\n", - " 0.04559973, 0.06587604, 0.05511078, 0.06419779, 0.06250691,\n", - " 0.08599654, 0.06595336, 0.06086615, 0.07498169, 0.09536185,\n", - " 0.05469088, 0.05244167, 0.03935122, 0.06451485, 0.04419627,\n", - " 0.06332076, 0.05733736, 0.06198856, 0.07252816]),\n", - " np.float64(0.18),\n", - " np.float64(0.07039175526018514))" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "res" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "80c48c53-6602-4979-af20-0f9e8894915e", - "metadata": {}, - "outputs": [], - "source": [ - "obs = wolfson(y)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "df5c8132-2f74-4816-b6af-ad871443edc0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.int64(0)" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(res>=obs).sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "ea59c601-08ff-40c6-af20-bc217e0f5663", - "metadata": {}, - "outputs": [], - "source": [ - "ws = [spatial_wolfson(gdf[\"PCGDP%s\"%decade], w) for decade in range(1960, 2010, 10)]" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "20530e99-41eb-4c07-b8fa-17ff256645fa", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[(array([0.06399817, 0.05730565, 0.06040884, 0.05500907, 0.05836557,\n", - " 0.06164464, 0.05958563, 0.06570759, 0.06142175, 0.06731981,\n", - " 0.08534805, 0.0617286 , 0.06364233, 0.05853294, 0.04225007,\n", - " 0.09780308, 0.04982557, 0.06711588, 0.08898018, 0.04221016,\n", - " 0.06565352, 0.06681079, 0.05739507, 0.04954549, 0.05125345,\n", - " 0.04718223, 0.05498083, 0.04545973, 0.0540994 , 0.0424817 ,\n", - " 0.05898962, 0.07024661, 0.06074863, 0.07066664, 0.06242651,\n", - " 0.04565519, 0.06414492, 0.04937377, 0.05820772, 0.05345118,\n", - " 0.04500619, 0.06637167, 0.05637192, 0.04594513, 0.05969457,\n", - " 0.06350877, 0.04855286, 0.05160559, 0.04743384, 0.06009093,\n", - " 0.05286712, 0.05857483, 0.05711692, 0.05565814, 0.06642243,\n", - " 0.05922773, 0.07874094, 0.05336004, 0.05476206, 0.06935363,\n", - " 0.05440816, 0.05604029, 0.05229941, 0.05705131, 0.04054759,\n", - " 0.06761293, 0.0582651 , 0.04896406, 0.04387207, 0.04990111,\n", - " 0.04852645, 0.05223442, 0.04525114, 0.05729694, 0.07727919,\n", - " 0.05421121, 0.05184796, 0.06725892, 0.06645797, 0.06464184,\n", - " 0.05877181, 0.05390285, 0.08371761, 0.05007482, 0.05415703,\n", - " 0.04423753, 0.06638531, 0.06073962, 0.04924119, 0.07641581,\n", - " 0.05837826, 0.06324694, 0.05734933, 0.0458635 , 0.04621606,\n", - " 0.05506024, 0.04414513, 0.04342484, 0.06010447]),\n", - " np.float64(0.09),\n", - " np.float64(0.07039175526018514)),\n", - " (array([0.07375257, 0.05322617, 0.05325353, 0.04696744, 0.04317728,\n", - " 0.05794446, 0.0473618 , 0.06348036, 0.04495332, 0.05926916,\n", - " 0.06528046, 0.06455026, 0.04939538, 0.05380263, 0.04947549,\n", - " 0.04634907, 0.04739405, 0.06420582, 0.04776508, 0.05064736,\n", - " 0.05052153, 0.04605473, 0.05597446, 0.05923986, 0.04963141,\n", - " 0.05024416, 0.0470866 , 0.06147468, 0.05120261, 0.05325013,\n", - " 0.05907336, 0.07208191, 0.06265521, 0.06540315, 0.05855876,\n", - " 0.05616487, 0.05759238, 0.05054927, 0.04851202, 0.05770022,\n", - " 0.03855235, 0.04244541, 0.05929439, 0.03518702, 0.0345028 ,\n", - " 0.05086469, 0.04570133, 0.0424409 , 0.04575415, 0.0448708 ,\n", - " 0.0619705 , 0.07582869, 0.06189237, 0.06782979, 0.05565611,\n", - " 0.07448442, 0.05422385, 0.04879481, 0.06445292, 0.04724643,\n", - " 0.05296554, 0.05530129, 0.06237563, 0.05875956, 0.06345624,\n", - " 0.04278562, 0.04658493, 0.05887244, 0.0501407 , 0.0573893 ,\n", - " 0.05940238, 0.04527428, 0.04179717, 0.05625261, 0.05840339,\n", - " 0.04988315, 0.05312827, 0.08382752, 0.04447995, 0.04881509,\n", - " 0.04445801, 0.05664504, 0.05407206, 0.03941519, 0.06802547,\n", - " 0.03924929, 0.06722294, 0.04854335, 0.04390084, 0.04969997,\n", - " 0.06657087, 0.05892878, 0.05082889, 0.05667752, 0.06481969,\n", - " 0.05951592, 0.05354451, 0.05747577, 0.04229047]),\n", - " np.float64(0.13),\n", - " np.float64(0.06458755747501611)),\n", - " (array([0.05033127, 0.04700798, 0.04103977, 0.07538355, 0.04112311,\n", - " 0.06615506, 0.04453466, 0.03956272, 0.0559403 , 0.07123237,\n", - " 0.04459841, 0.04753727, 0.04855087, 0.05553912, 0.06185091,\n", - " 0.05400744, 0.04992578, 0.03346874, 0.04487453, 0.03684066,\n", - " 0.05521159, 0.05685337, 0.04712887, 0.06597157, 0.04778912,\n", - " 0.06999686, 0.04035529, 0.05890795, 0.04481618, 0.05266949,\n", - " 0.04737869, 0.04306247, 0.04747678, 0.0568642 , 0.05679127,\n", - " 0.04947256, 0.06467962, 0.04402462, 0.07214468, 0.04718601,\n", - " 0.05295228, 0.05176914, 0.05245056, 0.06655257, 0.06489889,\n", - " 0.06603038, 0.04786268, 0.04795592, 0.04551103, 0.04488756,\n", - " 0.06854131, 0.0487532 , 0.04578864, 0.0477281 , 0.04675841,\n", - " 0.05455999, 0.06030091, 0.05302252, 0.04863036, 0.04781797,\n", - " 0.06369217, 0.06025116, 0.06384903, 0.0405927 , 0.04698614,\n", - " 0.07869102, 0.04758183, 0.03263553, 0.03831249, 0.04796655,\n", - " 0.04591898, 0.04584463, 0.04062107, 0.0488645 , 0.0603707 ,\n", - " 0.05355981, 0.04952536, 0.06370592, 0.04953925, 0.05547352,\n", - " 0.07183587, 0.06520107, 0.0412738 , 0.05457979, 0.0439007 ,\n", - " 0.04595009, 0.05120643, 0.04823029, 0.04201842, 0.05575521,\n", - " 0.06146726, 0.0583632 , 0.05099475, 0.03872909, 0.04949733,\n", - " 0.04837158, 0.04262712, 0.05790155, 0.06261165]),\n", - " np.float64(0.3),\n", - " np.float64(0.056196203586731525)),\n", - " (array([0.05089817, 0.05528466, 0.08045331, 0.05936524, 0.05285502,\n", - " 0.05410273, 0.04620467, 0.05475286, 0.05104453, 0.06202621,\n", - " 0.05064131, 0.06741257, 0.04894234, 0.05904049, 0.05587145,\n", - " 0.05246733, 0.06224116, 0.06106836, 0.0515984 , 0.05113487,\n", - " 0.05909191, 0.0559149 , 0.0821928 , 0.05622605, 0.05231114,\n", - " 0.06329065, 0.04736246, 0.07123851, 0.06574514, 0.0489701 ,\n", - " 0.04499568, 0.04580277, 0.0562551 , 0.03862931, 0.05251387,\n", - " 0.04771329, 0.0414628 , 0.05214177, 0.0663516 , 0.04836285,\n", - " 0.07526369, 0.05255606, 0.05234393, 0.0518273 , 0.05775702,\n", - " 0.04794933, 0.05531654, 0.03901103, 0.07111561, 0.04637675,\n", - " 0.04911504, 0.05491385, 0.03986179, 0.04676961, 0.05197573,\n", - " 0.0575125 , 0.04797334, 0.05838801, 0.04241979, 0.05943017,\n", - " 0.05841517, 0.05510606, 0.04788195, 0.06229748, 0.05391753,\n", - " 0.04514206, 0.05408954, 0.07382082, 0.04850161, 0.06388372,\n", - " 0.05241611, 0.04477122, 0.05878543, 0.05708606, 0.05448938,\n", - " 0.04191157, 0.05990564, 0.0411684 , 0.0522561 , 0.06080695,\n", - " 0.03891136, 0.07214188, 0.05617103, 0.03836531, 0.05112539,\n", - " 0.04999048, 0.05133658, 0.05696502, 0.06433724, 0.05764536,\n", - " 0.06258384, 0.03395186, 0.05659637, 0.0558076 , 0.06146492,\n", - " 0.05893703, 0.06443537, 0.04988729, 0.05977899]),\n", - " np.float64(0.22),\n", - " np.float64(0.0608058722438404)),\n", - " (array([0.05683646, 0.05955162, 0.05060906, 0.05105952, 0.0674761 ,\n", - " 0.04296224, 0.04873719, 0.06215176, 0.06466715, 0.049016 ,\n", - " 0.05207931, 0.05824445, 0.06037747, 0.0512273 , 0.04774765,\n", - " 0.05236435, 0.05106755, 0.05966975, 0.05082296, 0.05912647,\n", - " 0.07411187, 0.07027358, 0.04942302, 0.04676499, 0.06164883,\n", - " 0.06279849, 0.08558803, 0.07172823, 0.0577911 , 0.0414989 ,\n", - " 0.04955619, 0.05088413, 0.04619596, 0.05367508, 0.04737543,\n", - " 0.06204673, 0.05370197, 0.06083933, 0.05834855, 0.04591643,\n", - " 0.0442099 , 0.0564311 , 0.05975146, 0.04872401, 0.03549547,\n", - " 0.04486098, 0.05414305, 0.06679501, 0.05207422, 0.07390964,\n", - " 0.06640899, 0.05524119, 0.0615557 , 0.05469754, 0.05127429,\n", - " 0.05254732, 0.06219754, 0.0516383 , 0.03086267, 0.04985092,\n", - " 0.04235153, 0.05291973, 0.03852379, 0.05510399, 0.05145997,\n", - " 0.05774483, 0.03696932, 0.04993209, 0.06249942, 0.0545463 ,\n", - " 0.04719057, 0.05951003, 0.04600707, 0.05749058, 0.05318125,\n", - " 0.06549651, 0.06608467, 0.05603467, 0.04383301, 0.0389345 ,\n", - " 0.06418092, 0.05376811, 0.05726171, 0.05376693, 0.04974215,\n", - " 0.05113359, 0.04969371, 0.04602827, 0.03984234, 0.05504227,\n", - " 0.06589274, 0.04886909, 0.0437662 , 0.07461233, 0.05929708,\n", - " 0.08857284, 0.04211861, 0.08160934, 0.06044722]),\n", - " np.float64(0.18),\n", - " np.float64(0.06267192008890492))]" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ws" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "e69b35e4-d017-4da5-8566-3b821b2158fa", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statistic: 2.598293978249068, p-value: 0.028027151010668033\n" - ] - } - ], - "source": [ - "from scipy.stats import anderson_ksamp\n", - "\n", - "# Perform the Anderson-Darling test\n", - "result = anderson_ksamp([l60, lr60])\n", - "print(f\"Statistic: {result.statistic}, p-value: {result.significance_level}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "518f96e6-3670-47fe-968f-66c59bdd251c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statistic: 0.619140625, p-value: 0.019955165439173306\n" - ] - } - ], - "source": [ - "from scipy.stats import cramervonmises_2samp\n", - "\n", - "# Perform the Cramér-von Mises test\n", - "result = cramervonmises_2samp(l60, lr60)\n", - "print(f\"Statistic: {result.statistic}, p-value: {result.pvalue}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "1a494a27-be2c-4d41-8170-de7828029543", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "KS Statistic: 0.40625, p-value: 0.009516275438959759\n" - ] - } - ], - "source": [ - "from scipy.stats import ks_2samp\n", - "\n", - "# Perform the KS test\n", - "statistic, p_value = ks_2samp(l60, lr60)\n", - "print(f\"KS Statistic: {statistic}, p-value: {p_value}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "21332e7d-7e0c-47f7-924d-722c81e841a3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(9246.631758432539), np.float64(10370.867571924602))" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "l60.mean(), lr60.mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "id": "bdf4e2a2-86ad-41b0-b959-60827762049d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(2647.393845526429), np.float64(2631.9423970054327))" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "l60.std(), lr60.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "id": "c39241f8-3426-4b5e-aa15-5a7d8e084174", - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "could not broadcast input array from shape (200,) into shape (1000,)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[59], line 17\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, data \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(datasets):\n\u001b[1;32m 16\u001b[0m kde \u001b[38;5;241m=\u001b[39m sns\u001b[38;5;241m.\u001b[39mkdeplot(data, bw_adjust\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.5\u001b[39m, clip\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m5\u001b[39m), fill\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m---> 17\u001b[0m \u001b[43mkde_values\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m kde\u001b[38;5;241m.\u001b[39mget_lines()[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mget_data()[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;66;03m# Get KDE values from the plot object\u001b[39;00m\n\u001b[1;32m 18\u001b[0m plt\u001b[38;5;241m.\u001b[39mcla() \u001b[38;5;66;03m# Clear the current axes after each KDE\u001b[39;00m\n\u001b[1;32m 20\u001b[0m \u001b[38;5;66;03m# Calculate the envelope (min and max KDE values) at each x-value\u001b[39;00m\n", - "\u001b[0;31mValueError\u001b[0m: could not broadcast input array from shape (200,) into shape (1000,)" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Create multiple datasets for KDEs\n", - "n_samples = 100\n", - "n_datasets = 50\n", - "datasets = [np.random.normal(loc=np.random.uniform(-2, 2), scale=np.random.uniform(0.5, 1.5), size=n_samples) for _ in range(n_datasets)]\n", - "\n", - "# Set up an array to store KDE estimates at each point\n", - "x_values = np.linspace(-5, 5, 1000)\n", - "kde_values = np.zeros((n_datasets, len(x_values)))\n", - "\n", - "# Calculate KDE for each dataset and store the estimates\n", - "for i, data in enumerate(datasets):\n", - " kde = sns.kdeplot(data, bw_adjust=0.5, clip=(-5, 5), fill=False)\n", - " kde_values[i, :] = kde.get_lines()[-1].get_data()[1] # Get KDE values from the plot object\n", - " plt.cla() # Clear the current axes after each KDE\n", - "\n", - "# Calculate the envelope (min and max KDE values) at each x-value\n", - "kde_min = kde_values.min(axis=0)\n", - "kde_max = kde_values.max(axis=0)\n", - "\n", - "# Plot the envelope\n", - "plt.fill_between(x_values, kde_min, kde_max, color='skyblue', alpha=0.4, label='KDE Envelope')\n", - "\n", - "# Optional: Plot the mean KDE for reference\n", - "kde_mean = kde_values.mean(axis=0)\n", - "plt.plot(x_values, kde_mean, color='blue', label='Mean KDE')\n", - "\n", - "# Add labels and show the plot\n", - "plt.xlabel('Value')\n", - "plt.ylabel('Density')\n", - "plt.title('Envelope of Multiple KDEs')\n", - "plt.legend()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "id": "a51d64b4-081b-4f84-854f-d3628bcb2f3f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from scipy.interpolate import interp1d\n", - "\n", - "# Create multiple datasets for KDEs\n", - "n_samples = 100\n", - "n_datasets = 50\n", - "datasets = [np.random.normal(loc=np.random.uniform(-2, 2), scale=np.random.uniform(0.5, 1.5), size=n_samples) for _ in range(n_datasets)]\n", - "\n", - "# Set up an array to store KDE estimates at each point\n", - "x_values = np.linspace(-5, 5, 1000)\n", - "kde_values = np.zeros((n_datasets, len(x_values)))\n", - "\n", - "# Calculate KDE for each dataset and store the estimates\n", - "for i, data in enumerate(datasets):\n", - " kde = sns.kdeplot(data, bw_adjust=0.5, clip=(-5, 5), fill=False)\n", - " \n", - " # Extract x and y values from the current plot's KDE\n", - " kde_x, kde_y = kde.get_lines()[-1].get_data()\n", - "\n", - " # Interpolate the KDE y-values to match the x_values grid\n", - " interp = interp1d(kde_x, kde_y, bounds_error=False, fill_value=0)\n", - " kde_values[i, :] = interp(x_values) # Interpolate to match the x_values grid\n", - " \n", - " plt.cla() # Clear the current axes after each KDE\n", - "\n", - "# Calculate the envelope (min and max KDE values) at each x-value\n", - "kde_min = kde_values.min(axis=0)\n", - "kde_max = kde_values.max(axis=0)\n", - "\n", - "# Plot the envelope\n", - "plt.fill_between(x_values, kde_min, kde_max, color='skyblue', alpha=0.4, label='KDE Envelope')\n", - "\n", - "# Optional: Plot the mean KDE for reference\n", - "kde_mean = kde_values.mean(axis=0)\n", - "plt.plot(x_values, kde_mean, color='blue', label='Mean KDE')\n", - "\n", - "# Add labels and show the plot\n", - "plt.xlabel('Value')\n", - "plt.ylabel('Density')\n", - "plt.title('Envelope of Multiple KDEs')\n", - "plt.legend()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "id": "2e6fd9d8-e7d8-4391-aa11-027f7fff2b25", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The history saving thread hit an unexpected error (OperationalError('attempt to write a readonly database')).History will not be written to the database.\n" - ] - } - ], - "source": [ - "datasets = [ libpysal.weights.lag_spatial(w, np.random.permutation(y)) for i in range(99)]" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "id": "734767cb-bdcc-4682-9fbf-dc17b639c231", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "99" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(datasets)" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "id": "ea7ac23b-d571-4096-83a1-9dba2cc1a2c7", - "metadata": {}, - "outputs": [], - "source": [ - "l60.min(),l60.max()\n", - "x_values = np.linspace(l60.min()/2.5, l60.max()*1.5, 100)\n", - "x_min = x_values.min()\n", - "x_max = x_values.max()\n", - "n_datasets = 99\n", - "kde_values = np.zeros((n_datasets, len(x_values)))\n", - "common_range = (x_min, x_max)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "8d4236a2-6060-468c-9ae0-304c86386f50", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for i, data in enumerate(datasets):\n", - " kde = sns.kdeplot(data, bw_adjust=0.5, clip=(x_min, x_max), fill=False)\n", - " \n", - " kde_x, kde_y = kde.get_lines()[-1].get_data()\n", - "\n", - " # Interpolate the KDE y-values to match the x_values grid\n", - " interp = interp1d(kde_x, kde_y, bounds_error=False, fill_value=0)\n", - " kde_values[i, :] = interp(x_values) # Interpolate to match the x_values grid\n", - " \n", - " plt.cla() # Clear the current axes after each KDE\n", - "\n", - "# Calculate the envelope (min and max KDE values) at each x-value\n", - "kde_min = kde_values.min(axis=0)\n", - "kde_max = kde_values.max(axis=0)\n", - "# Plot the envelope\n", - "plt.fill_between(x_values, kde_min, kde_max, color='skyblue', alpha=0.4, label='KDE Envelope')\n", - "\n", - "# Optional: Plot the mean KDE for reference\n", - "kde_mean = kde_values.mean(axis=0)\n", - "plt.plot(x_values, kde_mean, color='blue', label='Mean KDE')\n", - "sns.kdeplot(l60, label='Spatial Lag', bw_adjust=0.5, clip=common_range)\n", - "\n", - "\n", - "# Add labels and show the plot\n", - "plt.xlabel('Value')\n", - "plt.ylabel('Density')\n", - "plt.title('Envelope of Multiple KDEs')\n", - "plt.legend()\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "32e1c2fd-8295-4ccd-9bc1-38b9411a7f58", - "metadata": {}, - "source": [ - "## Monte Carlo Example" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "8f897dd4-21d9-4c61-a9b2-4f12b8ae318d", - "metadata": {}, - "outputs": [], - "source": [ - "n_samples = 100\n", - "\n", - "k = 10\n", - "\n", - "w = libpysal.weights.lat2W(k,k)\n", - "w.transform='r'" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "c470b65b-1f85-42d2-8939-da1420101508", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])" - ] - }, - "execution_count": 78, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rhos = np.arange(0, .9, .1)\n", - "rhos" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "id": "23b4d3dd-19f6-4355-9c50-2619d25c15e6", - "metadata": {}, - "outputs": [], - "source": [ - "mu = 50\n", - "I = np.eye(k*k)\n", - "AIS = []\n", - "for rho in rhos:\n", - " A = I - rho *w.full()[0]\n", - " AI = np.linalg.inv(A)\n", - " AIS.append(AI)" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "id": "59a2e652-0a3a-4fce-8569-76f15029e73f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1.37859246, 0.70986085, 0.25233372, 0.09186194],\n", - " [0.47324057, 1.43289633, 0.48630564, 0.17150269],\n", - " [0.16822248, 0.48630564, 1.35206531, 0.45653987],\n", - " [0.06124129, 0.17150269, 0.45653987, 1.34096643]])" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "AI[0:4,0:4]" - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "id": "a198a599-2079-47ed-aa70-53783f54bdfc", - "metadata": {}, - "outputs": [], - "source": [ - "res = {}\n", - "permutations = 100\n", - "for rho, i in enumerate(rhos):\n", - " for realization in range(n_samples):\n", - " e = np.random.normal(0, 50, size=(k*k,1))\n", - " mue = mu + e\n", - " y = np.dot(AI, mue)\n", - " wy = libpysal.weights.lag_spatial(w, y)\n", - " counter = 0\n", - " for perm in range(permutations):\n", - " yr = np.random.permutation(y)\n", - " wyr = libpysal.weights.lag_spatial(w, yr)\n", - " result = cramervonmises_2samp(wy, wyr)\n", - " if result.pvalue <= 0.05:\n", - " counter += 1\n", - " res[(rho, realization)] = counter\n" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "id": "00ae88b6-3997-462e-83d9-09d50595d087", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(287.8508507836729)" - ] - }, - "execution_count": 103, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "yr.mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "id": "440685e2-ad0d-44bf-9dce-e81aa0c2c080", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(288.4577613659621), np.float64(289.0009182556533))" - ] - }, - "execution_count": 105, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wy.mean(), wyr.mean()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 104, - "id": "57d8433a-30dc-440d-bf7a-272bfeee835e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{(0, 0): 1,\n", - " (0, 1): 2,\n", - " (0, 2): 0,\n", - " (0, 3): 0,\n", - " (0, 4): 11,\n", - " (0, 5): 25,\n", - " (0, 6): 7,\n", - " (0, 7): 0,\n", - " (0, 8): 9,\n", - " (0, 9): 0,\n", - " (0, 10): 31,\n", - " (0, 11): 0,\n", - " (0, 12): 0,\n", - " (0, 13): 5,\n", - " (0, 14): 33,\n", - " (0, 15): 15,\n", - " (0, 16): 0,\n", - " (0, 17): 3,\n", - " (0, 18): 0,\n", - " (0, 19): 1,\n", - " (0, 20): 9,\n", - " (0, 21): 16,\n", - " (0, 22): 0,\n", - " (0, 23): 3,\n", - " (0, 24): 2,\n", - " (0, 25): 1,\n", - " (0, 26): 0,\n", - " (0, 27): 52,\n", - " (0, 28): 31,\n", - " (0, 29): 0,\n", - " (0, 30): 4,\n", - " (0, 31): 98,\n", - " (0, 32): 1,\n", - " (0, 33): 0,\n", - " (0, 34): 5,\n", - " (0, 35): 0,\n", - " (0, 36): 77,\n", - " (0, 37): 87,\n", - " (0, 38): 1,\n", - " (0, 39): 7,\n", - " (0, 40): 0,\n", - " (0, 41): 0,\n", - " (0, 42): 32,\n", - " (0, 43): 30,\n", - " (0, 44): 42,\n", - " (0, 45): 0,\n", - " (0, 46): 0,\n", - " (0, 47): 19,\n", - " (0, 48): 0,\n", - " (0, 49): 33,\n", - " (0, 50): 0,\n", - " (0, 51): 0,\n", - " (0, 52): 0,\n", - " (0, 53): 33,\n", - " (0, 54): 0,\n", - " (0, 55): 35,\n", - " (0, 56): 2,\n", - " (0, 57): 2,\n", - " (0, 58): 0,\n", - " (0, 59): 16,\n", - " (0, 60): 3,\n", - " (0, 61): 33,\n", - " (0, 62): 4,\n", - " (0, 63): 1,\n", - " (0, 64): 4,\n", - " (0, 65): 2,\n", - " (0, 66): 3,\n", - " (0, 67): 0,\n", - " (0, 68): 0,\n", - " (0, 69): 0,\n", - " (0, 70): 8,\n", - " (0, 71): 3,\n", - " (0, 72): 0,\n", - " (0, 73): 69,\n", - " (0, 74): 0,\n", - " (0, 75): 0,\n", - " (0, 76): 26,\n", - " (0, 77): 28,\n", - " (0, 78): 4,\n", - " (0, 79): 68,\n", - " (0, 80): 4,\n", - " (0, 81): 3,\n", - " (0, 82): 0,\n", - " (0, 83): 0,\n", - " (0, 84): 2,\n", - " (0, 85): 71,\n", - " (0, 86): 0,\n", - " (0, 87): 38,\n", - " (0, 88): 0,\n", - " (0, 89): 23,\n", - " (0, 90): 0,\n", - " (0, 91): 0,\n", - " (0, 92): 0,\n", - " (0, 93): 39,\n", - " (0, 94): 86,\n", - " (0, 95): 0,\n", - " (0, 96): 6,\n", - " (0, 97): 29,\n", - " (0, 98): 1,\n", - " (0, 99): 0,\n", - " (1, 0): 19,\n", - " (1, 1): 44,\n", - " (1, 2): 10,\n", - " (1, 3): 0,\n", - " (1, 4): 11,\n", - " (1, 5): 5,\n", - " (1, 6): 0,\n", - " (1, 7): 11,\n", - " (1, 8): 19,\n", - " (1, 9): 14,\n", - " (1, 10): 0,\n", - " (1, 11): 95,\n", - " (1, 12): 36,\n", - " (1, 13): 0,\n", - " (1, 14): 0,\n", - " (1, 15): 23,\n", - " (1, 16): 23,\n", - " (1, 17): 3,\n", - " (1, 18): 73,\n", - " (1, 19): 0,\n", - " (1, 20): 12,\n", - " (1, 21): 28,\n", - " (1, 22): 20,\n", - " (1, 23): 28,\n", - " (1, 24): 0,\n", - " (1, 25): 1,\n", - " (1, 26): 53,\n", - " (1, 27): 0,\n", - " (1, 28): 0,\n", - " (1, 29): 3,\n", - " (1, 30): 0,\n", - " (1, 31): 6,\n", - " (1, 32): 0,\n", - " (1, 33): 34,\n", - " (1, 34): 0,\n", - " (1, 35): 5,\n", - " (1, 36): 2,\n", - " (1, 37): 0,\n", - " (1, 38): 0,\n", - " (1, 39): 64,\n", - " (1, 40): 0,\n", - " (1, 41): 8,\n", - " (1, 42): 1,\n", - " (1, 43): 0,\n", - " (1, 44): 19,\n", - " (1, 45): 0,\n", - " (1, 46): 0,\n", - " (1, 47): 70,\n", - " (1, 48): 0,\n", - " (1, 49): 6,\n", - " (1, 50): 9,\n", - " (1, 51): 50,\n", - " (1, 52): 11,\n", - " (1, 53): 67,\n", - " (1, 54): 29,\n", - " (1, 55): 0,\n", - " (1, 56): 36,\n", - " (1, 57): 0,\n", - " (1, 58): 1,\n", - " (1, 59): 12,\n", - " (1, 60): 7,\n", - " (1, 61): 2,\n", - " (1, 62): 13,\n", - " (1, 63): 43,\n", - " (1, 64): 5,\n", - " (1, 65): 86,\n", - " (1, 66): 2,\n", - " (1, 67): 6,\n", - " (1, 68): 63,\n", - " (1, 69): 0,\n", - " (1, 70): 0,\n", - " (1, 71): 0,\n", - " (1, 72): 0,\n", - " (1, 73): 2,\n", - " (1, 74): 2,\n", - " (1, 75): 3,\n", - " (1, 76): 4,\n", - " (1, 77): 0,\n", - " (1, 78): 46,\n", - " (1, 79): 9,\n", - " (1, 80): 73,\n", - " (1, 81): 26,\n", - " (1, 82): 0,\n", - " (1, 83): 50,\n", - " (1, 84): 0,\n", - " (1, 85): 17,\n", - " (1, 86): 87,\n", - " (1, 87): 39,\n", - " (1, 88): 0,\n", - " (1, 89): 0,\n", - " (1, 90): 0,\n", - " (1, 91): 7,\n", - " (1, 92): 5,\n", - " (1, 93): 15,\n", - " (1, 94): 0,\n", - " (1, 95): 65,\n", - " (1, 96): 49,\n", - " (1, 97): 40,\n", - " (1, 98): 47,\n", - " (1, 99): 23,\n", - " (2, 0): 12,\n", - " (2, 1): 5,\n", - " (2, 2): 3,\n", - " (2, 3): 12,\n", - " (2, 4): 12,\n", - " (2, 5): 0,\n", - " (2, 6): 96,\n", - " (2, 7): 49,\n", - " (2, 8): 0,\n", - " (2, 9): 0,\n", - " (2, 10): 0,\n", - " (2, 11): 0,\n", - " (2, 12): 77,\n", - " (2, 13): 98,\n", - " (2, 14): 0,\n", - " (2, 15): 0,\n", - " (2, 16): 12,\n", - " (2, 17): 74,\n", - " (2, 18): 1,\n", - " (2, 19): 3,\n", - " (2, 20): 21,\n", - " (2, 21): 4,\n", - " (2, 22): 14,\n", - " (2, 23): 3,\n", - " (2, 24): 1,\n", - " (2, 25): 1,\n", - " (2, 26): 0,\n", - " (2, 27): 9,\n", - " (2, 28): 2,\n", - " (2, 29): 16,\n", - " (2, 30): 3,\n", - " (2, 31): 4,\n", - " (2, 32): 35,\n", - " (2, 33): 16,\n", - " (2, 34): 0,\n", - " (2, 35): 3,\n", - " (2, 36): 0,\n", - " (2, 37): 0,\n", - " (2, 38): 0,\n", - " (2, 39): 0,\n", - " (2, 40): 0,\n", - " (2, 41): 2,\n", - " (2, 42): 0,\n", - " (2, 43): 0,\n", - " (2, 44): 0,\n", - " (2, 45): 5,\n", - " (2, 46): 1,\n", - " (2, 47): 44,\n", - " (2, 48): 8,\n", - " (2, 49): 79,\n", - " (2, 50): 9,\n", - " (2, 51): 0,\n", - " (2, 52): 0,\n", - " (2, 53): 30,\n", - " (2, 54): 12,\n", - " (2, 55): 0,\n", - " (2, 56): 0,\n", - " (2, 57): 39,\n", - " (2, 58): 53,\n", - " (2, 59): 0,\n", - " (2, 60): 0,\n", - " (2, 61): 3,\n", - " (2, 62): 0,\n", - " (2, 63): 0,\n", - " (2, 64): 1,\n", - " (2, 65): 5,\n", - " (2, 66): 6,\n", - " (2, 67): 0,\n", - " (2, 68): 0,\n", - " (2, 69): 3,\n", - " (2, 70): 0,\n", - " (2, 71): 1,\n", - " (2, 72): 61,\n", - " (2, 73): 3,\n", - " (2, 74): 6,\n", - " (2, 75): 0,\n", - " (2, 76): 23,\n", - " (2, 77): 9,\n", - " (2, 78): 14,\n", - " (2, 79): 0,\n", - " (2, 80): 3,\n", - " (2, 81): 32,\n", - " (2, 82): 10,\n", - " (2, 83): 63,\n", - " (2, 84): 0,\n", - " (2, 85): 1,\n", - " (2, 86): 5,\n", - " (2, 87): 0,\n", - " (2, 88): 0,\n", - " (2, 89): 2,\n", - " (2, 90): 2,\n", - " (2, 91): 1,\n", - " (2, 92): 1,\n", - " (2, 93): 0,\n", - " (2, 94): 3,\n", - " (2, 95): 8,\n", - " (2, 96): 4,\n", - " (2, 97): 1,\n", - " (2, 98): 82,\n", - " (2, 99): 0,\n", - " (3, 0): 3,\n", - " (3, 1): 0,\n", - " (3, 2): 37,\n", - " (3, 3): 70,\n", - " (3, 4): 0,\n", - " (3, 5): 34,\n", - " (3, 6): 0,\n", - " (3, 7): 2,\n", - " (3, 8): 18,\n", - " (3, 9): 0,\n", - " (3, 10): 9,\n", - " (3, 11): 21,\n", - " (3, 12): 0,\n", - " (3, 13): 15,\n", - " (3, 14): 4,\n", - " (3, 15): 10,\n", - " (3, 16): 64,\n", - " (3, 17): 1,\n", - " (3, 18): 76,\n", - " (3, 19): 58,\n", - " (3, 20): 0,\n", - " (3, 21): 1,\n", - " (3, 22): 0,\n", - " (3, 23): 0,\n", - " (3, 24): 4,\n", - " (3, 25): 1,\n", - " (3, 26): 0,\n", - " (3, 27): 76,\n", - " (3, 28): 0,\n", - " (3, 29): 1,\n", - " (3, 30): 0,\n", - " (3, 31): 3,\n", - " (3, 32): 1,\n", - " (3, 33): 20,\n", - " (3, 34): 87,\n", - " (3, 35): 27,\n", - " (3, 36): 0,\n", - " (3, 37): 0,\n", - " (3, 38): 0,\n", - " (3, 39): 0,\n", - " (3, 40): 61,\n", - " (3, 41): 1,\n", - " (3, 42): 0,\n", - " (3, 43): 24,\n", - " (3, 44): 60,\n", - " (3, 45): 2,\n", - " (3, 46): 0,\n", - " (3, 47): 1,\n", - " (3, 48): 65,\n", - " (3, 49): 0,\n", - " (3, 50): 0,\n", - " (3, 51): 8,\n", - " (3, 52): 0,\n", - " (3, 53): 0,\n", - " (3, 54): 0,\n", - " (3, 55): 0,\n", - " (3, 56): 29,\n", - " (3, 57): 1,\n", - " (3, 58): 17,\n", - " (3, 59): 39,\n", - " (3, 60): 0,\n", - " (3, 61): 14,\n", - " (3, 62): 29,\n", - " (3, 63): 0,\n", - " (3, 64): 1,\n", - " (3, 65): 0,\n", - " (3, 66): 3,\n", - " (3, 67): 27,\n", - " (3, 68): 2,\n", - " (3, 69): 14,\n", - " (3, 70): 1,\n", - " (3, 71): 0,\n", - " (3, 72): 0,\n", - " (3, 73): 3,\n", - " (3, 74): 0,\n", - " (3, 75): 14,\n", - " (3, 76): 0,\n", - " (3, 77): 56,\n", - " (3, 78): 0,\n", - " (3, 79): 15,\n", - " (3, 80): 0,\n", - " (3, 81): 37,\n", - " (3, 82): 30,\n", - " (3, 83): 37,\n", - " (3, 84): 6,\n", - " (3, 85): 15,\n", - " (3, 86): 3,\n", - " (3, 87): 0,\n", - " (3, 88): 14,\n", - " (3, 89): 96,\n", - " (3, 90): 6,\n", - " (3, 91): 18,\n", - " (3, 92): 1,\n", - " (3, 93): 1,\n", - " (3, 94): 48,\n", - " (3, 95): 6,\n", - " (3, 96): 2,\n", - " (3, 97): 0,\n", - " (3, 98): 71,\n", - " (3, 99): 59,\n", - " (4, 0): 72,\n", - " (4, 1): 25,\n", - " (4, 2): 1,\n", - " (4, 3): 24,\n", - " (4, 4): 0,\n", - " (4, 5): 0,\n", - " (4, 6): 6,\n", - " (4, 7): 2,\n", - " (4, 8): 7,\n", - " (4, 9): 0,\n", - " (4, 10): 0,\n", - " (4, 11): 0,\n", - " (4, 12): 2,\n", - " (4, 13): 1,\n", - " (4, 14): 2,\n", - " (4, 15): 4,\n", - " (4, 16): 76,\n", - " (4, 17): 0,\n", - " (4, 18): 66,\n", - " (4, 19): 24,\n", - " (4, 20): 8,\n", - " (4, 21): 1,\n", - " (4, 22): 61,\n", - " (4, 23): 54,\n", - " (4, 24): 3,\n", - " (4, 25): 26,\n", - " (4, 26): 0,\n", - " (4, 27): 17,\n", - " (4, 28): 0,\n", - " (4, 29): 23,\n", - " (4, 30): 26,\n", - " (4, 31): 37,\n", - " (4, 32): 2,\n", - " (4, 33): 1,\n", - " (4, 34): 22,\n", - " (4, 35): 9,\n", - " (4, 36): 63,\n", - " (4, 37): 4,\n", - " (4, 38): 0,\n", - " (4, 39): 0,\n", - " (4, 40): 13,\n", - " (4, 41): 2,\n", - " (4, 42): 0,\n", - " (4, 43): 3,\n", - " (4, 44): 19,\n", - " (4, 45): 4,\n", - " (4, 46): 2,\n", - " (4, 47): 1,\n", - " (4, 48): 1,\n", - " (4, 49): 2,\n", - " (4, 50): 18,\n", - " (4, 51): 57,\n", - " (4, 52): 17,\n", - " (4, 53): 3,\n", - " (4, 54): 11,\n", - " (4, 55): 100,\n", - " (4, 56): 41,\n", - " (4, 57): 0,\n", - " (4, 58): 1,\n", - " (4, 59): 4,\n", - " (4, 60): 0,\n", - " (4, 61): 1,\n", - " (4, 62): 0,\n", - " (4, 63): 1,\n", - " (4, 64): 45,\n", - " (4, 65): 0,\n", - " (4, 66): 1,\n", - " (4, 67): 47,\n", - " (4, 68): 70,\n", - " (4, 69): 34,\n", - " (4, 70): 11,\n", - " (4, 71): 2,\n", - " (4, 72): 2,\n", - " (4, 73): 32,\n", - " (4, 74): 2,\n", - " (4, 75): 41,\n", - " (4, 76): 0,\n", - " (4, 77): 2,\n", - " (4, 78): 29,\n", - " (4, 79): 85,\n", - " (4, 80): 0,\n", - " (4, 81): 18,\n", - " (4, 82): 5,\n", - " (4, 83): 75,\n", - " (4, 84): 7,\n", - " (4, 85): 54,\n", - " (4, 86): 1,\n", - " (4, 87): 0,\n", - " (4, 88): 27,\n", - " (4, 89): 1,\n", - " (4, 90): 1,\n", - " (4, 91): 0,\n", - " (4, 92): 1,\n", - " (4, 93): 0,\n", - " (4, 94): 0,\n", - " (4, 95): 3,\n", - " (4, 96): 6,\n", - " (4, 97): 0,\n", - " (4, 98): 0,\n", - " (4, 99): 12,\n", - " (5, 0): 0,\n", - " (5, 1): 1,\n", - " (5, 2): 2,\n", - " (5, 3): 0,\n", - " (5, 4): 1,\n", - " (5, 5): 2,\n", - " (5, 6): 40,\n", - " (5, 7): 39,\n", - " (5, 8): 0,\n", - " (5, 9): 0,\n", - " (5, 10): 95,\n", - " (5, 11): 0,\n", - " (5, 12): 0,\n", - " (5, 13): 16,\n", - " (5, 14): 0,\n", - " (5, 15): 81,\n", - " (5, 16): 2,\n", - " (5, 17): 5,\n", - " (5, 18): 0,\n", - " (5, 19): 34,\n", - " (5, 20): 0,\n", - " (5, 21): 0,\n", - " (5, 22): 7,\n", - " (5, 23): 7,\n", - " (5, 24): 3,\n", - " (5, 25): 0,\n", - " (5, 26): 0,\n", - " (5, 27): 12,\n", - " (5, 28): 0,\n", - " (5, 29): 5,\n", - " (5, 30): 31,\n", - " (5, 31): 19,\n", - " (5, 32): 99,\n", - " (5, 33): 33,\n", - " (5, 34): 1,\n", - " (5, 35): 100,\n", - " (5, 36): 8,\n", - " (5, 37): 0,\n", - " (5, 38): 2,\n", - " (5, 39): 10,\n", - " (5, 40): 9,\n", - " (5, 41): 86,\n", - " (5, 42): 45,\n", - " (5, 43): 22,\n", - " (5, 44): 49,\n", - " (5, 45): 8,\n", - " (5, 46): 2,\n", - " (5, 47): 5,\n", - " (5, 48): 37,\n", - " (5, 49): 3,\n", - " (5, 50): 62,\n", - " (5, 51): 21,\n", - " (5, 52): 1,\n", - " (5, 53): 20,\n", - " (5, 54): 0,\n", - " (5, 55): 3,\n", - " (5, 56): 12,\n", - " (5, 57): 0,\n", - " (5, 58): 20,\n", - " (5, 59): 3,\n", - " (5, 60): 0,\n", - " (5, 61): 2,\n", - " (5, 62): 9,\n", - " (5, 63): 6,\n", - " (5, 64): 0,\n", - " (5, 65): 0,\n", - " (5, 66): 0,\n", - " (5, 67): 0,\n", - " (5, 68): 2,\n", - " (5, 69): 5,\n", - " (5, 70): 0,\n", - " (5, 71): 59,\n", - " (5, 72): 70,\n", - " (5, 73): 16,\n", - " (5, 74): 0,\n", - " (5, 75): 0,\n", - " (5, 76): 0,\n", - " (5, 77): 0,\n", - " (5, 78): 0,\n", - " (5, 79): 81,\n", - " (5, 80): 0,\n", - " (5, 81): 0,\n", - " (5, 82): 0,\n", - " (5, 83): 2,\n", - " (5, 84): 0,\n", - " (5, 85): 0,\n", - " (5, 86): 1,\n", - " (5, 87): 25,\n", - " (5, 88): 0,\n", - " (5, 89): 0,\n", - " (5, 90): 30,\n", - " (5, 91): 3,\n", - " (5, 92): 2,\n", - " (5, 93): 2,\n", - " (5, 94): 0,\n", - " (5, 95): 1,\n", - " (5, 96): 2,\n", - " (5, 97): 3,\n", - " (5, 98): 71,\n", - " (5, 99): 6,\n", - " (6, 0): 0,\n", - " (6, 1): 11,\n", - " (6, 2): 0,\n", - " (6, 3): 0,\n", - " (6, 4): 0,\n", - " (6, 5): 0,\n", - " (6, 6): 82,\n", - " (6, 7): 53,\n", - " (6, 8): 0,\n", - " (6, 9): 14,\n", - " (6, 10): 17,\n", - " (6, 11): 1,\n", - " (6, 12): 4,\n", - " (6, 13): 0,\n", - " (6, 14): 2,\n", - " (6, 15): 0,\n", - " (6, 16): 0,\n", - " (6, 17): 28,\n", - " (6, 18): 0,\n", - " (6, 19): 3,\n", - " (6, 20): 6,\n", - " (6, 21): 7,\n", - " (6, 22): 54,\n", - " (6, 23): 4,\n", - " (6, 24): 0,\n", - " (6, 25): 30,\n", - " (6, 26): 11,\n", - " (6, 27): 0,\n", - " (6, 28): 2,\n", - " (6, 29): 9,\n", - " (6, 30): 2,\n", - " (6, 31): 0,\n", - " (6, 32): 0,\n", - " (6, 33): 0,\n", - " (6, 34): 0,\n", - " (6, 35): 1,\n", - " (6, 36): 17,\n", - " (6, 37): 91,\n", - " (6, 38): 0,\n", - " (6, 39): 18,\n", - " (6, 40): 0,\n", - " (6, 41): 0,\n", - " (6, 42): 2,\n", - " (6, 43): 0,\n", - " (6, 44): 1,\n", - " (6, 45): 0,\n", - " (6, 46): 35,\n", - " (6, 47): 29,\n", - " (6, 48): 5,\n", - " (6, 49): 0,\n", - " (6, 50): 6,\n", - " (6, 51): 20,\n", - " (6, 52): 68,\n", - " (6, 53): 5,\n", - " (6, 54): 48,\n", - " (6, 55): 89,\n", - " (6, 56): 18,\n", - " (6, 57): 0,\n", - " (6, 58): 0,\n", - " (6, 59): 0,\n", - " (6, 60): 8,\n", - " (6, 61): 9,\n", - " (6, 62): 7,\n", - " (6, 63): 17,\n", - " (6, 64): 9,\n", - " (6, 65): 2,\n", - " (6, 66): 0,\n", - " (6, 67): 22,\n", - " (6, 68): 0,\n", - " (6, 69): 0,\n", - " (6, 70): 96,\n", - " (6, 71): 21,\n", - " (6, 72): 7,\n", - " (6, 73): 0,\n", - " (6, 74): 0,\n", - " (6, 75): 2,\n", - " (6, 76): 0,\n", - " (6, 77): 48,\n", - " (6, 78): 1,\n", - " (6, 79): 16,\n", - " (6, 80): 99,\n", - " (6, 81): 6,\n", - " (6, 82): 0,\n", - " (6, 83): 1,\n", - " (6, 84): 0,\n", - " (6, 85): 50,\n", - " (6, 86): 5,\n", - " (6, 87): 13,\n", - " (6, 88): 62,\n", - " (6, 89): 38,\n", - " (6, 90): 72,\n", - " (6, 91): 1,\n", - " (6, 92): 21,\n", - " (6, 93): 0,\n", - " (6, 94): 69,\n", - " (6, 95): 11,\n", - " (6, 96): 7,\n", - " (6, 97): 0,\n", - " (6, 98): 70,\n", - " (6, 99): 1,\n", - " (7, 0): 3,\n", - " (7, 1): 0,\n", - " (7, 2): 0,\n", - " (7, 3): 42,\n", - " (7, 4): 0,\n", - " (7, 5): 3,\n", - " (7, 6): 31,\n", - " (7, 7): 0,\n", - " (7, 8): 5,\n", - " (7, 9): 4,\n", - " (7, 10): 19,\n", - " (7, 11): 0,\n", - " (7, 12): 0,\n", - " (7, 13): 1,\n", - " (7, 14): 23,\n", - " (7, 15): 0,\n", - " (7, 16): 0,\n", - " (7, 17): 94,\n", - " (7, 18): 15,\n", - " (7, 19): 0,\n", - " (7, 20): 4,\n", - " (7, 21): 2,\n", - " (7, 22): 1,\n", - " (7, 23): 0,\n", - " (7, 24): 54,\n", - " (7, 25): 65,\n", - " (7, 26): 21,\n", - " (7, 27): 0,\n", - " (7, 28): 5,\n", - " (7, 29): 36,\n", - " (7, 30): 6,\n", - " (7, 31): 1,\n", - " (7, 32): 0,\n", - " (7, 33): 11,\n", - " (7, 34): 20,\n", - " (7, 35): 7,\n", - " (7, 36): 0,\n", - " (7, 37): 0,\n", - " (7, 38): 0,\n", - " (7, 39): 9,\n", - " (7, 40): 0,\n", - " (7, 41): 46,\n", - " (7, 42): 0,\n", - " (7, 43): 0,\n", - " (7, 44): 4,\n", - " (7, 45): 0,\n", - " (7, 46): 0,\n", - " (7, 47): 20,\n", - " (7, 48): 0,\n", - " (7, 49): 0,\n", - " (7, 50): 13,\n", - " (7, 51): 96,\n", - " (7, 52): 92,\n", - " (7, 53): 44,\n", - " (7, 54): 33,\n", - " (7, 55): 0,\n", - " (7, 56): 59,\n", - " (7, 57): 0,\n", - " (7, 58): 10,\n", - " (7, 59): 38,\n", - " (7, 60): 0,\n", - " (7, 61): 9,\n", - " (7, 62): 16,\n", - " (7, 63): 0,\n", - " (7, 64): 1,\n", - " (7, 65): 15,\n", - " (7, 66): 7,\n", - " (7, 67): 97,\n", - " (7, 68): 0,\n", - " (7, 69): 12,\n", - " (7, 70): 2,\n", - " (7, 71): 0,\n", - " (7, 72): 0,\n", - " (7, 73): 34,\n", - " (7, 74): 34,\n", - " (7, 75): 86,\n", - " (7, 76): 3,\n", - " (7, 77): 4,\n", - " (7, 78): 8,\n", - " (7, 79): 0,\n", - " (7, 80): 1,\n", - " (7, 81): 19,\n", - " (7, 82): 0,\n", - " (7, 83): 11,\n", - " (7, 84): 82,\n", - " (7, 85): 17,\n", - " (7, 86): 1,\n", - " (7, 87): 16,\n", - " (7, 88): 43,\n", - " (7, 89): 1,\n", - " (7, 90): 0,\n", - " (7, 91): 4,\n", - " (7, 92): 28,\n", - " (7, 93): 73,\n", - " (7, 94): 1,\n", - " (7, 95): 93,\n", - " (7, 96): 4,\n", - " (7, 97): 0,\n", - " (7, 98): 0,\n", - " (7, 99): 15,\n", - " (8, 0): 10,\n", - " (8, 1): 4,\n", - " (8, 2): 4,\n", - " (8, 3): 17,\n", - " (8, 4): 0,\n", - " (8, 5): 18,\n", - " (8, 6): 0,\n", - " (8, 7): 0,\n", - " (8, 8): 23,\n", - " (8, 9): 3,\n", - " (8, 10): 63,\n", - " (8, 11): 5,\n", - " (8, 12): 15,\n", - " (8, 13): 5,\n", - " (8, 14): 4,\n", - " (8, 15): 0,\n", - " (8, 16): 0,\n", - " (8, 17): 0,\n", - " (8, 18): 3,\n", - " (8, 19): 43,\n", - " (8, 20): 0,\n", - " (8, 21): 0,\n", - " (8, 22): 83,\n", - " (8, 23): 3,\n", - " (8, 24): 1,\n", - " (8, 25): 0,\n", - " (8, 26): 0,\n", - " (8, 27): 3,\n", - " (8, 28): 9,\n", - " (8, 29): 0,\n", - " (8, 30): 52,\n", - " (8, 31): 10,\n", - " (8, 32): 73,\n", - " (8, 33): 0,\n", - " (8, 34): 0,\n", - " (8, 35): 20,\n", - " (8, 36): 63,\n", - " (8, 37): 38,\n", - " (8, 38): 52,\n", - " (8, 39): 0,\n", - " (8, 40): 2,\n", - " (8, 41): 0,\n", - " (8, 42): 0,\n", - " (8, 43): 0,\n", - " (8, 44): 51,\n", - " (8, 45): 4,\n", - " (8, 46): 0,\n", - " (8, 47): 5,\n", - " (8, 48): 21,\n", - " (8, 49): 12,\n", - " (8, 50): 0,\n", - " (8, 51): 0,\n", - " (8, 52): 12,\n", - " (8, 53): 0,\n", - " (8, 54): 0,\n", - " (8, 55): 0,\n", - " (8, 56): 5,\n", - " (8, 57): 1,\n", - " (8, 58): 13,\n", - " (8, 59): 10,\n", - " (8, 60): 63,\n", - " (8, 61): 19,\n", - " (8, 62): 1,\n", - " (8, 63): 0,\n", - " (8, 64): 18,\n", - " (8, 65): 82,\n", - " (8, 66): 10,\n", - " (8, 67): 7,\n", - " (8, 68): 4,\n", - " (8, 69): 8,\n", - " (8, 70): 61,\n", - " (8, 71): 24,\n", - " (8, 72): 0,\n", - " (8, 73): 0,\n", - " (8, 74): 0,\n", - " (8, 75): 0,\n", - " (8, 76): 0,\n", - " (8, 77): 0,\n", - " (8, 78): 1,\n", - " (8, 79): 57,\n", - " (8, 80): 14,\n", - " (8, 81): 0,\n", - " (8, 82): 31,\n", - " (8, 83): 0,\n", - " (8, 84): 12,\n", - " (8, 85): 29,\n", - " (8, 86): 0,\n", - " (8, 87): 6,\n", - " (8, 88): 0,\n", - " (8, 89): 0,\n", - " (8, 90): 44,\n", - " (8, 91): 1,\n", - " (8, 92): 0,\n", - " (8, 93): 1,\n", - " (8, 94): 0,\n", - " (8, 95): 45,\n", - " (8, 96): 0,\n", - " (8, 97): 1,\n", - " (8, 98): 38,\n", - " (8, 99): 3}" - ] - }, - "execution_count": 104, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "res" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "f4e23eed-f1f2-44f6-a5b1-5c2d278d1e86", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(100, 100)" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "id": "e6b3dc46-5e71-49ee-99a2-44c4b10e4ff4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1. , -0.4 , 0. , ..., 0. ,\n", - " 0. , 0. ],\n", - " [-0.26666667, 1. , -0.26666667, ..., 0. ,\n", - " 0. , 0. ],\n", - " [ 0. , -0.26666667, 1. , ..., 0. ,\n", - " 0. , 0. ],\n", - " ...,\n", - " [ 0. , 0. , 0. , ..., 1. ,\n", - " -0.26666667, 0. ],\n", - " [ 0. , 0. , 0. , ..., -0.26666667,\n", - " 1. , -0.26666667],\n", - " [ 0. , 0. , 0. , ..., 0. ,\n", - " -0.4 , 1. ]])" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A" - ] - }, - { - "cell_type": "code", - "execution_count": 106, - "id": "172ac907-e02b-4ecb-8355-73e6e2fff132", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Simulated vector with mean 60:\n", - "[[59.50335141]\n", - " [57.96317815]\n", - " [61.08512045]\n", - " [59.10510888]\n", - " [60.21937925]\n", - " [61.00814328]\n", - " [59.16297447]\n", - " [60.28034152]\n", - " [61.69432809]\n", - " [57.71526519]\n", - " [59.38207926]\n", - " [59.20458413]\n", - " [60.08153114]\n", - " [60.1698427 ]\n", - " [59.01124681]\n", - " [59.48614337]\n", - " [59.43299963]\n", - " [59.85719209]\n", - " [60.39571047]\n", - " [61.12774218]\n", - " [61.23385475]\n", - " [60.81496405]\n", - " [59.33564438]\n", - " [60.17891651]\n", - " [62.55035785]]\n", - "Mean of the simulated vector: 60.0\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "# Set random seed for reproducibility\n", - "np.random.seed(42)\n", - "\n", - "# Number of observations\n", - "n = 25\n", - "\n", - "# Mean of the desired vector\n", - "desired_mean = 60\n", - "\n", - "# Spatial autoregressive parameter\n", - "rho = 0.5\n", - "\n", - "# Generate a spatial weights matrix W (e.g., random weights)\n", - "W = np.random.rand(n, n)\n", - "W = W / W.sum(axis=1)[:, np.newaxis] # Row-normalize W\n", - "\n", - "# Generate random error term epsilon\n", - "sigma = 1 # Standard deviation of the error term\n", - "epsilon = np.random.normal(0, sigma, size=(n, 1))\n", - "\n", - "# Simulate y using the SAR equation: y = (I - rho * W)^(-1) * epsilon\n", - "I = np.eye(n)\n", - "y = np.linalg.inv(I - rho * W) @ epsilon\n", - "\n", - "# Adjust the vector to have a mean of 60\n", - "y_adjusted = y - np.mean(y) + desired_mean\n", - "\n", - "# Reshape to ensure it's a 25x1 vector\n", - "y_adjusted = y_adjusted.reshape((n, 1))\n", - "\n", - "# Print the simulated vector\n", - "print(\"Simulated vector with mean 60:\")\n", - "print(y_adjusted)\n", - "print(f\"Mean of the simulated vector: {np.mean(y_adjusted)}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 125, - "id": "b2f560c7-37ff-4d6b-92ad-6098bad2bb95", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Simulated vector with mean 60 and standard deviation 30:\n", - "[[ 30.34774906]\n", - " [ 5.61321136]\n", - " [ 64.31617731]\n", - " [ 47.16960984]\n", - " [ 40.69502379]\n", - " [ 61.29060489]\n", - " [ 29.48728248]\n", - " [ 64.93173035]\n", - " [ 85.3314396 ]\n", - " [ 13.08798606]\n", - " [ 37.80721574]\n", - " [ 31.9878886 ]\n", - " [ 57.51533994]\n", - " [ 70.09962914]\n", - " [ 45.85430486]\n", - " [ 48.74656631]\n", - " [ 44.79416714]\n", - " [ 58.99032309]\n", - " [ 86.42163388]\n", - " [107.68137292]\n", - " [ 88.82310993]\n", - " [ 80.87627414]\n", - " [ 60.92027067]\n", - " [ 93.55725214]\n", - " [143.65383678]]\n", - "Mean of the simulated vector: 60.0\n", - "Standard deviation of the simulated vector: 30.000000000000004\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "# Set random seed for reproducibility\n", - "np.random.seed(42)\n", - "\n", - "# Number of observations\n", - "n = 25\n", - "\n", - "# Desired mean and standard deviation\n", - "desired_mean = 60\n", - "desired_std = 30\n", - "\n", - "# Spatial autoregressive parameter\n", - "rho = 0.8\n", - "\n", - "# Generate a spatial weights matrix W (e.g., random weights)\n", - "W = np.random.rand(n, n)\n", - "W = W / W.sum(axis=1)[:, np.newaxis] # Row-normalize W\n", - "W = libpysal.weights.lat2W(5,5)\n", - "W.transform = 'r'\n", - "W = W.full()[0]\n", - "\n", - "# Generate random error term epsilon\n", - "sigma = 1 # Standard deviation of the error term\n", - "epsilon = np.random.normal(0, sigma, size=(n, 1))\n", - "\n", - "# Simulate y using the SAR equation: y = (I - rho * W)^(-1) * epsilon\n", - "I = np.eye(n)\n", - "y = np.linalg.inv(I - rho * W) @ epsilon\n", - "\n", - "# Step 1: Adjust to have the desired standard deviation\n", - "current_std = np.std(y)\n", - "y_scaled = y * (desired_std / current_std)\n", - "\n", - "# Step 2: Adjust to have the desired mean\n", - "current_mean = np.mean(y_scaled)\n", - "y_adjusted = y_scaled - current_mean + desired_mean\n", - "\n", - "# Reshape to ensure it's a 25x1 vector\n", - "y_adjusted = y_adjusted.reshape((n, 1))\n", - "\n", - "# Print the simulated vector\n", - "print(\"Simulated vector with mean 60 and standard deviation 30:\")\n", - "print(y_adjusted)\n", - "print(f\"Mean of the simulated vector: {np.mean(y_adjusted)}\")\n", - "print(f\"Standard deviation of the simulated vector: {np.std(y_adjusted)}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "id": "6e973fca-219e-4b4c-9eef-235096ecac2e", - "metadata": {}, - "outputs": [], - "source": [ - "import esda" - ] - }, - { - "cell_type": "code", - "execution_count": 127, - "id": "fb4aa11d-2392-4791-b4f6-b8ce77bd6e18", - "metadata": {}, - "outputs": [], - "source": [ - "w = libpysal.weights.lat2W(5,5)\n", - "w.transform = 'r'" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "id": "e0c08044-2294-4389-a0c1-b6b51dd13425", - "metadata": {}, - "outputs": [], - "source": [ - "res = esda.moran.Moran(y, w)" - ] - }, - { - "cell_type": "code", - "execution_count": 129, - "id": "1f80875a-586f-4b4e-9133-bbcf0b741b20", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.46970954423793404)" - ] - }, - "execution_count": 129, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "res.I" - ] - }, - { - "cell_type": "code", - "execution_count": 130, - "id": "e4833b58-8f78-488d-bdaf-e1cf00bafdff", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.0006645744943399919)" - ] - }, - "execution_count": 130, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "res.p_norm" - ] - }, - { - "cell_type": "code", - "execution_count": 131, - "id": "13d77794-2be7-4fa1-bcae-7cc7082df3f3", - "metadata": {}, - "outputs": [], - "source": [ - "wy = libpysal.weights.lag_spatial(w, y_adjusted)" - ] - }, - { - "cell_type": "code", - "execution_count": 132, - "id": "d7576180-c441-41b0-9f57-d715272c124d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 33.45190812],\n", - " [ 41.38373628],\n", - " [ 39.23818385],\n", - " [ 63.4475469 ],\n", - " [ 30.12879795],\n", - " [ 32.54741576],\n", - " [ 40.9558588 ],\n", - " [ 59.16255983],\n", - " [ 48.82223884],\n", - " [ 57.29358942],\n", - " [ 47.3416866 ],\n", - " [ 42.40100132],\n", - " [ 56.50239279],\n", - " [ 68.78067957],\n", - " [ 63.62299604],\n", - " [ 57.1414976 ],\n", - " [ 55.15026303],\n", - " [ 62.41285291],\n", - " [ 82.58214432],\n", - " [ 91.97659184],\n", - " [ 64.81142022],\n", - " [ 64.84584925],\n", - " [ 77.80794979],\n", - " [ 96.99858044],\n", - " [100.61931253]])" - ] - }, - "execution_count": 132, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wy" - ] - }, - { - "cell_type": "code", - "execution_count": 133, - "id": "dc21b455-9997-4333-bf96-469e0eec005a", - "metadata": {}, - "outputs": [], - "source": [ - "wyr = libpysal.weights.lag_spatial(w, np.random.permutation(y_adjusted))" - ] - }, - { - "cell_type": "code", - "execution_count": 134, - "id": "87eb45b9-4b5a-4912-9aef-25362440c145", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[39.57874922],\n", - " [45.79804245],\n", - " [78.97744342],\n", - " [65.61006938],\n", - " [75.05685741],\n", - " [32.54741576],\n", - " [57.10613664],\n", - " [68.50510947],\n", - " [76.71388441],\n", - " [63.6822521 ],\n", - " [36.76605371],\n", - " [59.68093082],\n", - " [56.82169114],\n", - " [86.60776913],\n", - " [53.63380636],\n", - " [53.4911186 ],\n", - " [47.24513808],\n", - " [93.24792464],\n", - " [46.43915145],\n", - " [70.89752468],\n", - " [59.2178053 ],\n", - " [72.18241354],\n", - " [58.19952244],\n", - " [78.2660102 ],\n", - " [53.8684447 ]])" - ] - }, - "execution_count": 134, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wyr" - ] - }, - { - "cell_type": "code", - "execution_count": 140, - "id": "ef3c9172-7bea-4327-b958-8f2e2d920865", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "KstestResult(statistic=array([0.16]), pvalue=array([0.91499322]), statistic_location=array([42.40100132]), statistic_sign=array([-1.]))" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ks_2samp(wyr, wy)" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "id": "f0556e22-3234-437c-8d35-d7e068f476ee", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(59.17708216045005), np.float64(61.205650601843516))" - ] - }, - "execution_count": 141, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wy.mean(), wyr.mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "id": "53179cd8-51f8-402f-b82e-13d4d7d3a429", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(19.124769670399136), np.float64(15.18306374176247))" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wy.std(), wyr.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 138, - "id": "11a28149-a9cd-49d4-a4ac-f198e377a6b6", - "metadata": {}, - "outputs": [], - "source": [ - "result = cramervonmises_2samp(wy, wyr)" - ] - }, - { - "cell_type": "code", - "execution_count": 139, - "id": "5b5c0afe-2be1-424b-b301-40dfeea1308f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "CramerVonMisesResult(statistic=[0.0712], pvalue=[0.77119716])" - ] - }, - "execution_count": 139, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "result" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "id": "a12fdf73-60d0-4714-9ab6-6a91978a4345", - "metadata": {}, - "outputs": [], - "source": [ - "import inequality.gini" - ] - }, - { - "cell_type": "code", - "execution_count": 144, - "id": "06e53e74-7bbf-4f97-b69c-fbfdba5f8608", - "metadata": {}, - "outputs": [], - "source": [ - "from inequality.gini import Gini" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "id": "87f639ac-cd31-4829-af47-889aa2c6ab76", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(13.65740614902654)" - ] - }, - "execution_count": 146, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Gini(wy).g" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "id": "59bb7c20-cf22-4a6c-9923-194c9d55b53e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(15.772948960181928)" - ] - }, - "execution_count": 147, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Gini(wyr).g" - ] - }, - { - "cell_type": "code", - "execution_count": 156, - "id": "e1938bce-0497-4d9a-a274-fdca54d6e639", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "# Generate two sets of random data\n", - "data1 = np.random.normal(0, 1, size=1000)\n", - "data2 = np.random.normal(2, 0.5, size=1000)\n", - "\n", - "# Set the same range for both KDE plots\n", - "y = gdf.PCGDP1960\n", - "common_range = (min(wy.min(), wyr.min()) *.5, 1.5*max(wy.max(), wyr.max()))\n", - "\n", - "# Create the plot\n", - "plt.figure(figsize=(8, 6))\n", - "\n", - "\n", - "# Plot the second KDE\n", - "sns.kdeplot(wy, label='Spatial Lag', bw_adjust=0.5, clip=common_range)\n", - "\n", - "# Plot the random lag\n", - "sns.kdeplot(wyr, label='Spatial Lag (Random)', bw_adjust=0.5, clip=common_range)\n", - "\n", - "# Add labels and title\n", - "plt.xlabel('Value')\n", - "plt.ylabel('Density')\n", - "plt.title('KDE of Three Distributions Over the Same Range')\n", - "plt.legend()\n", - "\n", - "# Show the plot\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 157, - "id": "7408967a-d25d-4297-a570-8c1b45225692", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(-13.86162796406077), np.float64(-16.252926813534494))" - ] - }, - "execution_count": 157, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wolfson(wy), wolfson(wyr)" - ] - }, - { - "cell_type": "code", - "execution_count": 158, - "id": "4de509be-ab7b-4518-a99c-d08e38cea790", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":2: SyntaxWarning: invalid escape sequence '\\m'\n" - ] - }, - { - "data": { - "text/plain": [ - "\u001b[0;31mSignature:\u001b[0m \u001b[0mwolfson\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mincome_distribution\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mSource:\u001b[0m \n", - "\u001b[0;32mdef\u001b[0m \u001b[0mwolfson\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mincome_distribution\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;34m\"\"\"\u001b[0m\n", - "\u001b[0;34m Calculate the Wolfson Bipolarization Index for a given income distribution.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m The Wolfson index is constructed from the polarization curve,\u001b[0m\n", - "\u001b[0;34m which is a rotation and rescaling of the Lorenz curve by the\u001b[0m\n", - "\u001b[0;34m median income:\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m .. math::\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m W = (2D_{50} - G)\\\\frac{\\\\mu}{m}\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Where :math:`D_{50} =0.5 - L(0.5)`, :math:`L(0.5)` is the\u001b[0m\n", - "\u001b[0;34m value of the Lorenz curve at the median, :math:`G` is the Gini\u001b[0m\n", - "\u001b[0;34m index, :math:`\\mu` is the mean, and :math:`m` is the median.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m \u001b[0m\n", - "\u001b[0;34m See :cite:t:`wolfson1994WhenInequalities,hoffmann2024MeasuringMismeasuring`.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m \u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Parameters\u001b[0m\n", - "\u001b[0;34m ----------\u001b[0m\n", - "\u001b[0;34m income_distribution : list of int or float\u001b[0m\n", - "\u001b[0;34m A list representing the income distribution.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Returns\u001b[0m\n", - "\u001b[0;34m -------\u001b[0m\n", - "\u001b[0;34m w: float\u001b[0m\n", - "\u001b[0;34m The Wolfson Bipolarization Index value.\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m Example\u001b[0m\n", - "\u001b[0;34m -------\u001b[0m\n", - "\u001b[0;34m >>> income_distribution = [20000, 25000, 27000, 30000, 35000, 45000, 60000,\u001b[0m\n", - "\u001b[0;34m ... 75000, 80000, 120000]\u001b[0m\n", - "\u001b[0;34m >>> wolfson_index = wolfson(income_distribution)\u001b[0m\n", - "\u001b[0;34m >>> print(f\"Wolfson Bipolarization Index: {wolfson_index:.4f}\")\u001b[0m\n", - "\u001b[0;34m Wolfson Bipolarization Index: 0.2013\u001b[0m\n", - "\u001b[0;34m >>> income_distribution = [6, 6, 8, 8, 10, 10, 12, 12]\u001b[0m\n", - "\u001b[0;34m >>> wolfson_index = wolfson(income_distribution)\u001b[0m\n", - "\u001b[0;34m >>> print(f\"Wolfson Bipolarization Index: {wolfson_index:.4f}\")\u001b[0m\n", - "\u001b[0;34m Wolfson Bipolarization Index: 0.0833\u001b[0m\n", - "\u001b[0;34m >>> income_distribution = [2, 4, 6, 8, 10, 12, 14, 16]\u001b[0m\n", - "\u001b[0;34m >>> wolfson_index = wolfson(income_distribution)\u001b[0m\n", - "\u001b[0;34m >>> print(f\"Wolfson Bipolarization Index: {wolfson_index:.4f}\")\u001b[0m\n", - "\u001b[0;34m Wolfson Bipolarization Index: 0.1528\u001b[0m\n", - "\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mincome_distribution\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0my_med\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmedian\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mordinate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlorenz_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0ml50\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minterp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mordinate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0md50\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m.5\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0ml50\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mrat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0my_med\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGini\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0md50\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mrat\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mFile:\u001b[0m ~/para/1_projects/code-pysal-inequality/inequality/inequality/wolfson.py\n", - "\u001b[0;31mType:\u001b[0m function" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "wolfson??" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "68a5c4e1-6a1b-4ed3-a69a-bb49b556d620", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 63bc6f431ea62a43d5fab441535340cc8917ec56 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 7 Nov 2024 14:36:44 -0800 Subject: [PATCH 18/32] prunning --- docs/user-guide/measure/decompositions.ipynb | 4873 ------------------ 1 file changed, 4873 deletions(-) delete mode 100644 docs/user-guide/measure/decompositions.ipynb diff --git a/docs/user-guide/measure/decompositions.ipynb b/docs/user-guide/measure/decompositions.ipynb deleted file mode 100644 index 44544ec3..00000000 --- a/docs/user-guide/measure/decompositions.ipynb +++ /dev/null @@ -1,4873 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Demonstrating the Gini Coefficient:\n", - "## Spatial Inequality in Mexico: 1940-2000\n", - "\n", - "1. Imports & Input Data\n", - "2. Classic Gini Coefficient\n", - "3. Spatial Gini Coefficient\n", - "\n", - "-------------------------\n", - "\n", - "### 1. Imports & Input Data" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:00:59.142457Z", - "start_time": "2023-01-17T02:00:59.104306Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Last updated: 2024-08-14T11:03:02.242653-07:00\n", - "\n", - "Python implementation: CPython\n", - "Python version : 3.12.4\n", - "IPython version : 8.26.0\n", - "\n", - "Compiler : GCC 12.3.0\n", - "OS : Linux\n", - "Release : 6.5.0-45-generic\n", - "Machine : x86_64\n", - "Processor : x86_64\n", - "CPU cores : 16\n", - "Architecture: 64bit\n", - "\n" - ] - } - ], - "source": [ - "%config InlineBackend.figure_format = \"retina\"\n", - "%load_ext watermark\n", - "%watermark" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.756177Z", - "start_time": "2023-01-17T02:00:59.145113Z" - } - }, - "outputs": [], - "source": [ - "import geopandas\n", - "import libpysal\n", - "import matplotlib.pyplot as plt\n", - "import numpy\n", - "\n", - "import inequality" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.770545Z", - "start_time": "2023-01-17T02:01:01.761777Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Watermark: 2.4.3\n", - "\n", - "matplotlib: 3.9.1\n", - "inequality: 0.1.dev136+gcb7fee0\n", - "geopandas : 1.0.1\n", - "numpy : 2.0.1\n", - "libpysal : 4.12.0\n", - "\n" - ] - } - ], - "source": [ - "%watermark -w\n", - "%watermark -iv" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.776633Z", - "start_time": "2023-01-17T02:01:01.772340Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mexico\n", - "======\n", - "\n", - "Decennial per capita incomes of Mexican states 1940-2000\n", - "--------------------------------------------------------\n", - "\n", - "* mexico.csv: attribute data. (n=32, k=13)\n", - "* mexico.gal: spatial weights in GAL format.\n", - "* mexicojoin.shp: Polygon shapefile. (n=32)\n", - "\n", - "Data used in Rey, S.J. and M.L. Sastre Gutierrez. (2010) \"Interregional inequality dynamics in Mexico.\" Spatial Economic Analysis, 5: 277-298.\n", - "\n" - ] - } - ], - "source": [ - "libpysal.examples.explain(\"mexico\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.962407Z", - "start_time": "2023-01-17T02:01:01.779047Z" - } - }, - "outputs": [], - "source": [ - "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", - "gdf = geopandas.read_file(pth)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.103640Z", - "start_time": "2023-01-17T02:01:01.964971Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 316, - "width": 515 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = gdf.plot()\n", - "ax.set_axis_off()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.138110Z", - "start_time": "2023-01-17T02:01:02.106331Z" - }, - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...GR9000LPCGDP40LPCGDP50LPCGDP60LPCGDP70LPCGDP80LPCGDP90LPCGDP00TESTgeometry
017.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...0.054.354.324.254.404.474.434.481.0MULTIPOLYGON (((-113.13972 29.01778, -113.2405...
127.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...0.003.984.204.224.394.464.414.422.0MULTIPOLYGON (((-111.20612 25.80278, -111.2302...
232.731957e+10MX18Nayarit1034770.3416.750785e+062731956.8594836.07515.07621.0...-0.053.683.883.884.044.134.114.063.0MULTIPOLYGON (((-106.62108 21.56531, -106.6475...
347.961008e+10MX14Jalisco2324727.4361.967200e+077961008.2855309.08232.09953.0...0.033.733.924.004.214.324.304.334.0POLYGON ((-101.5249 21.85664, -101.5883 21.772...
455.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...0.134.023.793.944.214.324.324.445.0POLYGON ((-101.8462 22.01176, -101.9653 21.883...
\n", - "

5 rows × 35 columns

\n", - "
" - ], - "text/plain": [ - " POLY_ID AREA CODE NAME PERIMETER \\\n", - "0 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", - "1 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", - "2 3 2.731957e+10 MX18 Nayarit 1034770.341 \n", - "3 4 7.961008e+10 MX14 Jalisco 2324727.436 \n", - "4 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", - "\n", - " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... GR9000 \\\n", - "0 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 0.05 \n", - "1 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 0.00 \n", - "2 6.750785e+06 2731956.859 4836.0 7515.0 7621.0 ... -0.05 \n", - "3 1.967200e+07 7961008.285 5309.0 8232.0 9953.0 ... 0.03 \n", - "4 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 0.13 \n", - "\n", - " LPCGDP40 LPCGDP50 LPCGDP60 LPCGDP70 LPCGDP80 LPCGDP90 LPCGDP00 TEST \\\n", - "0 4.35 4.32 4.25 4.40 4.47 4.43 4.48 1.0 \n", - "1 3.98 4.20 4.22 4.39 4.46 4.41 4.42 2.0 \n", - "2 3.68 3.88 3.88 4.04 4.13 4.11 4.06 3.0 \n", - "3 3.73 3.92 4.00 4.21 4.32 4.30 4.33 4.0 \n", - "4 4.02 3.79 3.94 4.21 4.32 4.32 4.44 5.0 \n", - "\n", - " geometry \n", - "0 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", - "1 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", - "2 MULTIPOLYGON (((-106.62108 21.56531, -106.6475... \n", - "3 POLYGON ((-101.5249 21.85664, -101.5883 21.772... \n", - "4 POLYGON ((-101.8462 22.01176, -101.9653 21.883... \n", - "\n", - "[5 rows x 35 columns]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gdf.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.975365Z", - "start_time": "2023-01-17T02:01:02.141021Z" - }, - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 337, - "width": 515 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = gdf.plot(column=\"PCGDP1940\", k=5, scheme=\"Quantiles\", legend=True)\n", - "ax.set_axis_off()\n", - "ax.set_title(\"PC GDP 1940\");\n", - "# plt.savefig(\"1940.png\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "------------------------------------------------\n", - "\n", - "### 2. Classic Gini Coefficient" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.985182Z", - "start_time": "2023-01-17T02:01:02.978350Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.3537237117345285)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gini_1940 = inequality.gini.Gini(gdf[\"PCGDP1940\"])\n", - "gini_1940.g" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.993505Z", - "start_time": "2023-01-17T02:01:02.988524Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "range(1940, 2010, 10)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "decades = range(1940, 2010, 10)\n", - "decades" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.010083Z", - "start_time": "2023-01-17T02:01:02.996515Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[np.float64(0.3537237117345285),\n", - " np.float64(0.29644613439022827),\n", - " np.float64(0.2537183285655905),\n", - " np.float64(0.25513356494927303),\n", - " np.float64(0.24505338049421577),\n", - " np.float64(0.25181825879538217),\n", - " np.float64(0.2581130824882791)]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", - "ginis" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "--------------------------------------\n", - "\n", - "### 3. Spatial Gini Coefficient" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.023820Z", - "start_time": "2023-01-17T02:01:03.017957Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "inequality.gini.Gini_Spatial" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inequality.gini.Gini_Spatial" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.029897Z", - "start_time": "2023-01-17T02:01:03.026482Z" - } - }, - "outputs": [], - "source": [ - "regimes = gdf[\"HANSON98\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.038550Z", - "start_time": "2023-01-17T02:01:03.032955Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "w = libpysal.weights.block_weights(regimes, silence_warnings=True)\n", - "w" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.201808Z", - "start_time": "2023-01-17T02:01:03.041647Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 337, - "width": 515 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = gdf.plot(column=\"HANSON98\", categorical=True)\n", - "ax.set_title(\"Regions\")\n", - "ax.set_axis_off()\n", - "# plt.savefig(\"regions.png\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.234210Z", - "start_time": "2023-01-17T02:01:03.204552Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.01)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.random.seed(12345)\n", - "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], w)\n", - "gs.p_sim" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.388274Z", - "start_time": "2023-01-17T02:01:03.237277Z" - } - }, - "outputs": [], - "source": [ - "gs_all = [\n", - " inequality.gini.Gini_Spatial(gdf[\"PCGDP%s\" % decade], w) for decade in decades\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.396504Z", - "start_time": "2023-01-17T02:01:03.391373Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[np.float64(0.04),\n", - " np.float64(0.01),\n", - " np.float64(0.01),\n", - " np.float64(0.01),\n", - " np.float64(0.02),\n", - " np.float64(0.01),\n", - " np.float64(0.01)]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p_values = [gs.p_sim for gs in gs_all]\n", - "p_values" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.404200Z", - "start_time": "2023-01-17T02:01:03.399458Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[np.float64(0.2940179879590452),\n", - " np.float64(0.24885041274552472),\n", - " np.float64(0.21715641601961586),\n", - " np.float64(0.2212882581200239),\n", - " np.float64(0.20702733316567423),\n", - " np.float64(0.21270360014540865),\n", - " np.float64(0.2190953550725723)]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wgs = [gs.wcg_share for gs in gs_all]\n", - "wgs" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.412352Z", - "start_time": "2023-01-17T02:01:03.407034Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[np.float64(0.7059820120409548),\n", - " np.float64(0.7511495872544753),\n", - " np.float64(0.7828435839803841),\n", - " np.float64(0.778711741879976),\n", - " np.float64(0.7929726668343258),\n", - " np.float64(0.7872963998545913),\n", - " np.float64(0.7809046449274277)]" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bgs = [1 - wg for wg in wgs]\n", - "bgs" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.419153Z", - "start_time": "2023-01-17T02:01:03.414765Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1940, 1950, 1960, 1970, 1980, 1990, 2000])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "years = numpy.array(decades)\n", - "years" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.733573Z", - "start_time": "2023-01-17T02:01:03.421484Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 469, - "width": 629 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax1 = plt.subplots()\n", - "t = years\n", - "s1 = ginis\n", - "ax1.plot(t, s1, \"b-\")\n", - "ax1.set_xlabel(\"Year\")\n", - "# Make the y-axis label, ticks and tick labels match the line color.\n", - "ax1.set_ylabel(\"Gini\", color=\"b\")\n", - "ax1.tick_params(\"y\", colors=\"b\")\n", - "\n", - "ax2 = ax1.twinx()\n", - "s2 = bgs\n", - "ax2.plot(t, s2, \"r-.\")\n", - "ax2.set_ylabel(\"Spatial Inequality Share\", color=\"r\")\n", - "ax2.tick_params(\"y\", colors=\"r\")\n", - "\n", - "fig.tight_layout()\n", - "\n", - "# plt.savefig(\"share.png\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "-----------------------" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "\n", - "\n", - "def cv_decomp(df, column, group):\n", - " y = df[column]\n", - " groups = df[group]\n", - " std = df[[column, group]].groupby(by=group).std(ddof=0)\n", - " ybar = df[[column, group]].groupby(by=group).mean()\n", - " n_g = df[[column, group]].groupby(by=group).count()\n", - " Y_bar = y.mean()\n", - " cv = y.std(ddof=0) / Y_bar\n", - "\n", - "\n", - " res = pd.concat([std, ybar, n_g], axis=1)\n", - " res.columns = ['s', 'ybar', 'n']\n", - " res['lam'] = res.n / res.n.sum()\n", - " res['b'] = res.ybar / df[column].mean()\n", - " res['omega'] = res.lam * res.b**2\n", - " res['y_dev'] = res.ybar - Y_bar\n", - " res['cv'] = res.s / res.ybar\n", - "\n", - " # Rosenbluth\n", - " V = cv\n", - " V2 = V * V\n", - " r_within = (res.cv * res.cv * res.ybar * res.ybar * res.n).sum()\n", - " r_between = (res.n * res.y_dev * res.y_dev).sum()\n", - " den = df.shape[0] * Y_bar * Y_bar\n", - " r_within /= den\n", - " r_between /= den\n", - " V2r = r_within + r_between\n", - " print(f'V2: {V2}, within: {r_within}, between: {r_between}, V2r: {V2r}')\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " return V*V, r_between, r_within, V2r" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "V2: 0.5020013737145368, within: 0.4286865118397805, between: 0.0733148618747563, V2r: 0.5020013737145368\n" - ] - }, - { - "data": { - "text/plain": [ - "(np.float64(0.5020013737145368),\n", - " np.float64(0.0733148618747563),\n", - " np.float64(0.4286865118397805),\n", - " np.float64(0.5020013737145368))" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cv_decomp(gdf, 'PCGDP1940', 'HANSON98')" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "y = gdf['PCGDP1940']\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "\n", - "def vol_decomp(df, column, group):\n", - " def gmean(values):\n", - " return np.prod(values)**(1/len(values))\n", - "\n", - " y = df[column]\n", - " n = df.shape[0]\n", - " df['ly'] = np.log(y)\n", - "\n", - "\n", - " Gmean = gmean(df.ly)\n", - "\n", - " grouped = df[['ly', group]].groupby(group)\n", - " Gmeans = grouped['ly'].apply(gmean)\n", - " diff = np.log(Gmeans) - np.log(Gmean)\n", - " diff2 = diff * diff\n", - " lam = df[['ly', group]].groupby(by=group).count() / n\n", - " between = (diff2.values * lam.values).sum()\n", - "\n", - "\n", - " group_var = df[['ly', group]].groupby(by=group).std(ddof=0)**2\n", - " within = (group_var.values * lam.values).sum()\n", - "\n", - "\n", - "\n", - " print(Gmean,Gmeans, diff2, lam, between, within, df['ly'].var(ddof=0))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "8.66124720968162 HANSON98\n", - "1.0 9.145681\n", - "2.0 8.759428\n", - "3.0 8.530656\n", - "4.0 8.922624\n", - "5.0 8.282520\n", - "Name: ly, dtype: float64 HANSON98\n", - "1.0 0.002962\n", - "2.0 0.000127\n", - "3.0 0.000231\n", - "4.0 0.000884\n", - "5.0 0.001999\n", - "Name: ly, dtype: float64 ly\n", - "HANSON98 \n", - "1.0 0.18750\n", - "2.0 0.21875\n", - "3.0 0.31250\n", - "4.0 0.06250\n", - "5.0 0.21875 0.0062028008997258 0.3009515466471512 0.3845017425430747\n" - ] - } - ], - "source": [ - "vol_decomp(gdf, 'PCGDP1940', 'HANSON98')" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "def pyatt_decomp(df, column, group):\n", - " df_short = df[[column, group]]\n", - " group_y = df_short.groupby(by=group).sum()\n", - " theta = group_y.values / group_y.values.sum()\n", - " M = df_short.groupby(by=group).mean()\n", - " group_n = df_short.groupby(by=group).count()\n", - " lam = group_n.values / df_short.shape[0]\n", - "\n", - " return group, theta, M, lam\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "('HANSON98',\n", - " array([[0.26993176],\n", - " [0.21554001],\n", - " [0.23618164],\n", - " [0.09172908],\n", - " [0.18661751]]),\n", - " PCGDP1940\n", - " HANSON98 \n", - " 1.0 10409.333333\n", - " 2.0 7124.428571\n", - " 3.0 5464.700000\n", - " 4.0 10612.000000\n", - " 5.0 6168.428571,\n", - " array([[0.1875 ],\n", - " [0.21875],\n", - " [0.3125 ],\n", - " [0.0625 ],\n", - " [0.21875]]))" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pyatt_decomp(gdf, 'PCGDP1940', 'HANSON98')" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "dfs = gdf[['PCGDP1940', 'HANSON98']]" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PCGDP1940
HANSON98
1.010409.333333
2.07124.428571
3.05464.700000
4.010612.000000
5.06168.428571
\n", - "
" - ], - "text/plain": [ - " PCGDP1940\n", - "HANSON98 \n", - "1.0 10409.333333\n", - "2.0 7124.428571\n", - "3.0 5464.700000\n", - "4.0 10612.000000\n", - "5.0 6168.428571" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfs.groupby(by='HANSON98').mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PCGDP1940HANSON98
022361.01.0
19573.02.0
24836.02.0
35309.03.0
410384.02.0
54359.03.0
611016.03.0
74414.03.0
83327.03.0
93408.04.0
1017816.04.0
116909.03.0
126936.03.0
137990.05.0
143758.05.0
153569.03.0
1621965.05.0
173605.03.0
182181.05.0
191892.05.0
202459.05.0
212934.05.0
226399.01.0
238578.01.0
248537.01.0
254840.02.0
2612132.02.0
273734.02.0
284372.02.0
299073.01.0
307508.01.0
315203.03.0
\n", - "
" - ], - "text/plain": [ - " PCGDP1940 HANSON98\n", - "0 22361.0 1.0\n", - "1 9573.0 2.0\n", - "2 4836.0 2.0\n", - "3 5309.0 3.0\n", - "4 10384.0 2.0\n", - "5 4359.0 3.0\n", - "6 11016.0 3.0\n", - "7 4414.0 3.0\n", - "8 3327.0 3.0\n", - "9 3408.0 4.0\n", - "10 17816.0 4.0\n", - "11 6909.0 3.0\n", - "12 6936.0 3.0\n", - "13 7990.0 5.0\n", - "14 3758.0 5.0\n", - "15 3569.0 3.0\n", - "16 21965.0 5.0\n", - "17 3605.0 3.0\n", - "18 2181.0 5.0\n", - "19 1892.0 5.0\n", - "20 2459.0 5.0\n", - "21 2934.0 5.0\n", - "22 6399.0 1.0\n", - "23 8578.0 1.0\n", - "24 8537.0 1.0\n", - "25 4840.0 2.0\n", - "26 12132.0 2.0\n", - "27 3734.0 2.0\n", - "28 4372.0 2.0\n", - "29 9073.0 1.0\n", - "30 7508.0 1.0\n", - "31 5203.0 3.0" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfs" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "groups = dfs.HANSON98.unique()" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1., 2., 3., 4., 5.])" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "groups" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "y1 = dfs[dfs.HANSON98==1.0].PCGDP1940.values" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "y2 = dfs[dfs.HANSON98==2.0].PCGDP1940.values" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([22361., 6399., 8578., 8537., 9073., 7508.])" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y1" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 9573., 4836., 10384., 4840., 12132., 3734., 4372.])" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y2" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([12788., 17525., 11977., 17521., 10229., 18627., 17989.])" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y1[0] - y2" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "d = y1[:, np.newaxis] - y2" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[12788., 17525., 11977., 17521., 10229., 18627., 17989.],\n", - " [ 0., 1563., 0., 1559., 0., 2665., 2027.],\n", - " [ 0., 3742., 0., 3738., 0., 4844., 4206.],\n", - " [ 0., 3701., 0., 3697., 0., 4803., 4165.],\n", - " [ 0., 4237., 0., 4233., 0., 5339., 4701.],\n", - " [ 0., 2672., 0., 2668., 0., 3774., 3136.]])" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.where(d <0 ,0, d)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(3284.904761904762)" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d.mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [], - "source": [ - "d12 = y1[:, np.newaxis] - y2" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [], - "source": [ - "d21 = y2[:, np.newaxis] - y1" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[12788., 17525., 11977., 17521., 10229., 18627., 17989.],\n", - " [-3174., 1563., -3985., 1559., -5733., 2665., 2027.],\n", - " [ -995., 3742., -1806., 3738., -3554., 4844., 4206.],\n", - " [-1036., 3701., -1847., 3697., -3595., 4803., 4165.],\n", - " [ -500., 4237., -1311., 4233., -3059., 5339., 4701.],\n", - " [-2065., 2672., -2876., 2668., -4624., 3774., 3136.]])" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d12\n" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[-12788., 3174., 995., 1036., 500., 2065.],\n", - " [-17525., -1563., -3742., -3701., -4237., -2672.],\n", - " [-11977., 3985., 1806., 1847., 1311., 2876.],\n", - " [-17521., -1559., -3738., -3697., -4233., -2668.],\n", - " [-10229., 5733., 3554., 3595., 3059., 4624.],\n", - " [-18627., -2665., -4844., -4803., -5339., -3774.],\n", - " [-17989., -2027., -4206., -4165., -4701., -3136.]])" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d21" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(956.1904761904761)" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.where(d21 < 0, 0, d21).mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [], - "source": [ - "import itertools\n", - "\n", - "\n", - "def E(df, column, group):\n", - " y = df[[column, group]]\n", - " groups = df[group].unique()\n", - " k = groups.shape[0]\n", - " E = np.zeros((k,k))\n", - " for pair in itertools.permutations(groups, 2):\n", - " row, col= (np.where(groups == c)[0] for c in pair)\n", - " i, j = pair\n", - "\n", - " yi = y[y[group]==i][column].values\n", - " yj = y[y[group]==j][column].values\n", - " dij = yi[:, np.newaxis] - yj\n", - " E[row, col] = np.where(dij < 0, 0, dij).mean()\n", - " dij *= -1\n", - " E[col, row] = np.where(dij < 0, 0, dij).mean()\n", - " for j in groups:\n", - " i = np.where(groups == j)[0]\n", - " yi = y[y[group]==j][column].values\n", - "\n", - " dii = yi[:, np.newaxis] - yi\n", - "\n", - " E[i, i] = np.where(dii < 0, 0, dii).mean()\n", - " return E\n" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [], - "source": [ - "e = E(gdf, 'PCGDP1940', 'HANSON98')" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[2348.5 , 4241.0952381 , 5211.83333333, 3879.41666667,\n", - " 5950.5 ],\n", - " [ 956.19047619, 1712.44897959, 2459.78571429, 1858.21428571,\n", - " 3365.91836735],\n", - " [ 267.2 , 800.05714286, 1129.29 , 1032.4 ,\n", - " 2068.48571429],\n", - " [4082.08333333, 5345.78571429, 6179.7 , 3602. ,\n", - " 6417.71428571],\n", - " [1709.5952381 , 2409.91836735, 2772.21428571, 1974.14285714,\n", - " 2985.14285714]])" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "e" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [], - "source": [ - "y = np.array([10, 20, 30, 80])" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [], - "source": [ - "d =y[:, np.newaxis] - y" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0, -10, -20, -70],\n", - " [ 10, 0, -10, -60],\n", - " [ 20, 10, 0, -50],\n", - " [ 70, 60, 50, 0]])" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "d" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(13.75)" - ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.where(d < 0, 0, d).mean()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$G = (m'p)^{-1} p'Ep$" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [], - "source": [ - "def pyatt_decomp(df, column, group):\n", - " y = df[[column, group]]\n", - " groups = df[group].unique()\n", - " k = groups.shape[0]\n", - " E = np.zeros((k,k))\n", - " for pair in itertools.permutations(groups, 2):\n", - " row, col= (np.where(groups == c)[0] for c in pair)\n", - " i, j = pair\n", - "\n", - " yi = y[y[group]==i][column].values\n", - " yj = y[y[group]==j][column].values\n", - " dij = yi[:, np.newaxis] - yj\n", - " E[row, col] = np.where(dij < 0, 0, dij).mean()\n", - " dij *= -1\n", - " E[col, row] = np.where(dij < 0, 0, dij).mean()\n", - " for j in groups:\n", - " i = np.where(groups == j)[0]\n", - " yi = y[y[group]==j][column].values\n", - "\n", - " dii = yi[:, np.newaxis] - yi\n", - "\n", - " E[i, i] = np.where(dii < 0, 0, dii).mean()\n", - "\n", - " p = y.groupby(by=group).count() / y.shape[0]\n", - " m = y.groupby(by=group).mean()\n", - " G = (p.values * m.values).sum()\n", - " res = {}\n", - " res['p'] = p.values\n", - " res['m'] = m.values\n", - " res['E'] = E\n", - " return res\n", - "\n", - "res = pyatt_decomp(gdf, 'PCGDP1940', 'HANSON98')" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [], - "source": [ - "m = res['m']\n", - "p = res['p']\n", - "E = res['E']" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(7230.53125)" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(m*p).sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.1875 ],\n", - " [0.21875],\n", - " [0.3125 ],\n", - " [0.0625 ],\n", - " [0.21875]])" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.1875 , 0.21875, 0.3125 , 0.0625 , 0.21875]])" - ] - }, - "execution_count": 59, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p.T\n" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.35372371]])" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.dot(np.dot(p.T, E), p)/ (m*p).sum() # Gini" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [], - "source": [ - "from inequality.gini import Gini" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.3537237117345285)" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Gini(gdf.PCGDP1940).g" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'0.1.dev136+gcb7fee0'" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inequality.__version__" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [], - "source": [ - "import libpysal" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'4.12.0'" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "libpysal.__version__" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overlap" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PCGDP1940HANSON98
022361.01.0
19573.02.0
24836.02.0
35309.03.0
410384.02.0
54359.03.0
611016.03.0
74414.03.0
83327.03.0
93408.04.0
1017816.04.0
116909.03.0
126936.03.0
137990.05.0
143758.05.0
153569.03.0
1621965.05.0
173605.03.0
182181.05.0
191892.05.0
202459.05.0
212934.05.0
226399.01.0
238578.01.0
248537.01.0
254840.02.0
2612132.02.0
273734.02.0
284372.02.0
299073.01.0
307508.01.0
315203.03.0
\n", - "
" - ], - "text/plain": [ - " PCGDP1940 HANSON98\n", - "0 22361.0 1.0\n", - "1 9573.0 2.0\n", - "2 4836.0 2.0\n", - "3 5309.0 3.0\n", - "4 10384.0 2.0\n", - "5 4359.0 3.0\n", - "6 11016.0 3.0\n", - "7 4414.0 3.0\n", - "8 3327.0 3.0\n", - "9 3408.0 4.0\n", - "10 17816.0 4.0\n", - "11 6909.0 3.0\n", - "12 6936.0 3.0\n", - "13 7990.0 5.0\n", - "14 3758.0 5.0\n", - "15 3569.0 3.0\n", - "16 21965.0 5.0\n", - "17 3605.0 3.0\n", - "18 2181.0 5.0\n", - "19 1892.0 5.0\n", - "20 2459.0 5.0\n", - "21 2934.0 5.0\n", - "22 6399.0 1.0\n", - "23 8578.0 1.0\n", - "24 8537.0 1.0\n", - "25 4840.0 2.0\n", - "26 12132.0 2.0\n", - "27 3734.0 2.0\n", - "28 4372.0 2.0\n", - "29 9073.0 1.0\n", - "30 7508.0 1.0\n", - "31 5203.0 3.0" - ] - }, - "execution_count": 66, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfs" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [], - "source": [ - "def overlapping(dfs, column, group, group_a, group_b):\n", - " a = dfs[dfs[group] == group_a]\n", - " b = dfs[dfs[group] == group_b]\n", - " a_min = a[column].min()\n", - " a_max = a[column].max()\n", - " b_min = b[column].min()\n", - " b_max = b[column].max()\n", - " print(a_min, a_max)\n", - " print(b_min, b_max)\n", - "\n", - " if a_min > b_max:\n", - " return False\n", - " if b_min > a_max:\n", - " return False\n", - " if a_min >= b_min:\n", - " return True\n", - " if b_min >= a_min:\n", - " return True\n", - " return False\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6399.0 22361.0\n", - "3734.0 12132.0\n" - ] - }, - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "overlapping(dfs, 'PCGDP1940', 'HANSON98', 1.0, 2.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6399.0 22361.0\n", - "3734.0 12132.0\n", - "1 2 True\n", - "6399.0 22361.0\n", - "3327.0 11016.0\n", - "1 3 True\n", - "6399.0 22361.0\n", - "3408.0 17816.0\n", - "1 4 True\n", - "6399.0 22361.0\n", - "1892.0 21965.0\n", - "1 5 True\n", - "3734.0 12132.0\n", - "3327.0 11016.0\n", - "2 3 True\n", - "3734.0 12132.0\n", - "3408.0 17816.0\n", - "2 4 True\n", - "3734.0 12132.0\n", - "1892.0 21965.0\n", - "2 5 True\n", - "3327.0 11016.0\n", - "3408.0 17816.0\n", - "3 4 True\n", - "3327.0 11016.0\n", - "1892.0 21965.0\n", - "3 5 True\n", - "3408.0 17816.0\n", - "1892.0 21965.0\n", - "4 5 True\n" - ] - } - ], - "source": [ - "for i in range(1, 5):\n", - " for j in range(i+1, 6):\n", - " res = overlapping(dfs, 'PCGDP1940', 'HANSON98', i*1.0, j*1.0)\n", - " print(i,j, res)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Ordering the groups" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PCGDP1940
HANSON98
1.06399.0
2.03734.0
3.03327.0
4.03408.0
5.01892.0
\n", - "
" - ], - "text/plain": [ - " PCGDP1940\n", - "HANSON98 \n", - "1.0 6399.0\n", - "2.0 3734.0\n", - "3.0 3327.0\n", - "4.0 3408.0\n", - "5.0 1892.0" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfs.groupby(by='HANSON98').min()" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PCGDP1940
HANSON98
1.022361.0
2.012132.0
3.011016.0
4.017816.0
5.021965.0
\n", - "
" - ], - "text/plain": [ - " PCGDP1940\n", - "HANSON98 \n", - "1.0 22361.0\n", - "2.0 12132.0\n", - "3.0 11016.0\n", - "4.0 17816.0\n", - "5.0 21965.0" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfs.groupby(by='HANSON98').max()" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PCGDP1940
HANSON98
1.08557.5
2.04840.0
3.04808.5
4.010612.0
5.02934.0
\n", - "
" - ], - "text/plain": [ - " PCGDP1940\n", - "HANSON98 \n", - "1.0 8557.5\n", - "2.0 4840.0\n", - "3.0 4808.5\n", - "4.0 10612.0\n", - "5.0 2934.0" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfs.groupby(by='HANSON98').median()" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " region_pair abs_deviation\n", - "0 (A, A) 10000\n", - "1 (A, B) 40000\n", - "2 (A, C) 20000\n", - "3 (B, B) 15000\n", - "4 (B, C) 15000\n" - ] - } - ], - "source": [ - "# Example DataFrame\n", - "data = {\n", - " 'income': [50000, 60000, 55000, 70000, 65000],\n", - " 'region': ['A', 'A', 'B', 'B', 'C']\n", - "}\n", - "df = pd.DataFrame(data)\n", - "\n", - "# Create all possible pairs of observations (including those within the same region)\n", - "pairs = list(itertools.combinations(df.index, 2))\n", - "\n", - "# Calculate the absolute deviations and region pairs\n", - "deviation_data = []\n", - "\n", - "for i, j in pairs:\n", - " income_i = df.loc[i, 'income']\n", - " income_j = df.loc[j, 'income']\n", - " region_i = df.loc[i, 'region']\n", - " region_j = df.loc[j, 'region']\n", - " abs_deviation = abs(income_i - income_j)\n", - " deviation_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - "# Create a DataFrame from the deviation data\n", - "deviation_df = pd.DataFrame(deviation_data)\n", - "\n", - "# Sum the absolute deviations grouped by region pairs (including own region pairs)\n", - "result = deviation_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "\n", - "\n", - "# Display the result\n", - "print(result)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " region_pair abs_deviation\n", - "0 (A, A) 8000\n", - "1 (A, B) 29000\n", - "2 (A, C) 270000\n", - "3 (B, B) 8000\n", - "4 (B, C) 243000\n", - "5 (C, C) 8000\n" - ] - } - ], - "source": [ - "import itertools\n", - "\n", - "import pandas as pd\n", - "\n", - "# Create a DataFrame with three regions and overlapping/non-overlapping income ranges\n", - "data = {\n", - " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", - " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", - "}\n", - "df = pd.DataFrame(data)\n", - "\n", - "# Create all possible pairs of observations (including those within the same region)\n", - "pairs = list(itertools.combinations(df.index, 2))\n", - "\n", - "# Calculate the absolute deviations and region pairs\n", - "deviation_data = []\n", - "\n", - "for i, j in pairs:\n", - " income_i = df.loc[i, 'income']\n", - " income_j = df.loc[j, 'income']\n", - " region_i = df.loc[i, 'region']\n", - " region_j = df.loc[j, 'region']\n", - " abs_deviation = abs(income_i - income_j)\n", - " deviation_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - "# Create a DataFrame from the deviation data\n", - "deviation_df = pd.DataFrame(deviation_data)\n", - "\n", - "# Sum the absolute deviations grouped by region pairs (including own region pairs)\n", - "result = deviation_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "\n", - "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Sum of Absolute Deviations by Region Pairs (Including Own Region Pairs)\", dataframe=result)\n", - "\n", - "# Display the result\n", - "print(result)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
income
region
A50000
B53000
C80000
\n", - "
" - ], - "text/plain": [ - " income\n", - "region \n", - "A 50000\n", - "B 53000\n", - "C 80000" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.groupby('region').min()" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
minmax
region
A5000054000
B5300057000
C8000084000
\n", - "
" - ], - "text/plain": [ - " min max\n", - "region \n", - "A 50000 54000\n", - "B 53000 57000\n", - "C 80000 84000" - ] - }, - "execution_count": 76, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.groupby('region')['income'].agg(['min', 'max'])" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "All Absolute Deviations\n", - " region_pair abs_deviation\n", - "0 (A, B) 20000\n", - "1 (A, C) 270000\n", - "2 (B, C) 243000\n", - "Non-Overlapping Absolute Deviations:\n", - " region_pair abs_deviation\n", - "0 (A, B) 20000\n", - "1 (A, C) 270000\n", - "2 (B, C) 243000\n", - "\n", - "Overlapping Absolute Deviations:\n", - " region_pair abs_deviation\n", - "0 (A, A) 8000\n", - "1 (A, B) 9000\n", - "2 (B, B) 8000\n", - "3 (C, C) 8000\n" - ] - } - ], - "source": [ - "import itertools\n", - "\n", - "import pandas as pd\n", - "\n", - "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", - "data = {\n", - " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", - " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", - "}\n", - "df = pd.DataFrame(data)\n", - "\n", - "# Calculate the range of incomes for each region\n", - "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", - "income_range['range'] = income_range['max'] - income_range['min']\n", - "\n", - "# Create all possible pairs of observations (including those within the same region)\n", - "pairs = list(itertools.combinations(df.index, 2))\n", - "\n", - "# Initialize accumulators\n", - "non_overlapping_data = []\n", - "overlapping_data = []\n", - "all_data = []\n", - "# Calculate the absolute deviations and classify them\n", - "for i, j in pairs:\n", - " income_i = df.loc[i, 'income']\n", - " income_j = df.loc[j, 'income']\n", - " region_i = df.loc[i, 'region']\n", - " region_j = df.loc[j, 'region']\n", - " abs_deviation = abs(income_i - income_j)\n", - "\n", - " range_i_min = income_range.loc[region_i, 'min']\n", - " range_i_max = income_range.loc[region_i, 'max']\n", - " range_j_min = income_range.loc[region_j, 'min']\n", - " range_j_max = income_range.loc[region_j, 'max']\n", - "\n", - " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", - " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - " else:\n", - " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - "# Create DataFrames from the deviation data\n", - "all_df = pd.DataFrame(all_data)\n", - "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", - "overlapping_df = pd.DataFrame(overlapping_data)\n", - "\n", - "# Sum the absolute deviations grouped by region pairs\n", - "all_data_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "\n", - "\n", - "# Display the results\n", - "print(\"All Absolute Deviations\")\n", - "print(all_data_result)\n", - "print(\"Non-Overlapping Absolute Deviations:\")\n", - "print(non_overlapping_result)\n", - "print(\"\\nOverlapping Absolute Deviations:\")\n", - "print(overlapping_result)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " region_pair abs_deviation\n", - "0 (A, A) 8000\n", - "1 (A, B) 29000\n", - "2 (A, C) 270000\n", - "3 (B, B) 8000\n", - "4 (B, C) 243000\n", - "5 (C, C) 8000\n", - " region_pair abs_deviation\n", - "0 (A, B) 20000\n", - "1 (A, C) 270000\n", - "2 (B, C) 243000\n", - " region_pair abs_deviation\n", - "0 (A, A) 8000\n", - "1 (A, B) 9000\n", - "2 (B, B) 8000\n", - "3 (C, C) 8000\n" - ] - } - ], - "source": [ - "import itertools\n", - "\n", - "import pandas as pd\n", - "\n", - "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", - "data = {\n", - " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", - " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", - "}\n", - "df = pd.DataFrame(data)\n", - "\n", - "# Calculate the range of incomes for each region\n", - "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", - "income_range['range'] = income_range['max'] - income_range['min']\n", - "\n", - "# Create all possible pairs of observations (including those within the same region)\n", - "pairs = list(itertools.combinations(df.index, 2))\n", - "\n", - "# Initialize accumulators\n", - "non_overlapping_data = []\n", - "overlapping_data = []\n", - "all_data = []\n", - "\n", - "# Calculate the absolute deviations and classify them\n", - "for i, j in pairs:\n", - " income_i = df.loc[i, 'income']\n", - " income_j = df.loc[j, 'income']\n", - " region_i = df.loc[i, 'region']\n", - " region_j = df.loc[j, 'region']\n", - " abs_deviation = abs(income_i - income_j)\n", - "\n", - " range_i_min = income_range.loc[region_i, 'min']\n", - " range_i_max = income_range.loc[region_i, 'max']\n", - " range_j_min = income_range.loc[region_j, 'min']\n", - " range_j_max = income_range.loc[region_j, 'max']\n", - "\n", - " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", - " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - " else:\n", - " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - "# Create DataFrames from the deviation data\n", - "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", - "overlapping_df = pd.DataFrame(overlapping_data)\n", - "all_data_df = pd.DataFrame(all_data)\n", - "\n", - "# Sum the absolute deviations grouped by region pairs\n", - "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "all_data_result = all_data_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "import itertools\n", - "\n", - "import pandas as pd\n", - "\n", - "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", - "data = {\n", - " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", - " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", - "}\n", - "df = pd.DataFrame(data)\n", - "\n", - "# Calculate the range of incomes for each region\n", - "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", - "income_range['range'] = income_range['max'] - income_range['min']\n", - "\n", - "# Create all possible pairs of observations (including those within the same region)\n", - "pairs = list(itertools.combinations(df.index, 2))\n", - "\n", - "# Initialize accumulators\n", - "non_overlapping_data = []\n", - "overlapping_data = []\n", - "all_data = []\n", - "\n", - "# Calculate the absolute deviations and classify them\n", - "for i, j in pairs:\n", - " income_i = df.loc[i, 'income']\n", - " income_j = df.loc[j, 'income']\n", - " region_i = df.loc[i, 'region']\n", - " region_j = df.loc[j, 'region']\n", - " abs_deviation = abs(income_i - income_j)\n", - "\n", - " range_i_min = income_range.loc[region_i, 'min']\n", - " range_i_max = income_range.loc[region_i, 'max']\n", - " range_j_min = income_range.loc[region_j, 'min']\n", - " range_j_max = income_range.loc[region_j, 'max']\n", - "\n", - " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", - " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - " else:\n", - " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - "# Create DataFrames from the deviation data\n", - "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", - "overlapping_df = pd.DataFrame(overlapping_data)\n", - "all_data_df = pd.DataFrame(all_data)\n", - "\n", - "# Sum the absolute deviations grouped by region pairs\n", - "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "all_data_result = all_data_df.groupby('region_pair')['abs_deviation'].sum().reset_index()\n", - "\n", - "print(all_data_result)\n", - "print(non_overlapping_result)\n", - "print(overlapping_result)" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Non-Overlapping Absolute Deviations:\n", - " region_pair sum count\n", - "0 (A, B) 20000 4\n", - "1 (A, C) 270000 9\n", - "2 (B, C) 243000 9\n", - "\n", - "Overlapping Absolute Deviations:\n", - " region_pair sum count\n", - "0 (A, A) 8000 3\n", - "1 (A, B) 9000 5\n", - "2 (B, B) 8000 3\n", - "3 (C, C) 8000 3\n", - "\n", - "All Absolute Deviations:\n", - " region_pair sum count\n", - "0 (A, A) 8000 3\n", - "1 (A, B) 29000 9\n", - "2 (A, C) 270000 9\n", - "3 (B, B) 8000 3\n", - "4 (B, C) 243000 9\n", - "5 (C, C) 8000 3\n" - ] - } - ], - "source": [ - "import itertools\n", - "\n", - "import pandas as pd\n", - "\n", - "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", - "data = {\n", - " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", - " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", - "}\n", - "df = pd.DataFrame(data)\n", - "\n", - "# Calculate the range of incomes for each region\n", - "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", - "income_range['range'] = income_range['max'] - income_range['min']\n", - "\n", - "# Create all possible pairs of observations (including those within the same region)\n", - "pairs = list(itertools.combinations(df.index, 2))\n", - "\n", - "# Initialize accumulators\n", - "non_overlapping_data = []\n", - "overlapping_data = []\n", - "all_data = []\n", - "\n", - "# Calculate the absolute deviations and classify them\n", - "for i, j in pairs:\n", - " income_i = df.loc[i, 'income']\n", - " income_j = df.loc[j, 'income']\n", - " region_i = df.loc[i, 'region']\n", - " region_j = df.loc[j, 'region']\n", - " abs_deviation = abs(income_i - income_j)\n", - "\n", - " range_i_min = income_range.loc[region_i, 'min']\n", - " range_i_max = income_range.loc[region_i, 'max']\n", - " range_j_min = income_range.loc[region_j, 'min']\n", - " range_j_max = income_range.loc[region_j, 'max']\n", - "\n", - " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", - " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - " else:\n", - " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - "# Create DataFrames from the deviation data\n", - "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", - "overlapping_df = pd.DataFrame(overlapping_data)\n", - "all_data_df = pd.DataFrame(all_data)\n", - "\n", - "# Sum the absolute deviations and count the number of pairs grouped by region pairs\n", - "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", - "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", - "all_data_result = all_data_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", - "\n", - "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Non-Overlapping Absolute Deviations by Region Pairs\", dataframe=non_overlapping_result)\n", - "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Overlapping Absolute Deviations by Region Pairs\", dataframe=overlapping_result)\n", - "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"All Absolute Deviations by Region Pairs\", dataframe=all_data_result)\n", - "\n", - "# Display the results\n", - "print(\"Non-Overlapping Absolute Deviations:\")\n", - "print(non_overlapping_result)\n", - "print(\"\\nOverlapping Absolute Deviations:\")\n", - "print(overlapping_result)\n", - "print(\"\\nAll Absolute Deviations:\")\n", - "print(all_data_result)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3222.222222222222" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "29000/9 # MAD A,B" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3222.222222222222" - ] - }, - "execution_count": 81, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "5/9 * 9000/5 + 4/9 * 20000/4 # weight average MAD A,B overlapping and non overlapping" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1800.0, 5000.0)" - ] - }, - "execution_count": 82, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "9000/5, 20000/4 # MAD AB overlapping, MAD AB nonoverlapping" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.11091514795218499)" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inequality.gini.Gini(df.income).g" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(63000.0), 9)" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mu = df.income.mean()\n", - "n = df.shape[0]\n", - "mu,n" - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
region_pairsumcount
0(A, A)80003
1(A, B)290009
2(A, C)2700009
3(B, B)80003
4(B, C)2430009
5(C, C)80003
\n", - "
" - ], - "text/plain": [ - " region_pair sum count\n", - "0 (A, A) 8000 3\n", - "1 (A, B) 29000 9\n", - "2 (A, C) 270000 9\n", - "3 (B, B) 8000 3\n", - "4 (B, C) 243000 9\n", - "5 (C, C) 8000 3" - ] - }, - "execution_count": 85, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "all_data_result" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.11091514795218499)" - ] - }, - "execution_count": 86, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "all_data_result['sum'].sum() / (mu *n**2) # gini" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.int64(566000)" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "all_data_result['sum'].sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.int64(566000)" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "non_overlapping_result['sum'].sum() + overlapping_result['sum'].sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Non-Overlapping Absolute Deviations:\n", - " region_pair sum count\n", - "0 (A, B) 20000 4\n", - "1 (A, C) 270000 9\n", - "2 (B, C) 243000 9\n", - "\n", - "Overlapping Absolute Deviations:\n", - " region_pair sum count\n", - "0 (A, A) 8000 3\n", - "1 (A, B) 9000 5\n", - "2 (B, B) 8000 3\n", - "3 (C, C) 8000 3\n", - "\n", - "All Absolute Deviations:\n", - " region_pair sum count\n", - "0 (A, A) 8000 3\n", - "1 (A, B) 29000 9\n", - "2 (A, C) 270000 9\n", - "3 (B, B) 8000 3\n", - "4 (B, C) 243000 9\n", - "5 (C, C) 8000 3\n", - "region_pair (A, A)\n", - "sum 8000\n", - "count 3\n", - "Name: 0, dtype: object\n", - "region_pair (A, B)\n", - "sum 9000\n", - "count 5\n", - "Name: 1, dtype: object\n", - "region_pair (B, B)\n", - "sum 8000\n", - "count 3\n", - "Name: 2, dtype: object\n", - "region_pair (C, C)\n", - "sum 8000\n", - "count 3\n", - "Name: 3, dtype: object\n", - "\n", - " AD Sum Matrix:\n", - "[[ 8000. 20000. 270000.]\n", - " [ 9000. 8000. 243000.]\n", - " [ 0. 0. 8000.]]\n", - "\n", - " AD Pairs Matrix:\n", - "[[3. 4. 9.]\n", - " [5. 3. 9.]\n", - " [0. 0. 3.]]\n" - ] - } - ], - "source": [ - "import itertools\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "# Create the DataFrame with three regions and overlapping/non-overlapping income ranges\n", - "data = {\n", - " 'income': [50000, 52000, 54000, 53000, 55000, 57000, 80000, 82000, 84000],\n", - " 'region': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']\n", - "}\n", - "df = pd.DataFrame(data)\n", - "\n", - "# Calculate the range of incomes for each region\n", - "income_range = df.groupby('region')['income'].agg(['min', 'max'])\n", - "income_range['range'] = income_range['max'] - income_range['min']\n", - "\n", - "# Create all possible pairs of observations (including those within the same region)\n", - "pairs = list(itertools.combinations(df.index, 2))\n", - "\n", - "# Initialize accumulators\n", - "non_overlapping_data = []\n", - "overlapping_data = []\n", - "all_data = []\n", - "\n", - "# Calculate the absolute deviations and classify them\n", - "for i, j in pairs:\n", - " income_i = df.loc[i, 'income']\n", - " income_j = df.loc[j, 'income']\n", - " region_i = df.loc[i, 'region']\n", - " region_j = df.loc[j, 'region']\n", - " abs_deviation = abs(income_i - income_j)\n", - "\n", - " range_i_min = income_range.loc[region_i, 'min']\n", - " range_i_max = income_range.loc[region_i, 'max']\n", - " range_j_min = income_range.loc[region_j, 'min']\n", - " range_j_max = income_range.loc[region_j, 'max']\n", - "\n", - " all_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - " if (income_i < range_j_min or income_i > range_j_max) and (income_j < range_i_min or income_j > range_i_max):\n", - " non_overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - " else:\n", - " overlapping_data.append({'region_pair': (region_i, region_j), 'abs_deviation': abs_deviation})\n", - "\n", - "# Create DataFrames from the deviation data\n", - "non_overlapping_df = pd.DataFrame(non_overlapping_data)\n", - "overlapping_df = pd.DataFrame(overlapping_data)\n", - "all_data_df = pd.DataFrame(all_data)\n", - "\n", - "# Sum the absolute deviations and count the number of pairs grouped by region pairs\n", - "non_overlapping_result = non_overlapping_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", - "overlapping_result = overlapping_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", - "all_data_result = all_data_df.groupby('region_pair')['abs_deviation'].agg(['sum', 'count']).reset_index()\n", - "\n", - "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Non-Overlapping Absolute Deviations by Region Pairs\", dataframe=non_overlapping_result)\n", - "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"Overlapping Absolute Deviations by Region Pairs\", dataframe=overlapping_result)\n", - "#import ace_tools as tools; tools.display_dataframe_to_user(name=\"All Absolute Deviations by Region Pairs\", dataframe=all_data_result)\n", - "\n", - "# Display the results\n", - "print(\"Non-Overlapping Absolute Deviations:\")\n", - "print(non_overlapping_result)\n", - "print(\"\\nOverlapping Absolute Deviations:\")\n", - "print(overlapping_result)\n", - "print(\"\\nAll Absolute Deviations:\")\n", - "print(all_data_result)\n", - "\n", - "# Create a numpy matrix for overlapping deviations along the diagonal\n", - "regions = df['region'].unique()\n", - "num_regions = len(regions)\n", - "matrix = np.zeros((num_regions, num_regions))\n", - "count = np.zeros_like(matrix)\n", - "\n", - "region_to_index = {region: idx for idx, region in enumerate(regions)}\n", - "\n", - "for idx, row in overlapping_result.iterrows():\n", - " print(row)\n", - " region_pair = row['region_pair']\n", - " abs_deviation_sum = row['sum']\n", - " npair = row['count']\n", - " if region_pair[0] == region_pair[1]:\n", - " region_idx = region_to_index[region_pair[0]]\n", - " matrix[region_idx, region_idx] = abs_deviation_sum\n", - " count[region_idx, region_idx] = npair\n", - " else:\n", - " region_j = region_to_index[region_pair[1]]\n", - " region_i = region_to_index[region_pair[0]]\n", - " matrix[region_j, region_i] = abs_deviation_sum\n", - " count[region_j, region_i] = npair\n", - "\n", - "for idx, row in non_overlapping_result.iterrows():\n", - " region_pair = row['region_pair']\n", - " abs_deviation_sum = row['sum']\n", - " npair = row['count']\n", - "\n", - " region_j = region_to_index[region_pair[1]]\n", - " region_i = region_to_index[region_pair[0]]\n", - " matrix[region_i, region_j] = abs_deviation_sum\n", - " count[region_i, region_j] = npair\n", - "\n", - "print(\"\\n AD Sum Matrix:\")\n", - "print(matrix)\n", - "print(\"\\n AD Pairs Matrix:\")\n", - "print(count)" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(566000.0)" - ] - }, - "execution_count": 90, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "matrix.sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.int64(566000)" - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "all_data_result['sum'].sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 92, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(24000.0)" - ] - }, - "execution_count": 92, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "matrix.diagonal().sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 93, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(533000.0)" - ] - }, - "execution_count": 93, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.triu(matrix, k=1).sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(24000.0), np.float64(533000.0), np.float64(9000.0))" - ] - }, - "execution_count": 94, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "within_ad = matrix.diagonal().sum()\n", - "between_ad = np.triu(matrix, k=1).sum()\n", - "overlap_ad = np.triu(matrix.T, k=1).sum()\n", - "within_ad, between_ad, overlap_ad" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 8000., 20000., 270000.],\n", - " [ 9000., 8000., 243000.],\n", - " [ 0., 0., 8000.]])" - ] - }, - "execution_count": 95, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "matrix" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.True_" - ] - }, - "execution_count": 96, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "matrix.sum() == within_ad + between_ad + overlap_ad" - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 97, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(2+3+1)/7 == 2/7 + 3/7 + 1/7" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.857142857142857" - ] - }, - "execution_count": 98, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2/7 + 3/7 + 1/7" - ] - }, - { - "cell_type": "code", - "execution_count": 99, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.8571428571428571" - ] - }, - "execution_count": 99, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(2+3+1)/7" - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(36.0)" - ] - }, - "execution_count": 100, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "count.sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.float64(9.0), np.float64(22.0), np.float64(5.0))" - ] - }, - "execution_count": 101, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "within_pairs = count.diagonal().sum()\n", - "between_pairs = np.triu(count, k=1).sum()\n", - "overlap_pairs = np.triu(count.T, k=1).sum()\n", - "within_pairs, between_pairs, overlap_pairs" - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "metadata": {}, - "outputs": [], - "source": [ - "ads = within_ad, between_ad ,overlap_ad\n", - "pairs = within_pairs, between_pairs, overlap_pairs" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[np.float64(2666.6666666666665),\n", - " np.float64(24227.272727272728),\n", - " np.float64(1800.0)]" - ] - }, - "execution_count": 103, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "[ad/c for ad,c in zip(ads,pairs, strict=False)] # MAD by type" - ] - }, - { - "cell_type": "code", - "execution_count": 104, - "metadata": {}, - "outputs": [], - "source": [ - "ads = np.array([within_ad, between_ad ,overlap_ad])" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 24000., 533000., 9000.])" - ] - }, - "execution_count": 105, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ads" - ] - }, - { - "cell_type": "code", - "execution_count": 106, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.11091514795218499)" - ] - }, - "execution_count": 106, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ads.sum() / (mu * n**2)" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "metadata": {}, - "outputs": [], - "source": [ - "den = mu * n**2" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.00470312, 0.10444836, 0.00176367])" - ] - }, - "execution_count": 108, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ads/den" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.11091514795218499)" - ] - }, - "execution_count": 109, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(ads/den).sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.04240283, 0.94169611, 0.01590106])" - ] - }, - "execution_count": 110, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ads/den / (ads/den).sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 111, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.9999999999999999)" - ] - }, - "execution_count": 111, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(ads/den / (ads/den).sum()).sum()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Extensions\n", - "\n", - "- put the regions on a map :->\n", - "- count of pairs that are neighbors versus non-neighbors\n", - "- is overlap more frequent for regions that are neighbors?\n", - "- i think there is another decomposition here." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Bidecomposition of the Gini\n", - "\n", - "The Gini as \n", - "\n", - "$$\n", - "G = \\frac{\\sum_{i=1}^{n} \\sum_{j=1}^{n} |x_i - x_j|}{2n^2 \\mu}\n", - "$$\n", - "\n", - "with\n", - "\n", - "$$\n", - "\\mu = \\frac{1}{n} \\sum_{i=1}^{n} x_i.\n", - "$$\n", - "\n", - "\n", - "Focusing on the double summation of the absolute deviations, we can decompose this into two parts, deviations involving pairs of observations from the same region, and deviations involving pairs from different regions:\n", - "\n", - "$$\n", - "\\sum_{i=1}^{n} \\sum_{j=1}^{n} |x_i - x_j| = \\sum_i \\sum_i \\mathbb{I}_{i,j} |x_i - x_j| + \\overline{\\mathbb{I}}_{i,j} |x_i - x_j| \n", - "$$\n", - "\n", - "where\n", - "\n", - "$$\n", - "\\mathbb{I}_{i,j}\\{ \\text{region}(i) = \\text{region}(j) \\}\n", - "$$\n", - "and\n", - "\n", - "$$\n", - "\\overline{\\mathbb{I}}_{i,j}\\{ \\text{region}(i) \\ne \\text{region}(j) \\}\n", - "$$\n" - ] - }, - { - "cell_type": "code", - "execution_count": 112, - "metadata": {}, - "outputs": [], - "source": [ - "# Create data with overlap in incomes for group 2 and 3\n", - "data = {\n", - " 'Income': [50000, 55000, 60000, 45000, 46000, 47000, 45000, 46000, 47000, 48000],\n", - " 'Group': [1, 1, 1, 2, 2, 2, 3, 3, 3, 3]\n", - "}\n", - "\n", - "# Create DataFrame\n", - "df = pd.DataFrame(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 113, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_209447/1723929582.py:6: FutureWarning: \n", - "\n", - "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", - "\n", - " sns.boxplot(x='Group', y='Income', data=df, palette='tab10')\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 546, - "width": 868 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "\n", - "# Set up the plot\n", - "plt.figure(figsize=(10, 6))\n", - "\n", - "# Create a boxplot to visualize income distribution by group\n", - "sns.boxplot(x='Group', y='Income', data=df, palette='tab10')\n", - "\n", - "# Add titles and labels\n", - "plt.title('Income Distribution by Group')\n", - "plt.xlabel('Group')\n", - "plt.ylabel('Income')\n", - "\n", - "# Show the plot\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 114, - "metadata": {}, - "outputs": [], - "source": [ - "import itertools\n", - "\n", - "pairs = np.array(list(itertools.combinations(df.index.values, 2)))" - ] - }, - { - "cell_type": "code", - "execution_count": 115, - "metadata": {}, - "outputs": [], - "source": [ - "p_df = pd.DataFrame(data=pairs, columns=['i', 'j'])" - ] - }, - { - "cell_type": "code", - "execution_count": 116, - "metadata": {}, - "outputs": [], - "source": [ - "p_df['y_i'] = df.Income.values[p_df.i]\n", - "p_df['y_j'] = df.Income.values[p_df.j]\n", - "\n", - "p_df['region_i'] = df.Group.values[p_df.i]\n", - "p_df['region_j'] = df.Group.values[p_df.j]\n", - "p_df['adiff'] = np.abs(p_df.y_i - p_df.y_j)\n", - "p_df['within'] = p_df.region_i == p_df.region_j\n", - "\n", - "p_df['diff_within'] = p_df.adiff * p_df.within" - ] - }, - { - "cell_type": "code", - "execution_count": 117, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ijy_iy_jregion_iregion_jadiffwithindiff_within
0015000055000115000True5000
10250000600001110000True10000
2035000045000125000False0
3045000046000124000False0
4055000047000123000False0
\n", - "
" - ], - "text/plain": [ - " i j y_i y_j region_i region_j adiff within diff_within\n", - "0 0 1 50000 55000 1 1 5000 True 5000\n", - "1 0 2 50000 60000 1 1 10000 True 10000\n", - "2 0 3 50000 45000 1 2 5000 False 0\n", - "3 0 4 50000 46000 1 2 4000 False 0\n", - "4 0 5 50000 47000 1 2 3000 False 0" - ] - }, - "execution_count": 117, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p_df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 118, - "metadata": {}, - "outputs": [], - "source": [ - "tad = p_df.adiff.sum()\n", - "wad = p_df.diff_within.sum()\n", - "bad = tad - wad" - ] - }, - { - "cell_type": "code", - "execution_count": 119, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(np.int64(231000), np.int64(34000), np.int64(197000))" - ] - }, - "execution_count": 119, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tad, wad, bad" - ] - }, - { - "cell_type": "code", - "execution_count": 120, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.04723926380368098)" - ] - }, - "execution_count": 120, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inequality.gini.Gini(df.Income).g" - ] - }, - { - "cell_type": "code", - "execution_count": 121, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.04723926380368098)" - ] - }, - "execution_count": 121, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p_df.adiff.sum() / (df.shape[0] * df.shape[0] * df.Income.mean())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Given the region cardinality what is the maximum between region ineq?" - ] - }, - { - "cell_type": "code", - "execution_count": 122, - "metadata": {}, - "outputs": [], - "source": [ - "def giniD2(y, group):\n", - " n = y.shape[0]\n", - " pairs = np.array(list(itertools.combinations(range(n), 2)))\n", - " p_df = pd.DataFrame(data = pairs, columns=['i', 'j'])\n", - " p_df['y_i'] = y[p_df.i]\n", - " p_df['y_j'] = y[p_df.j]\n", - "\n", - " p_df['region_i'] = group[p_df.i]\n", - " p_df['region_j'] = group[p_df.j]\n", - " p_df['adiff'] = np.abs(p_df.y_i - p_df.y_j)\n", - " p_df['within'] = p_df.region_i == p_df.region_j\n", - "\n", - " p_df['diff_within'] = p_df.adiff * p_df.within\n", - " tad = p_df.adiff.sum()\n", - " wad = p_df.diff_within.sum()\n", - " print(tad, wad)\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "231000 34000\n" - ] - } - ], - "source": [ - "giniD2(df.Income.values, df.Group.values)" - ] - }, - { - "cell_type": "code", - "execution_count": 124, - "metadata": {}, - "outputs": [], - "source": [ - "y = df.Income.values" - ] - }, - { - "cell_type": "code", - "execution_count": 125, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([50000, 55000, 60000, 45000, 46000, 47000, 45000, 46000, 47000,\n", - " 48000])" - ] - }, - "execution_count": 125, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IncomeGroup
0500001
1550001
2600001
3450002
4460002
5470002
6450003
7460003
8470003
9480003
\n", - "
" - ], - "text/plain": [ - " Income Group\n", - "0 50000 1\n", - "1 55000 1\n", - "2 60000 1\n", - "3 45000 2\n", - "4 46000 2\n", - "5 47000 2\n", - "6 45000 3\n", - "7 46000 3\n", - "8 47000 3\n", - "9 48000 3" - ] - }, - "execution_count": 126, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df" - ] - }, - { - "cell_type": "code", - "execution_count": 127, - "metadata": {}, - "outputs": [], - "source": [ - "df['Income_sorted'] = np.sort(df.Income)" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IncomeGroupIncome_sorted
050000145000
155000145000
260000146000
345000246000
446000247000
\n", - "
" - ], - "text/plain": [ - " Income Group Income_sorted\n", - "0 50000 1 45000\n", - "1 55000 1 45000\n", - "2 60000 1 46000\n", - "3 45000 2 46000\n", - "4 46000 2 47000" - ] - }, - "execution_count": 128, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 129, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "231000 45000\n" - ] - } - ], - "source": [ - "giniD2(df.Income_sorted.values, df.Group.values)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "So the within component increases now if we sort the incomes from low to high but keep groups as they are.\n", - "\n", - "What about moving the groups around?" - ] - }, - { - "cell_type": "code", - "execution_count": 130, - "metadata": {}, - "outputs": [], - "source": [ - "df['Group_sorted'] = np.sort(df.Group)[::-1]" - ] - }, - { - "cell_type": "code", - "execution_count": 131, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IncomeGroupIncome_sortedGroup_sorted
0500001450003
1550001450003
2600001460003
3450002460003
4460002470002
\n", - "
" - ], - "text/plain": [ - " Income Group Income_sorted Group_sorted\n", - "0 50000 1 45000 3\n", - "1 55000 1 45000 3\n", - "2 60000 1 46000 3\n", - "3 45000 2 46000 3\n", - "4 46000 2 47000 2" - ] - }, - "execution_count": 131, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 132, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "231000 26000\n" - ] - } - ], - "source": [ - "giniD2(df.Income_sorted.values, df.Group_sorted.values)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This changes things, so we have to consider all permutations of the groups. In other words [1,1,1, 2,2,2, 3,3,3,3] which is [A,B,C] \n", - "means we have to consider [A,B,C], [A,C,B], [B,A,C], [B, C, A], [C, A, B], [C, B, A]\n", - "\n", - "but the number of regions is vastly smaller than the number of units so this should be feasible for modest number of regions." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Basic idea:\n", - "\n", - "1. Calculate observed statistic\n", - "2. Sort incomes from low to high\n", - "3. Permute the set of groups\n", - "4. recalculate statistic\n", - "5. repeat steps 2-4 for all permutations of the sets\n", - "\n", - "We keep the incomes fixed from low to high. \n", - "On a given permutation of the groups (e.g., [C, A , B]\n", - "since C has four members, A has 3 and B has 3,\n", - "C gets the four lowest values, A gets the next three highest, and B gets the three highest.\n", - "\n", - "Lets say incomes are 1,2,3,4,5,6,7,8,9, 10\n", - "\n", - "Then [C,A,B]\n", - "gives: C: [1,2,3,4]\n", - "A: [5, 6 7]\n", - "B: [8,9 10]\n", - "\n", - "But [A, C, B] gives\n", - "A: [1,2,3]\n", - "C: [4,5,6,7]\n", - "B: [8,9, 10]\n", - "\n", - "and so on\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} From 56056c198b2a6490d3e7b54acf7e92963eb39009 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Thu, 5 Dec 2024 16:04:59 -0800 Subject: [PATCH 19/32] prunning --- docs/_static/auto/references.el | 15 +- docs/api.rst | 20 +- docs/tutorials.rst | 12 - docs/user-guide/measure/gini.ipynb | 530 ++++++++++++++--- inequality/theil.py | 260 ++++----- inequality/wolfson.py | 8 +- notebooks/gini.ipynb | 875 ----------------------------- notebooks/pengram.ipynb | 667 ---------------------- notebooks/shutz.ipynb | 600 -------------------- notebooks/weighted.dbf | Bin 43746 -> 0 bytes notebooks/weighted.shp | Bin 51924 -> 0 bytes notebooks/weighted.shx | Bin 356 -> 0 bytes pyproject.toml | 4 +- 13 files changed, 611 insertions(+), 2380 deletions(-) delete mode 100644 docs/tutorials.rst delete mode 100644 notebooks/gini.ipynb delete mode 100644 notebooks/pengram.ipynb delete mode 100644 notebooks/shutz.ipynb delete mode 100644 notebooks/weighted.dbf delete mode 100644 notebooks/weighted.shp delete mode 100644 notebooks/weighted.shx diff --git a/docs/_static/auto/references.el b/docs/_static/auto/references.el index 8b5e941a..fea02c31 100644 --- a/docs/_static/auto/references.el +++ b/docs/_static/auto/references.el @@ -1,9 +1,20 @@ +;; -*- lexical-binding: t; -*- + (TeX-add-style-hook "references" (lambda () (LaTeX-add-bibitems + "hoffmann2024MeasuringMismeasuring" + "wolfson1994WhenInequalities" + "schutz1951MeasurementIncome" + "Atkinson_1970_Measurement" + "care_2012" + "ellison_1997" + "maurel_1999" + "nijkamp2015cultural" "rey_interregional_2010" "rey_comparative_2015" - "Rey_2013_sea")) - :bibtex) + "Rey_2013_sea" + "van_Mourik_1989")) + '(or :bibtex :latex)) diff --git a/docs/api.rst b/docs/api.rst index de9558f6..2c8e2144 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -13,7 +13,7 @@ Atkinson Inequality Measures .. autosummary:: :toctree: generated/ - inequality.atkinson.Atkinson + atkinson.Atkinson Gini Inequality Measures @@ -22,8 +22,8 @@ Gini Inequality Measures .. autosummary:: :toctree: generated/ - inequality.gini.Gini - inequality.gini.Gini_Spatial + gini.Gini + gini.Gini_Spatial Schutz Inequality Measures -------------------------- @@ -31,7 +31,7 @@ Schutz Inequality Measures .. autosummary:: :toctree: generated/ - inequality.schutz.Schutz + schutz.Schutz Theil Inequality Measures ------------------------- @@ -39,16 +39,16 @@ Theil Inequality Measures .. autosummary:: :toctree: generated/ - inequality.theil.Theil - inequality.theil.TheilD - inequality.theil.TheilDSim + theil.Theil + theil.TheilD + theil.TheilDSim Wolfson Bipolarization Measure ------------------------------ .. autosummary:: :toctree: generated/ - inequality.wolfson.wolfson + wolfson.wolfson Pengram @@ -57,6 +57,6 @@ Pengram .. autosummary:: :toctree: generated/ - inequality.pen.pen - inequality.pen.pengram + pen.pen + pen.pengram diff --git a/docs/tutorials.rst b/docs/tutorials.rst deleted file mode 100644 index fab23d06..00000000 --- a/docs/tutorials.rst +++ /dev/null @@ -1,12 +0,0 @@ -.. tutorials - - -Tutorials -========= - -.. toctree:: - :maxdepth: 1 - :caption: Gini - - notebooks/gini.ipynb - notebooks/pengram.ipynb diff --git a/docs/user-guide/measure/gini.ipynb b/docs/user-guide/measure/gini.ipynb index 71c63b2f..db60fb21 100644 --- a/docs/user-guide/measure/gini.ipynb +++ b/docs/user-guide/measure/gini.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 69, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:00:59.142457Z", @@ -30,18 +30,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Last updated: 2023-01-16T21:00:59.129990-05:00\n", + "The watermark extension is already loaded. To reload it, use:\n", + " %reload_ext watermark\n", + "Last updated: 2024-12-02T11:43:47.151240-08:00\n", "\n", "Python implementation: CPython\n", - "Python version : 3.10.8\n", - "IPython version : 8.8.0\n", + "Python version : 3.10.15\n", + "IPython version : 8.30.0\n", "\n", - "Compiler : Clang 14.0.6 \n", - "OS : Darwin\n", - "Release : 22.2.0\n", + "Compiler : GCC 11.2.0\n", + "OS : Linux\n", + "Release : 6.1.0-22-amd64\n", "Machine : x86_64\n", - "Processor : i386\n", - "CPU cores : 8\n", + "Processor : \n", + "CPU cores : 20\n", "Architecture: 64bit\n", "\n" ] @@ -55,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 70, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:01.756177Z", @@ -73,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 71, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:01.770545Z", @@ -85,14 +87,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Watermark: 2.3.1\n", + "Watermark: 2.5.0\n", "\n", - "libpysal : 4.7.0\n", - "inequality: 1.0.0+28.g078a825.dirty\n", - "matplotlib: 3.6.2\n", - "numpy : 1.24.1\n", - "json : 2.0.9\n", - "geopandas : 0.12.2\n", + "pandas : 2.2.3\n", + "geopandas : 1.0.1\n", + "IPython : 8.30.0\n", + "numpy : 2.1.2\n", + "inequality: 0.1.dev217+g3354455.d20241010\n", + "libpysal : 4.12.1\n", + "matplotlib: 3.9.2\n", + "scipy : 1.14.1\n", "\n" ] } @@ -104,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 72, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:01.776633Z", @@ -137,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 73, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:01.962407Z", @@ -152,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 74, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:02.103640Z", @@ -162,7 +166,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -177,13 +181,13 @@ } ], "source": [ - "ax = gdf.plot()\n", + "ax = gdf.plot(edgecolor='grey')\n", "ax.set_axis_off()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 75, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:02.138110Z", @@ -331,7 +335,7 @@ " 4.30\n", " 4.33\n", " 4.0\n", - " POLYGON ((-101.52490 21.85664, -101.58830 21.7...\n", + " POLYGON ((-101.5249 21.85664, -101.5883 21.772...\n", " \n", " \n", " 4\n", @@ -355,7 +359,7 @@ " 4.32\n", " 4.44\n", " 5.0\n", - " POLYGON ((-101.84620 22.01176, -101.96530 21.8...\n", + " POLYGON ((-101.8462 22.01176, -101.9653 21.883...\n", " \n", " \n", "\n", @@ -388,13 +392,13 @@ "0 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", "1 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", "2 MULTIPOLYGON (((-106.62108 21.56531, -106.6475... \n", - "3 POLYGON ((-101.52490 21.85664, -101.58830 21.7... \n", - "4 POLYGON ((-101.84620 22.01176, -101.96530 21.8... \n", + "3 POLYGON ((-101.5249 21.85664, -101.5883 21.772... \n", + "4 POLYGON ((-101.8462 22.01176, -101.9653 21.883... \n", "\n", "[5 rows x 35 columns]" ] }, - "execution_count": 7, + "execution_count": 75, "metadata": {}, "output_type": "execute_result" } @@ -405,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 76, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:02.975365Z", @@ -416,7 +420,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABAcAAAKjCAYAAABhmWaAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzddXwU1xYH8N/sxt0TPCGCuxVPcA8hUErxAsULbdHSAi2UAi1WoLgWd9fi7lIgWIhBiLttsrvz/kgzb5esZ7OzSc738/J5uzt37pxNhu3OmXvPZViWZUEIIYQQQgghhJAyS8B3AIQQQgghhBBCCOEXJQcIIYQQQgghhJAyjpIDhBBCCCGEEEJIGUfJAUIIIYQQQgghpIyj5AAhhBBCCCGEEFLGUXKAEEIIIYQQQggp4yg5QAghhBBCCCGElHGUHCCEEEIIIYQQQso4Sg4QQgghhBBCCCFlHCUHCCGEEEIIIYSQMo6SA4QQQgghhBBCSBlHyQFCCCGEEEIIIaSMo+QAIYQQQgghhBBSxlFygBBCCCGEEEIIKeMoOUAIIYQQQgghhJRxlBwghBBCCCGEEELKOEoOEEIIIYQQQgghZRwlBwghhBBCCCGEkDKOkgOEEEIIIYQQQkgZR8kBQgghhBBCCCGkjKPkACGEkGLh7+8PhmGU/tja2sLT0xOBgYFYuXIlUlNTtT5GTk4Ojh49igkTJqBx48aoVKkSLC0tYW1tjQoVKqBNmzb47rvvcP78eUil0mJ4l/kyMzNx6NAhLo7KlSvD2toaFhYW8PDwQL169TBkyBCsXLkSkZGRGvXp6emp9HdnZWWFcuXKoVq1aggICMCUKVOwe/duxMXFaRV3eHi4yr+RiYkJnJ2dUbduXYwcORJnz54Fy7K6/IqUio6OxtGjR/Hjjz+iS5cucHZ2loshPDxcp36zs7OxZs0a9OjRAxUrVoSFhQWcnJxQp04dTJ48GY8ePdLbe+jTp49czP7+/lrtz7IsDh8+jL59+8Lb2xuWlpZwdXVF48aN8fPPP2t8zhBCCCFFwhJCCCHFoG3btiwAjX/s7OzYbdu2adR3Xl4e+9dff7Hly5fXuP8KFSqwq1atYvPy8vT2HrOysthFixaxrq6uWr3XFi1asCdOnFDZd5UqVbTqEwBrZmbG9u/fn719+7ZG8YeFhWl9jCZNmrCvX7/Wx6+PLVeunNrjhYWFad3vP//8o7ZvhmHYSZMmsSKRqEjv4cCBA4X6btu2rcb7f/jwgW3Xrp3KWG1sbNgtW7YUKU5CCCFEHYZl9XwLgBBCCEH+yIErV64AAJo0aYKmTZty21iWRUpKCu7du4c3b97I7bdu3Tp8/fXXSvtNTk5GcHAwLl26JPe6u7s7GjVqBFdXVwgEAsTExODFixeIiIiQazd27Fj89ddfRX17iIiIQGBgIJ48eSL3uqurKxo2bAgXFxdYWVkhISEBHz58wMOHDyEWi+XaLl26FN9++63C/j09PbnY27dvj+rVq3PbJBIJUlJSkJycjKdPn+Ljx49y+woEAkydOhW//PILzMzMlL6H8PBweHl5cc+HDBkCW1tb7rlYLMb79+9x7do1pKWlca97eHjg9u3bqFKlitK+NcEwjNo2YWFh8PT01LjPo0ePIjg4GBKJBAAgFArRsmVL+Pr6QiQS4c6dO3Ln3BdffIFdu3ZpFMunUlJSUKNGDcTExMi93rZtW1y+fFnt/mlpaWjZsiWePXvGvda0aVPUqlULqampuHjxIlJSUrht27Ztw5AhQ7SOkxBCCNEIz8kJQgghpZTsyIE5c+YobXfo0CHW3t6ea2tubs5GRUUpbJucnMxWr15d7q5q165d2du3b7NSqVThPk+fPmUnTZrEmpubswDYoUOHFvm9hYaGsm5ubnJ3ofv168fev39faRxpaWns4cOH2fbt23P7zZs3T+kxZEcOqLtr/O7dO3bWrFmss7Oz3O+mZ8+erEQiUbrfpyMHlN2lT0tLY8ePHy/Xtlu3bipj0gQA1sLCgv3ss8/YiRMnstu3b2fPnj2r88iB9+/fs7a2tty+9evXZ1+9elWo3Z49e1grKyuu3fLly3WKf8SIESwA1tTUlO3Xr5/WIwcGDx7M7ePk5MReuHBBbntGRgY7cOBAuZEhb9680SlWQgghRB1KDhBCCCkWmiYHWJZlT5w4IXdBOHPmzEJtpFIp26tXL66NQCBgV69erXE8ERERbJs2bYqcHMjKymLr16/PxWFlZcUeOXJEqz7u3LnD1qlTR2/JgQIxMTGsv7+/3O9y2rRpSttrmhwo0LdvX7n2L1++1CguZR4+fFhomoe2McmaMGECt1+5cuXYhIQEpW0PHTrEtXV2dmZTUlK0iv3ChQvc/rNmzWLnzJmjVXLg33//ZQUCAbfPmTNnFLaTSCRsixYtuHYDBgzQKk5CCCFEU1SQkBBCCO+6d++OevXqcc//+eefQm127tyJY8eOcc9/++03jBs3TuNjVK5cGRcuXMDQoUOLFOvixYvx+PFjubgCAwO16qNp06a4f/8+goKCihTLp9zd3XHmzBk0bNiQe23JkiV49+6dXvqfNWuW3PMLFy4Uqb8GDRrAxMSkSH3IOnDgAPd46tSpcHZ2Vto2KCgIn332GQAgMTERO3fu1Pg42dnZ3NQXHx8f/Pjjj1rHumbNGq5IZseOHdG5c2eF7QQCARYvXsw937dvHxISErQ+HiGEEKIOJQcIIYQYhRYtWnCPP72YZVkWixYt4p43btwYU6ZM0foYJiYmCAgI0DnGzMxM/Pnnn9zzAQMGoHfv3jr1ZWZmhlq1aukcizLm5ubYtWsXBIL8/8RLJBK5311R1KtXD9bW1txzfSUd9CEiIkJu7n+3bt3U7tO9e3fu8cGDBzU+1pw5cxAaGgog/yLfwsJCi0jzz2fZRNfw4cNVtm/ZsiV8fHwA5P89ZfclhBBC9IWSA4QQQoyCo6Mj91i2+B0AXL9+Xa5o2+TJk7mLX0Pav38/kpKSuOfKignyrVq1anIXvvv379fLUo4Mw8De3p57/unfiU+xsbFyzzUplijb5urVq8jLy1O7z4MHD7B06VIAwKBBg9ChQwctIwXevHmD9+/fc881WfpQNql18eJFrY9JCCGEqEPJAUIIIUYhOTmZeyx7AQrIXwyZmZkhODjYYHHJkl0hwcvLC02aNOElDk3069ePe5ycnCyXXNEV+98qEwU+/TvxiS3i4ktisRivX79W22bkyJGQSCRwcnLikgTaCgkJ4R57eHigXLlyaveRnSoiuz8hhBCiL5QcIIQQYhRu3LjBPZZdXg8Arl27xj2uV6+e1sO49UU2jmbNmvESg6Y+je/27dtF7vPx48fIysrinn/6d+KTq6ur3PPIyEi1+3zaRt1F9x9//MHVm/j9998LHVNTr1694h5ruhxk5cqVuccvX77U6biEEEKIKpQcIIQQwruTJ0/i6dOn3PP27dvLbQ8PD+ceF8c8fU1FRUVxj2vUqMFbHJrw9fWVm3rx6bB7XSxYsEDu+ad/Jz55enrCycmJe37mzBm1+5w6dUruueyUkU+9efMGP//8MwCgbdu2ausEqJKYmMg9dnd312gfDw8P7nFWVhZEIpHOxyeEEEIU0V+JYEIIIUQHR44ckbvQMjc3L7QKgexFm4ODg6FCk5OWlgaxWKxVHKdOnSp0AfqpX375Re6iVl8YhoGtrS1SU1MByE/b0FZGRgZmzJghtxpA165dUa1atSLHqS8CgQA9e/bEtm3bAOTf2R8yZIjSv9PJkydx8+ZNudfS09MVtmVZFqNGjUJOTg7MzMywbt06MAyjc6wZGRncY0tLS432+bRdRkYGzM3NdY6BEEII+RQlBwghhBS7U6dOFVp+LSUlBXfv3sWbN2/kXl+6dCkqVaok95rsRZuNjU3xBarCpxeOslX7lbl79y5Wr16tss2UKVOKJTkA5P+uCpIDyi58Zc2ZMwe2trbcc7FYjOjoaFy9epXrBwDc3NzUvi8+TJ8+Hbt27UJeXh7ev3+PTp06Yffu3fD29pZrd/DgQYV3/rOzsxX2u2HDBly5cgUAMHPmzCInRXJycrjHZmZmGu3zaSJAWayEEEKIrig5QAghpNjdu3cP9+7dU9nG1tYWK1asUHjRZmtry935lr3rakiyF81A/rKGxk42IWBnZ6e2/fbt29W2adSoEXbu3GlU9QYK1KhRA0uXLsXEiRMB5J931atXR8uWLeHr6wuRSIS7d+9yc/5bt26NkJAQLnH16d8YAKKjozFt2jQA+atAzJw5s8hxytbMyM3N1WifT6cRaDrigBBCCNEUJQcIIYTwwsbGBs7Ozqhbty46dOigcgi4k5MTlxyQrZZvSHZ2djAxMeGmFmgSx9y5czF37ly518LDww1yYS2VSuWSA7qMThAKhbCzs0PFihXRpEkT9O3bF126dCnSkPriNmHCBFhZWWHixInIysqCWCzGlStXuDv/BTp27Ig9e/bA09OTe03R+Td+/Hhu1MTatWv1MpRfdvSLpiMAPm3H1wgaQgghpRclBwghhBS7OXPmFLpI1oanpydCQ0MBAC9evNBTVNqrXLky3r17x3scmnj9+rXc8n6yBe2UCQsLk7tYLqm++uor9OzZE2vWrMHZs2fx+vVrpKamwtXVFfXr18ewYcPQt29fiEQiuZEon05nOXr0KI4cOQIAGDZsGPz9/fUSn7OzM/dY00KRMTEx3GMrKyuqN0AIIUTvKDlACCHE6LVq1QoXLlwAADx58gQikYiXi6PWrVtzyYG7d+8a/PjauHPnjtzzzz77jKdI+OHq6orZs2dj9uzZStuEhIRwCRSGYdC4cWO57Y8ePeIe3717V+Xv8P3799zjhw8fyrX966+/0LBhQ+65bM2CiIgIDd6N/LKL1atX12gfQgghRBuUHCCEEGL02rVrxy0jJxKJcPDgQXz55ZcGjyMgIICrhh8WFoa7d++iadOmBo9DE/v37+ceu7i4oGbNmjxGY5xkVyuoVauWyroM2owUSU9Pl0vOpKWlyW2XXQYzJiYGMTExakd2PHz4UOH+hBBCiL4I1DchhBBC+NW6dWvUrl2be758+XJIpVKDx9G3b1+5IeHLly83eAyaePnyJU6fPs09//zzz426TgBf9u7dyz0ePHiwwY7r6+uLihUrcs8vX76sdh/Zmgnt2rUrjrAIIYSUcZQcIIQQYvQYhuEqxgP5VeiXLVumdT9isRiXLl3SOQ5ra2uuEj4A7N69m5uTbixEIhEGDhzIJU9MTU0xffp0nqMyPv/88w+uXbsGIH/1AEWrZMydOxcsy2r0M2fOHG6/tm3bym37tFYBwzDo1asX93zr1q0qY7116xZev34NIL9IZM+ePXV814QQQohylBwghBBSIgwaNAjdu3fnnk+fPh3r16/XeP/IyEh06NCBmxagq+nTp6NBgwbc84EDB+Lo0aNF6lNf4uLi0KVLF7kh6DNmzEDlypV5jMr4REZGYsSIEdzz2bNnw9XV1aAxjBkzBgJB/tews2fP4vz58wrbSaVSucRYv379DB4rIYSQsoGSA4QQQkoEhmGwfft2+Pr6AgAkEglGjx6Nnj174t69e3KV+WU9e/YMkydPhp+fX6Hl7HRhYWGBgwcPws3NDQCQlZWFoKAg9O/fHw8fPlQah1QqxeXLl/H1118XOYZPhYeHY/bs2ahZs6bcEPW+fftytRrKip9++gm7du1CZmZmoW1SqRSHDh1Cy5YtuQJ/n332GaZOnWroMFGnTh0MHDiQez5gwIBC0wsyMzMxbNgwXL9+HQBgZmaGefPmGTJMQgghZQgVJCSEEFJiODk54datWwgODuYu9E+cOIETJ07Aw8MDjRo1gqurKwQCAWJiYvD8+fNC1eBtbW2LHIeXlxfu3r2LwMBAPHnyBCzLYt++fdi3bx9cXV3RqFEjuLi4wMbGBpmZmXj//j2ePn2KxMREuX4CAgLkahgos2PHDty/f597LpFIkJqaiuTkZDx9+hTR0dFy7YVCIWbMmIG5c+cada2BtWvXYu3atXKv5ebmyj3v1q0bzMzM5F4bM2YMxowZo7DPe/fuYf78+bCwsECDBg3g6+sLCwsLxMXF4datW3JLBzZq1AinT5+GiQk/X4dWrVqFhw8f4vnz50hMTERAQACaNWuGmjVrIi0tDRcvXkRycjLXfv369fDx8eElVkIIIaUfJQcIIYSUKM7Ozjh//jzWrVuHBQsW4OPHjwDyq76fPHlS6X7e3t744YcfMGzYML3EUaVKFdy8eRN//vknlixZgoSEBABAfHw8zpw5o3Q/hmHQqlUrfP/99wgMDNToWBcuXOCWclTF3NwcQUFB+P777wsty2eMYmJi8OTJE5VtQkJCFO6nTk5ODm7duoVbt24V2iYQCDBu3DgsWLBAL8kiXdnZ2eHcuXMYPHgwLl68CCB/CcpPl6G0sbHBn3/+iaFDh/IRJiGEkDKCkgOEEEJKHFNTU0yYMAEjRozAmTNncP78edy+fRtxcXFITEwEwzBwcnKCj48PmjVrhu7du6N169Z6v4tuZWWFGTNmYOLEiThz5gwuXLiAO3fucHFIpVI4ODjA1dUV9evXR5MmTdCjRw9UrVq1SMc1NzeHvb097O3tUaFCBTRs2BCNGzdGx44d4eLioqd3VzL99ddfOHv2LC5evIgXL14gLi4OqampcHFxQaVKldClSxcMGDAA1atX5ztUAED58uXxzz//4PDhw9i5cycePnyIjx8/wsbGBpUrV0bPnj0xYsQIqhtBCCGk2DGsssmRhBBCCCGEEEIIKROoICEhhBBCCCGEEFLGUXKAEEIIIYQQQggp4yg5QAghhBBCCCGElHGUHCCEEEIIIYQQQso4Sg4QQgghhBBCCCFlHCUHCCGEEEIIIYSQMo6SA4QQQgghhBBCSBlHyQFCCCGEEEIIIaSMo+QAIYQQQgghhBBSxlFygBBCCCGEEEIIKeMoOUAIIYQQQgghhJRxlBwghBBCCCGEEELKOEoOEEIIIYQQQgghZRwlBwghhBBCCCGEkDKOkgOEEEIIIYQQQkgZR8kBQgghhBBCCCGkjKPkACGEEEIIIYQQUsZRcoAQQgghhBBCCCnjKDlACCGEEEIIIYSUcZQcIIQQQgghhBBCyjhKDhBCCCGEEEIIIWUcJQcIIYQQQgghhJAyjpIDhBBCCCGEEEJIGUfJAUIIIYQQQgghpIyj5AAhhBBCCCGEEFLGUXKAEEIIIYQQQggp4yg5QAghhBBCCCGElHGUHCCEEEIIIYQQQso4E74DIIQQQggh2mNZFpmZmUhLS0NOTg4kEgnfIRFCCNGQUCiEhYUF7OzsYG1tDYZh+A4JDMuyLN9BEEIIIYQQzUmlUkRGRiI7O5vvUAghhBSRpaUlKleuDIGA34H9lBwghBBCCClBWJZFRESEXGKAYRgIhUIeoyKEEKINiUQC2UtxS0tLVKlShdcRBDStgBBCCCGkBMnMzOQSA0KhEB4eHrCxseH9jhMhhBDNSaVSZGRkICYmBhKJBNnZ2cjMzISNjQ1vMdF/RQghhBBCSpC0tDTusYeHB+zs7CgxQAghJYxAIICdnR08PDy419LT03mMiJIDhBBCCCElSk5ODoD8qQR83mEihBBSdDY2NtxUAr7ryFBygBBCCCGkBClYlUAoFNKIAUIIKeEEAgFXM4bvVWfovyiEEEIIIYQQQkgZR8kBQgghhBBCCCGkjKPkACGEEEIIIYQQUsbRUoaEEEIIIaRIRNkihD6JwMfQWOSJ8mBqbopy3u7wrlcF5pbmfIdHCCFEA5QcIIQQQgghWstKz8b57VdwduslvHsSAYm4cCEtoYkQ3vU90XlYADoMbgMrW0seIiWEEKIJhmVZlu8gCCGEEEKIZt68eQOxWAwTExP4+voa/PgSiQT7Fh/D7t8OITsjR+P9LG0sMGBmH3w+rRdXmZsQQgj/n+sFqOYAKYRlJWClyWDFYWClGXyHQwghhBAjEfXqA75pPgubZ+3SKjEAANkZOdg8axcmtZiFqFcfiilCQgghuqLkQCnGsixYaQZY8Xuwec/Bim6AzT4BNnMH2IzVkKb9CmnKFEiTRkKa2A/S+I6QxjYBG1sTbFwzsGlzAIbmCRJCCCEEeP0gFJNb/YTX90OL1M+re/n9vHn4Tk+RGYeoqCgcPHgQM2bMQLt27WBvbw+GYcAwDObOnatVX8+ePcOECRNQp04d2NnZwczMDK6urvD398fSpUuRnp6utg+JRIKdO3eie/fu8PDwgJmZGdzd3eHv749169ZBLBar3F8qleLq1av44Ycf4O/vz/VhZ2eH2rVrY9y4cXj69KlW70sdsViMtWvXonXr1nB1dYWlpSW8vb0xevRoPH/+XON+EhISMHv2bNStWxd2dnaws7ND3bp1MXv2bCQmJuo15qK4f/8+lixZgi+++AJ169ZFuXLlYG5uDltbW1SrVg1Dhw7FpUuX1Pbj7+/PnWvqfpTx9PTUuI+Cn/DwcJVxsSyLgwcPol+/fvDy8oKlpSWcnJxQo0YNDBo0CFu2bIFEUng6kqbu37+PX375BZ06dULFihVhbm4OGxsb+Pn5Yfjw4bh+/bpW/Z0+fRpBQUFcXxUrVkRQUBBOnz6tc4wlDU0rKCFYNheQpuT/sCmANBmQpgLSFLBsyv+3cdvztwF5uh1QWAWM8z4wAkd9hE8IIYQQPeFj+GnUqw+Y3OonpCWqvyjVlJ2zLZZfn4dK1SrorU++REREwNPTU+n2OXPmaJwgWLRoEWbNmqXyoqlSpUo4duwY6tevr3D7x48f0adPH9y+fVtpH40aNcLx48dRrlw5hdsrV66MqKgolbEKBAJMmTIFCxcuVHnhqYmEhAR069YN9+7dU7jd3Nwcq1atwsiRI1X2c+fOHfTu3RsxMTEKt5crVw5HjhxB06ZNixSvPrRq1Qo3btxQ265fv37Yvn07LCwsFG739/fHlStXNDqmsks/T09PREREaNQHANjb2yMmJkZpTJGRkRg4cKDaC/Tk5GQ4ODhofNwCbdq0wbVr19S2GzJkCDZs2AAzMzOlbaRSKb7++mts2rRJaZuRI0di3bp1EAiK5966sUwroIKEBsayLMBmANKk/y7wk/+7mE8BW3BBzyb/d6Gf+v+LfTbLcEEyNmAc11JigBBCCCGQSCRYOHilXhMDAJCWmI5FQ1Zixc1fS3wNAtkLLoZh4O3tjfLly+Pq1ata9bN7927MmDEDAGBmZobx48ejQ4cOcHFxQWhoKP766y9cv34dUVFR6NKlC16+fFnowio7OxvdunXD48ePAQAdOnTAmDFj4OXlhcTERBw4cAAbN27EgwcP0KNHD9y4cUPhBV50dDQAwMfHB8HBwWjZsiXKly+P7OxsXLp0CcuWLUNycjIWL14MoVCIBQsWaPVeZUkkEgQFBXGJgT59+mDUqFFwcnLCnTt3MH/+fMTFxWH06NGoUKECunbtqrCfqKgo9OzZE/Hx8TAxMcF3332HHj16AABOnDiBpUuX4uPHj+jZsycePHiAihUr6hyzPpibm6Nt27Zo0aIFatSogXLlysHJyQnx8fF48uQJ1q5di7CwMOzfvx8CgQB79uxR2V/jxo2xZcsWnWI5d+4ccnNzVbb5559/8O233wIAPv/8c6WJgaioKPj7+yMsLAxCoRCDBg1Cz549UaVKFUilUoSFheGff/7B4cOHdYoV+P/5Wb58efTr1w+tW7dG5cqVIZFIcOvWLSxZsgQfPnzA9u3bkZeXh127dinta9asWVxioEGDBpg2bRq8vb0RGhqKxYsX49GjR9i4cSNcXV2LdJ6XBDRyoIjyL/bT/rvYl/9hC72WmJ8M0PVuvqGYB0DguI7vKAghhBCigKHvMO3+7TA2z1L+xbqoRiz4El/MCCq2/g0hMTERa9euRdOmTdG4cWM4Ojri8uXLCAgIAKD5yIHatWtzw+dPnDiB7t27F2oTHByMQ4cOAQB+//13TJkyRW77H3/8galTpwIAhg8fjk2bNhW6q79lyxZ89dVXSvsAgBYtWmDOnDno1KmTwlEBoaGhaN68OXch/urVK1StWlXte1Rk8+bNGDFiBABg3LhxWL16tdz2t2/folGjRkhLS4OPjw9CQkJgYlL4HueQIUPw999/AwD27duHfv36yW3ft28f+vfvDwAYOnQotm7dqlO8+lLw71iZ7OxstGvXjhsB8uTJE9StW7dQu4KRA23btsXly5eLK1z0798f+/btAwBcu3YNrVq1KtSGZVn4+/vj6tWrcHR0xKlTp/DZZ58p7E8sFkMoFOo06qRHjx4YMmQIgoODFSYXExIS0LJlS7x+/RoAcOXKFbRp06ZQu9evX6NWrVoQi8Vo3Lgxrl69CkvL/6+qkpWVhbZt2+L+/fswMTFBSEgIfHx8tI5XHWMZOUA1Bz7BslKw0hSw4lCwuffA5pwFm7UHbMZfkKbNgzTlW0iThkKa0BPSuFZgY2uDjWsCNqEz2KQBYFPGg037CWzGMiBrG5BzHMi9AYhDAGkcjD4xAAACF74jIIQQQogRyErPxu7fDhXrMXb/dhhZ6dnFeozi5uzsjFmzZqFjx45wdNRt5GVaWhqXGGjYsKHCxACQn2gocOvWrULbCy54ra2tsWzZMoUXXsOHD0fLli0B5CcHFE1huHnzJjp37qz0ws3b2xuzZ88GkH+Rd+TIEeVvTo0//vgDAODk5ITff/+90HYfHx/MnDkTQH6iQNEd55iYGOzcuRMA0Llz50KJASD/bnfnzp0BAH///bfSqQeGoioxAACWlpaYNGkS91yTYfTFJTU1FceOHQMAVK1aVWFiAAB27tzJjZhZv3690sQAkP/+dZ2OcuLECXz++edKRx25uLhgyZIl3PMDBw4obLd8+XKu/sbKlSvlEgMAYGVlhZUrVwLIP8+XLVumU7wlBSUHAEiTJ0Ca0APSuBZgY2uBjWsKNqEr2KSBYFMmgk2bDTZjOZD1N5BzEsi9BYhflZyLfW0J3PiOgBBCCCFG4Pz2K1qvSqCtrPRs/PO3dsPvSyPZId2q7sB7e3sr3AfIv9NckGBo3rw57O3tlfbTpUsXAEBcXJzOF50FIyOA/JEEunj9+jVCQkIA5F+8W1lZKWw3bNgw7rGi5MCxY8cglUoB5Cc/lCnoRyqVche7xszW1pZ7nJNTvP8WVdm3bx93/CFDhihtt2rVKgBAtWrV0LdvX4PEpoy685NlWRw9ehQAUL16daWJjM8++wzVqlUDABw9elRp3YbSgJIDAJD3ABC/BqQJAHSvmFmS5YgtcS2hExaFTMSud/Ug/u/DlRBCCCFl19mt6iull6TjGDMXFxc4OTkBAN69U76Sg+xFTsEFS4GkpCTusbu7u8rjyW7XtjZCAZFIxD3WtW6EbMG6tm3bKm3n4eEBPz8/AFBYxE/TfmS3aVIMkG+ydQaqV6/OWxzbt28HkF9TY/DgwQrbREZG4s6dOwCAnj17cq/n5eUhPDwcUVFRyMsz3I1VdednWFgYV7tA1Tkju/3Dhw9qV2koySg5AABQXEyjrIjI8kPDo8Mx/KIXNvybi9lXHqDxhr8w6cxJHH0VgpSckj3UjxBCCCHaE2WLEPo43CDHCn0cjtwc1cXQyoIxY8YAAB4+fIgzZ84obDNv3jwA+UOyP63cb2Njwz1OTU1VeSzZ7S9evNApXtkK+TVq1NCpD9ljq7v4LdgeFRWFzMxMhf3Y29vDw8NDaR/lypWDnZ0dAHAjFoyJVCpFbGwsLl68iKCgIOzYsQNA/nsvmBKhzMuXL9GsWTM4ODjAwsICFStWRGBgIFeUT1dhYWFcIqVVq1ZKR7YUJAYAoE6dOoiJicHw4cPh4OAALy8vVK5cGQ4ODggKCuIKZhYndeenLuceYJznjb7QagUAGJsxYNN+4jsM3txMaIbcT+aapYlEOP76JY6/fgkBw6BRufJo51UV7b284e3oVOTlagghhBBi3EKfREAqMcxIQolYgtAnEajRjL9CXMbghx9+wIMHD3D27Fn07t0bEyZMQPv27eHi4oJ3795hzZo1uHLlCoRCIVatWlXogsbe3h7lypXDx48fcfv2beTm5ipdwk12tEBkZKTWsWZlZWH58uUA8qvuBwYGat0HALx//557rG71gEqVKgHIHw7+/v17uZETBf1osgJBpUqV8Pz5c7VLNRqSqqUEq1atikOHDqmtURAbG4vY2Fju+YcPH/DhwwccO3YMixYtwoEDB3RK4mzfvp0bSq9qSoHsxXZSUhLq1q2L+Ph4uTZZWVk4cuQITp48ic2bN2PQoEFax6MJqVSKhQsXcs8///zzQm10OfcAGNV5o280cgAALPsBpg34joI3N2NVDzuTsizuRX/AohvX0GnHVgRs24RfrlzEtchwiP4r4EEIIYSQ0uVjaKz6Rno9Hr/F4YyBtbU1Tpw4gU2bNqFixYpYsmQJunXrhqZNm+KLL77AlStX0KdPH9y6dQujR49W2EevXr0A5Fdrly3IJuv69es4efIk9zw9XftlKqdPn84lFcaPH4/y5ctr3cenx5Yd+aCItbU19zgjI0NhP+r6kO3n0z6MjYmJCebPn4/Hjx+rvKgXCARo3749lixZgn/++QePHj3C1atXsXz5cm6/Fy9eICAgQKdEUMEKEJaWlgovsgvITmuZOXMm4uPjMWjQIPz7778QiUR4//49fvvtN5iZmSEvLw9fffUVHjx4oHU8mli2bBnu3r0LIH9pzEaNGhVqo69zrzShkQMAGEYA2M0Fm9gHZa3mQExOZVx7r11xk8i0VGx98ghbnzyCtakpWlX2RDuvqvD39IKrlbX6DgghhBBi9PJEhi26nCuiGw4AcPfuXezYsUNp3YHz58/D1dUVfn5+CgsOTp8+Hbt27UJ6ejpmzZqFuLg4jBs3Dp6enkhMTMTBgwcxc+ZMmJiYcAUNs7O1m0K6c+dOrvBcjRo1MH/+fC3f5f/JFtlTNsqhgLm5Off405gL+lHXh2w/2r7v4nTu3Dnk5uZCKpUiMTERN27cwJo1a/DLL7/g1atX+Ouvv5RewB46dAgODg6FXm/dujXGjRuHUaNGYdu2bYiNjcXkyZO5pTA1cfPmTa7ORWBgIDclQxHZqR45OTn46quvsGnTJu61ChUqYMaMGahSpQq+/PJL5OXl4ccff8Tp06c1jkcTV65cwYwZMwAAbm5uWLNmjcJ2+jr3ShMaOfAfxrQGYKW4uEZpxbLAD4/6I6MIc5Ay8/JwNvQNpv9zFs02rkXQ3p1YefcWnsfFlupKnoQQQkhpZ2puatDjmZnTPasDBw6gXbt2uHTpEurUqYPDhw8jMTERubm5CA0NxYIFCyAWi7Fu3To0b96cK6Ymy8vLC3v37oWNjQ1YlsXy5cvh5+cHMzMzlCtXDhMmTEBWVhZ3cQ/IV8RX5/LlyxgxYgSA/KUHDx48WGj5N21YWPy/9tenqy98SrbA3KfHLOhHXR+y/RQlbn3z8/ND7dq1UbduXQQEBODHH3/Es2fPUK9ePfz9999o2bKl0jvWihIDBUxNTbFx40ZuCsbhw4fx4cMHjeMqKEQIAEOHDlXZVvZvaWJiggULFihsN2DAADRu3BhAflIkJSVF43jUef78OYKCgiAWi2FhYYH9+/fDzU3xSmz6OvdKE0oOyGBsJgEWus2XKon2vh+Iq1Fpeu3zSWwMlt2+iZ57dqDl5vWYdfE8LrwLRbYBK5MSQgghpOjKeauedqj/4ykvIlcWxMbGYtiwYRCJRKhVqxZu3ryJ3r17w8nJCaampqhatSpmzpyJ48ePg2EYhISEYOLEiQr76tq1Kx4+fIghQ4bIXTgyDIOAgABcu3aNm34AAI6OjhrFeP/+ffTq1QsikQg2NjY4deqUzoUIC8gmJtQN15a9M/3pXfSCfjQZ8l3QjyZTEPjk6OiIbdu2AQCePn2q9GJbHRMTEy6hA8gX6lNFJBJh3759APILOXbs2FFle9m/Zf369VWumFFQXFEqleptakFYWBg6deqE5ORkCIVC7NmzB23atNEo3qKce6UJJQdkMAJrCBx+B+O0AxB6q9+hBMsQ2+G3+5r9h0BXMZkZ2P3sKUadOIKG6//CiGOHsfPfJ4hO129CghBCCCH6512vCgRCw3xVFJoI4V2vikGOZaz27NnDXYD88MMPcnOcZbVv3x7t27cHABw5cgTJyckK2/n6+mLbtm1ITEzE+/fv8fr1a6Snp+PixYto3rw53rx5w7WtVauW2vieP3+OLl26ID09Hebm5jhy5AiaNWum7dssRLYQnGyBOEUKCsExDFOogFzBc3V9yPYjW2TOWNWoUQO+vvmFOg8cOKBzPzVr1uQeazpy4Pjx49z59eWXX6pdrlL296nudyu7/dOihbqIjo5Ghw4dEB0dDYZhsHnzZrVFMnU594CScd7oipIDCjBmTcG4HAXMu/AdSrGxFqbBw9pcfUM9EUnEuBT+Dj9d+gettmxA913bseTWdTz6GA2J1DCVkAkhhBCiOXNLc3jX9zTIsbzre8LMQv1c8dJMdnm0hg0bqmxbUFxNKpXi9evXKtsKBAJUqFABvr6+cgkH2bu1TZs2VdlHaGgoOnbsiMTERJiYmGDv3r1cgqKoZC9aX758qbJtwfZKlSoVSp4U9JOamoqYGOXFLT9+/Ii0tPwbVUUd9WAorq6uAKB0NQNN6LLSmDZTCgD5JJNEorqOm+x2daswqJOQkICOHTtydTpWrlypclWFArqce0DJOW90QckBJRjGDIxlD77DKDYMA/Ty4q/SZkhCPFbfu4Pg/bvx2aa1mHr+DE69eY10mfk8hBBCCOFX52EBpeo4xkz2AkmsZjUo2TXrdb2w2r9/P4D8+dM9e/ZU2u79+/fo0KEDPn78CIFAgG3btum8bKEirVq14h6rGu4eExPDJUJatmypcz+y2xT1Y4wK7vQXZTi77DKDmqwsER8fjzNnzgDInyJQp04dtfs0btyYm4+vrKBmgYIih0B+oUJdpaamonPnztz7W7hwIcaPH6/Rvl5eXtzvQt1Ui4KlPytUqABPT0+d4zV2lBxQxawZSvOvqGfFi3yHAABIzM7GwZDnmHD6OBpv+AuDDu/HlscPEaHH4iSEEEII0V7HIW1haWOhvmERWNlaosNg5fOCywovLy/u8bVr11S2LbhQYRhGpwuVc+fO4caNGwCAgQMHKi1oFxcXhw4dOiA8PBwAsHbtWnz55ZdaH08VPz8/7k7svn37kJWVpbDd1q1bucdBQUGFtvfq1QsCQf739i1btig9XkE/AoFAru6Csbp37x43YkCTC3RFxGIxNm/ezD1XNQ+/wO7du7kklCajBoD85f66dMkfef38+XO5qSuypFIpjh49CgCwsrJSO1JGmaysLHTv3h0PHz4EAMyaNQvTp0/XeH+GYbhE18uXL3H79m2F7W7fvs2NHAgMDNRpFEZJUXqvfPWAEdgDJjXVNyyhKlu+gZ25cQ3hy5NKcTMqEvOuXkLA9k3o+PcW/Hb9Cu68j0KemuFJhBBCCNEvK1tLDJjZp1iPMWBmEKxsS2/1b011796du+j49ddflc4LX79+Pe7fvw8A+Oyzz+Ds7Fyojao55f/++y8GDRoEAHB2dlZa5C4lJQWdO3fGq1evAOSvGz9q1CjN39B/5s6dC4ZhwDCM3AW+rClTpgAAkpKSMG3atELbQ0ND8dtvvwEAfHx8FCYHPDw8MHDgQADA2bNnFc7P379/P86ePQsAGDx4MDw8FBfB9PT05GIuLnfv3uUuapX58OGD3IW5oqHyly5dUlntPy8vDyNHjuSmrfTs2VOjOfMFUwpMTEy0SggVLCHIsizGjx8vN8qlwIIFC7iRA8OHD5dbJrCAur9Bbm4ugoKCuCTXpEmTdFpSc/LkyVwthYkTJxZapjA7O5sr/GliYoLJkydrfYyShNaMUce8BSB+xncUxSJHbIk0kfrlXvgUmpyE0OQkbHh4H3bm5mhTxRPtPL3RtoonHEvxMiKEEEKIsfh8Wi9cP3wHr++Hqm+spWpNvNFvqvHfvdXEmTNn5Oa6y85Rfvz4sdyFsY2NDfr27Su3f/Xq1TF8+HBs3rwZHz58QIMGDTB58mS0bt0atra2iIqKwp49e7Br1y4AgFAoVHph37VrV7i5uSEwMBD169eHjY0NoqOjcerUKWzatAkikQgWFhbYvXs3N59dlkgkQvfu3fH48WMA+aMLOnTogGfPlH8ntra2lhv9oI2hQ4di8+bNuHHjBlavXo2YmBiMGjUKjo6OuHv3LubNm4e0tDQIBAL8+eefSqdS/Prrrzhz5gzi4+MxYMAA3L9/Hz165E8TPnHiBJYsWQIgfw6/LheS+vTixQsMHz4cLVq0QM+ePVG/fn3ub/HhwwdcunQJW7ZsQWpqKgCgQ4cOGDZsWKF+tm3bhl69eqFXr17w9/dHtWrVYGdnh4yMDDx48ADr16/nhty7ublhxYoVGsVWUJOiS5cuSpcCVKRp06YYN24c/vrrL5w/fx6tWrXCt99+Cz8/P8THx2PHjh3YsWMHgPzaEXPnztW4b1kDBgzAuXPnAADt2rXDiBEjVJ6fZmZm8PPzK/S6n58fpk6dioULF+L+/fto2bIlpk+fDm9vb4SGhmLRokV49OgRAGDq1KlcccjSimFpMXqVWNENsMnD+Q6jWERl+yLgeDu+w9CJgGHQsFx5tPOsinZeVeHr5Fyqh/gQQgghBd68eQOxWAwTExODfVGNevUBk1v9hLTEdL31aedsi+XX56FSNd3nGxsTf39/jZeIq1KlCjdUX5ZIJMLQoUOxd+9elftbW1tj/fr1Su/o1q5dG8+fP1e6f6VKlbB161a0a6f4e2B4eLjWF/pt27bF5cuXC70+d+5c/PzzzwDyh/srusAF8ovKdevWDffu3VO43dzcHKtWrcLIkSNVxnHnzh307t1baVFCDw8PtSstuLu7Iy4uDk5OTkhMTFR5PF1t3boVw4drdo0xbNgwrF69GlZWVgq3FSx3qEqdOnWwZ88euSJ8ysyYMQOLFi0CkD/Vo1+/fhrFWUAikeCrr76SK2j4KR8fH5w4cQLVqlVTuN3T05ObTqHoclXb7/3K/s0B+dMcRo0aJTf14lMjRozA+vXruakr+sbH57oiNHJAHbNGAMwAGPcddl3E5ZTjOwSdSVkW96M/4H70Byy+eQ1V7B3QydsHHap6o6FHeQiL6R8uIYQQUhZVqlYBC8/+iBmd5+slQWDnbIuFZ38sNYkBfTE3N8eePXswevRobN26Fbdv38aHDx8gEolgZ2eHatWqoUOHDvj6668LLeUn648//sDx48dx48YNREdHIyUlBc7OzqhevTr69OmDr776SulSiXxxcXHBzZs3sWHDBuzatQshISHIzMxE+fLl0b59e0yaNEmjJRebNWuGf//9FytWrMCRI0e4C0IvLy8EBgZi8uTJCqdiFHj37h3i4uIAAN9++61e3psi/fv3h6OjIy5evIiHDx8iOjoasbGxyMvLg729PXx8fNCyZUsMHjwYdevWVdrP9OnTUb9+fdy6dQsvXrxAfHw8kpKSYG5uDnd3dzRu3Bh9+/ZFUFCQ2qUIgfwL5Z07dwIAHBwcdKrLIBQKsW3bNgwYMAAbN27E7du3ER8fDxsbG9SqVQvBwcEYPXo0LCyKt56JpgQCATZt2oTg4GCsX78e9+7dQ0JCAlxcXNCkSROMHj0aXbt25TtMg6CRAxpgc/4Bm/cQyDoAsCl8h6M3p2KC8M1VzYcJlRTOlpZo7+WNjt4+aFWpCsyLuDwKIYQQYkz4vMMU9eoDFg1ZiVf3dJ9iUK2JN2b8/Q0q+qmvmE6IoRXc0XdwcEBERATs7Oz4DomUATRyoARhLDqAsegAVugDNm0G3+HojQjeAPQ3PNBYJGZnY9+LZ9j34hmsTE3RtooXOlb1QYCnF+yNJENJCCGElESVqlXAipu/Yt/iY9iz8DCy0rPV7/Sf/OKGQeg3tZdGdzAJ4UPB1JBJkyZRYoCUOTRyQAssKwWbMg4QGccSgEXF2EzC1YRu+O3GVbxOTOA7nGJnIhCgaYWK6FQ1f/pBeVv6wCeEEFLyGMsdpqz0bPzz91Wc3XoJoY/DIREXXlVIaCKEd31PdBkegPaD2tCqBMToeXt7IyEhAeHh4XB0dOQ7HFJGGMvnOiUHtMSyLCC6DDZjCSB+zXc4Rcc4QGzWCQff98PS2zeRmK14bdnSqLabOzpV9UFHbx/4UUFDQgghJYSxfImUlZuTi9AnEfgYGoNckRhm5iYo5+0B73pVYGZhXMsmE0KIsTGWz3VKDuiIZSVA9hGwGcsAaRzf4RSd1XBkWXyPdQ/uYuPDBxBJxHxHZFBV7B3QsWp+nQIqaEgIIcSYGcuXSEIIIfphLJ/rlBwoImnKNCDnCN9h6AVjOwuwGoKPGen44+Z1HHkVwndIvKCChoQQQoyZsXyJJIQQoh/G8rlOyYEiksZ3AiThfIehP4wDGLu5YCy74WlsDBZcu4K70e/5joo3VqamaFPZE528fRDgWZUKGpZBybnJuBp/Xe61gikoDOSnohQ8Z/7fUOd2LP77aP7vI5r99HUZmrR1MnNEA4f6sDIpvEYyIaRkMZYvkYQQQvTDWD7X6ZaolliWBfLuA4w1wJiVrsQAALApYHNOgbHshrruHtgd/DniMjORnitCmkiE0OQkLL11A7GZGXxHahBZeXk4E/oGZ0LfUEHDMiopNxmHPhzhOwy9MGFMUMe+Npo6NUEDx3qwFFJhMEIIIYQQko9GDuiAzb0LNmkkgBy+QykejDUYtztgGMUFhNJFIiy7fQPbnz6GtAyfPlTQsGx4nf4Gv4Ys5DsMvbMQWGB+nblwNXflOxRCiJaM5Q4TIYQQ/TCWz3WquqYDxqwpGMc1AEpp9V02E8h9qHSzrbk5Zrdth8P9B6KOm7sBAzMuz+JisfT2DXTduQ3ttm/GgmuXcS/6PSRSKd+hET2SsqXz75kjzcGmd1tL7fsjhBBCCCHaoeSAjhjzloD1KL7DKDZs7k21beq4uePQ519ibtt2sDHVLlHibm0Di1JU6C8iNQUbHz1A/wN78dmmtZjxz1lcCAtFjjiP79BIEUnYwut2lxYh6S9xKe4y32EQQgghhBAjUHquznjAMEIFpcFKAwEYi64atRQKBBhSrwE6e/ti/rVLOPnmtUb7taxUGamiHLxOTERmbi6ScrKLErBRSczOxr4Xz7DvxTMqaFgKlObkAADsjTqAug51aHoBIYQQQkgZR8kBHbFsLti8Z3yHUTyshoAxraHVLu42NljZtSf61gjDnMsXEJmWqrJ9dRdXfNWgEQQMA5FYjMMvX2Djo/t4l5xclMiNjmxBQyHDoFnFSlTQsIQp7cPuRVIRNr3bimnVv4eAocFkhBBCCCFlFRUk1BGbuR1s+ny+w9A/gRsYlzNgBDY6d5EjzsPqe3ew/sE95CmZf+/l4Ij9/b6Ak+X/l1WTsiwuhb3Dhof3y8TyiVTQsGR4kPwQf75ZzXcYxW5IlUFo7x7AdxiEEA0YS+EqQggh+mEsn+s0ckBXVoMA8Wsgex/fkegVY/VFkRIDAGBhYorvm7dCL78a+PnqRTyIjoZIIua2t6hUGb+16ySXGAAAAcOgfVVvtK/qjccxH7Hx4X2cCX1TaldEeBYXyxU1rGLvgI5VvdHR2wcNPcpDKKA7uMaitE8rKLA3aj/qOtSm6QWEEEIIIWUUjRwoApaVgk37Ecg+wHcoesPYzQNj1V+vfbIsi/TcXCRkZYJhGHg5OGq87/oH97DwxlW9xmPsnC0t0d4rP1HQslJlWJiY8h1SmXYr8Q7Whq7nOwyDqGbrh3Heo+Fg5sB3KIQQFYzlDhMhhBD9MJbPdRo5UAQMIwDsfgUs+4DN3ASILgIlvUShwEnvXTIMAztzc9iZm2u9b+0yuFQiFTQ0LtIyMnIAAF6lv8a3j6eivmM9tHVtjbr2dagOASGEEEJIGUHJgSJiGAYwawzGrDHYvBdgkwYCbCbfYemuGJIDRVHDpWwPcf60oOFnFSuhs7cvOnv7wtXamu/wygRJKS9I+CkppHiY/AgPkx/B0dQRbVxbobVrK7iau/AdGiHEiIlEeXgTEY/omBTk5klgZipEeQ8H+FZxhbk5jYAjhJCSgJIDesSY1gTs5oNN/ZbvUHQn0HzIvyE4WlrCw9oGMZkZfIfCOwnL4kZUJG5ERWLO5QtoWK48uvj4obO3Dyra2fMdXqlVVmoOKJKcl4yj0cdxLPoEOnt0xBeVPqfCmYQQTlZ2Lk5ffo5Tl57hbXg8JJLCyVShUABfT1d0a1cbXdrWgpWlGQ+REkII0QTVHCgG0tTZQPYevsPQCeN2F4zAge8wOFl5eZjxz1mcfvsaEjpVlart6obOPn7oUNUb9v9N32BZgAWbP9Hlv18dC/b/r//3/wWbCz4KuP9H/goSBdvY/zqVfa562yfHUrH9v/+p2MbKvR8pm/9c1TQeZ4csQCBWur3gN6LOs9TnuJpwXW27sqC9WwAGVfmSphoQwjO+56ZKJFLsOnoP2w/eRnZOnsb7WVqYYkjwZ/gysAmEQvocIYSQAnx/rheg5EAxYNkcsIn9APErvkPRkhCM+/P8WgpGJk0kws2oSFyJCMPViDB8zKCRBES5CvZm8KnxFFKUrSkBhtDWtQ2GeQ6mBAEhPOLzS2TkhyT8suIkXobG6txHDR8P/PRNN1SuYFxTGQkhhC/Gkhygb3fFgGEswDisABgr9Y2NicDBKBMDAGBnbo4uPr74rX0nXB/+NU4PHIqZrdqgecXKMP1v2T8fRyeMb9IMNOiZtKwBSgwUkyvxV7EpbAukZawWAyEEeBkag7GzdhcpMQAAIW/z+3n1rmj9GJO4uDhs27YNEyZMQIsWLeDl5QVbW1uYm5ujXLly6Ny5M9asWYPMTNV1qbZu3QqGYTT62bp1q8I+5s6dq3EfBT9z585V+x5DQkIwdepU1K1bF46OjrC0tISnpyc6dOiABQsWIDw8XPtf3H9iY2OxceNGfPnll6hZsyZsbGxgZmaGcuXKoUuXLli/fj2ys7M17i8iIgLff/89qlevDmtrazg5OaFJkyb4/fffkZWVpXOchvL06VOYmppyf59hw4apbK/p39nf31/tscPDwzF9+nQ0atQIDg4OMDU1hZOTE1q0aIFffvkFcXFxavdfuXIlgoOD4evrCysrK1hYWKBixYro3bs39uzZA7FY3chOzcXFxeGXX35BixYt4OTkBFNTUzg4OKBRo0aYNm2axuelWCzG2rVr0bp1a7i6usLS0hLe3t4YPXo0nj9/rrd4jR2NHChGbPYxsKlT+A5Dcya+ELic5DsKrWXm5uLW+0jcj/6Adl7eSM3JwaSzJ5EjFkPAMJDSKV6mmAmBdp9FIlNCo0uKU3PnZhhVdQSEjJDvUAgpc/i4wxT5IQljZ+1GarrmF2jq2NtaYs2vA0rFCIKNGzdi1KhRattVqVIFBw8eRKNGjRRu37p1K4YPH67RMbds2aLwonHu3Ln4+eefNeqjwK5duzBgwACF21iWxY8//ojFixervKhbtmwZJk+erNVxAWDDhg0YO3YsJBLVNX58fX1x4MAB1K1bV2W748ePY9CgQUhLS1O43c/PDydPnoSPj4/WsRqCVCpF8+bNcffuXe61oUOHKk0GAdC4HlDbtm1x+fJlpdv//vtvjB49WmUixsnJCXv27EHHjh0Lbfvpp5/w66+/Qt3lZZMmTXDgwAFUrlxZo7iVOXfuHL744gskJycrbWNpaYl169Zh8ODBStskJCSgW7duuHfvnsLt5ubmWLVqFUaOHFmkeFUxlpEDVJCwGDGWvcCKLgA5p/kORTNGtlKBpqzNzNChqg86VP3/h/zu4P7Y++wpxjVphsGHDyAiNYW/AIlBtatpxSUGhBBAQiMIisWtxDsQsxKMqToKJgL6TwkhpZlEIsUvK07qNTEAAKnp2Zj35ymsXfBlia9BwDAMfH194e/vjwYNGqBChQooV64ccnJyEBERgR07duDs2bOIiIhAx44d8ezZM5QvX15ln2fPnlXZpmLFigpfHzduHPr27auyb4lEgjZt2iAtLQ12dnbo3bu30rZff/01Nm7cCABo1KgRvvrqK9SpUwc2NjaIi4vD3bt3cfDgQZ0L1sbGxkIikcDMzAw9evRAp06dUKNGDdja2iI0NBQbNmzAuXPn8ObNG3To0AEPHz5U+t4fPXqE/v37Izs7GzY2Npg5cyYCAgKQnZ2NPXv2YMOGDXj9+jW6d++O+/fvw9bWVqeYi9OqVatw9+5duLm5qb1L/6mxY8di3LhxSrdbq1jp6saNGxg2bBikUikEAgGGDh2KwMBAlC9fHpGRkdi2bRuOHz+OpKQkBAYG4tmzZ6hatapcHx8/fgTLsrC2tkZQUBDat28PX19fWFhYICQkBH/++Sfu3buHe/fucX9LGxsbrd5jgXfv3qF3795cIiMwMBCDBw9G5cqVER0djSNHjmDbtm3Izs7GsGHDULVqVbRs2bJQPxKJBEFBQVxioE+fPhg1ahScnJxw584dzJ8/H3FxcRg9ejQqVKiArl276hRvSUEjB4oZm3MWbMpEvsPQjHkXCBz/5DsKvfuQloZuu7YjPVfEdyjEABpVsUTFyhGwlJSH2CQRsbkf+A6pVGvo2ACjq46EhdCC71AIKTMMfYfp70N3sG7ntWLrf/TA1hjcp1mx9W8IBX8PVZYvX45vv81f0erbb7/F0qVLC7WRHTkQFhYGT09PvccKAKdPn0a3bt0AACNGjOAu/j+1efNmjBgxAgDwww8/YP78+UqTALm5uTAz0341imXLliE2Nhbff/89XF0VL2H9/fffc7+v4cOHY/PmzQrbtWnTBteuXYOJiQmuXr2K5s2by23//fffMW3aNADAnDlzNJpOYUjv379HzZo1kZGRga1bt2Lo0KEANB85UJT31KNHD5w8mT+CePXq1QqTDLJ/h/Hjx2PVqlVy26dPnw5nZ2eMHTtWYeJFIpHgyy+/xL59+wAAP//8M2bPnq1TvBMmTMDq1asBAFOnTsXixYsLtVm5ciW++eYbAED37t1x4sSJQm1kz/Fx48ZxfRZ4+/YtGjVqhLS0NPj4+CAkJETtv3VdGMvIAUoOFDNWmg42rhkA/c2tKTam9cA47TXaugO6YlkW9datQkZuLt+hEAMxFzKQsCz6tRTjfd5rvsMp9WxNbNGtXBe0dwuAudCc73AIKfUM+SUyKzsXgSPXaLUqgbasLM1wZMOYUr/MoVgshqOjIzIyMtC4cWOFQ5gNlRwYMGAA9uzJX1nrypUraNOmTaE26enpqFKlCpKTk5VeWBlKbm4uPD098fHjR9jb2yMpKQkCgfz31bt376JZs/wk0+jRo7F27dpC/UilUtSuXRshISFwcHBAXFwcTE1NDfIeNBEYGIhjx45h+PDhmD17Nry8vAAYJjng5OSE5ORkODs7IyEhQWGb1NRUODg4AAAaNmyIBw8eaH2cxMRElC9fHrm5uahTpw6ePn2qU7wNGzbEo0ePwDAMUlJSYGdnV6gNy7JwcXFBUlISnJyckJiYWKhNzZo1ERISAicnJ0RFRcHKqnDNuIULF2LmzJkAgH379qFfv346xayKsSQHStdVoBFiBLaAaQO+w9BM3hMgayffUehdQnYWJQbKGJGEhVgKsBK6UDWEdHE69kbtx9SnM3Am5hxypfTvjZDS4vTl58WaGADyExBnrpT+gl8mJiawsMgfZZWTk8NbHGlpaTh69CgAwMvLC61bt1bYbufOndxc7lmzZhksPkXMzMy4IeGpqakKL/KOHDnCPVZWt0EgEGDIkCEAgJSUFFy6dEn/werowIEDOHbsGJydnfH7778b/Pi5/31XLkhIKGJvbw8XFxe59tpydnbm6kaEhobq1Ifs8Z2dnRUmBoD8pEnB1AdF8b5+/RohISEAgM8//1xhYgCAXG2Pw4cP6xxzSUDJAUMQqp5TZkzYjD/AiiP5DkMvCgoRhqkoUkJKt9xc47kbUBak5qVhd+ReTH0yA0m59O+OkNLg1KVnhjnORcMch08XLlzg7shWr16dtzj279/PzdMePHiw0mkC+/fvBwC4uLjIDc+Pi4vD27dvlRb8Ky4i0f+nhwqFhYvhXr9+HUD+vHplBR+B/KJ8BW7cuKHHCHWXmprKDX9fvHgxnJ2dDR5DtWrVAOSPWFEmLS2NO4cL2uui4G+p6O+oqYLjJyYmqjwX3717J9deVsE5A8ifF5/y8PCAn58fAOM5Z4oLJQcMIe9fviPQHJsN5N7kOwq9YFkWV8LDEJZCFyllVUYOfcTxISUvFYffH+E7DEJIEYlEeXgbpl1BNF29CY+HKLcETMHUUnp6Ol68eIG5c+ciKCiIe33SpElq9x0+fDjKly8PMzMzuLi44LPPPsOPP/6IDx+KVktn+/bt3OOCu+ifkkql3LSHOnXqgGVZrFy5ElWrVoW7uzt8fX1hb2+P+vXrY9OmTZBKi7f4b15eHm7dugUAcHd3h5NT4SLaBXeAfXx8VM4Jl03MFOzDt+nTp+Pjx49o3bq1xqtVKLJ//37UrFkTVlZWsLW1ha+vL4YOHarRCIkxY8YAyL/YVjQlAwDmzZtXqL224uLiuN97jRo1dOpD9vgsy2LBggUK26xevRpJSUly7WW9ePGCe6wuYVewPSoqSu2SpCUZfXMuZqw0DZC84zsM7Zjwl83WJ6FAgJvvI3Eu9C3foRCepJTez26jdy3hBiIyS8coJELKqjcR8ZBIDVOaSiKR4m14vEGOVdzmzp3LrStvZ2eHWrVq4eeff0Z6ejqEQiFWrVqFVq1aqe3n8uXL+PjxI/Ly8pCYmIg7d+7g119/hY+PD9atW6dTbOHh4bh2Lb+4ZMuWLeHt7a2wXVRUFNLT0wHkz0UPDg7GN998U+iu8pMnTzBy5Ej06dNH52Hmmli/fj13x1rRfO+cnBxuu7KVDAo4OjpyVfujoqL0HKn2bty4gfXr18PU1BRr1qzRedUHIP9iNyQkBNnZ2cjIyMDbt2+xfft2tGvXDkFBQUhNTVW671dffcUli8aPH49Ro0bh+PHjuH//Pg4dOoSgoCD88ccfAPKnmXTo0EGnGH///XduSczPP/9cpz4AoGPHjtx0l0WLFiE4OBiHDh3C/fv3cfz4cYwYMYIbjTF06FCFSZf3799zj9WdN5UqVQKQn4yQ3a+0oeRAcZPGASZ+AHT/h25obNpcsLmK1/ksadp5VsWl8BKWnCF6E5ta+u5ClRQsWCx6+TuuJ9xUu94xIcQ4RcekGPR4H2INezxDa9++PZ49e4bx48erbFe1alVMmTIFBw8exN27d3H37l3s2bMH/fr1A8MwyMnJwZgxY7B+/XqtY/j777+5z+SCSviKFNxtBYCTJ0/i8OHD8PPzw7Fjx5CWlob09HScOHGCu5t69OhRzJgxQ+t4NPHu3TvuIrBgecJPFSQyCtqoU5AcyMjI0FOUusnNzcXXX38NlmXx3XffoVatWjr1Y2VlhS+++AIbNmzAtWvX8OjRI5w7dw6zZs3ipigcOXIEgYGByMtTXENEKBRi27Zt2L9/P+rVq4eNGzeiV69eaNKkCYKDg3HkyBEEBATg/PnzmD9/vk5x3rlzB8uXLweQfzE+duxYnfopMH/+fJw/fx4BAQE4dOgQgoOD0aRJE/Tq1QubN29GvXr1cODAAWzdulXhFAZtzhvZZSD5Pm+KEy1OXcwYEx8wLifASuLBJn4OSEvAsmriF2CTBoI17wzGdioYk8p8R6SzOu4efIdAeBSdmouSe/aWfJmSLGx4twl3E+9imNcQOJkVHgZKCDFeuXkSgx4vL690JHTHjRuHvn37AgAyMzMREhKC7du348KFC+jfvz/Wr1/PVdX/VFBQEIYOHVro7nGTJk3Qv39/nDhxAn369EFeXh6+/fZb9OrVCx4emn/X2bFjBwDAwsJC5V1b2WHTOTk58PDwwPXr1+WWGuzevTuaNWuGevXqITo6GqtWrcJ3332n9g6sNrKystCnTx/ujvfKlStRvnzhWl6yBR41WU7R3Dy/YHFB7QW+LFy4EC9evICnp6fOS/oBwIcPH7hVBGR17NgREydORNeuXfHo0SNcuXIFa9as4e6of6rgXP33X8VTom/duoVNmzahRo0aqFChglYxxsbGom/fvhCLxWAYBtu2bVNaAFBT0dHR2LJlCzfl5FNPnz7F1q1bUaNGDdSsWbPQdm3Om4JzBuD/vClONHLAQBihKxjHPwGUoAJporNgk0fzHUWRPPhYApIxpNjkSfKX2SP8epL6L374dzZuJtzmOxRCiBbMTHUvFqYLU9PScc/Kzc0NtWvXRu3atdGsWTMMGzYMFy9exPz58/H06VP4+/vj3LlzCve1t7dXOay8R48e3EVkVlYWNm3apHFct2/fxuvX+cv7BgYGwt7eXmnbglUVCkybNk0uMVDAxcUFP/zwA4D8ugCHDh3SOB51xGIx+vXrhydPngAAxo4dK1c1Xlm8mkxvKCiIZ2lpWfRAdfTq1SturvzKlSuLdKGsKDFQwN3dHQcOHOCWbFy5cqXCdteuXUPz5s1x/PhxVKhQAX///TdiYmKQm5uLqKgorF69GlZWVtizZw+aNm2K5881X2EkPT0d3bt354bjL1y4EO3atdP8DSoQEhKCpk2bYteuXbC2tsZff/2FqKgo5ObmIiYmBtu3b0eFChVw4sQJNG/eHFeuXCnUhzbnjWxBTD7Pm+JGyQEDYkzrgHHaVbLm9LNZfEdQJNcjI/gOgfDMSkDJAWOQLcnGtvDtyJHwt3wXIUQ75T0cDHq8Cu6GPZ6hzZo1C02bNkVOTg5GjRrFzbvW1tdff80lEBRd8CijSSHCAra28v/t7NSpk9K2nTt35h4XFDEsKpZlMWzYMJw6dQpA/tz0VatWKW0vG68mQ74LRkZoMgWhOLAsi9GjR0MkEiEoKAg9evQo1uNVrVoVHTt2BAC8ffsW0dHRcttFIhEGDBiA1NRUeHh44Pbt2xg0aBDc3d1hamqKihUrYty4cbh69SosLCwQHR2tclqKrJycHAQGBuLBgwcAgClTpmDatGlFfk9DhgzBhw8fYGVlhWvXrmHs2LGoWLEiTE1N4e7ujsGDB+P27dtwd3dHWloavvzyS7kLfEC780Z2NA1f540hUHLAwBizemCcD4GxnQEwRRtKYxBsyR42Q8kBYspaq29EDCJHKsJfb9chPDP/32WutHjXTieEFI1vFVcIBYapmSQUCuDjWfjOdGkTGBgIAIiMjMTdu3d16sPNzY2bR67pygW5ubnYu3cvgPw7ybIX9IpUrFhRbgRDQTE2RWS3xcfrp6jk+PHjsXPnTgBA165dsWPHDggEyi9bLCwsuN+JumJxycnJ3IWeqvdVnG7fvs0ldlq0aIE9e/YU+jl+/DjXPiwsjHv92TPdlv2UHVb/6Xlz5swZ7rWJEycqnapSq1YtDBo0CADw4MEDblSHMmKxGJ9//jm3WsLIkSPx+++/6xS/rCdPnuD+/fsAgIEDBypd9aBcuXKYOHEigPwpCGfOnJHbLjsFRt15U1C8kmEYvU6dMTalY/xWCcMwJoD1V4BFV7BpcwGR+uVFeFOCkwNSlqVlDAkgsVDfhhjMk9SneJL6FBUsy4MBgy8rf4HonI9o5+YPIWPYIcyEENXMzU3h4+WGV6GxxX4sX09XmJuV/q+lskPzIyIi0KJFC5360bai/YkTJ7gigwMHDlS7vry1tTWqVKmC8PBwAIBEorz+hOw2VUsIamr69OlYs2YNAKBNmzY4ePAgNyRelZo1a+LatWt4+/YtxGKx0lhevnzJPS7KUnpFIXsHe+rUqWrbX716FVevXgUAzJkzB7Vr19b6mKrOGdklHRs2bKiyn0aNGmHjxo0A8n+X9erVU9hOKpVi8ODBXJKjf//+Oq+yUdR4C7x8+ZJL0AHyCZOXL1+ifv36SvspOG8qVaokV5ywtKGRAzxihOXA2HzLdxhqiMCyxbt2bXERMAxaVKRydGWdKK8E1fkoQz5kR+N99gcsfrUEOyJ24Y9Xy5CRV3qr/xJSUnUL0P4iRKfjtDPMcfgme8dW16HJ8fHx3LJ9iorzKaLNlIICbdq04R6/e6d85afQ0FDusbZF6j41f/58LF68GEB+EcYTJ05oPL+7YHnIzMxMbgi7IrJTMVq2bFmEaEuWFy9ecI8/PW9kEynqprvIrnagKhk0evRo7NmzBwDQs2dPtaM/tKGveGWXFFU1RScmJoar11HazxlKDvCNKQGZpxI8eqBjVcXr95KyIzOHPuZKghdpIZj7Yh4is/hfc5oQ8n9d/WvB0qJ4k6xWlmbo0la3JdxKEqlUioMHD3LP69Spo1M/69ev55YjbNu2rdr2iYmJ3Nz9evXqKb3T+6ng4GDu8eHDh5W2ky1C2Lp1a436VmTFihX46aefAOT/bs6cOVOo9oEqvXv35h5v2bJFYRupVMolShwcHBAQEKBzvEXh7+8PlmVV/oSFhXHthw4dyr0+d+5crY8XFhaG8+fPAwC8vb0LJXG8vLy4x9euXVPZl+xFtOx+sr777jtudEH79u2xf/9+vYwqUXTcosTr5+fHjR7Zt28fsrIU11rbunUr9zgoKEjbcEsU+tbMNwElB4pTu6reEGo59I6ULskZLN8hEA3FixIw78UC3Eu6z3cohJD/WFmaYUjwZ8V6jMF9msHKUv3yc8Zsw4YNKofeS6VSfP/999x88datW8PT01OuTXh4OB49eqTyOCdOnMAvv/wCIL9i+vDhw9XGtnv3bu7uqaajBoD8lREKhq8vX75cYXX6kJAQ/PHHHwDyp0z06dOnUJu5c+eCYRgwDCN3kSVry5Yt+Pbb/NG0fn5+OH/+PJyctFv+tmnTplxyYtOmTQqXt1uyZAk3JH3SpElKpysUxPvp38gYHT9+XOXd89jYWAQHB3PV+MeNG1eoTfv27bnVEtasWaN0KcPTp09ziaIKFSooHIY/d+5cLFu2DEB+PYWjR4/KLQOoifDwcO5v4O/vX2h7gwYNuATHwYMHceHCBYX9PHz4EGvXrgUAWFlZKVwhYcqUKQCApKQkhYUSQ0ND8dtvvwEAfHx8Sn1yoPRP7jJ2TAmodlmCkwOuVtaY2aot5l+7zHcohCfxaVJUdOc7CqKpXGkuVr1dA3dzN1ibWOOHGtNhKqCpIYTw6cvAJrhy+zVeFkPtgRo+HvgysIne+zW0r7/+Gj///DP69u2Lzz77DFWqVIGVlRWSk5Px6NEjbN26FU+fPgUA2NnZYfXq1YX6CA8PR0BAAJo3b46ePXuiXr16cHNzA5A/rP/AgQM4cOAAN2rgjz/+0GgYf8GdchMTEwwcOFDj9yQQCLBmzRq0b98emZmZaNWqFaZNm8bdbb969SoWLlzIVXnXdTm+I0eOYNSoUWBZFnZ2dlixYgXi4+NVFjf08vJSOO97xYoVaNmyJbKzs9GpUyf88MMPCAgIQHZ2Nvbs2YP169cDyE9AfP/991rHaowmTpyIvLw8BAcHo3nz5vD09ISlpSUSEhJw+fJlrFu3jpuG0qpVK4wfP75QHw4ODpgxYwZmz56N9PR0tGjRAhMnTkTHjh3h6OiI2NhYHD16FBs2bIBUmj/deOHChYWmCaxcuRI///wzgPzkweLFi+VGQChSrVo1jWpKyBIIBPjtt98wZMgQSCQSdO3aFaNHj0bPnj3h5uaGpKQknDt3DitXruRGA8ycOVPhko9Dhw7F5s2bcePGDaxevRoxMTEYNWoUHB0dcffuXcybNw9paWkQCAT4888/9ToCwhgxbMEnDOGNNKYWAOOt2s04rANjwc+wK31gWRaTzp7Eidev+A6F8MBMCLRs+hpiVrclowi/RnoNR2vXVuobElKGvHnzhiu45uvra5BjRn5IwthZu5Garr8bBva2lljz6wBUrqDdHWJjpGmBwBo1amDHjh0Ki6hdvnxZo2HuVlZWWLZsGb7++mu1bV++fMkNm+7WrRtOnjypUZyyDh48iOHDhyM9PV3hdlNTU/z5558YM2aMwu1z587lLhi3bNmCYcOGyW0fNmwYtm3bplVMly5dUnhHGci/kz5o0CCkpaUp3O7n54eTJ0/Cx8dH4fbs7GwuydGwYUOV9QuKU3h4ODcMfujQoUpHXXh6eiIiQv3qXMHBwdi4caPCC2Qg//vyd999hxUrVkDV5aGpqSkWLFjA3XGX5e/vr9XymkD+lAdFo2gK3nvbtm1x+fJlhfv+8ccf+OGHH+TqCnyKYRhMnjwZS5YsUfrvNCEhAd26dVO6FKe5uTlWrVqFkSNHqn9DOuLjc12R0p36KCkYK4BN5TsKpdjsXSU6OcAwDBa274zXiYl4nZjAdzjEwHIlgDihPkxcHlOCoATaGLYFEVmR+LxSP5jRCAJCeFO5ghOWzu6L7345oJcEgb2tJZbO7lsqEgNA/rJup0+fxu3btxEWFobY2FikpKTAysoK5cuXR8OGDREUFITAwECld0kbNWqEHTt24NatW7h//z4+fvyIhIQEiMViODo6olatWmjfvj1GjhzJjShQ5++//+YeazOlQFZwcDCaNGmClStX4uTJk4iKioJUKkWlSpXQoUMHTJ48WemFNh969uyJp0+fYsWKFTh58iTev38PMzMz+Pj4oF+/fpgwYYLKEQ6y0xEKpjoYs23btuHKlSu4desW3r17h4SEBKSlpcHGxgaVKlVCixYtMHToUDRv3lxlPwzDYNmyZRg0aBA2btyI69evIyIiAllZWbCxsYGPjw/atm2L0aNHw8/Pz0DvTrUpU6agZ8+eWL9+Pa5cuYK3b98iIyMDVlZWqFKlClq1aoWRI0fKrVigiIuLC27evIkNGzZg165dCAkJQWZmJsqXL4/27dtj0qRJqFWr9NdFAWjkgFGQxvkD0mi+w1CBAeNyDoxJFb4DKZKwlGQE7tmBjP/mXJGypWsdK2RY01z2kqqyVSXMrD4NVibaD1klpLTh8w5T5IckzPvzFELexujcRw0fD/w0qRsqly8diQFSuhSMdPD19UVISIjaZR8J0QdjGTlABQmNgdEXJWTBZu3kO4gi83JwxLJO3fgOg/DkfhglhUqyyKwovMkIVd+QEFKsKldwwtoFX2L0wNZaFxG0sjTD6IGtsXbBl5QYIEarYFj8Dz/8QIkBUuZQcsAYcMsZGnFV/ewDYKWZfEdRZO2remNCk+KtukyMU3yGGA4mjnyHQYrgXabydbYJIYYjFAowuE8zHNkwBt+Nao/q3u4QChV/pRQKBaju7Y7vR3XAkQ1jMLhPM6VtCeFbbm4u7ty5Ay8vLwwaNIjvcAgxOKo5YAwKkgOWfYDsIwCUL4XDGzYDkEQDAv6GuejLpGbN8TQ2Blcjw/kOhRiYDeOKFCTzHQbRUViG6orHhBDDsrI0Q58uDdCnSwOIcsV4Gx6PD7EpyMsTw9TUBBXcHeDj6QpzM/q6SUoGMzMzpWvdE1IW0Ke1MTCpCpjWB2PeBqzkA5B7m++IFBOW5zsCvRAKBFjepRu679qOj/8tv0PKBlGODUAjBEusd5lhYFlW46rghBDDMTczQS2/cqjlV47vUAghhOiIxnUZAcbmGzDmLfJXLBBHwCinFzAOYIy+NoLmHCwsEVyjNt9hEAOLSaLMQEmWLs5ArCiO7zAIIYQQQkolSg4YAUZgD5jWAWPuD4HbFTDuT8HYzuY7LHmlZNSArC4+JX+KBNHO82j9rc9N+PHTs7m4Gn+d7zAIIYQQQkodSg4YCYaxkHlsDsZ6EGDRm7+APiWswHcEeufn7AIzqkJbpqRmS+Fk6sJ3GKQIcqW5uJt0D3nSPL5DIYQQQggpVSg5YMQYi658h/B/pTA58DQ2BrkSIyz+SIqVFevKdwikiP5NfYaVb/6iBAEhhBBCiB5RcsCYmdbkOwIOUwqnFXjY2GB1t55wt7bhOxRiQNnZVnyHQPTgSepTrHq7hhIEhBBCCCF6QskBYyZwAwRGMgS6FCYHytvaoauPH7b2DoaduTnf4RAD+ZBohAU/iU4epzzBtvC/+Q6DEEIIIaRUoOSAEWMYBjCpwXcY+QSOfEdQbKo5u+DH1v58h0EM5Hl0DhhjXBGE6ORO0j2IJCK+wyCEEEIIKfEoOWDsTGvxHQEAgM3czncIxcrVqvQs00hUy8qVwsXUje8wiJ7kSnPxPO0F32EQQgghhJR4lBwwcoyx1B0QnQUrus13FMXGysyU7xCIAZmzznyHQPQoOTeF7xAIIYQQQko8Sg4YO0E5viPgsOm/gmXFfIdRLKxMKDlQlmRkUlHC0sTP1pfvEAghhBBCSjxKDhg7SSTfEfyf+BWQvZ/vKIqFlZkZ3yEQA4pKYPkOgeiJldASFSxLX8FUQgghhBBDo+SAkWPFb/gOQQ6bvgysNJXvMPSORg6ULS+isyFkhHyHQfRAzEqowCQhhBBCiB6Y8B0AUUP8lu8I5LEpYNPmAHYLwAhKz9BsK1NKDpQluRLA2dQdcbnRfIdCiihXmovkvBQ4mZXeFVUIKQlyxHkIiY9HRGoqciVimAlNUMXeHjVcXWFBCXhCCCkRKDlg7CQRfEdQWM4psLmPAbvZYCza8R2NXlByoCyiqQWlRWxOLCUHCOFBRm4uDoU8x4GQ53iZEA+xVFqojYlAgBouruhbszaCqteEDU3jI4QQo0XJASPHOO0Dcq+DzdwG5N3nO5z/k0aDTRkD1rwjGLufwAg9+I6oSIQCAcyEQuRKJHyHQgwkW5rBdwhETz7mxKCGXXW+wyCkzJBIpVj34B7W3L+DzLw8lW3FUin+jYvFv3GxWHzjKsY2bobRjZpAKKCZrYQQYmzok9nIMQJrMBadwTgsAWDOdziFic6DTV/IdxR6cXXYSKzvEYi2VTz5DoUUMwEDZIgpOVBa3Ey4hVxpLt9hEFImvEtOQp99u/DHretqEwOfyszLwx+3riN4/268S04qpgiNT//+/cEwDPcTHh6utO3cuXPl2qr6uXz5ssrjSqVS7N27F71790alSpVgYWEBKysreHl5oX///jh9+rTK/fPy8nDmzBl8++23aNGiBVxcXGBqagoHBwc0bNgQU6dOxbt373T4jSh35swZfPHFF6hatSqsrKxgYWGBSpUqITAwEHv37oVUwegURZ49e4bRo0fD29sblpaWcHV1RevWrbF27VqIxca58lZmZiZWr16N9u3bo0KFCjA3N4e7uzsaNmyIiRMn4ty5cyr3T0tLw6JFi9CyZUs4OTnB3NwclSpVQt++fdX+rQEgKysLhw4dwtixY9GkSRM4OjrC1NQUzs7OaN68OebOnYuYmBi1/fj7+2t8DheFvs9PsViMtWvXonXr1nB1dYWlpSW8vb0xevRoPH/+vEixliQMy7I0traEkKb+BGTv5TuMwhhbMG63wTClY2h+eEoy2m/fTIPOSzEPO1P41nzCdxhEj+rZ18E3vhNgIqABcQDwKPkxjkefRBOnxmju3AwOZg58h0T06M2bNxCLxTAxMYGvr+GW8vw3LhbDjhxAck5OkftytLDAtt59UdvNXQ+RGa8TJ06gZ8+ecq+FhYXB09NTYfu5c+fi559/1qjvS5cuwd/fX+G25ORkBAYG4tq1ayr7CA4Oxs6dO2FuLn8DKj4+HjVq1EBiYqLK/c3MzLB48WJMmjRJo5iVEYlEGDhwIA4ePKiyXevWrXHs2DE4ODgobbNhwwZMmDABubmKk8ZNmzbFyZMn4eLiUpSQ9erSpUsYPnw4IiKUTyeuV68eHj9+rHDbrVu3EBwcjI8fPyrdf8iQIdi8eTOEwsIFmZ8+fYqWLVsiI0P1jRM7OzusX78e/fv3V9rG398fV65cUdlPAV0vQ/V9fiYkJKBbt264d++ewu3m5uZYtWoVRo4cqVO8muDrc/1T9C2qJBHY8x2BYmw6kHsfMG/OdyR64engiC4+fjj99jXfoZBi4mpDKxWUNk9S/8Xa0PUY6zO6zK9EkZSbhOVvVgIAQjPfYW/UftS2r4WWLi3Q0KE+zIXyFwESVlLmf2dEvXfJSXpLDABAck4Ohh45gP39BqCqo5Ne+jQ2GRkZGD9+PADAzc0NcXFxWu3/77//qtzu5eWldNsXX3zBJQa8vLwwdepU1KlTB3l5eXjw4AEWLVqEhIQEHDx4EC4uLli7dq3c/iKRiLvwql+/PgIDA9GsWTO4u7sjNTUVp0+fxsqVK5GTk4PJkyfD0tISX3/9tVbvT9Y333zDJQbc3Nwwbdo0NGzYEKampvj333+xaNEiRERE4Nq1a/jiiy9w5swZhf2cOnUKY8aMgVQqhbu7O2bNmoVmzZohKSkJGzZswKFDh3D37l0EBQXh8uXLCi+UDe2ff/5Bz549kZOTAwcHB4wZMwb+/v5wc3NDVlYWQkJCcOLECcTGxirc/9WrV+jatStSU1MhEAgwcuRI9O3bF87OzggLC8OaNWtw4cIFbN++HTY2Nli9enWhPtLS0rjEQMuWLdGjRw80btwYzs7OiI+Px6FDh7BhwwakpaVh4MCBsLOzQ9euXVW+r8aNG2PLli1F/wUpoM/zUyKRICgoiEsM9OnTB6NGjYKTkxPu3LmD+fPnIy4uDqNHj0aFChXUvu+SjkYOlCDS9CVA5jq+w1DMvCMY+0VgBDZgWQkAQZGHC/HpScxHBO3bxXcYpJi08bMC62RENTyI3vSv1A/dynXhOwyDkrJSSFgJTAX5o7fuJt3D6rdrFba1EFigiVMjtHRpASkrxbWE63iY/BitXVqirkNdvEl/g5fpr9DcuRk+c24GISOEhdBCro8cSQ5epb9BPYc6yBRnwtrEutjfI5Fn6DtMEqkUffbtwr9xii9OiqKuuwcO9htQKmsQTJ48GStWrED79u1RsWJFbNu2DYDmIwd0/Yp+//59NGnSBABQtWpVPH78GLa2tnJtIiMjUa9ePaSkpEAgEODjx49wc3Pjtn/48AHDhw/HL7/8gs8++0zhce7cuYOAgABkZ2fD3t4eUVFRhY6jidjYWJQvXx5SqRSOjo54+vQpKlasKNcmLS0N9erV46Zk3Lt3D40bN5Zrk5eXh+rVq+Pdu3ews7PDw4cP4e3tLddm/Pjx+OuvvwAAW7ZswbBhw7SOV59k74DXr18fZ86cgbu74tE0ubm5MFNQ0LNHjx44efIkAMXviWVZfPXVV9i6dSsYhsGdO3e486PAzZs3sWLFCsyZMwc1a9ZUePyjR48iKCgILMvC29sbb968Ufhdv2DkQNu2bdVOfdGVPs/PzZs3Y8SIEQCAcePGFUqevH37Fo0aNUJaWhp8fHwQEhICExP93183lpEDpe+TuBRjTBsCjPYfugYhOg82vj3YjDVgE/uBTewFNucs31HprJ5HOTSrUFF9Q1Ii2Viob0NKptuJd/kOwSAyxVlYH7oJz1KfY+HL3zHq/lhMeTIdf7xahhPRyueW5khzcC3hBha+/B2LXy3BrcQ7EElF+CfuIpa+Xo7jH0/iTcZb/B2xC+MefoOxDybil+e/Yn/UQTxMfoSr8dew4s0qHP1wDL88/xWTH0/BqY9nEJL20oDvnhjaugf3iiUxAABPY2Ow/qHiobwl2f3797Fy5UqYm5tzF6OGcvPmTe7x5MmTFV4QVa5cGcOHDweQX5vgzp07ctsrVKiAc+fOKb3wAoBmzZph3LhxAIDU1FScP39ep3jv3LnD1RIYPnx4ocQAkD+c/dtvv+We37p1q1Cbw4cPc3PMZ86cWSgxAAC///47HB0ducd8mzlzJhITE2FlZYUjR44oTQwAUJgYiI+Px6lTpwDk3/FXlOxgGAbLli2DtbU1WJbFokWLCrVp0aIF9u7dqzQxAACBgYHo06cPACA0NBSPHj1S9/aKjT7Pzz/++AMA4OTkpPCc8PHxwcyZMwHkJwoOHz5c1PCNGiUHShDGIgCMyznAsi/foSjGJoPNWAaInwHiV2BTJoLNUj13zJiNathEfSNSIlmaa1bQiJQ8EVkRiMuJ5zuMYnMl/hpWvV2DOc9/xo3Em/j91VK8Sn8NFiziRQn4N/UZIrKKvgQu+1/VFSmkCM18hxMfT2HFm1XYFLYVL9JCEJr5DqGZ75ArzcXeqP2IzIoq8jGJccrIzcWa+3fUNyyCNffuIkPJ/PCSSCwWY9SoUZBKpZgxYwb8/PwMenzZufZVq1ZV2k724lnZ/Hx1AgICuMehoaE69aGveI8cOcI9VjYiwMrKCp9//jkA4MWLF3j9mr8ppMnJydi1K3+U6qBBg1ClShWt+3jw4AE3wkTVcHcHBwfuQvr06dPIysrSIWL9/L0NSV28r1+/RkhICADg888/h5WVlcJ+ZM8nSg4Qo8IInSGwXwDGaT8gcFO/A8/YtFlgc3TLJPMtwNMLn9eszXcYpBiYmhpnpWKiH/eSS+eUkbS8dOyJ3Id7SfcRL0rgOxw5x6NPIFuSzXcYpBgcCnmu9aoE2srIy8Xhly+K9RiGtHTpUjx+/Bi+vr7cHUdDqlatGvdYVbV22Ysl2X20IRKJuMe6zt/XV7zXr1/ntnl4KF9iu23bttzjGzduaBWrPp04cQLZ2fmfm7169eJez8rKwtu3bxETE6N2aolsQT5Vow5kt2dlZeH+fd3+O6mPv7chqYu34JwB5M+LT3l4eHBJPj7PGUOg5EAJxZjVA2NfEpYQlIJN+RasqHjvOhQHhmHwa7uO6O5r2Iw/KX6MUKS+ESmxTkSfwvPU0nOhUWB/1AFkSXS721Pc0sUZ2Bu5H2/S3yItL53vcIgeHQgxzBJeB148M8hxiltYWBhXM+Cvv/4qtAqANjp16gQ3NzeYmZnBzc0N/v7+WLhwIZKTk1Xu17lzZ65Y4YoVK5CZmVmozfv377F161YAQKtWrVC7tm43Q2Sr0teoUUOnPurUqYMWLVoAALZu3Yro6OhCbdLT07F8+XIA+aMLOnXqJLc9IyMDUVH5I5iqV6+u8niy2wvuGvPh9u3b3OM6derg3r176NSpE2xtbeHr64ty5crB3d0dEyZMUFqM0MbGhnucmpqq8niy21+80O2/kdr8vV++fIlmzZrBwcEBFhYWqFixIgIDA7F9+3bkFXPCsYC6eGV/D5qeN1FRUQr/TZUWlBwowRjzVmBsZwOWnwMm/BWuUC8XbMoYsHklb41QoUCAJZ26oW0V5RWBSckjZfRTbZsYpyxJFn5/tRTnYs7rXNDL2LxNf4urCdfVN+TRpfgrmB/yG64n3EBSblKp+d2XZTniPITEa1dhX1chCfEQGen689oYM2YMsrKyMGDAAHTo0KFIfZ0/fx7x8fHIy8tDfHw8rly5gpkzZ6Jq1ao4evSo0v3MzMywa9cuuLi4IDQ0FPXq1cO6detw48YNXL58GUuWLEGjRo2QnJyMqlWrYvPmzTrF9/HjR64avaurq9wQbm1t2bIFXl5eSEpKQsOGDbF06VJcvnwZ169fx9q1a1GvXj2EhYXBxcUFO3fuLDT//v3799xjRTULZFWqVIl7XJBQ4IPshemlS5fQokULnD9/nqu/AOTXFFi9ejXq16+PJ08KL8Ese8GravnA3NxcuboSkZGRWsf75MkTrvBhnTp11CYHYmNjcffuXaSmpkIkEuHDhw84duwYhg4divr16xd7YkaT81OX84ZlWbn9ShtKDpRwjPUgCOzng3E+CsZuLsA48B2SYmwm2OQRYPO0vzPAsixYlr854mZCIdZ070kFCksREWucd1+J/rBgsTNyDzaFbUGe1DB3KIqLlJVie8ROvsPQWFxOHH5/taxEr1hD8oXEx0NioCSPWCpFSELJrheyY8cOnDt3Dvb29li2bJnO/dSpUwc//fQTjh8/jgcPHuD27dvYtm0bd7c8JSUFwcHBOH1aefHRzz77DI8ePcKUKVMQGRmJMWPGoFWrVggICMCUKVOQlZWFefPm4d69ezpVRmdZFqNHj0Z6ev5IoZ9++gkWFrpX+/Xz88O9e/cwb948ZGZm4vvvv0dAQABat26NsWPH4v3795gyZQoePXqksAhdQRyA/N10Rayt/7/CSsHyfXxISkriHo8ZMwYMw2D+/PmIjIyESCTC8+fPubnuMTEx6N27N9LS0uT68PPz46ZYnDx5Um6YvKwlS5YgIeH/09Fkf1+aEIlEGDlyJCQSCQDg119/VdpWIBCgffv2WLJkCf755x88evQIV69exfLly7mEwosXLxAQEKBTkkITmp6fJfG8KW6UHCglGMYEjNWXYFzPAVaDARjhPCBpEtjE/mAzt2h9sc8mjwAruqm+YTGxMDHF+h69Uddd+Rw2UnJkSmjYc1lRUJk/KVf1MFxjdinuMiKyiucLVHG4FH8FuRKaulMaRKgZpqz/46UY9Hj6lJiYiO+++w4AsGDBArXzv5WZPHkynj59il9++QU9evRAw4YN0axZMwwZMgRnz57F2rX5y5RKJBKMHDkSOTmKR8KxLIs9e/Zg3759CodwZ2RkYOfOnXJF/LSxYMECHD9+HEB+0bfx48fr1I+s48ePY+fOnQovvPLy8rBv3z7s2rVL4agk2d+Doqr+smSnehTM+eeD7ND0nJwcbNq0CbNmzUKlSpVgZmaGmjVrYsuWLfj6668BAOHh4VizZk2hfubPnw8gf9WJ7t27Y/Xq1YiJiUFeXh7evHmDb7/9FrNmzZL7vWj7vidMmMDVKRg6dCh69uyptO2hQ4fwzz//4LvvvkP79u1Rv359tG7dGpMmTcKTJ08wdOhQAPkjCyZPnqxVHJrS9PwsiedNcaPkQCnDCBwgsPsJjPMxwKwF3+EokAc2/TewyV+DlSSqbw78d/dJCjZ5GKRJI8Hm8VNZ1tbcHFt69YGfkzMvxyf6YWkqQI6UphWUJW8zQjHlyXSsfLMaT1KeQsrjSCRtiaViHHhf8iojS1gp3qa/hYSV8B0KKYJciWGH+edKSu758v333yM+Ph5NmzbFmDFjdO7HwcFB5fbRo0dza7JHR0fj4MHCq0JJpVL0798fU6dORWRkJEaMGIGHDx8iOzsbGRkZuH79Onr16oWXL19ixIgRWl+g7dy5Ez/99BMAwMvLC7t27YJAULRLiu+//x7Dhw/Hy5cv0bt3b9y4cQMZGRnIzs7Gw4cPMXz4cERGRmL69Ono27cvdwe7gOxdYXUrL8gWqbO0tCxS3EUhG3PdunUxePBghe0WLFjAXZju3bu30Pa+fftydS7S0tIwYcIElCtXDmZmZvDz88Py5cvh6OjIJREAKFzeUpnffvsNGzduBAA0adIEq1evVtle1TlsamqKjRs3cqMdDh8+jA8fPmgciya0OT9L4nlT3Cg5UEoxpr5gHLeAcVgDCFz4Dqew3KtgE3uBFWla8ZOR20+a+gNYieGHHzpaWmJRxy4GPy7RH3c7E75DIDyQsBLcT36Ipa9X4LvH03Ag6hASRUnqd+RZvCjBaIsQqpKcl4x5Ib9hwsNJWPlmNS7FXS7VS0yWVmZCw35empWA6ueKXLx4Edu2bYNQKMTatWuLfKGszujRo7nHiuaZr1mzBvv37wcAzJ07Fxs3bkSDBg1gYWEBa2trtGzZEkePHuUuRlesWMHdZVXn5MmTGD58OFiWhYeHB86fP69yZQBN+1y6dCmA/CXjDh8+jBYtWsDa2hoWFhZo0KABNm/ezF3wHTp0CH/99ZdcH7IXu+qGfMvesVc3lLw4ycb8aYFFWc7OzmjcuDGA/Hn/ii5iZ8+ejQsXLqBjx45yd7gtLS0xaNAgPH36FJUrV+Zed3R01CjGdevW4YcffgCQX5Dv1KlTcsPrdWFiYsIluADVtRK0pe35WRLPm+JG35JLMYZhAIv2AGMDNnkIACMrDiWNB5v8FVjrkWBsJoNhTBU2Y8XvgdxbsjsC2QfASuLAOG00TKwynscprhhLSgZnG/rYK+uS85Jx/ONJhKS/wo81Zhj13PiYnBi+QyiSLEk27ic/xP3khwCAOva18b3fZKP+nZP/q2Jvb+DjORj0ePqyaNEiAEDjxo3x6tUrvHr1qlCbsLAw7vHx48fh6uoKAPjiiy+0Pl7NmjW5x4ruuhbc5bW1tcWMGTOU9rNgwQL8/fffAIDNmzerHCoOAJcvX0bfvn2Rl5cHR0dHnD17Ft7e3lrHryzegjn3yvzwww9YtmwZMjIysHnzZkycOJHbVqFCBe6xumJxskUIZYsTGlqlSpW4FQvUxVGwXSqVIikpSeEFb7t27dCuXTuIRCJ8/PgRLMuiQoUK3HD5N2/ecG1r1aqlNr7du3dj3LhxAIAqVarg/PnzcHHRzw1HdeewLnQ5P2WLEL5//17l+ys4bxiGUVu8sCSjb8llAGPeDLBbADbnBJD3FGCNab41C2RuAJt7B7BfCsaksoImGcgf5PLJcMPcq2BzH4Exa2CIQDnXIiMMejyiXw6WDFQPHCNlxduMt3iZ/go17FQvX8Sn2JzSlYz8N/UZ7ibdQzPnpnyHQjRQw9UVQoYxSFFCE4EANVxci/04xaFguPGdO3cwYMAAte2/+eYb7rEuyQF1ybWCKvA1a9ZUuZRixYoV4e7ujtjYWLx8+VJln3fv3kXPnj2Rk5MDGxsbnD59GnXr1tU6dlXxurm5yV3kf8rCwgK1atXCnTt3CsVra2uLSpUqISoqSu17kd2u6/KL+lCrVi1uhMen0yQ+JbvdxET15Zu5uTk8PT0Lvf7gwQPucdOmqj+Djx07hiFDhkAqlaJcuXK4cOGCXi+I9Z0g1vX8lE1SvHz5EvXr11fatuC8qVSpUpFHTxgzmlZQRjBWwRA4bQHjdg+Myxkw9osBq0GAaR0Aiu/YG1TeU7CJgWCzTxTaxJhWB6y/UrgbK7pQ3JHJEUuluBlVcgqDkXwediYY0DoPA1rnwcGt9C4/Q7T3d8RORGbxt5SVKtHZH3E65hzfYejdnqj9EFHBwhLBwsQUNVzdDHKsGi6uMFdz0UPyyS6BV758+ULbCy4exRosDVlQrFDVBefTp0/RpUsXZGRkwMLCAsePH0ezZs20DVspfcXbqlUrAMCrV68QE6N81JXsMPaWLVtqFas+tWnThnv87t07lW1DQ0MB5CdInJyctD5Weno6zp49CwBo3ry5ypEKFy5cwOeffw6xWAxnZ2ecP39eLyNEZKk7h7VRlPOz4JwBVE9viImJwevX+TXP+DxnDIGSA2UMwwjAmFQFY9kbArvZEDgfBON6GTCpzXdo+csdpn6XX0/gkyJWjM1EQOhZaBfGxLB3/IQMA6dSXISktErNluJ93hu8z3uDuNyPfIdDjMiH7GjMefYLdkfuRbbEeKoPf8yOwYKQRUjJS+E7FL1Lyk3C0tcr8DG7ZE+ZKCv61lA//Fgvx6lpBN9DdHT58uX/ll1W/lNQoR3In2JQ8Lou1q1bxz1u27Ztoe1eXl4AgGfPniElJUVpP8+ePeOW0yvY51OvX79Gp06dkJycDFNTUxw8eBD+/v46xa1MwbETExO5UQSKJCUl4dmzZ0rj7d27N/d469atCvvIysrCvn37AOTfNfbz89Mx6qJr06YNN73k+PHjSkcPhIWF4fHjxwDyL0x1qWnx22+/cRX2Va0scfPmTQQGBkIkEsHe3h5nz57VaAqCNsRiMTZv3sw9l02SaKuo56efnx83emTfvn3IylJc40f2fAoKCtI53pKAkgMEjNAVjNMOwLw936Hkyz4ANmOp3EsMYwHGXtGaqixYSazWSyPqimEYTP6sBcwEQgyr1wDLO3dDF29fCGj+rFHLzpPC1sSO7zCIkZJCijMx5zDz6U849fEMQjPeQSw1bJX2T12Mu4x0sTFNAdOvl+mv8OOzOTj0/ghypYWXWSPGo0+NWrA2Ld4RhjamZgiqXlN9w1Lu33//xdu3b1W2Wb9+PTdH38PDQ+GFSkHtAJFIhO+++07p0n+y0xt69OhRqE1kZCQ6dOiA2NhYCIVC7Nq1C926ddPqPQH5RQYZhgHDMLh8+bLSeIH8pRwVFdyTSqX45ptvuG2K4g0KCkLVqlUB5F8MF9xtlzV16lQkJydzjxUJDw/n4tV3IkSWUCjElClTAAARERGYN29eoTZisRjjxo2DVJr/PVfRShh5eXlISEhQepydO3dydTHatm2LL7/8UmG7x48fo3v37sjMzIS1tTVOnjyJRo0aafWeLl26pDIhlZeXh5EjR3JJoJ49eyocxaDJ30Bf52fB3yApKQnTpk0rtD00NBS//fYbAMDHx6fUJwcYVte0JSl1WFYCNn0hkLWN71AAAIz9EjCW8sVxWNENsKIrQPZ+gM2U2WIOCCsAwoqASVUI7H4o1thCEuLh5eAAC5P8L0y330fhy0P7ivWYpGg+b5OBj7k0JYRoxkxgBm/rqvCz9YWfrS+8barCUmgJKSuFgCnevDrLspj29AfEieKK9TjGwt3cDUM8B6G2vWHuUJcGb968gVgshomJCXx9fYv9eH/du4M/bl0vtv6ntmiFsY31N0zdGA0bNgzbtuV/vwoLC1M4J3zr1q0YOXIkAgIC0LVrV9SpUwfOzs4Qi8V4+fIldu7ciXPn8qcaCYVCHD58WGERwYSEBNSqVQtxcfmfIa1atcKYMWNQvXp1SCQSPHr0CH/++Sc3tLtGjRp4/Pix3DrviYmJaN68OVfEbtq0aUqX2ivg6OiosGaA7Hu/dOlSoYu93Nxc1K9fn7tgrFOnDiZOnIh69epBKBTixYsXWLNmDW7dyi9O7e7ujmfPniksHnfq1Cn07NkTUqkU7u7u+PHHH9G0aVMkJydjw4YN3NKPrVq1wuXLlyFUsEJGeHg4NzKhbdu2ChMa+pKTk4OWLVvi4cP8oq1ffPEFhg4dCjc3N4SGhmLZsmXc++7WrRtOnDhRaL5+QkICKleujKCgIHTu3BnVqlWDQCBAaGgodu/ejWPHjgEAPD09cfXqVYUX46GhoWjRogV3zixbtgwdOnRQGbubmxvc3OSnHQ0bNgwHDx5Er1694O/vj2rVqsHOzg4ZGRl48OAB1q9fz513bm5uuH37tsJRIOr+Bvo8PyUSCdq2bYsbN/JXUAsODsaoUaPg6OiIu3fvYt68eYiLi4NAIMCJEyfQtWtXlcfRlaE/15Wh5AAphM3cDjb9V/C/uoE5GLcbYASF7/iyuffBJo8AWAXDgBl7CNzvGSA+ICErC9amprgX/QHDjhZea5gYjwGtWLwXKx+uSIgqDBhUsqqIoVUGwcfWp1iPJWEl+P3lUoSkqy6qVdp85tQMAyr3h4OZYSvkl0SG/hIpkUrRZ98u/FsMq/XUdffAwX4DICzm5f/4pmlyYPjw4Wr7cnZ2xqZNmxAYGKi0zePHj9GnTx+5VRIUqV+/Po4cOYIqVarIvX758mUEBASojUXW0KFDFQ7nV5ccAPLvnAcGBuLJkycqj+Hl5YVDhw6pLBy3YcMGTJgwQem69U2bNsXJkyeVVqYPCQnhCtX16dOHSygUl48fP6Jnz55yBQM/1a1bN+zZs0du6b0CCQkJ3PQEZVq2bImdO3cW+jsX0PTckzVnzhzMnTtX7jXZv7UqderUwZ49e+QKAspSlxzQ5/kJ5P8Ou3Xrhnv3FF8/mJubY9WqVRg5cqRWx9SGsSQHqPILKYSxHgIIK4BN/U7xxbfBiAAlyxsyZo0BhzVgk78GPq09zyivzKsPmbm5OBf6Fsdeh+B6ZAROfjkEMRmld/hvaSHOswBo9gfREQsWkVlRuBB3CXmsuFhXOMgWZ6OpcxO8zngDCau6gnVpcjvpDhJzE/FjzZl8h0I+IRQIsKxzN/TbvxvJOTl669fRwgJLO3Ut9YkBTXXr1g2bNm3CrVu38OjRI8TGxiIxMREsy8LJyQn16tVDly5dMGzYMNjZqZ4qV79+ffz777/Ytm0bjh49iqdPnyIpKQkMw8DNzQ0NGjRAv3790L9/f5gW87QRTVSpUgX37t3Dnj17cODAATx8+BDx8fHce69bty569+6NIUOGqK0UP2rUKDRv3hx//vknLly4gOjoaFhbW6NGjRoYOHAgRo4cqbIAY8GdegD49ttv9fYelSlXrhxu376NTZs2Yffu3Xjx4gVSUlLg7OyMpk2bYtiwYSqHsjs4OGDjxo24cOECHj58iJiYGOTk5MDd3R1NmjTBF198geDgYIMsITt9+nTUr18ft27dwosXLxAfH4+kpCSYm5vD3d0djRs3Rt++fREUFKRw1AZfXFxccPPmTWzYsAG7du1CSEgIMjMzUb58ebRv3x6TJk3Se+0FY0UjB4hSrOgm2ORh/AZhPQaMzbdKP9BY0WWwyeMByMxZFVaGwPUfvYfyLC4W6x/ewz/vQpEjU1H38Odf4l70Byy4rrzKKeFf1zpWyLC+z3cYpBSoaFkB/SoFw8fGGzYmNnrr92HyI5yNOY9X6a/B8j5yiz+L6y6Au4U732EYNb7uMD2Li8XQIwf0kiBwtLDAtt59UduN/tbEuBTc/Q4ICMDFixf5DoeUEcYycoBStUQpxrwFYK7dkB29y1wLNm1OodULCjDm/mAclgIQyr5YLKEsvnENJ16/kksMAEBmXh6G1muAvjXLRkaxpEqgwR1ET95nf8Cy139i/MNJmPH0R2x6twVX4q8hXhSvc5+hGe+w6u0avEx/VaYTAwCwO3IfFSk0UrXd3LG/3wDUdfcoUj913T2wv98ASgwQo1SwpN3s2bN5joQQw6PkAFGJsZsHxuZbQKh4jpJBZO8Bm/odWFbx3DHGojMY+0XgxoyLw8Hmqp6zpq3k7Gzceq+4mN2t95EwFQqxqH1nVHV01Otxif5EJdHFBtG/jzkfcTXhOjaHbcWcZ78gKTdZ6z7S8tKx6u1fZWoKgSqPUh5j0cs/kJ5HGT1jVNXRCQf7DcCU5q1gY2qmfgcZNqZmmNqiFQ72G4Cqjtqv1U5IcXv//j3Cw8PRunXrYl2pgBBjRckBohIjdANjM/a/i28e5ZwGxBFKNzOWvcDYzf/vWR7YlIlgJYl6O/y5d28hUTID5+CL55BIpWAYBuZCKuNhrGLScmGqpIYFIfqQKcnCxnebIdViaVUpK8Xa0PU6JRVKs7cZbzHvxQLE5eg+GoMUH6FAgHFNmuHmiNH42b896ri5w0RJ3QATgQB13Nzxi3973BwxGmMbN6MaA8RoVaxYESzL4urVq3yHQggv6EqGaMa0ASD0BCThPAah+q4aY9UPELqCTV8BiJ+DzVgGxn6+yn009STmo9JtMZkZuB4ZgbaeXhAaoNgL0RUDexNHJOSVjeXhCD+ep73AvBcL0M7NH02dmoBhBMiWZMHeVHEF/kPvj+B52gsDR1kyxIricDvpDnqVL7yeOTEONmZmGFy3PgbXrQ+RWIyQhHhEpKYgVyKBmVCIKvYOqOHiCnMVxd8IIYQYD/q0JhphGAawHg42bQ6PUai/G8eY+wNmbQHRZYDRbrijKs5WViq373/xDG09vQxSCZbozgJ2ACg5QIrXu8wwvAsLw67IvTBhTGAptMTsmj/A2sRa7jPiYfIjHP94ksdIjV9cDv17LSnMTUxQ36Mc6nuU4zsUQgghOqLkANEYYzUAYCzBps6C3OoABqPZfFyGYQAL/RZSdLNWXZH8/Lu3SBeJIKDkgFFjJaqTPIToU5YkCwCQJk7D7qi9eJn2ChWtKqK6bTWUtyyH9e828Ryh8YsrQpFHQgghhGiHkgNEK4xlb7C5D4DsvYY/uCQBMEV+YcLsQwCbCVh9ZZC79TEZqgtjedjYwtrMDJt79cHLhHjMuXwBb5OTij0uop2cHFNAfwNKCNGIs6kzbiXegYSVICE3EY9T9FswtTSjmgOEEEKI4VBFGKI1xmY8GJdTYJx2ACY+Bjsum/FHfmIg7wXYtNlg0xepXOZQX/Y8e4o19++qbNOnRk0IGAaOlpZoXqky9vTtX+Slnoj+JWfSRx4xPBtTG1qJQEfJeckISXsJVklBWEIIIYToD31TJlpjhB5gTHzAmDUF43wEsB5lmAOL34BNmQA2e9//X8veA0hji+2QF8PeYdbF82rb9aleS+65k6UVdgT1Q4tKlYsrNKKD2BS6QCOG5WXtiYgs5SutEPUWvvwdf75ZxXcYhBBCSKlHyQFSJAxjBsZ6hOEOKLoMZB+Qf43NKrbDtaniieVduqO2q5vSNs0qVEQl+8KVyG3MzLCpZxC6ePsWW3xEOxFJuXyHQMoQEwiRmpfKdxilwsOUx4jMiuI7DEIIIaRUo+QAKTJG4ARY9ucvADYLrOQD2MztkKZMAptzSW9dmwgE6OlXHUe/GISdQf3QtopXoTaB1Woo3d/cxAQru/bAuu6B+KJWHbirKWxIild2nhS2JnZ8h0HKCG9bbyTlJvMdRqlxOY7WHSeEEEKKExUkJHrB2P0CVuACZK42+LHZ5ImA9OP/n+c9B6Pn1QoYhkHzSpXRvFJlvEpMwMaH93HsVQjypFJEpqq+MygUCNDR2wfeTk6Y0aoNvj93GhfC3uk1PqI5G4ED0pHGdxiklLM3tce7jDC+wyhVbiXeQv9KfWEuNOc7FEIIIaRUouQA0QuGYcDYTgIr9ACbNgeA1HAHl0kMAAAkkWAlMWCExVMQsJqzC37v2AVTmrfCs7hYBHhVVbtPUnYWBhzcB2crK2Tn8bEMJAGAWuUtkSymxAwpfi5mzgilKQV6lSXJxr3kB2jl0oLvUAghhJBSiaYVEL1irPqDcTD86IFCcu8V+yHcbWzQvqo3BBospehkaYVdffohNScbEakpxR4bKaySoymqVH2DHGkO36GQUq6SZUWEZlISqjhcoakFhBBCSLGh5ADRP/MWgHlnwLQOIHDmJQQ2V/XSg3zwdnLG3r5foIq9A9+hlEnNqwHpYppOQIoXAwYiKRW+LC6vM94gOjua7zAIIYSQUomSA0TvGMYSAseVEDgfBON6E2AcDR+EESYHAKCinT329u0PP2cXvkMpc97Hm/IdAikD/Gx9ECeK4zuMUm1HxG5kiDP4DoMQQggpdSg5QIoVwzCAWWPDH1gSBlaSYPjjasDN2ga7+3yOuu7FUxOBKHY3LAuWAku+wyClmLXQCpFZ7/kOo9R7nvYCc579gtAMmrpBCCGE6BMlB0ixY6yHA4yt4Q+cV/x1B3TlaGmJHUH94OvEz7SLskgsBZyFVfgOg5Ri5S3LI1uSzXcYZUJCbiJ+DVmIeFE836GQ/+RKc/E2IxQ3E27javw13Ey4jbcZocilaTaEEFJi0GoFpNgxZo0B531gk78GJFEGOy6bexeMRVeDHU9bNmZmmNmqLb46dojvUMqMxCRbgIc8FSn9yluUw5uMt3yHUaZYCCzgaMrDtDXCyZZk40bCLVyLv46o7PeQsJJCbYSMEJWtKqG1S0u0cGkOSyGN4CKEEGNFIweIQTAm3mDsfzPsQQ2wYkFRta3iieYVK/MdRplx5102hPSxR0ipkCnJxOznPyMk7SXfoZQ5UlaK49EnMfnR9/g7YifCsyIUJgYAQMJKEJYZju0ROzH50fc4Hn0SUtaAyx0TQgjRGH1LJoaT+8iwxxO/Bpv33LDH1BLDMJjZqg3fYZQZqdlSuJtRMobol6+ND6JzPvIdRpn0ITsaMTkxfIdRpnzMjsEvL37FgfeHkCMVabVvjlSEA+8P4ZcXC/Axu3T/3UJCQjB16lTUrVsXjo6OsLS0hKenJzp06IAFCxYgPDxc5f5Pnz7F119/DT8/P1hbW8PW1hY1a9bE1KlTERERofb44eHhWLlyJYKDg+Hr6wsrKytYWFigYsWK6N27N/bs2QOxWKy2D4ZhNPoZNmyYFr+dwmJjY7Fx40Z8+eWXqFmzJmxsbGBmZoZy5cqhS5cuWL9+PbKzNZ+2FRERge+//x7Vq1eHtbU1nJyc0KRJE/z+++/IysoqUqzF4fr16xg0aBC8vLxgaWkJBwcHNGjQAHPnzkVCgu41tNasWSP3d9q6davStpr+rWV/FLly5Qp+++03BAUFoVatWnB3d4eZmRns7e1Rp04djB07Fg8ePND5PSmir7/3zZs3MWjQIFSpUgUWFhbw8PBA586dsXv3br3Ga8wYlmVZvoMgZYM0aRiQe9PwBzZrBcb6K8C0JgAzgDEDYKr0Q40PT2I+4uSbVzj99g0+pNNye8Wpd0NLJJrp9z9KpOwyZ8xhKjSl6vk8+tb3G9R3rMd3GAb15s0biMVimJiYwNfX12DHDcsMxx+vlunlfLcxscHUat/B07p01YJhWRY//vgjFi9erPLie9myZZg8ebLCbXPmzMG8efOg7Cu6ra0ttmzZguDgYIXbf/rpJ/z6669K9y/QpEkTHDhwAJUrK06ah4eHw8vLS2UfBYYOHarywlOVDRs2YOzYsZBIFI8+KeDr64sDBw6gbt26KtsdP34cgwYNQlqa4u9Tfn5+OHnyJHx8fHSKV5/y8vIwbtw4bNy4UWkbd3d37N+/H61bt9aq7+joaNSoUUPu97BlyxaliRxtvxf7+fnh1atXhV6vWLEiPnz4oHJfhmEwYcIELF++HAJB0e5V6+vvPXfuXMybNw9SqeKRTd27d8eBAwdgYWFRpHiV4etz/VNUc4AYBMvmALn3+Tl47nWwudcLv24zBYzN14aPR4F6HuVQz6McZrZq+z/27js8yip74Pj3Tp/MpDcCCaGFJs0CioCAICpgwd5X7G1XXdR1dX8KrmvvZbGXtfeK2BAVC0UUBEF6J70n02fu74/ImJCezMw7k9zP8/gYZt659yQzmcx73nvP4deiQhZu3sjCTRvZVVWpdWhdzqodfnK0e89Vupg+tt5sqNmkdRjd2i8Vq7tdckAL+c6CkCUGAGp8Ndy74QH+NeSfZFm7TveeSy65JHiid/DBB3PBBRcwfPhw7HY7RUVFLF++nHfeeafZE7G77rqL2267DYCsrCyuv/56Dj/8cKDuquY999xDQUEBZ511FosWLWL8+PGNxsjPz0dKic1mY9asWUyZMoW8vDwsFgvr16/nkUceYcWKFaxYsYKpU6fy888/Y7fbW/y+br/9dk444YRm709O7nj9j8LCQvx+PyaTiZkzZzJt2jSGDBlCfHw8W7Zs4emnn+bzzz9n06ZNwXizs7ObHOuXX37h9NNPx+l0Yrfb+ec//8nkyZNxOp28/vrrPP3002zcuJEZM2bw008/ER+vbSGiv/71r8HXS15eHtdffz0HHnggbrebr776ivvvv5/CwkKOP/54li1bxsCBA9s89lVXXUVVVRUZGRkUFbXeYnfNmjWtHvPiiy9y3333AXUJoabYbDaOPvpoxo4dS15eHllZWSQkJFBQUMDy5ct58sknKSws5NFHHyUuLo677rqrzd/T/kL1fD/55JPMmzcPgP79+3PTTTcxfPhw9u7dy8MPP8zixYtZsGABF1xwAa+++mqH440FauVAFyelH9BpfpVc1r6ErP63pjHsTyTMRcSdpXUYzZJS8ltxEa+uWc3rv7X+hq203UkTSin2FmodhhLj0k1plHrKCKD2T2spTh/HbcNuJd2cpnUoERPpK0wBGeC2df9hW+32kI/d19aXW4behE7E/k7X5557jgsvvBCAm266idtvv73Zz18ejweTydTgtt27dzNgwADcbjc9e/ZkxYoV9OzZs8Exe/bsYcyYMezdu5cRI0bwyy+/NLry+o9//IPU1FQuv/zyJk+G/H4/Z511Fm+++SYA8+bN45Zbbml0XP2VAy1dce6sBx98kMLCQubMmUN6enqTx8yZM4cHHngAgNmzZ/Pcc881edwRRxzBkiVLMBgMfPvtt4wdO7bB/ffeey833HADULdCY+7cuaH7RtppxYoVjBkzBoARI0awZMkSEhISGhyzdu1aDjvsMGpra5kxYwYff/xxm8b+4IMPOPHEE0lPT+fGG29kzpw5QOefx0MPPZTly5cjhGD79u1NrjrZ997UnNLSUsaMGcPWrVsxGAwUFBSQmtqx7l2heL7Lysro168flZWV9O7dm5UrV5KW9uffE7/fz6xZs/joo48AWLx4MZMmTepQvC2JlpUDsf9OrLRI1jyKrLm31aVlYY3BX4iseUCz+ZulRXvFdhBCMCwjkwxby9l8pf0M3iytQ1C6AKshTiUGooDD7+CRTY/h9rdv/7vSdgvyF4YlMQCwrXYbn+R/GpaxI6m6uprrrrsOqFt+/J///KfFCzP7JwYAXn/9ddzuutfxvHnzGiUGAHr16hW8wvnrr7/yySefNDrm7rvv5oYbbmj2Kqler+e///1vMIa33367le8uvK699lruuuuuZhMDAHfeeSdZWXV/u999990ml34vX76cJUuWAHDhhRc2OlGEuiTDkCFDAHj44Yfxer2h+BY65MUXXwx+ff/99zdKDAAMGzYsuP1kwYIFbbq6X11dzVVXXQXAfffdR0pKSkji3bBhA8uXLwdg0qRJzW5HaSkxAJCamsrFF18M1CUSli5d2qF4QvV8P/PMM1RW1q3UvfvuuxskBuDP3xe9Xg/UJRy6MpUc6MKkbzfUzofaZ5A1D2kXR/UdIGs1m79ZuuhODuyj10VPbYRoFW/WkZtiIt6sA1pPhG3eqw9/UEqX1s/Wl52OnVqHofxhp2MXXxYu0jqMLsnpd/Lx3gVhneOjvQtw+ttebC4avfLKK5SXlwNw8803d2iMn376c/vlscc234r5mGOOCX7d0RP71NTU4N79LVu2dGiMSDKZTIwbNw6AyspKSktLGx3z/vvvB7+ePXt2k+PodDrOO+88ACoqKli8eHHog22jfc+3xWJp8Up0/ef7nXfeaXXcf/7zn+zevZtJkyYFv9dQ+N///hf8urktBW1VP3Hlcrk6NEaonu994yQkJHDSSSc1OU52djZTp04FYNGiRVRXV3co5ligkgNdmT4LdH9kYR3/Q8rIZ0el+xtwLYz4vG0TGyU3rhx9GFP69tM6jKgTZ9Jx+hEOTjrEwoTRO+k9cBWjDlzLkWM3c+YEP+MHxCGaSRSYDCrhonScAQNlnnKtw1D2U+opa7adntJx35f82O6uBO3lCrj4oeTHsM4Rbm+99RYAaWlpDa5gFhUVsXnz5maLpdVX/4Q3MzOz2ePq3/ftt992JFyA4CqFfVdEo92+eKHpmL/7rq6+lM1m4+CDD252nIkTJwa//v7770MYYfvse75TU1NbvNrenud76dKlzJ8/H5PJxPz580MTKHVbXV9++WWg7ufbXDHMtggEAsEtLQCDBw/u0DiheL49Hk9wNcTYsWObXNGz/zhut7tBIq+rUcmBLkwIPVim1/1D1oJ3XeSDCERvZk1W3oz0td4OSGs6Ibh/2nT6daLYT1d0wmjJXs92ig0/U+3780OXV3rZ7d2ASPuJ6eP3ctphJvqnm4P3TzsgDmvmKg0iVrqK/vH9qPBWaB2Gsp9FRYu5ec2trKlcq3UoXcqS4iYK+oZjnhLtTtI6KxAIsGLFCgCGDx+OlJJHH32Ufv36kZmZSV5eHomJiYwaNYpnn3222Wro9YsC7lvm3JT6923fvr1DrfmKiopYv349QHDZdUseffRRBgwYgMViITExkQMOOIDLLruMn3/+ud1zd4TX6+XHH+sSSJmZmU0uld/3/QwYMKDFk+36J6P7HqOFfc93a4mj+s/3unXNf5b3er1ccsklBAIBrr/++g6fdDfl66+/ZufOutVyJ510UqsFLPfn9/vZs2cPH3/8MUceeWQwyTF16lQOOOCADsUUiud748aNwS4Zrf28ouV1E24qOdCFSSkhUPbnDZ6O7enpDGGdCbYrIz5vmwTykWVnI33Rv5wuwWzmqZknYm8ho9mdTDsgjt3+31o9rspXST6r6Nn/F047ooYzDtfjjP8Jn2y5t7OiNCfZmMyWmq1ah6E0I9+Vz1u73tW0zk5X4gl42OnYFZG5djp24Qlot/+7M3bt2hVcZpySksLJJ5/M3/72N7Zt29bguNWrV3PRRRdx0kkn4fF4Go1T/yT9m2++aXa++lePpZTs3r273THfe++9wVaLp512WqvH//zzz2zZsgW3201VVRXr1q3jySef5OCDD+ayyy5rcFU/HJ566ilKSkoAOPXUUxvd73K5gvc318lgn+TkZGw2G1D33Gll3/NdXV3dYpKl/vNdWFjY5GsH6p7TNWvW0K9fP/71r3+FNNb6Wwras1VBCIEQAoPBQHZ2Nscdd1zwtX3QQQc1qLvQHqF6vuv/7rQ2Tk5OTvBrLV834aaSA12Z8y1wfRj8p/Su1iQMYf8bmMZpMnerAkXIqtu0jqJN+iWn8ODR0+nuC+KTrHpkYvuvDOZ7drInoLo+KJ2TZEpSyaUot8OxgxvX3Myn+Z9R4w1N273uaqdjV8SKbvqln10RSkSEWlnZnxdiFixYwHvvvcfAgQP58MMPqaqqorq6mo8//jh45fGDDz7gxhtvbDTO8ccfH/z6tttua3IvtsvlCrY63Ke9+5+XLVvGQw89BNSdEF1++eXNHpuUlMTs2bN58cUX+eGHH/j5559ZsGABV199dfDq8ZNPPskFF1zQrhjaY+vWrcE6Dvva1e2v/s+gLVe1950s1tRo9x5R//n+17/+1eSKkpKSEu6///4GtzX1fG/evJl//7uuK9jjjz+OxWIJWZwOhyNY6yA7O5sjjzyyU+PFxcUxf/58fvjhhyaLbrZFqJ7v9oyzb4ymxulKVHKgi5LedY1PevW5msQihIjuzgCB5pfuRZspfftzzWGHax2GpiqcPlINHftjoiidkRvXm22121o/UNFcgauQ13a9yTWr5vBpwedahxOzilzFEZ6v9V7s0ai29s+iyy6Xix49evDdd99x3HHHER8fj91uZ8aMGSxZsiR4MvTYY481uuJ/2GGHMXPmTKBulcHEiRNZtGgRDocDh8PBokWLmDhxIqtXr26wN9rpbHsxx8LCQk455RR8Ph9CCF588UXi4uKaPLZnz57s2bOH5557jvPOO4+xY8dy4IEHMn36dB566CF+/vnnYMX6V199lQ8//LDJcTrD4XBw0kknBZfWP/roo02eUNZPpLS0b3wfs7luu2F7fnahduqppzJy5EgAFi5cyIwZM1i6dCkul4uqqio++OADxo0bx969e1t9vi+99FJcLhennnpqgwKGofD+++8HT6LPOeecRq0zW7JmzRrWrFnDqlWr+Oyzz7jxxhsxmUxcd9113HjjjR3uFhGq57s94+wbo6lxuhKVHOiCZKAKWfE3oOGyI2EapUk8AASiuKe8jK3s35WjD2Na/wFah6EhwYr1iehFbBRQUroGHToc/vbv61W05ZU+3tz1dtja8HV1vggXMvbG6Kqc/a/S3nDDDU225UtLS+Omm24C6vaHv/vuu42OefHFFxk9ejRQ16pt6tSp2Gw2bDYbU6dOZfny5cyYMSOYRACabVm4v+rqambMmBFMStx1110tXgU2mUzNJg4A8vLygkXqoO7EPZR8Ph+nnnoqq1fXrXy9/PLLOf/885s8tv5z0Nyy+/r2bYOwWq2dD7SD9Ho97733HgMG1H2m+/TTTxk7dixWq5XExEROPPFENm7cyGWXXRZMIkDj5/uFF17gq6++IiEhIbgiJJQ606Vg2LBhDBs2jJEjRzJt2jTuvPNOfv31VzIyMnjooYeYMWNGcM9/e4Tq+W7POPW3zmj5ugk3lRzokiQi9X1EyutgqFdkxjiy+YeEm79Au7lbE2PJAZ0Q3HfUseSlpGodima2FLvJkMO1DkPpRvLiB1DsLtE6DKUD/NLPU1uewRNo/QOk0pBBGCM6n1HERheh/e1/sjZt2rRmjz366KODX+8rYlhfSkoK3377Lffccw+DBg1qcF9ubi73338/H374YYMihMltKFjscrk44YQTWLlyJQDXXXcdN9xwQ6uPa82ECRMYOnQoUFc9vrlii+0lpeT888/nk08+AerqIjz22GPNHl//OWjLku99qz3aW1gv1Pr27ctPP/3EzTffHFyFsc/QoUN54YUXmD9/fvDKvV6vJyEhIXhMcXEx1113HQD//ve/O7xMvzn5+fl8+eWXAIwePTokRQ5zcnJ4/PHHAfjiiy949tln2z1GqJ7v9oxTf4WQ1q+bcIrNd2GlRUKXWPeF6SBIfRecryMdryH0PSIei/RtRuoyIRDFSwUDsZUcALCbTDx7/CzOe/8dtld0z5ZqH//s48gxSVT6KrQOReni4g12ttdGf2cTpXl7Xfm8s/s9zux9utahxJQMS+Or3+GdLyOi84VKdnY2QohgIcz6hcv2V/++4uKmt21YLBauv/56rr/+esrLyykpKSEhIaFBS7tNmzYBdb3ZW5oP6q7An3baacEe7xdddBH33ntv2765Nhg6dCjr1q3D5XJRWlra5KqJ9rryyit55ZVXADj22GN5+eWXW1zObrFYSE1NpbS0tNUCjeXl5cETvdZ+dpGQmJjI7bffzu23305JSQllZWWkpqaSmlp3Ecjv9weLWw4ZMqRuu+4fnnnmGUpLS0lKSiI1NZXXX3+90fjLli1r8PW+q+VHHnkkGRkt/8698sorwSv77SlE2Jpp06ZhtVpxOp28/fbbXHLJJe16fKie7/pFCFsbp34Rwmh43YSLSg50cULoIe5ssDau7Bpu0rUIWXkdJD0GIq2pI5p7JDRZdq+l49tze2OB8ivBdhE604FtfozWshMSefvUM7j04w9Ymb9X63AizuEJ4C7Lg4TGV14UJZQyLZlsron+riZKyz4r+ILB8YMYlTSywYdrpXm943LQoYtIUUK90JMTF5sfuG02G7m5uWzfvh2gxWXS9e9rqf3aPsnJyY1WBpSVlQVPFg855JAWX8+BQIBzzz2Xjz76CIDTTz+dJ598stV52yPUv0//+Mc/mD9/PgBHHHEE77zzDkZj66tYhg4dypIlS9i8eTM+n6/Zn+/vv/8e/LotbRwjKS0tjbS0hp+Z165dG1zSPmbMmAb37bu9oqKCc845p9Xxn3jiCZ544gkAFi9e3Gpy4KWXXgLqtpiceeaZbfsm2kCv15OcnIzT6WTHjo4l30PxfA8cOBC9Xo/f729wXHvH6UrUtoJuQojItcCTMoCseRxZcTnIWqh5DGRhE/8VNfNfcQu3N/VfSTP/lbb9P/cX4PokYj+jUEmxxvHSrFM4pn9eg9st+71BCmBsdsPlal3BF+tq6Gnqo3UYShfWy9JTJQa6CInkoU2Pcv2vN1Lji70VY1ow6Uz0jtAJe++4HEy6yG5jCKUjjjgi+PXWrc23O92y5c/3k169enVornfffTe4fP/001teDXPppZcGryYfd9xxrV6B74h169YBdQXb9l3t7qjbb7+de+65B6hbxv7xxx+3eX/3+PHjgbrl3/u2TzSlfpvIceOitJtWPW+99Vbw69ae71BatWoVv/76KwDTp0/v9HNbn8fjCbYi7OgS/VA83yaTKZhw+fHHH1usO7BvHLPZzCGHHNKhmGOBSg4oISerbkHWPPznDd7mf2GjiTB0fh+VFiwGI49NP47LDh7DWcNH8uzxs/j5kiv465jDgscc1X8Ajx47g9QuV0BFsGpDCnr1VqaEiT9CbdyUyCl2l7CiLDb+LkWDCenjIzNPWvSfpLXk5JNPDn793nvvNXtc/SKEEyZMaPc8LpeLO+64A6hbVXDWWWc1e+zf//53nnnmGQCmTJnCW2+91abVCu3x/fff89tvvwF1J2udSTw8/PDD/N///R8Aw4cP59NPP21zsUWAE088Mfj1888/3+QxgUAgWGAvKSmJyZMndzjeSCguLg7WWhg4cCBHHXVUg/vnzp2LlLLF/+r/LJ5//vng7ZMmTWpx7s4UImzNBx98EDwRHz68YzWkQvV87xunqqqqySKhULflYF/thSlTprTrdRlr1CdqJaRkoAaczf9RjGrG2EwOQF2RwhvGTeD2yVOZ3KcfFoORaw49nJOHHADAxQcdQkDCNYeN47ZJU5jUpy+GEF850MqGQhc9hCpOqIRenn0ABa4oLqaqdNjS0mWtH6QAMC5tLBadufUDO8Gis3B42tiwzhFuM2fOZNiwYQA89NBDwRPm+tavX899990HQHp6OieddFKjYwoKCpot6ud0OjnzzDODWwruv//+Zq+6zp07lwcffBCAww8/nA8++KBBK7a2eP/994N1FJqyefPmBsmJK664otlYhBAIIXjhhReaPOb555/n2muvBepOgr/44gtSUlLaFe+YMWOCCZdnn32WH3/8sdEx999/P+vXrwfg6quvbna7wr54+/Tp064Y2mvv3ua3hZaXl3P88ccH2zjOnz8/Ylui/H4/r776KgCpqanMmDGjTY/78ssv2bx5c4vHrFu3jr/97W/BfzdXy6BPnz7B56EpoXq+L7roIhIT6+q13XjjjZSWlja43+/3c8UVVwS3BF1//fUtfn+xTtUc6KaklCF9g5HSA76t4N8BRLb1UWjowdC12gMKIfjPkUdRUFPNvG8W8+EZ53D28LqOFeeMGEW508nCzRv5aOPv9E1Kpl9yCj/n7+W7nTuo8cZWVe8FP/sZPzqeGl+11qEoXYQBA3ud+VqHoYTJ79UbKHWXkWpu38lHd2TVW5nZcwZv7276ilooHNdzBlZ9bK9s0+l0zJ8/nylTplBbW8v48eO54YYbglcqv/32W+66665gRfRHH320yTaBL7/8Mo8//jhnnHEG48ePp2fPnlRXV7NixQrmz58f3JZw0UUXMXv27CZjefTRR5k3bx5Qt3XhnnvuCSYUmjNo0KBGJ06zZs1iwIABnHTSSYwZM4bs7GzMZjP5+fl89tlnPPvss8Hv57TTTmsy2dEW77//PhdffDFSShISEnj44YcpLi5utmAj1FX5t9lsjW5/+OGHGTduHE6nk2nTpnHTTTcxefJknE4nr7/+Ok899RRQl4CYM2dOh+INpTvuuIOvv/6a0047jcMOO4z09HQqKipYsmQJ8+fPp6CgLkH973//u8W2k6H22WefUVhY14b8zDPPbFPNB6jrWHHMMccwZcoUjj76aEaMGEFqaio+n48dO3bw+eef89JLL+FyuQC44IILOvV9heL5TklJ4e677+ayyy5jx44dHHroodx8880MHz6cvXv38tBDDwWLeZ555pmtrriIdSo50F05niPgL0DEnQd4QLrr/hNmMAxGiLZfVZbeTcjKv4NxBCLhNkTS48jap8C7Onzxh5o+C4jdvY7NMen1/Hf68fy4e2ej+5KtVs4aPpKzho9ESkml28WQ9HTWlxRTUxlbyYFqdwBZOQhsP2kditJF+PBhEeG9Wqpoa2nZMmZkHat1GDFhRtaxrCz/mW2120M+dl9bX6ZnHRPycbUwfvx4Xn31VWbPnk1FRQU33XRTo2OMRiOPPPJIi3vHt2/fzl133dXkfQaDgeuuuy64taAp77zzTvDrPXv2BPdmt2Tbtm1NXiXfvHlzsAZAcy6//PLgKoWOeP/994NXZauqqjj22NZ/LxcvXtzkSdqBBx7IG2+8wTnnnENVVVWTz8HAgQNZsGBBs0vDnU5n8OtQ7rNvzm+//catt97a5H1xcXHceeedDa60R0L9LQXt7VLg9/v5/PPP+fzzz5s9Rq/X8/e//50777yzwzFCaJ5vqKvNsXfvXv7973+zZcsWLrjggkbHTJ8+neeee65T8cYClRzoroQVHC8iHS82cV8y0jwBYT4CzOMRuqavrEgpwfESsvpewA0ivq47guUo0OciS2eG93sIJf9uZNlZkPQIQh+brZSaE282M22/goX7u/eH73hi5fIIRRQen66p5bQjepPvaZwIUZSOyLRkUlPTfGExJbb9ULKUY3pMQy/0WocS9XRCx6X9Lub29XeGtJij3WDn0n4XoWvHBYlod/LJJzN69GgeffRRFixYwK5duwgEAuTk5DB16lSuueYaBgxofqXiSSedhMvl4quvvmLLli0UFRVhNpvJzs7m6KOP5sILL2To0KER+V4+/PBDfvzxR5YtW8aOHTsoKSmhtraWhIQE+vXrx4QJE7jggguC2ymixXHHHcevv/7Kww8/zIIFC9i9ezcmk4kBAwZw6qmnctVVVzW5amOf+svT9211CJdLL72UxMREvvnmG7Zv305xcTF2u53c3FxmzJjBRRddRG5ublhj2F9VVRUffvghUFeVf/To0W1+7LXXXsvgwYP5+uuvWb16Nfn5+RQVFREIBEhOTmbw4MEcccQRnHfeefTv3z8k8Xb2+d5n3rx5HH300Tz++OMsWbKEwsJCkpKSGDlyJLNnzw5pt4ZoJmRLm4mULktKN7J4CgSKWjlSgHE4mI5AmA+j7uq6D6QHWfs8eL6td6gNkfoOwtAPKb3IosNA7rfMW98X/C0vbdOSsP8VYf+r1mFE3OMrlnH/j99pHUan9Us1MeqAAoo9ap+40nl59gFsqml576QSfdJNaZj1ZmwGGxuqN7Z4rE0fx9i0wzgj5zSMMVQpf9OmTcHWXXl5LSd/Q2l77Q7u3fBASBIEdoOd6wf9nT62yJ74KEpr5s6dy7x588jLy2P9+vXo9SqBqISfVu/r++s6qVqlXYQwI2wXt+FICd5fofYxZNk5yLLTkWVnI8tnN0wMAMhaZOmZSM/PCGFEpL4B+j6AESzHI1LeQpf+GSLxgbqVC1FIOt9Dyu5XnXxavwGcPXwkxhgvUri11MPH36fQU4xEoPqYK51T5G5+v6sSfQSCQfEDKfOWs9u5hw3VG8mNy8Wmb7wveR+bwcbKsl94ftv/Wiy8ptTpY8vlX0P+SV9b306N09fWl/8b8k+VGFCi0r6WdTfddJNKDCjdjlo50I1J6QH/bvBtQ1b8jZAWEjQMRlhmgnlCXS2DQAn4fq+7L+58ZMU1jZML0cI4HGGZjrBdqHUkEbO1vIzjXnsJp8+ndSghM3lwHL4kVYNA6Zw0UyolntLWD1Q0ZRImUszJFLgKG92XaEzEbrCxx9mwKnjfuD7sde3FHairsXJSrxM5oddxEYm3s7S+whSQARbkL+TjvZ/gCrja/DiLzsJxPWcwPeuYLrWVQOk6PB4PSUlJ9OjRg40bN4a89aOiNEfr9/V9VHJAAUC6PgddGrJ2Pri/Ce9kIg6kI7xzhIBIeQVhavs+q1glpeSDDeu5ZfGimOtS0DLJzPH5VPoqtA5EiWED7XlsrNmkdRhKK1rbAqJDR178gOA2g0HxA5vccnB5/0s5LHVM2OIMlWj5EOn0O/mh5EeWlHzPTscu/NLf6Bi90NM7LocJaeM5PO2wmO9KoCiKEg7R8r6u0mEKAMIyre4L/3FI7/o21CLohBhIDADIypsh+RnQ2UEk1hVb7ILWFhfx988Xah1GGAjiAzlUUqF1IEoM88mus5qmK3P6W756HSDAhuqN9LX1RYdoMjGQZ8/jma3P8cHejxiVNIJRSSMZYO+vCha2wKq3MiXzSKZkHokn4GWXYxdFriK80odRGMiwZJATl4Mphuo5KIqidGdq5YDSiJQ+ZMWV4F6sdSjRQ98XEX89mKcgRNfby372u2812e4w1o3pa8WcuVLrMJQYZtFZcAfcSNSfymiVYkyhzFvW4cdbdVayrD3YWtu4WK5NH8exWcdwXM8ZnQkx5KLlCpOiKIoSGtHyvq42fCmNCGFAJNwBujStQ4ke/m3IiiuQZWchPau0jibkrhx9qNYhhMXybU7chYeQbAx/n2Kla3IFXPS0ZGkdhtKCdHPH/1ZlW3th1puaTAwA1PodfFfyfYfHVxRFUZRYopIDSpOEPhWReA+IJK1DiS7elciy0whU/L1LVbYem53DiMweWocRFsu3OfhiaRa9dCNUBwOlQ+xGu9YhKC0ocDcuQtgWg+IHsse5lwpvZcvjuwqp9cXGdjhFURRF6QyVHFCaJczjERnfIZL+C+ZjAJPWIUUP18fg36V1FCEjhODgrJ5ahxE2Tm+A13/w0cs4QOtQlBhU66vVOgSlGblxvals5eS+KSmmFDZUb2zzdpHvS77HF1D1JxRFUZSuTSUHlBYJYUJYpqJLfgSR8S2YJmgdUvTw/KB1BCGVm5ikdQhh5xNOrUNQYtBeZz4mnUqORiNjBwvdlXnKSDElt/n4V3a+zk5H10kIK4qiKEpTVHJAaTOhS0EkPwW2K7UOJSpIz1KtQwipPklt/6Acq5yBGq1DUGJQgICqOxCFrDoL22t3dPjxBmEkw5xOnM5KX1sfzC0kgJKMSfSx5XZ4LkVRFEWJBaqVodIuQugR8VcjhQ5Z86jW4WjLsxQpAwjRNXJs3WHlgDvQcrszRWmOWWfWOoRuzYCBFHMKBqFHLwzohQ6zzsyGmsYtCduqyP1ny95ttdvpa+vDttrtTR57YPIodF3kvV5RFEVRmqP+0ikdY+qa1e3bJVAGvo5/MI02vRISuOSgQ3ju+JO6bKIgTd9H6xCUGFXuLdc6hG4r29qLBFMCRe4i9rry2eXcxXbHjk4lBppS4Gy+sOFBSaNCOpeiKIqiRCOVHFA6xjAUVOV3pOtDrUMIGYNOx43jJzKpT19unXik1uGExZ7CeK1DUGJUkbuYeIN6/USSAUOwo0CZpyzs8zkDTpKbqENg0VkYkjA47PMriqIoitZUckDpEKGzg76f1mFor/YZpLPrJAgAdldVsnT3TiyGrrfraHepV+sQlBiWacnQOoRuo5elJ0mmxHZ1FAiFZGNSo9v80s+iwq/wS3/E4lAURVEULajkgNJxxmFaRxAVZOU/kZ7lWocRMtkJiZw9fBSXHzKGZItF63BCKje96yU8lMgRUq2WCjcDegbFD2SvK58ST2nE5zeKxt0PvNLLa7veZO5v/+5Q20RFURRFiRUqOaB0mIg7B6ynaB1GFPAiHa8jZeSuboVbTmIifx0zlhdPPAW7seu0cEtNUFf+lI4rdDe/J13pvDhdHMnm5IivFqjPHXA3e99Oxy6+KV4SwWgURVEUJbJUckDpMGEaiS7xDjCN1zoU7emSga63ZH1YRiZPzjwBk06vdSghYTQ7tQ5BiWFVvmrSzelah9FlBQhQ7C7RNIbSVlYrfF/yQ4QiURRFUZTIU8kBpdNE0gOIhDvAPBn44yqz8WDQdaP9uY6XkEXjCVTORXp+7lKrCMbm9ObhY2egF7G/pNpF+IuaKV1bShN70pXQcAVcxOnjNI2h2lfTYuHJLvTWHnJSupCeVUjnh0jH23X/96xCStVCVlEUJVaoDbhKpwldEsSdgog7BRmoBf9uhHFQ3Qmyfyuy+n5wf6l1mOEnK8D5KtL5KuizkZbjEdbjEIb+WkfWaUf3z2PlJVfwc34+K/bu5qe9e1hdWIDHH1vL9C0kAEWtHqcozfHIrrdCKJokGhNx+B2axtBS4cFkU1LkAokBMlADzveRznfB9zvga+IoA9IwGBF3MlhOqCtorCiKokQlIbvSJU4laknXImTlTSC7Ya9wwzBE/ByEeZzWkYSU2+djTVEhK/buZnVhAVaDkQybjTKnk3fW/6Z1eE0a0sNCep9fNNvPrMQ+szDhlT4CBLQOpUvqb+vHltqtms1v1VlwBpq/0j029VAu639JBCNq2qZNm/D5fBgMBvLy8iI+v5R+qH0aWfskyNq2P1DYELZLwXYxQnSN7WqKoiihoPX7+j5qW4ESEcIyBZH0IBD7S9PbTRihC56Mmg0GDunZi8sPOZQnZpzAg0dP55/jJ3L75Klk2aOzH/z6Ahe9DENaPEZKiPNnoQt0nUKMSui4pYee1iytw+iyDKLhgsYcazbZ1uyIzZ/YyraRZGNyZAKJYtK3FVl6KrLmgfYlBgBkLbLmAWTZaUifdkmgcKqqquLuu+9m3LhxpKSkYDabycnJ4ZRTTmHhwoUdHtfhcNCvXz+EEAgh6NOnT7PHzp07N3hcW/+bO3duo3GKiop48cUXueqqqzj88MPp27cv8fHxmM1msrKyOProo5k/fz61te18HbTitddeY9q0afTo0QOLxUJubi7nnHMOP/74Y5vHcDgc3HPPPYwePZqUlBRsNhuDBw9mzpw57NixI6TxNsfr9fLpp59y7bXXcvjhh5OWlobRaCQpKYmDDjqI66+/nq1bW/89KCws5JlnnuGss85i6NCh2O12TCYTWVlZHHPMMTz11FM4nS3XVKqqquL1119nzpw5TJw4kQEDBpCYmIjJZCIjI4NJkyZxzz33UFravi4xy5cv54orrmDIkCEkJCRgt9vp378/M2bM4IEHHqC4uLjJx7ndbpYuXcqjjz7Kueeey6BBg9DpdMHXYzisXbuWSy+9lP79+2O1WklPT2fChAk88cQT+HxNrXpq2sKFC5k1axbZ2dmYzWays7OZNWtWp36/o4laOaBElKx5HFnzsNZhRI5pPLqU57SOIuL+t/oX5n7zldZhNKlXoomxI4sp9OxpcLvVn4G3YhAbCtzsra7BZjQycYiJ6rgVGkWqRKtB8QPZUL1R6zC6pD5xuej/uKJc6C4iEAjgCDhIMaWQbk4L+8+9tZULx/ecycnZs8IaQ1todYVJetciyy6o20bXWSIJkfI8wnhA58eKEj/++CMnn3wy+fn5zR5z3nnn8dxzz6HXt2/lxHXXXcf9998f/Hdubi7bt29v8ti5c+cyb968do3/6quvcuaZZza47ZlnnuHiiy9u9bG5ubm88847HHzwwe2ac39Op5NTTjmFTz75pMn7dTodt9xyC7feemuL42zevJnp06ezadOmJu9PSEjglVdeYebMmZ2KtyXFxcUMGTKk1ZNtk8nEPffcw9VXX93k/U8//TSXX345/la2cebl5fH2228zYsSIJu//8ssvOeqoo1qNOy0tjZdffpmjjz66xePcbjdXXXUVzz77bIt1tt577z1OPPHERrfPnj2bF154odnHhfr09Omnn+aqq67C4/E0ef+YMWNYsGABaWlpzY4RCAS45JJLePbZZ5s95qKLLuLJJ59Ep2v/9fdoWTmgag4okWW7HDwrwbsGjENA1wM8SyAQ+X7WkSCsJ2odgiZOP2A4//1pGUUhvpoQCnsqPbz9bQLTh2dB4kaqfVVYAumsWteboto/X4e1Xi8rNhsZPEwHOrWEXPlTja9G6xC6rO2OP6/o2fQ2HIG6+gNlnjLKPGXo0IV1S8f+Kxf29+Hej9lRu5PZfc8j2dS9VhFI39bQJQYAZAWybDakvo4w9AvNmBrasGEDxx57LJWVleh0Oi666CJOOeUUUlNT2bZtG/Pnz2fRokX873//w2638/jjj7d57F9++YWHHnoIi8WC0Wikurq6xeOvuOIKTjml5VbTfr+fI444gqqqKhISEpo8gRNCkJeXx6RJkzjwwAPp1asXWVlZuFwuduzYwcsvv8xnn33Gjh07OOqoo1i7di09e/Zs8/e1vwsuuCCYGJg8eTJXX301PXv2ZM2aNdxxxx1s2bKFuXPnkpWVxSWXNL29p7q6mhkzZgQTAxdffDFnnHEGVquVxYsXc+edd1JVVcXpp5/O999/z6hRozocb0vcbncwMTBq1ChOOOEEDj30UDIzM6msrGThwoU8+uijuFwurrnmGqxWa5PfU2FhIX6/H5PJxMyZM5k2bRpDhgwhPj6eLVu28PTTT/P555+zadMmpk6dys8//0x2dtOrrXJycpg8eTIHH3wwOTk5ZGVlEQgE2L17N2+//TbvvvsuJSUlHH/88SxfvpyRI0c2OY7H42lwpfzII4/k7LPPZvDgwVgsFvbu3csPP/zA22+/3ezPp/7Jf3x8PAcddBAbNmygoKCgzT/jtvrkk0+47LLLCAQCZGZmcvPNN3PooYdSVlbG008/zbvvvsvy5cuZNWsWX3/9dbOJu5tvvjmYGDjwwAO54YYb6N+/P1u2bOGee+7hl19+4ZlnniE9PZ077rgj5N9HpKiVA0rESekFDMFlQ1L6wLUQWXk9hOpDn/U08K4Cn8ZX93SZiNR3EPpu1LkBeHvdWraUl/Hkyui+6m436zh2pJkf1uvZU930Cd9hvdNIiveiN9XiN1Tg1BUSEM33Qle6PoHArDPjamFvuhIeScZEKryVYRs/zz6ATTWbWz3u2ry/MSq56Q/OkRDpK0xS+pGlp4JvbegHNw5HpLwZ8zUIZs6cyYIFCwB4/vnnOf/88xvcL6Xkggsu4IUXXkAIwbJlyxg9enSr4/r9fg499FBWrlzJbbfdxrPPPsuOHTtaXDnQFgsXLmT69OkAXHjhhTzzzDONjtn3GmvJQw89xLXXXgvAtddeywMPPNCheL766iumTJkCwHHHHcd7773X4CStpKSEgw8+mJ07d5KUlMTWrVtJTm6coLvlllv497//DcA999zD9ddf3+D+H374gYkTJ+Lz+Zg4cSJff/11h+JtzZ49e5g9eza33XYbhx12WJPHLFu2jMmTJ+N0OklMTGTXrl3Exzfclvnggw9SWFjInDlzSE9vupXunDlzgj/32bNn89xzjVes+v3+VlervP/++8yaVbcyatasWbz77rtNHrfvZyyE4L///S+XXXZZs2N6vV6MRmOj29944w2cTiejR49myJAh6HQ6Jk2axDfffAOEbuWA1+tl8ODBbN26lYSEBH7++Wf6929YKPzKK6/kv//9L9D07y7Axo0bOeCAA/D5fBxyyCF8++23WK3W4P0Oh4OJEyfy008/YTAYWL9+PQMGDGhXrNGyckAlB5SoIWvmI2seDMlYIuMncH2JrLoxJON1inEkIuVlhDBrHUnE7Kio4MQ3XqHSHf0nTwOSU9hc3r4Wh3mpSfTIU/3Ou7O+tj5sq92udRjdTk9LT/a69oZt/BxrNrucu1s9bmTicK4YcBkWvSVssbQk4smBmifqagyEibDPQdgvDdv44VZcXExmZiZSSsaNG8d3333X5HEVFRVkZ2dTW1vLySef3OKV1X0eeOAB5syZw6BBg/j1118ZOHBgSJIDZ555Jq+//joA33zzDUcccUSHxvH5fCQnJ1NTU8MhhxzCihUduygwffp0Fi5ciMFgYNu2bU1e/X799deDWx+aOvH3er2kp6dTWVnJkCFDWLt2bZPLuy+77DKefPJJoG7PfFuSNOFSf7vIO++8w0knndTuMTweD3369CE/P5/ExETKyso6tKwdYPDgwWzYsIG0tLQm6wVs3bqVwYMH4/V6ufLKK3nsscc6NE9TwpEcePPNNzn99NMBuPPOO7nxxsbnBQ6Hg+zsbMrLyxk6dCi//da4qPYVV1zB/PnzgbrtQ00lfJYuXcrYsWODx7dndRBET3JAFSRUooftUjBPDMFAOhD26Kl96F2NrLwl+EYnPT8hAy0vCYx1uUlJnDo0NvaRmvXt3121qbQCc6B7LSlWGjKKxldClPCz6MObZHX6XfSz9WVQ/EAyzc2v+FpduYb/rL+LMk/7EouxSAZq6roShHOO2ifq2iLGqJUrVwb/xh977LHNHpeUlBQ8qVi4cCEOR8ttO3fs2MEtt9wCwBNPPIHJFJpCuVVVVXzwwQcA9O3blwkTJnR4LIPBgMVSlyRzuTp2QaC6uppFixYBMHXq1GaXxZ900kkkJCQAdXvZ97d48WIqK+tWFv3lL39p9gS5/pXhpsaJpMmTJwe/3rJlS4fGMJlMjBtX1xGrsrKy3UUF69u3cqG55/Kpp57C6/Wi0+n45z//2eF5IuX9998Pft3UigCAuLg4TjvtNADWrVvHxo0NVx1LKYO/L4MHD252Jchhhx3GoEGDAPjggw9CXjchUlRyQIkaQugQifeCrlfnBjJPBulCOt8PSVwh4XoPHHXLvGTlDciSY5DOBTH7xtEWV405jGSLNlfV2sNk6NhSVrOnT2gDUWJKmacbtmWNAjoR3o8tJZ4SttZuY0P1RordJQyKH4hoJtO807GLeb/9h52OXWGNSXPO99vflaC9ZC24PgjvHGFU/2QsMzOzxWP33e9wOPjpp59aPPaKK66gtraWc889l0mTJnU6zn3eeuutYHX7c889t1PV4RctWkRJSQlQd+LUEStWrAgWips4sfmLRCaTKXhitmLFCrxeb4P766/YaGmcQw45hLi4OAC+//77DsUcKm73n9sU21ukMtTjbNiwgVWrVgHNP5dvvfUWAAcddBC9etV9XpdSkp+fz9atW0PeuaKz9r0mBg0aRI8ePZo9rv7rZf/XxLZt29i7d2+j41oaZ8+ePZ1a2aMllRxQoorQJSGSHwddC3v0RSLCPgdEE1dujQcjEm5Bll8EnqXhC7QDZPW9yEAVmKdAoBhZeS2y/CKkb6fWoYVFgtnC1YcernUYLdIB/g4maKqrorNdY+hJLu5hJ04XLUtxokOJp4REY6LWYXQ7ha6iiM0VIMBeZ8tbGCq8Fby64/UIRaQN6Wx633HI53G8E5F5wsFutwe/3nflujn171+3bl2zx73++ut88sknJCcnN+hSEAr/+9//gl+fd9557X58dXU169atY+7cucE96kCzFfdbU//n0FqCYd/9Pp+vUTeCto5jMBiC+8HXr1/f7nhDad8yeoAhQ1putdwcr9cbbPOYmZlJSkpKmx/rcDjYtGkTDzzwQLAWA8A111zT6Nji4uJg68Xhw4fj8XiYN28ePXv2pGfPnvTv35+EhAQOP/zwZusVRFJNTQ27dtUlb9v6uoLGr4mOvD6bGidWqOSAEnWEcSgi9QMwjW/iThsi+RmIOxcRfx0YhjW83zgCWXEVeFvOxmtClwQiHmGtt5/MswRZMgNZ81+kbLq9Siw7c9gI+jVRMCgapFvjyEtN49fCjlXG/XF7GfFe7faERco5GQkcblrIw723MSHR3voDupEMc9PFoZTw6B2XQ7UvsluysixZSFpOIK6v/p1djtbrFMQiKV3gi9AHXN/vSBmbxV7rn9TVP9nbn8fjYdmyZcF/79zZ9MWB8vLy4MnZXXfd1Wwhuo7Yvn07S5YsAWDcuHGNirM1Z+7cucEe9AkJCRxwwAHMmzeP6upq9Ho9jz32GOPHN/G5rQ127/7z96e5LQX75OTkBL/ed+K3/zg2m42kpKQ2jVNcXNzgqnsk5efn8/zzzwOQnp7eYItBezz11FPB1Runnnpqq8fvK4ophMBmszFw4EDmzJlDYWEhADfeeCNnnXVWo8fVP0mOi4tj4sSJzJ07t0GHgUAgEGzpecUVV3To+wmVUL+uOjtOrFDJASUqCX0qIvkZhP1a/nyZWhDJTyFMIxG6OETcqejS3kWkvgfW00HEgTDXtUmMRoahdW/GxiFgGFrvDjey5iFkyfFI97JmHx6LjHo9/xzXeh2JA9Ij281hWEYGnkCADaUlHR7DGwjw3Vo7cf6sEEYWHTKMRs7NiCfVYGCytW4FjiGwi9mJn/GvHBOWTixBjSYWIRhhiyPDaES0cgLYlNZOGpXQ6R2Xgy/Qcp/vcHD4W94Tvs8XhV+GORKNeH8HIvVz9/0xX+wZOHBgcK/xggULmi1IeP/99wdP4oBmWxJef/31FBYWMnbsWC6++OKQxvrSSy8FtzT+5S9/6fR4U6ZMYe3atVx55ZUdHqP+z6H+Koym2Gy24Nc1NQ3rVOwbp7UxWhsnEqSUXHrppcGY/+///i9Yu6E9tm7dys033wzUfd+dqQMwatQoli9fzp133tnkVpOysj9rrDz77LMsXbqUMWPG8NVXX+FwOCgvL+fVV18NtrOcP38+jzzySIfj6axQv646O06sUMkBJWoJoUPYL0ekvolIfh6R/jnC1LiirDAegC7x34j07xD6jvfXDTvp+KONIw1XD+zj34osP5dAxQ3IQNs+kMaCI/v245KDDsHQTGGgmQMH8cEZ5zCpT9+w15DUAWN6ZbO2qCgknRSq3G5+/T0HU6BrLS8/I93IkZZPuCt7Mzr554cBQYD+YhGP5O7g8ARbCyNEPx1wR28n16Z+xt1ZX/Fs7x94LncNT/XZyeN9yngg18V/esNN2Sb+2tPG9JR4TPt9WCpwFmoTfDczwD6AnY5dYe1S0JREQyK7nXvadOwPJUup8cbmB8EW+SO87S3S84XQ7bffDtRdOZ0xYwaPP/44BQUFeL1eNm3axLXXXsvNN9/coKjgvn3/9X377bc899xzGAwGnnjiiU7VA2jKyy+/DIDFYgkWYWuLK664gjVr1rBmzRqWLl3K888/z+TJk1m0aBGnn356gxUR7VW/+F1rRRfN5j+Lku7/89s3TlsKN7Y0TiTccccdfPTRR0BdUcKOJFccDgcnnXRScKvKo48+Gjwxb8mJJ54YfC6XL1/Oa6+9xqxZs1i1ahVnnnkmH3/8cZOPq19PwOVyMWzYMBYvXszkyZOxWq0kJSVx5pln8vXXXwdPkufNm9dq4c1wCfXrqrPjxAqVHFCinjCOQJjHIfTNFxIBEDo7WI5GxN8ExhF/3Bqayr4h4f0ZWXVrXcbeOguMo5o+zvU+BCL7ITichBDcOH4in579F6b2rVu+ODKzBzccPoHZow6i3Onk7XVrefa4Wdx+5FEYO9h+pzVpf2wjWL4ntMt/86tr2LX1APSy67SqTDHUbXExBJpeEmcM7OCipC+4KceMOSZXEUjm9RYkyz9bbgkCCFmBMbCDuMBvJMsV9GQJebpFHGT4lFPtn/BE75+5J9fHqekJ2PV6avw1LVa0V9rHgJ5B9oGkGlODt8Ub7Oxp4wl6qGVaWi4sV59Xevm6+NswRqORSG93i+Htdaeccgrz5s0D6roBXHXVVWRlZWEymRg4cCAPPfQQycnJwSQC0Kinvdvt5pJLLkFKydVXX82IESMIpaVLlwYrsZ9wwgkkJrY9sZ2RkcGwYcMYNmwYhx56KOeffz5fffUVt99+O7/++iuTJk3i888/71Bc9a+Y7ytM2Jz6WwDq95mvP05rY7Q2Tri98sor/N///R9Q1y3i1VdfbXfrQZ/Px6mnnsrq1asBuPzyy5utxr+/pKSk4HM5evRozjjjDN59913+97//sXXrVk444QReeOGFRo/bf2XDbbfdFizsWF9eXh6XX345ULfa4MsvtVlZFerXVWfHiRUqOaB0KUKXjLCdjy71bUTal4iEf2kdUkPOt5E1jyJ08YiU/4F5WtPHSW/Tt8ewfskpPHXciSy78DLeO/1sLjtkDP93xGRemnUqpx0wHCEEB6RnkGEL/b72A9Iz8MnObSNoycaSCqp3HwoyFk+UG0sUrV8BFfjJE1/yaO4uZqTEc3RyPKenx3Nhph17JyouR8KcXnFk0/4TOSFrSJc/Mt26gEd6/ciDuU6mJqk/o6GQaEwk3ZLOhpqN1Ppr6WvrA0CGOQOnX5urL5IAg+wDybMPCLY3NOuaTzgvKvoKv4z81oewEhFOsEd6vhC75ZZbWLRoEUcddVSDK4hWq5VzzjmHX3/9ld69ewdvT96vJs9//vMfNmzYQE5OTjDREEqdLUTYlJtvvpkxY8bgcrm4+OKLgwXt2qN+kqS1pdj1r17vv8R73zhtWc7d0jjhtGDBAmbPno2Ukh49evDFF1+0WEW/KVJKzj//fD755BMATjvtNB577LFOx3buuedy6qmnEggEuOqqqxpsI4CGz5MQgqlTpzY71tFHHx38esWKFc0eF06hfl11dpxY0f4G34oSI4ShN1LW1O3v9zVfETjiah9D6jMRcadD0iPI6rvB8fx+B3W95MA+6bbml6OPyOzBR2eew98/X8jX27d1ei4BjO6VHfLVAk1ZuaeEGWkHUWVdGfa5ws0qymnrdnpjYBun2Bs+V316TeT/onR18PmZ8QzTf9LpcQRukuRPTDX/RHrPo3loby2EfWNM15RjzabMU06+t66olSvgYlvtdvrb+rGldqtmcW2q2dzoNpveRo4th821jfuRl3nKWVn+M2NSGm9/i1n63q0fE8vzhcGRRx7JkUceidvtJj8/HyklvXr1Ci5Hrl9h/4ADDmjw2LvvvhuAqVOnBpec72/fyUdtbS2vv17XKSMjI4Mjjzyyxbg8Hg9vvPEGUFfRvv7JW2edcMIJLF++nJ07d7J8+XIOP7x9nYrqF3nbvXs3hxxySLPH1i/yVr/4275xli1bRm1tLRUVFS0WJdw3Tnp6eoNETjh9/fXXnHLKKXi9XpKTk/nss8/aXBCyviuvvJJXXnkFgGOPPZaXX3653SsPmnPCCSfw5ptvUltby6efftqgMGH9n3dSUlKjlS/11T+2uLg4JLG1175Wi9CwqGBTWntdhWKcWKGSA0qXJoxDIfVtcPwPWfMwyOjY/yOr5oIuA2GZDPE3ID3LGiYwYnhpZWclWaw8c9ws5v+0jAd+/L7DJd9SrVbS4mwRSQzs43LGQWyuIgsSSEyyc3/Is/mGE1On835pZCvLt+a41HiOMH8W8nFHGj5jbs4k5u3yIVWCoF0GxQ9kY/WmJos7apkYaE6tv5ZKb/Ot6r4oWNS1kgPGwYCeyBQlNPwxX9dgNpvp06dPo9tXrvwzgTxmzJgG9+1bsvz8888Hq9g3p6SkhDPPPBOo663eWnLg448/Dl4JPvvss9GHcIVX/W4KO3bsaHdyYOjQP4s0//57y0Up991vMBjIy2vYMWjo0KG88847weMOO+ywJsfw+Xxs2VKX4Oto+8D2Wr58Occddxwulwu73c7ChQs7tG3kH//4B/PnzwfgiCOO4J133sFoNIYszv2fy/ry8vIwGo14vV78/pbfE+rfbzBoc7oZHx9PTk4Ou3btavPrChq/Jjry+mxqnFih1kMqXZ4QBoTtAkTaJ2CepHU4f/AjK69BOt5CVv270coG6f62SxUlbC+dEFw5+jBePPEUUjuwZ+uA9Az8UoZtG0Fzqpyxf2I4JTkBIVvu090WJ9g+4cE+Dg6Nj47ChYcn2Jhl+woRppOcXPE19+Z6Y7QGQ+QZhZEBtv5sqN4Yc10fij0lJBmb3qu93bGjydtjlRAWMEToA65hMEJ0ndotTamuruazz+oSlGPHjo3olcVwbCnYZ8+eP+uCdGQp9ejRo4MrK1prBbl06dLgY/Y/Ka7fSrGlcX766afgCoxx48a1O972+vXXXznmmGOoqanBYrHw0Ucfceihh7Z7nNtvv5177rkHqPv+P/7445Dva2/puTQajYwdOxaoq6tRv/PG/vYlX6DhFfxI2/ea2LBhQ4OWi/ur/3rZ/zXRt2/fYKHHll5XUFdQFOq+56aSg7FAJQeUbkPoeyGSnkQkPQK6KCgiJp3IqpvB+Wrj+2qfQBZPIlD9ANJfFPnYosT43rl8cMY5WNuYdRbAob2y+a24iApX57sRtFdJTeyv+DgqoSJkYyUFVnJZ8qc81MfBYS0mCSQzUuK5P9fNwDAU8BkSF8eFycsQhPc1kSqXcX9uOUlRXnNBaymmZFJMyU0uzY8V6eam+857Ah4W5n8WbBXXFTTZXScc88SdHJF5tHTnnXcGK5g3VZ1eStnqf7m5uQDk5uYGb/v6669bnLe0tDS4P33kyJGMHDkyZN9TIBAIXq0HGD58eLvHiI+PZ8qUKQB8+eWXzS7dfvfdd6mqqgJg1qxZje6fNGlSsMjiiy++2OzvYf1ie02NE0obN25k2rRplJeXYzQaeeedd5g0aVK7x3n44YeDRQyHDx/Op59+2uKy/o566623gl839VyefPKfv6fvv/9+s+O8++67wa8nTJgQmuA64MQTTwx+3VSRRajr+vDmm28CdasEBg4c2OB+IQQnnHACULcyYF+Can9Lly4Nrhw44YQTQt5pJFJUckDpVoQQCMsxiLSFEHcWUb1HWFZA7RPgfLfVQ7uynvEJHDew9aWmqVYrg1LTWBbBbQT721tVSyyfEyTp9aTLn0M+bmJgJZcmf8rDfWobtECM0wku7mHnqT67OMX+CSlyOTemf83NOaZGJ9h64GC7jfGJ7bsq1dNkYk7GGnSyPBTfSqtsgTXcnbOLHHNsF1YLl9y43jj9LgrdsZv0tOlt1PiaL0r1+q43eWXnaxGMKMysJ4II8wogYQPLCeGdI8y8Xm+LV1JfeeWVYE2BiRMnNtjLHW6vvfYaXm9dLaP2rBp4+umnW1w+HggEmDNnDmvXrgXqTgKbulr6wgsv1H3+EoK5c+c2OdZ1110H1C35v/LKKxvNW1JSwj/+8Q+gbr/7RRdd1GgMk8nE3/72NwDWr1/Pfffd1+iYH3/8kWeffRaoex5Gj256G9CkSZOCMW/fvr3JY1qzc+dOpk6dSmFhIXq9nldffZXp06e3e5znn3+ea6+9FoCBAwfyxRdfkJKS0q4xXnjhhQYt+Zry4IMPBpNIffv2bfKk/oILLiAjo+4C26233srevY27a33zzTe89NJLAAwbNiysqzP2PUfNXaWfNWsW/fr1A+qSc/VXNOxz/fXXU15eHvy6Kddcc01wK85f//rXRm0KnU4nf/3rX4G6bRTXXHNNR76dqKBqDijdktDFIxLmIi0nIKtuAd8GrUNqhh4idNUmmp01fCRvrlvb7P0HpGWwp6aK3yO8jWB/br8fq0zFJUo1jaOjTk6PC+vV9YTAz1ycBKenHEiRP5n+upV1WxgCfx4j8DBALOKB7CR+943GrveQrivAHNiOwI3EiGQq31fWEKcTuAKy/sMbiNfruKXnTvQRbg1qCmzh1iwHDxYN5zdHdNQ5iQYt1ReIFYmGRPQ6Hfmu5penAqypbP79KtYInR1slyJrHgjfHLbL6uaJYZWVlfTu3ZtZs2Zx9NFHM2jQIHQ6HVu2bOG1117jww8/BKBPnz689NJLEb2quG9LgcFg4Oyzz27z4y655BLmzZvHKaecwmGHHUZubi5xcXGUl5fzyy+/8MILL/Drr78CkJCQwOOPP97hGI888kjOOOMMXn/9dT788EOOOuoorrnmGnr27MmaNWv4z3/+w86ddZVu77777kadHva5/vrreeONN9i4cSM33HADmzdv5owzzsBqtbJ48WLuuOMOfD4fVquVhx56qMPxtqa0tJSpU6cGC9TNmTOHwYMHBxMpTUlOTm60BP/999/n4osvRkpJQkICDz/8MMXFxS0W+evbty+2/Yo/z507lzlz5nDyySczfvx4+vfvj91up7q6mjVr1vDKK6/w/fffA3VJlqeeeqrJuhR2u51HHnmEM888k7179zJ69Gj++c9/cuihh+J2u/n000954IEH8Pv9GAwGnnjiiSZf6wUFBXz66aeNbttn/6v848ePZ8CAAc1+z80xGo08+uijHHfccVRVVTFu3Dj+9a9/MWbMGMrLy3n66aeDK1/Gjx/Pueee2+Q4AwcO5Prrr+euu+7ip59+Yty4cfzjH/+gf//+bNmyhbvvvptffvkFqHsN7l8PI5YI2ZXWvilKB0jpQRaNr7tSH21MR6BLeUbrKDRX4/Ew4olHG90ugDG9sjVdLbC/GQf7qTJGa7KpJZL5fUqwBFouthMNAiINt8jAEthItW4483YnUbZf+ywjcH+fauIDqzSJEUCKJJ6rGMt3la231erKTMJEdlwvttZ2vgOJ1gwYiDfaKfdWtHhctjWb6wddS6IxMSwngZs2bcLn8zVZlC0cpPQjS08FXxiSHsbhiJQ3ESK2t+OUlJQ0KObWlHHjxvHKK68EtwZ0RJ8+fdixYwe5ubltuqL9+++/BwujTZ8+nQULFrR5rra+docMGcLLL7/MQQcd1OT9L7zwArNnzwbqrjY3t3rA6XRyyimnBK9e70+n0/F///d/zT5+n82bNzN9+vQGnSHqS0hI4JVXXmHmzJnNjnHooYeyfPlyjEYjBQUF7b5S//XXXzN58uR2PeYvf/lLo5Pi888/nxdffLFd4yxevLjR1oV9r5vWZGdn89xzz3HUUUe1eNzjjz/O3//+92ARzf3Z7XZefvnl4HL8/bX35/P8889z/vnnN7p932u0td+Hp59+mquuuqrZeMeMGcOCBQtIS0trdoxAIMDFF1/Mc8891+wxF154IU899VSHukdE+n29OWrlgKJgRNgvQ1bfB7S/P29YeZYhXV8hLC1XIe7qqtyNr2anWKxk2O1RlRgAkN6EujPTGGERgrMybBxm/R1jIDZO3nSyBKusWyWSEPiFu7Ozeaz4AFbX7iviKbk9N6BpYgBAyAouSFxMkv5IPi6Lrs4NkZJqTEWn03WJxACADx9JpqRWkwO7nbu5etUcLDozGZYMMi2Z9I7LYWbWdHQi9nZ0CqGHpPuQpWeENpEukhCJ98Z8YgDqlro/88wzLFq0iJ9//pmCggJcLheZmZmMHj2aM844g5NPPjni+5D3Le+G9hciXLlyJQsXLmTp0qVs27aNwsJCKioqiIuLo2fPnhx00EHMmjWLE044ISQV861WKwsWLODVV1/lhRdeYPXq1VRUVJCZmcmECRO46qqrggXxWjJgwAB++eUXHn/8cd566y02b96Mx+MhJyeH6dOnc/XVV7eYoHG5XKxatQqo+5m1NzEQjT777DMWLFjA999/z+bNmyksLKS0tBSr1UpGRgajRo1i5syZnHbaacTFxbU63pVXXsmkSZN4/PHH+eKLL9izZw96vZ5+/fpxzDHHcM0115CVlRWB76xtLr74YsaOHcsjjzzCokWL2Lt3LzabjSFDhnD22Wdz0UUXtdpVQafT8eyzz3LyySfz1FNPsWLFCkpKSkhLS2P06NFceumlHHvssRH6jsJHrRxQlD9Izy/IimsgkK91KPvRIxLvRFhP1DoQzfxeUsypb73GOSNGYTeZWbh5A/nV1ZRrUHSwNVMHpuJOWaJ1GM2K1+t4IGcrAcx4iCNO7orYfvxwkiKOH9wT2eCESQlu+omvtA4pKCDSuHznUDzd8M9tf3s/ttREX0vCzhpoH4gkQEAG2tVy8ZDkg4k32Nnj2kuGOZ3Zff6CQdf+6zRaXWGS3t+QZbNDkyAQSYiU5xHGAzo/lqKE0L6r2gaDgQ0bNgT3rCtKOKmVA4oSZYTpQEh7HxyvI6Ub8IL0gvNtkFouC/Yjq+/t1smBHnY7/548lR927+SEgUN44qfl1HqjszNAlVMQzc24qv0BqmQWKXI5XalknpAOxpkWMi4KvymdLOH0dDsvFXW/1QO7a/eQbk6j2K1tPZBQ21izMfj1IPtANtT7d0t+Kv+zx/3G6k1Ue2u4Ku9yTLoofOE2QRgPgNTXkZXXg3dNxwcyDkck3ocw9A1dcIoSIvva1Z199tkqMaB0O7G3tk1RwkjokhH2y9HFX4Mu/np0CTeB+Y9qrSIZjAdqE5is1WbeKFHmdPL2+t94e91vfLV9K08fdyLDMzK1DqtJJTVerUNo1Q+1Le+LVULv8LjYbdvXGW7pxi8DxOlbX6YaqzbUbGSQfSB59gH0jmtf3/rVlb9y34YHcfpjp3ClMPSrqxFg/3v7uxgIG8I+p+7xKjGgRKlvv/0WvV7PzTffrHUoihJxKjmgKK3QJT2MSPsCkbEEkfI6Il6DPxbSgZTNtxPqyr7dsZ3le3bz4666KsV9kpI4LDuHmQMHaRxZ0/ZWR387w49Kq5EiUeswuhV/l1qn0T5lnjJSTSnouvBHjg01G9lUs5lSd1n7H1u9kbvW30uVt4qdjl0sLvqGIlfzlcijgRB6hP0yRPoSRMKtYBhG84tRDWAYhkiYW3e8/dIuUWNA6boWLVqEz+eL6YrzitJRaluBorSBMPxZuEbGnQs1D0d+q4H3VzBptHJBI26fj3nffMW4nN7B5mfXfPYJ+TU1fLez9aq7WnD5fFhlMi4Rvfv4PVKyV46kF99qHUq3scXTE3C0elxXtcu5m4H2PDbWNF09vKuo9dfS09KTva72tc/c7tjB3375e7DNo17omZQ+keN7zsSsN+EJeEg0Rl9CT+jsEHc2Iu7suu143t/BvxOkB4QJ9L3BOBghonmzlaIoirKPSg4oSjsJoUMah4Pnx4jOK6vvgJQ3EDFY6bqjnl/1M9UeN1/v+LPSuS8Q4D9LvtYsprYo3zuc9CQPwlKKQ78Tv3BrHVIjX1TZOT9B6yi6j++ru8/vbXM21mzqFgmCeKMdOlArVfLnkiO/9LOo6CuWlHyHWWfGojdzw6DryLBE75YgIcxgGgmM1DoURVEUpYNUckBROkKD5ADe1eD6ELpJYcL86moeW7EUKSUljti64vrT7hLYDWBEJwaQm5RAryQjCXY3mIup0e9CCm1rE3xTUcW5SVnoo647R9cTECmsqK4GItvCLBptqtlMblwuOxzRufInFCq9lSEbyxPw4Al4qPZV85/1dzEzazqDE6JzS5WiKIoS+1RyQFE6QBhHoMW2cll9H5iPQujaWQQqBt353Tc4vNFf3K81ASnZVl7JtuAuAwsG3SD6JCXQM8mA3ebCb9mFQx/Zk/RcsxldoP37o5X2K2UQUiUGgLqr4zscO8ix5mDUGdhau631B8WYAlchicbEkCYJACq8Fby881VGJY3kUM9o7MKOQX2MUxRFUUJI/VVRlI4wjgTrSeD+HgKFkZs3UASBUujiyYEfd+3k400btA4jbHyBAJvLKtj8x7l5lj2b/gfkIyJ2/ii5NNODIPq2O3RFv7mSge7XxrAlu5y7gPa1AYwlPSyZxBvsxOnjEAj2uPZS4wtNnZpVFavprcumr0VV+1cURVFCSyUHFKUDhD4TkXgX0rcTWXYeBNpXfKrD9L0Rht4NbpKBSnB9gXR9gki8HaHvGZlYwsTr9zP3m6+0DiOi8mtqOcg3hCrj+jDPJJmeksjMhK1YA+GeS9lntyfK21doaGvtNqx6a0y18muLDdUNEx5pplT0Rh2V3ioABIIB9v4A+KQfb8CLJ+DG6Xfh8Nfil4FW56j11WI0GCj3VCCoq1PglwESjQk4/S4C7Btj3+tPYBQGjDoTJp0RXTeqX6MoiqK0jUoOKEonCENvSH0FWXoOBPaEf0LT+Ab/lNKHLJ4Esrau37SuR/hjCLNX1qxmU1mp1mFEXGlJOsas8J2wD7RauSZzF9bAd9D6eYcSQubILQmJOV7pxYRR6zDCrsRTSrIxmRRTMp6Al2RjMptqNjd7/KD4gY0SDE2RSCq8FQ1uc/gdDYobNscgDBh1RkzCSKIxEb1OtRdUFEXp7lTaWFE6Seh7IeKvi8xc5nENb/Bvr0sMxM2GuHPA1/yHzVixo7JC6xA0sXJXGcaAPWzjH2Q3qNUCGrGov7QtMui6fnIAoNxbji/gQ4cuuK2iOTtqd2IQrV+/aSoF0JbEAIBP+nD6nVT6qijfL8GgKIqidE/qI4uihILlGNBHYP+ncWjDf3vXASDizkYXPwcMA8IfQ5ilWuO0DkET3kAAk2NY2Ma3qXd7zZh1auVAiyRkWWJ/1VNbVPmqqfJVtXqcK+BqMTnglV4CBJB+iQx0fttKta+aMncZgVa2M5S6yyh2l1DmKaPSU4lf+js9t6IoSncXCATw++veT/V6bVdxqY+LihICQugRtkvCP5F7WYN/Su96MAwO1iEQXWAPaVpc90wOAHy/0YXN3yssY8fp1V4CrZiFqjnQkkpfJcWuEvrE5WodSlTxSV+z95VShtvvBiQ+Z2i6ulT7qnH4HEjZ8PUqpaTSU0mBs4BqXxU1vhoqvVWUecvxB1RyQFEUpbNqamqC771Wq1XTWGL/TEJRooX1eNCFtxigdH/W8AbfOoTlqLDOGWnddeUAQLXHwy/re2IOJId8bKtQH+K1YlLJgVb58GHSmbQOI6q0lBzYKXfjkz7cfg/OUifeWk+nVxAEkBR7Ssh3FeDyu4K3+6WfMm85zoCr0YaFtm5hUBRFURoLBAJUVVVRUFAQvC0+Pl7DiFRBQkUJGSGMYLsIWX1b+CZxf4f0FyP06XUZRu96iL8pfPNpoLvXbiusqcW2eTC5A37Bp3O1/oA2suqaP9FQwsukUydQbeFTS9SDdOjqdRtorJBCSmQJOo8gmRRksQQEQi/o7FtoNVBCMXqhxyAMSCSegKfJY7fr3KrrgaIoSgf5/f4Gq7WsVis2m7btylVyQFFCKe4UqP0vBErCNIEXWTwBMlcDRjBPAsPAMM2ljY82btA6BM1tLaskftdoEnv/gAzRFX+zUMkBrRjVyoE28cnQLI/vCozCgFs2fUIOdVfsv5HfMZHxBDwSgzBg1pvReQV0Oj3QdonGRIw69VFSURSls6xWK71790ZofJVMvaMrSggJYQHbBcjqe8I4iRUw1NUXSLxL8zeRUJJShqSNod1owhPw4/HH7pXI1fmljDOPQ2R+2+nVFHE6QbKuSLUw1IhR/eDbpLmr092RQWfE7W/55+HDx1fyGzJlBjkim7RAKkYR2c4P8eZ4DAb1UVJRFKUj9Ho9VquV+Ph4bDZbVHymV+/oihJqxlHhHV/WIiuuhqT7EcIc3rkiTAjBy7NOYdpLLzBryFCeX/UzAdn+q64zBg7ijd/WhCHCyPp+ewnT0/KoNmzq8Bh9zRb+kbUdc6DjYyidY9Cp5EBbOHxOrUOIGnrRtmrVEkkBhRTIwn03RNQ/e91AXkJeZCdVFEVRwkZtFFOUkJMgwrxfyP05smw2UrrDO48GUqxxnHrAMG6eMIn3Tz+bwWnp7Xr8cQMH4/B2neXJlSVZHX7spKR4/tVjpUoMaEiKJF4v1v5KQCyo8lUxyN61tkl1lEGnbSurtmqpLoKiKIoSe1RyQFHCwXp6+Ofw/gTOD8I/jwbOGjYSgGEZmYzL6Y3N2Lalskf3z2PO2HF8trnrnAz/tKsco2x/sumSHnbOS/gcnSwLQ1RKW0h0vFF1OFtdXS+JFy4bajaqloaAjuhPDph1ZnLVc6UoitKlqG0FihJyEoSZutxbeK+qyNrnwHpKXf2BLsSk1/PJpg38XlLCxxs3IBA8e/wsVhcU8MTK5Y1qCWTYbMybNIWx2b258pMP8XSh3ttuvx9z7TC89mVtOt4sBLfkSHqyMMyRKa1Z7TuKz8qrtQ4j5uQ7C0g3p1PsLtY6FM3EwsqBI9LHYzN039aziqIoXZFKDihKqEkJeIlEcgD/VnB/A5bJ4Z0nwjLtdo4ZMJDxvXM5ZegBFNXW8r9ff+H2yVOpcrt4YfUvwWPPHDaCf4ybQLXHw2lvvcbGEBQ0jDa/7xGMGW4i3qAnXqfDbtARrxfE6SBOJ7HqAlh0EovOT45+F5aA6vigtTIxhof31hLJyvFdhVu68Usfvay98AQ8lHnK8HezNoe6KF/YKRAclTlV6zAURVGUEFPJAUUJB+klUicFsvZJMB2K0HWtKzg6IUgwW0gwW+idmMQB6Rl8tmUzlxw8mh2VleQmJjIsI5NJffpi1huY9uYLFNXWah12WAT8lfynx6I2HhzeWJTWeXW5zN1lRT0ZHVfmKQfKAciN680Ox05tA4owXZSvBjsweRSZlgytw1AURVFCTCUHFCXkJMJ0ONLxWmSm8/6MLB6LNE9FWI8D0zhEhNtZRYLVaOSEQYNx+nw8e/wsFm3dwhWffIg3EODYAQODiYHLDh5DosXMtvJytldUsHzvbo0j77wD07vXVdNYJrHycNEgqv2q8n6omHQm7AYbNb6umfxrSlu7FWjlmB7TtA5BURRFCQOVHFCUUDMOR+hsyEguC5VOcH2EdH0EIhlSXkIYu17VbyEEcUYjASl5+uef8Abqrswu3LwxeEyp08EN4yYA4PX7GfT4Q1qEGlJDk1X/91jh0/XgN4dKDISCHj3pljR0QodJZybNZKXEU6J1WBFR462lv60fJZ4SKr1VWofTQJ+4XAbaVftCRVGUrkglBxQlxITuj8ryQkS85zQAshxk1y6CphOCF088mX8u+hyHz8vVY8YigfPee5vjBg4OHlfp7hpV4vslOrQOQVEiLs4Qh0VnYWN11+k+0lal3lJKvXX1U5KMiZh1FgrdhRpHVeeYHtMQQtXSUBRF6YpUckBRwkbLPaPRvSQ1FMwGA/dPO5Zqj5sEswWAj848l6z4+OAxFS4nCWYzVTGeJMiOq9Q6BKWNDIG9jE8czHeVNVqHEvOqfdVU+6pJMSWTbk5nS81WfNKndVgRV+GtpL8tlcIoeBtLNiYzOuUQrcNQFEVRwiS6K94oSkzT8MpKoHv0thd/FC3cp35iAKBPUjLf/OUi4k3mSIcWUqnm7vF8dgUCNxck/cABcVatQ+kyyjzlbKjeSLo5nXhDfOsP6GIsOgtOv0vrMAA4sddxGHTqupKiKEpXpZIDihI22v16yeq7kDI6PkxqSS8E2yvKuWrMoTxyzAwemDadBHPsJQrs+iKtQ1DaQchK/paxReswupx8Vz46dPSwZGodSsT0sPQgzmBlr2uv1qEwwN6fI9InaB2GoiiKEkYqOaAoYaPhygH/dmT1g9rNHyWEEIzskcUpQ4Zh1hsoczo4f+RBmHSxs+1CLwIYZIHWYSjtVClVm7dwqPRVUuouo5+tr9ahhN1Aex4l7pI/2jpqS4eOv/Q5N+pbLCqKoiido9aGKUrYaFywyfEC0jIdYRqpbRxRINlq5aj+A9hbXcUXWzdzcM+eLN+zG7/UomJk+wxLBUH322cdyxy6A3g0Pw5QXSbCwSu9bK3dRpYlC73QIdAhhMCsM1HpraLIHdsrbUzCRI4tm4010VOIcVqPqfSOy9E6DEVRFCXMVHJAUUJMSj8iKnpUS6TrA5UcqKdnfAJ/GXkQfxl5EOVOJ4u2beHzLZtZsnMHbn90noCnWFo/Rokee5nALdvBrxIDYZfvym/y9t5xOdT4aqLiint7ZZgzCMgAW2q2ah1KUIopmVm9TtA6DEVRFCUC1PowRQkh6S8CAkj31yArNI4G8CzVOoKolWy1csrQYTx13Iksv+gyBqamkWyx8OgxM+mdkKh1eEG/laqWYbEkXbebeH00JAe7p2RjEpXeyphMDOTZB1DuKafEU6J1KA2c3fssLHqVpVQURekOVHJAUULJvwMAWXWnxoH8wbcZ6S/WOoqoF2828/ixMzlmwECOHpDH1H4DtA4pqMgpkKL7VWiPVcbANublVHaDZqLhZ8BAlrkHefYBDLQPpHdcDj0tWQyw92eQfSAZ5sZ1HTwBL5mWTIzCqEHEHWMURvLsA9hUsxmv9GodTgMjE0dwcPKBWoehKIqiRIiQMgY23SpKjJDO9yFQiaz+j9ahBInEexFWtSS0LX7YtZMPNqxnfXER+TXVGHR6qtwunD5ttxysPe1LLKjq97FkJ5O4dadf6zBikg4defYBbK7djF8Gmj3OpDPR09KT7Y7t9InLRS/0bHfswC/96IWuxcdGizRTGjqhi8o6CSadiTuG30a6OV3rUBRFUZQIUckBRQkRKb1Q+xzSuwbcn2sdzp/0vRFpHyGE6rveEikltV4vdpOpwe2rCws44+03NK1J8M2J6+hlWqLZ/ErH/B6Yyn273YQ7RSAlWDzxWNwJmFzx6JxWcJrx1xrw1giEHkx9KyjL3IjP4A5zNJ3XOy6HnY5dbTpWIIg3xFPlqwpzVKE3wNafXc5duAPRWZ/ilOyTOK7nDK3DUBRFUSJIJQcUJUSkZwX4dyPd34PrQ63DaSjufHQJN2kdRcxw+bx4/AESzGYAPtuyiS1lZUgkT65cQY0nsh/mZ/bx8dCYZyM6pxIabl0eT5X04+caR8jGTF0xntpiQW2Vj+pqDxWVLvz+1q+Sm4x68oYkkzTIRWXPTTgtFSGLKVSyrdnsdu7WOoyQybMPYK8zn1p/bfA2PXr62/tFVTeC/dn0Nh458AEMOlW3WlEUpTtRyQFFCZFA9f0I81Sk801wvqV1OPsRiPgbIe68YCcF6V0D3t/BegJCmFp5fPeyZOd2/vPt1zx13In0TkxqcF+Z08GFH77H6sKCiMb03aw19DD+ENE5ldCQGPjdP5mH9rrxdPJPrhEof+4QCotrWz22JUJAv37JZAyWuHN3UmHfg4iC2pf9bH3ZWrtN6zBCYoCtP5trt5BhzsBmiEOgAyQOv5MCV2TfP9prXOrhXNL/Qq3DUBRFUSJMFSRUlFBxLwFDf5Cd+9AeHhJZfSey9FSkd13dTe4lyKqbkcVHImufRQaiMW5tTOjdh5dOOpVX1qwOrhJ49peVVLndpFjjePDo6cQZI1vw7NYVQ5FEwdmb0m4CH0P0X/CP7M5fhb0xx8gFxzXdwq89pIQtW8r5cUEFP/83AceLY0hdPp60koEQ0OZ1Fm+IZ1vtdk3mDqXcuN4Mih/IdkddgdoidxHbareztXYrW2u3RX1iAODAZNUCV1EUpTtSyQFFCQHpL4ZAKQh9XZLAGKXVnX1rkaUnI50fg+V4wAyBImT13eB4Revookp6nI1/jDuC935fR0BKchISOPe9t3h+1c+sLSrk+IGDIxrPot16druPiOicSmil6Du3L/7E1Hj6ia845qDXOXRkQoiiqlNQWM3yxaUse1ZP5XMHY3FFvp1nta+aPPsAdDH+0cSkM7GheiM+qW0h044yCAPDE4dpHYaiKIqigdj+C6wo0cLzHRj6gfsbMI1BWE/UOqIW+JE1D4A+A2wXBW+V7i81jCk66YRgXE5vblr0OQ6vlzVFhfz728Xsqqqk0h35wm7/XDYQqZrkxaw4Sjv82AFWC8fbvwPqtgRcd9o7WC3hWb1SUlqL//Phmqwg2FiziZy4bCw6S8TnDhW/jO0uFUMThmDRx+7PX1EURek4lRxQlBCQ7iVg6Id0foyIOweI8hZa/t3gfB9hvwR0WXW3eVch/dHXTktr/ZJTyLTb+fvnC4O32YwmHjt2JnZjZGs1LC3QsdU1OaJzKqFjlIVA+2sOmITguswdCPnnyoPMpG1ccWr4KvT/vr6UjLWHh238luxw7CTeYCfZmKTJ/J1h09vY8cd2glh1YPIorUNQFEVRNKKSA4rSSTJQXbeVQNcLAiVgHIKsfljrsFola58ALIi0D+qKFepzwf2V1mFFpcsPGUPvhD+XWVd7PBTU1FDjjXwLsht+6IsksvUOlNAQ0kF/S/tbit6co8Mc2Njo9uPGvMSBQ0O7vaC+pZ+WkblzFMIf2Y8K6eZ0kk3J1Phirw5Kdlwv/DLKk8OtGJWk6g0oiqJ0Vyo5oCidJKvvAVkJhsGIlNfA8RrIij8PEJHfu9sm/t3g34XQJSFsFyDSPgPzBK2jikoWg5G5k6YE/13tcbOprONLxDtjdYmO32untH6gEpVuyvyFmSnxbT7+9PR4evN1k/fpdHDDmR9iNoWn3ZyU8MNrbvY+Phz7oiPosf0gzO62x94RaaY0it3FbKzZhFd6wzpXOFR7q7UOoVP62vqQYkrWOgxFURRFIyo5oCidIN3LwPkGAEKfihACLEcDAoSt7iDzeO0CbI13bfBLIXQIfS8Ng4luk/r05ej+eQA4PB62lpdpFsvfv++NFOE9SVPCQydLONn+Cffmejk3I56+5pb3dh8aV9zi/b1SNnLxya5QhtiIw+lh9U/FfP+Gk02P52L0hm8/ut1gC9vYkWA32LUOoVMOTBqldQiKoiiKhlRyQFE6w7sc9H0AkI4XARCGAWCZCYahdcfos8CQp1GALZO+ta0fpAT958ipfHnubG6deCQT+/TFoNPmLXRTheDWVaciiWzNAyV00uRSjrR8wi2ZX/BMn83clRtgdmY8/S0NT7yrZesnyxOHLQpXmI0MHJKM19g4GSH8OjJWjyOpMgeAOGcKacUD2z2+URd7r2mLzkK6KQ0ATyDyW41CSdUbUBRF6d5UckBROkHY/4ou/XNExnKEaTzSu6nudttlYBxSt3rAuwZh/6vGkTZNRGnSIlqlWOPol5zC6sICeickMmvwUM1ieXWDkSc3n4GTPAIiSbM4lM7TB/LJlN9zhPkTbs74ijm9rME/zhU+c6uP9wUiV1ne75WNuhgk1PTA/85h/PhpGVtfT8f66QR+e6wHy57Tk/n7oe0aX0fkOyR0RJIxkYH2PHLjeuOVHoo9JSQZEzHqYrceSJIxiRxrttZhKIqiKBoSUsr2l05WFKURKSWy5kF08X9H+naBPhOkD6QTdMnI8vPBs1TrMP+k64VI/xwhYvfDrFaeXLmcl35dhcPrpcIV3iXdbaEXARafuJ6exu+0DkUJkVrdcO7Nz2BCooUplgUtHru9aBjnzYtcZ4EemfEIAS6XD6fTi8vta/H4Q6emUnzQd4g2nPfn2fPYVLMpRJGGXrwhnhRTMjscO7UOJeRGpxzCVQMu1zoMRVEURUNq5YCihIgQAqQL6S9AGHIQwoTQxf1Ri0CHSHoCjKO1DjNI2C5UiYEOOnfEgbh9/qhIDAD4pY6jPhhCsa99V2mV6GULrOHWHj/R1+xs9VifP7JL8QsKq8kvqKa8wtlqYgBg2ZelJH5zBLqAvtVjvVG8LL9PXC6SQJdMDAAMsPfXOgRFURRFYyo5oCghIgM14PoEdClN3i90cYjkp6MjQSDsEHeK1lHErDijkcsPGaN1GA24AzqO+nAk5YGDtA5FCREhK+knWm8v6o1wcqAjfllWjOGTsRhaKWbo8DsiFFHb6dAxKH4g2x07YrK9Ylvl2QdoHYKiKIqiMZUcUJRQERYwHgS+xv3Ig4fsSxDo+0YwsCboeyJE5PYpd0VnDR/BYb1y0AmBWR+eVnLtVeMTTPvoEKrlcK1DUSIo0isHOmr9b6W43z0Qi6v59q5VUdQKMM2USn9bP3pYerChuvn39a7AKAzkxvXWOgxFURRFYyo5oCghIoQBkXgnsup2ZO3/aK6ch9DFgUnjq7s61ce6sywGIy+fdCq3TjySEwYNZu7EIxmR2UPrsCh3C47+eCwOBmkdihIhXn90JKfaYvv2CkpfH0R8bSZSgtkdT2J1NjZnKmZhwhWIjq06PS1ZOP0uttRuZa9rr9bhhF0fWx8Muth5HSmKoijhof4SKEoICZ0Nkh5Flp2OME8CQ9NXYoQ+F4kBqNuvK5KfRTpeBXekWpLFxpXGaKcTgnNHjGJXZSWLtm3htZNOY+meXVz04XtoWem1yCmY/slEvphRi1Hu1jASJRJ8vtiqHVJQWE3pk+nIQBo+fwCAOGsKY8/Tsz3pF42jq6stsNeVH/NtCdtD1RtQFEVRQK0cUJSQE/r0uq0Dvo3IQA3SsxzpWox0LkA63kTWvojU9wbLUYi0LxHJzyDMExD2ayIXpO+3Zlc2KO2Xk5jIeSMPZHtlBeNycvnrmLFah8TuGsGHuydoHYYSAV5/bCUHALxefzAxAOBy+8j/OpFsXR/tggIG2Pqzy7mrWyUGAAaoegOKoigKKjmgKGEhDP3BPBGEDXw7kJVzkJXXIqv+haz+D+gzEbYLQZ+DMB9R9xjjIDAdFpkAA2Xg3x6ZuboJnRAMSUtHJwRCwPicXPomJZNkqavtYNLreezYmXx+zvkkmiNT7+H25fEEhNpC0tXF0raCpugEDO6fyboNhaycbyfdkKFZLK6AC6OoW1llELH9c20PtXJAURRFAZUcUJSwEcKIEAIRdyoi7RMwHfHnnVX/BpFU1/6w/mPi/hK5AD3aL9/tivRCkJeSRpnTwZWjD2XxeReSm5jEuJxcBqWmMSAllVmDh0Qklmqv4KdytXogGhSU9+PFLy/lnR/OZ9GvJ7FyyxS2Fo6ivCYLf6Btf4oDgaZv9/lbbxEYrYSAIXlZrNtUAEBNhZ/tr2QRr4/XJJ7dzj0kGZPItvYiNy5XkxgiLd2cRpKp+SKRiqIoSvchpFpbrCgRIaUE13vIqjtAVoGIRyTeg7BM2e+YD5FVt4OsDG9A1lPRJf4nvHN0YzUeDw8t/YGNpSVcd/j4BsUK15cUM+PV/0UkjrwkySfTnkfgjch8SkMuTxyvfP0XXlsIHo+/yWOEgAS7haQEA8kJepLjJUnxXpLi3STZHSTbq/l5Y2/e/8qJ0aDDaNRjMuoxGXWYTDrcbj/FZc4If2ehMWxgFms35je6Pe9gK4aj1uKR2i7vz7L0IN9VoGkM4TY29VAu63+J1mEoiqIoUUAlBxQlwqS/EFl1K7j/6F9uuxhhvxZRbwmr9Bf9cUwYCxQaBqBL+yR84ysArCsu4t/fLubQXjlcfsgYzIa65/nEN17h18LInHR8ecJG+pgXR2QupY6U8NWvJzH/nd4UlTq0DicqDR/UkzUbmu8EcPDRNipHrURqWN6zd1wOOx27NJs/Es7NPZupmUdqHYaiKIoSBdS2AkWJMKHPRCTNRyTeByIJap8G6djvmAxE0n8RiffXHRMOvs1I769hGVpKiZTqSjXA0PQMXjnpNDLtds56903eWPsrm8tKKa6tjVgM961qeT+xT2Txn7WzWV09PUIRdW0b9x7M3x67jnlPpanEQDNGDO7VYmIAYOVntWTt1rbt607HLrKtvTSNIdxUvQFFURRlH7VyQFE0JP3FyNpn0SXc2PT9MgC+35E1j4H7y9AHoMtCpL2H0KW0eqj0bUU6PwDvWoT1OIT1xJaPdy9DmA8NUaBdQ4nDwd3ff8tHG3/H4296iXm4rDxlGYm6VY1u3+MZzxlfDCW/tq7+xaXD3Mw54CN0sjSi8XUFFTWZPPPpmXz0tQP1l7V5qck2nE4PDlfbEohTrjSy3R6eRGZbxBviqfZVazZ/OJl0Jp44+DH0InbrViiKoiiho1YOKIqGhD692cQAgBA60PdAmMaALj30AQTykRXXIKWv9WP9+VA7HzxLkFVzkb5tLR/vXY4M1IQkzK4iLS6Oe486hv+deAp5KakRnfvhtQdSGRiFX2QCILHyxq6zmfj+n4kBgCfXmjl24cmU+kdHNL5Y5vMbePO72Zw171Q+XKwSA61JTbK1OTEAsOhxD7mBgWGMqHl94nK7bGIAINOcoRIDiqIoSpBaOaAoMUL6C5A1T4DzTaANJ/PtYRqPSPg/hKFv8/MHqpBFh/x5g2EYIvV1xB9tvxod71wA/q0I+19DG2sX4fH7ee6XlTyy/EdcvhA/n62IN0oSzbC7RrRwlOSxiRUcnfmeKmbYiovuu46N26q0DiMmjBjSi1/X72n34/ocYEE/M/IdVgbY+rO5dkvE542UIfGDuXHI9VqHoSiKokQJtXJAUWKE0PdAlzgXkfYZWE8ipL++nu+QJTMJVN/b7NV+oUsAfb3kgW8tsvwKpL+ZfcOm0cja55B+tTy9KSa9nssOGcO7p52FTrR0kh561V7RSmIAQHDVN8n8ddlf8NAnEmHFLLe7mR6DSgNpKXY2bi3q0GN3bXBhqFe0NRLMwsQOx86IzhlpNoNN6xAURVGUKKKSA4oSY4QhB13iXYi0BWAJZQE5L9Q+jSwaS6DkBAIVf0fW/Bfp+gzp21xXYNA4vOFDPN8iS6Yja59vtDVB6DNAl46s/W8IY+x6Bqelc+6IUVqH0axPd+gZ+/403DS/qqS7y0pXf0rbIjnBisvdsVUofh+khmNrVQvSLGl4u3hhVbvBrnUIiqIoShRRn2gUJUYJQ390SQ8hUj8AcyjbULnBtx5cHyNrX0B6fkFWPwye78HzXePDpQNZfSey9FSkr+HyW5F0P3hWIn1d++pbZ91yxGTunDINiyGyV0bbqtIjWFJ/S4kCgMOdwNvfn8/GHV37BDIURgzpxabtxZ0aw+pKCk0wbeSXXX9FiF2tHFAURVHqUckBRYlxwjgEXfITiJS3wHR4aAeXFSCsCOtMZPlfIVDW/LG+35A1j+8X23BE6psg1X7slgghOP2A4Xxw+jkMTE3TOpwm3f9LEhJVuAxgb1kej374V06++VweedVEWYVT65CiWnqqnQ1bCzs9TqDaHIJo2s4fiGwtEC2olQOKoihKfdF5mUpRlHYTppGIlBeQrsXIymtBhqi/eu0TSAJAG2qXur5ABqoRuvg/4xImMA4LTSxdXF5qKu+ffha3L/mGV9es1jqcBjZV6tjrOZxepiVah6IJKWH1tsm89c3BfLeyCindWocUE+w2M1aLieLSzncuEUmRTcJ4uviWAlA1BxRFUZSG1MoBRelihGUyIvlFEEkhGtFPmxIDJSmQIQAAk4VJREFUALjB9WmI5u2eLAYjt0+eymPHHke8KbJXSltz7MdD2O6arHUYEedwx3PRfXP42/15LPmpSrUqbKOkBCuJ8VZ27mlhxVE7VBg7v/qgPWq8NfSO6x3ROSNNrRxQFEVR6lPJAUXpgupWEbwMuoyIzy1rn0C6v0e6vyNQdRuB4qOQnsi3IIt10/MGsuCsczmwR5bWoQQ5fIJzvszTOoyIK6joz6btXbfXfTikpdgxmQzsKagIyXjpOSYq/aEZq638+Nnp2Mkg+0D0omt+XFI1BxRFUZT6uuZfO0VREMaBiJRXQZ8d2Yn9u5Dls5HlF4DjZfDvAO9vkY2hi8hOSOT1k0/nsoPHaB1KUIEDZDfbkVZYET0JmliQlZ5IICApKgldQqXPSGPIxmqvDTUbyTRnkmRM1CyGcFHJAUVRFKU+lRxQlC5MGHojUl4DwwBtAzFP0Hb+GGbU67lh3ARePOFkUq1xWocDCKRI0DqIiCoqj84ikdGod89kapxuyipqQzpufLa2xQH3uvJJN0e2lWIkqG0FiqIoSn0qOaAoXZzQZyJSXgHjcG0C0PdGGHK1mbsLmZDbh0/OOo/xOdr/LH2yeyUHCsu71/fbUf16p1FSXkt1jSvkY69ZIEnUa3vlflvNdqx6q6YxhJoqSKgoiqLUp5IDitINCF1yXZFC02GRnzxQjvREV+X9WJVus/HCiSdz/eHj0QuhWRxuGd/6QV1IYZlF6xCi3uD+mewpqMDh9IRl/OJdHio/7odZp12RzixrDzLNka/jEi5xeit6odqTKoqiKH9SyQFF6SaEzo5IfhrMUyI7saxGlv8F6V4a2Xm7KJ0QXH7Iobx28ukYddq8hTv83WspcnG5domYaGfQ6xg1NJvftxTi9oR36f+WX12Ylg9Hp8FHl0HxA9nl3M12x46Izx0uatWAoiiKsj+VHFCUbkQIMyLpUbCcENmJpQNZfhHStTiy83Zhh/TsxZnDRmgyd60vGmofRE5i98qFtFlWeiJZGYmsWrc7YnOuWlRL5o4DIzYfQLY1m43VmyI6ZySoegOKoijK/lRyQFG6GSEMiMS7Ie6cCM/sQVZciXR/H+F5u64rxxyG1RD5zgFV3u61zL5neuj30Me6EYN7UVZZy6788ojP/d3rDnKrRkZkLps+jipvFRIZkfkiQYeOeIOdnpaeWoeiKIqiRBmVHFCUbkgIHSL+/8B2ZYRn9iE9P0V4zq4rPc7G7FEHR3zeImf3WjnQM61C6xCihi3OxNC8Hvz6+56wbyNoyVfz3eT6B4V0TLMwkWRMpIclk95xOfSz9SPVnEqVryqk82gt05LBUZlTuaT/hVqHoiiKokQZlRxQlG5KCIEu/mpEwq0gIrj3NFAWubm6gUsOPoREc2Sv5N++IpmASI7onFoa3mcNBoP6c9k/Nw2zyci6TQVahwIIKtd0vjBmD0smdoMdvdDhlh4qvJUUuArZ6djF1tqt7HTsCkGs0SXfVcB3JT9Q4anQOhRFURQlyqhPO4rSzYm4sxHpX4HtEhARaNOlkgMhlWC2cNkhoyM6595awVs7j43onFrql7maa86q1joMTY0ams3WnSWUVdRqHUpQ4ojOPycmnZkaXw1+GQhBRLHDL31dqriioiiKEhoqOaAoCkKXjC7+OkTaIoj7C2AM32T+HchA9z7RCrXzRhxIhi2ylcf/9aOdajksonNqxeWJwx/QYzZFvr5DNBjQJ51V63Yjo2jbfXyKnj36LZ0aIzcul52OnSGKKLZ4A74uuSpCURRF6RyVHFAUJUjo09Al3IxI/xKsZwBhOBny/Y4sHk+g8makd23ox++GrEYj86cfT4olAis//iAR/HP5Ycgu/GfE7bXwwpeXceotF/LgyxZN99hrRSfA6fRoHUYjo44x45Odez5cfmeIook9Vb4qTVpCKoqiKNFN/WVQFKURoc9Cl3gbIu1TsJxIyN8qpBOcbyFLTyJQchLS8SYy4AjtHN3MgVk9eeu0M8lNTIrYnJ/u0LO+dlrE5ou079dP57n3AlRWu7UORRP9+6QxoE8GewortQ6lEVNa5xIWefYBFLqLQhRNbEo0JmgdgqIoihJlVHJAUZRmCUNvdEn3INI+Bl1GeCbxrUVW/QtZPB7p69wy4e6ub1Iyb516JiMze0Rszku+6k1ApEZsvkipqM3glc/6aR1GxAkBQ/OyyO2VwpbtJWzcFp0n0K58U4cfa0BPkbs4hNHEpiRjktYhKIqiKFFGJQcURWmVMAxAxP0lvJPIGmTVPGQ0bWyOQWlxcbxy0mlM6RuZE9sCp+CjPUdFZK5I2VuWxxUPnsOm7V2rhV1rLGYDA3LTWbcpnx17ortwaMGGjr9P5Nr6UOmNvtUQkZZoStQ6BEVRFCXKqOSAoihtE3caiDD3t/csBdfH4Z2jG4gzGpk/4wTOHj4yIvPd9EM8HnpHZK5w27BnNJffdyy782u0DiWi7DYzPdIT2bQ9Nq6ob/vNiVF0rHBqvjMfg+iexSXrSzKq5ICiKIrSkEoOKIrSJkKXCNZTwj6PrL4TGYiedmmxyqDTcdukKVx/+Piwz+UO6Pg0//CwzxNuyzYezd/uH015pUvrUCIqKdFKot3C9t2lWofSZgE/pOs6tn3GEXDQ19YntAHFGB067Aa71mEoiqIoUUYlBxRFaTMRdx5hf9sIlABqa0EoCCG4/JBDefDo6Rh14X3eluyNbCvFcPjvO8NwurtXR4KMVDtGvT4qiw62xlSd1OHHVvu6dzvVBGMCOqE+AiqKoigNqb8MiqK0mTD0RsTfGN5JdKkInbqiFUonDBrCg0fPCOscX+3SIxFhnSPcqmq7dmKgV48kkpP+3BqU3SMJj9dPcVlsbqGQsu2vNwMG+sTlkmcfQH9bP6o81WRbs8MYXXRLVFsKFEVRlCaoTXeKorSLsJ2P9O8FxwvhmUCfG55xu7ljB+SRl5LKprLwLB2v9Ah8ohdGuTss44eblFDVxVsW+v0Byisc6HSC5MQ4Sitqcbq8WofVYb74Cgi07dg+9lw21/zZDUUgKPNEd9HFcFL1BhRFUZSmqJUDiqK0m4i/EUxh2mOu7xqF7aKNEILZow4K6xxl3pywjh9OLm88Xl8bzzRjkN1mprq2rpZCICApLY/txIDQSUoobPPxgf26oEgkDr8j1GHFDNWpQFEURWmKSg4oitJuQugQlpnhGdugkgPhcuLgIaRYrGEbf31FVtjGDrcqR6rWIYRVdo8kah0ercMImdwhVtyBtq/0qPTEXk2FcIrTh+99QFEURYldKjmgKErHmMO1ckBtKwgXi8HI2SPC197woq/SeH/vGUjMYZsjXKqcKVqHEDYjh2bz+5a2X2WPBc7qxqs8LDoLZp0ZfRMfbZLUlfIGXP6uvYVGURRF6RhVc0BRlA4R+p5IfV/wbwvhqEYwhu/kVYFzho/iyZ9W4An4wzC64LrvEtk87EzmDH0FQewsW69yJGsdQlj07pnMmt/3aB1GyBXu9DBIl8uewA4EgpyyUSx+2gl/FMUUOonJosdkFpgsOjhDgknbmKNJd95SoSiKojRPrRxQFKXjQrx6QMT/XW0rCLN0m43Thw2nX3IyOhGe7gJPrDXz341nIWMk/ywl/LJpkNZhhEVRaTU90hO0DiMsltxtxbb0YOKWHsTip11Qr1uGDAjcjgDV5X5K871UxRVpF2gUqvXVah2CoiiKEoVi45OboihRSZgORzpeCc1g5iMh7vzQjKW0aN6kKQAs2rqFqz9bgMMb+iv8D66yYNGfyQX9XwcMIAwgvQhcIZ+rMypr07nnzb+w5KcqrUMJC5fbh8/nx24zU1PbtZaSy4Dg129avwKe2tNIsa9rbavoLIffqXUIiqIoShQSUu5XwldRFKWNZKAaWTSaNvcTa4o+GxH/DzBPQ4TpSrbSvN+KCrnoo/cprA1/r/sHJlRwfNYbYZ+nPW567jq+W9k1EwP1DeiTztYdJY2q9ncHg0ZbyR7nRhp97NBt0DqcqJBpzuSekXdoHYaiKIoSZdS2AkVROkzo4sE4ooMPtiHscxBpCxGWo1ViQCMHZGTy3ulncUB6RtjnWl5oC/sc7VFSnc2Pv1RrHUZE1Do83TIxALBhhZNFDwX46l5BH9cwrcOJCqrmgKIoitIUlRxQFKVzTB2oO2A+BpH2GcJ+KULEXmX7rqaHPZ7XTz6dI/v0C9scGTYbe105/FA+C6/IDts87fHNmin4A93jhDk9xa51CFFAsOhhH7m+wVoHojmH34FaOKooiqLsT20rUBSlU6RnBbLs7LY/QN8bkbZAJQWikMfv5/z332Hpnl0hHTfeZMbl8+IN7Nt+Ijm2TwCbQVLtFVR7BC4/XDS0giMzv8Mg80M6f3PmL7iK1z7xRGQuLSXGW3E4PXh94ehQEXv0Bjji7152is1ah6Kppw7+L2a9eh9WFEVR/qRWDiiK0jnGkSDaWA1d2BAJt6vEQJQy6fXMn3E8/ZJD29ZvUFpavcQAgGDhdj1vbzbw2Q49P+Tr+LlIxxVfpzD8reN4dut51MohIY2hKeVV3aO3XXKiVSUG6vH7YMenXbODQ3vUqq0FiqIoyn5UckBRlE4RwlRXULA1psMRaR8jzIeFPyilwxItFp47/iRSrdaQjdmeBWregODOn6yMfOsIbl51AQXew5GEpx5FWVX3+BO4fXcZg/tnah1GVOk7wad1CJpz+FRyQFEURWmoe3wyUhQlvKyngGl80/fp0hEJ/0YkP4/Q94psXEqH9E5M4smZJ2LS60My3sr8vQxNS2/3497YaGT8e8M555uLqJIdLHzZgvKq7rOrrrrWjar5Waf/KCtFCd17S4FJZ1JFCRVFUZRGVHJAUZROE0Igku6DuLMAA6AH85GIpPmI9G8QcaerbgQx5qCsnjww7diQjJVps+OTHW93uaxQx2d7Ql9lvqyy+1w93lNQwQEDe2odhubGHG/DeMwaHIHufWJ8UNKB2AzR1T1EURRF0Z5KDiiKEhJCl4IuYS4i7VNE+tfokp9AWKYghEHr0JQOmp43iBsOnwCA3dSx/fkHZ/Wkxu1mY2lpp2J5d0toT2QCAaiodIV0zGhXWFKFXt9d/+xLjrzMTOmQn/BKr9bBaG5aj6n0tGRpHYaiKIoSZbrrpwRFUcJEGHoj9Gp/c1dx6cGjefOUMzg8p3e7H3twVk9W5u+l1tf5k7EVhQK/CN3rqsqZ0W3aGO5TXFrDsG66esBs1eFN7lyCqqvItmbT395PreZSFEVRGlHJAUVRFKVZQggO6dmLf02YxMCU1HY9tsrlDmUklPtyQzZaeU2PkI0VS37buJcDBna/K8Zup+SnR+PJ2nEwWfpsrcPR1EHJo7QOQVEURYlSQranjLSiKIrSbVW53fxt4cd8u3N7q8cmmi04vJ79Whh2lOSFqcWMT3kvBGPVWbllCtc+0L/J+4aO7oU0CvzlXgr3VFFZ5QzZvNFi5JBerF6/R+swNNN3mIV+k3wUxW/pNvUHjMLA9KxjmZF1LGa9aierKIqiNKaSA4qiKEqb+QIB/v3tYl76dVWrx/ZJTMIbCLCnuqrD8xl1ko9mbGWA9csOj9GUL1efzG1PNb0SYvD4bL7S/3HiLCU99DZyRTymXQG2bCoKaRxaGjU0m1XrdmsdhqYMZjhomg3rAaXskduRNP2RqIe+FwX+2E6mDE8cxrUD/4ZehKYLiaIoitL1qG0FiqIoSpsZdDrmTZrCrRMno2tlz/L2ygrKnE5GZnZsCb9VL1kya1WTiQGJQNLxYpdl1QnN3qdz1jtBFIKCgINl/kIqeodiFUT0WLVuNyMG9+rWLQ59blj+US3f3GWh5o0R9C4fRaI+qdFx655NIdc3OPhvozBGMMrQKHAVIujGT7aiKIrSKpUcUBRFUdrtLyMP4s4p01o9zunz4vJ1rGVgTgKk6Zc3ur3EP4Yrf7yQc7+dzV7vhA6NXV4V1/ydzaynW+MtIT0tvkPzRatff9/DkP49MBrU1eSC7R4WP+Xml7t6EP/TIeQGBgWvshtMOr66H3qXHESKPpWadw4gTZ+uccTtc2TGJGp8NVqHoSiKokQxlRxQFEVROuSkwUPpm5Tc6nG7qipDMl+NHMYtqy/gsHcO5PNdepYW6DjivaHcsPJCJO07uS2vbr41467kxjUG9BImy2xqarpe+8N1mwvom9O+YpMGvY6+OakMzcsiLcUepsi0IQOCVYtq+epeHUXPDiW74CBkQAKCxc86WXV/Jrs3uan+uv0dPLRiFAbGp41jZfnPWoeiKIqiRDGVHFAURVE6RK/TcenBo1s9zuH10tPe8Svubvrx6Ma/MOqtw3l1Q+Pl3O9uMVAZGN6uMcuqmk4mZGUlssFb1uC2AwypjNqUwIYlu3G6vKQk20hOisNijr2l5c3ZuK2IIQNa3/6hE4Lhg+vaIW7bVcq6TfmUlNWQnBTHyKG9Wt1qEmsqin1886KTkj1/tuP0uuuWlqz7wUEf9wFahdYuXunjlR2v4ZN+rUNRFEVRophKDiiKoigdduLgoWTZW75yHG8yYzM2f6W+OdUeeG3nWYx4awoPr7JAC/ulfyga2K6xy5upkZifX8n4Pelk6//8nhIDJvLz61Y/mM0GNo1w89tIJwVjIScnpV3zRrMaR8utJ3VCMHhAD9b8vhefv2H9hfIKB6vX7WFw/8xutUVh+YuCeH1sbDVZWraMNFP7VogoiqIo3YtKDiiKoigdZtLrefWk0zm6f16D2xPNZg7J6smw9AwcXg+bykvbPXZ+reD/lsbjl63/qXrqt6R2jV1e2XwdhK1bijF+52QidVfIlwcKSEq0AtA3Lx03dVdfHdJH4cCucyV2197yZlcP6HR1iYF1m/JbHGPd5gIGt2EFQldRXe7H/NsgrcNoswRj84U4FUVRFEUlBxRFUZROyU1KYmx2DtnxCRzSsxdD09Opdrv5KX8va4uL8EegY+7aUkGtHNKmY6WE8sqWawe4PT4orEsgJAgzScl1BQxd+9WgS5fWZsfokZlA8pQ0MjJi48oyQHFZDaOGZjM0L4v0P2oJ6HSCwf1bTwzso9d1ra0FrVn2QQ059NdkbimBQNs/ym2t3Ra+YBRFUZSYp5IDiqIoSqeN7pXN7uoqftq7h3XFxWjR9G/Gwgn8XHUckoYn7JK6xIFX9AKgxpWC19d6hIZkI0hJyjI/27eXYjTqWSVLGhyT6Gi+naJ5qI3ffKVsHOpi6EG9OvAddVxqspV/zK5m+KD2XSkuKath1brdrNuUT3FZDXabmcy0hDYnBqDZZg9dmOD3N+yk6tNCP7I0ImTj2hbx3oEsWzGc75YNZcnywdhrx7RpvLWVv4U6REVRFKUL6XiTaEVRFEX5w5C0dA7O6snK/L2axbC7RnDapz3pn3Au943fRYLRxdd7s3lxvZWdNYLnpxQzIfVddhS3bYVBtcUHAYH/j/31ffPS2SELGxzjKm5+n36VzguBuu0HX8bv5bDJWZQtL6OmtuW9/Z2VkRrHQ1cvJDt1A0Xll7FmQ8fHqql1tyveEYN78ev63R2fMEYVbPdQcEc6OYNy6DdWILNKyQ/sItDGNFmGPgtreQYAXp2VbVUmCio97K6qRi8EeWmJ9EwWmG3lOIzbcVdn4PH/WThz4Zoajh12GDX2pS3O83vV7/gCPgw69fFPURRFaUz9dVAURVFC4uzhIzVNDuyzpUow65PGbeY+2ZHMhFR45YuxQDMVCevZSTUAVqsRt8eHL0PX4LK4XsLunWXNPBqyqiz8Fvfnv5cGCugxJo4BuxLYurm4zd9Pe2Sl23jwbx/RM2UzAL3SyoAk9DqBPxDea/oJdgu//r4nrHNEu10bXOzaABBHfMpQhh5hwTaghiLjDpyBhi0yjcJIL08ee76z8uPyWsADgMTDgIm9KDFWEpCSgJSsKypnXVHd4wS5GPWN24MuXFvFlEHj0SVuwKVr+vXlCrjZXLOFwQmxUydBURRFiRwhZQQ2gyqKoihdntvn4/DnnqTc1fJ+fq2YdQHeOHQTV9z1Z2cDISA3NxVrkhnidLjNkkqdm0LpoMjnACE48Pd4SkpqqDzCSFXAE3zsEEMKlYuaL7SYlGjl95EuAvttwT9En8HerwqbflAnZPew8eBf3ycz6c995SXV2VQ60kiMK+G2F89g1frWkyIdpRMQ5vxDzNIbYMjhcWSM8OKN///27jvMjer6G/h31MtK23tfl921ve4NjG16DZ0AbwKkkBDS6y8NSIGQkBAIJCGNJPRO6NgY3Htv23vvXdKqS/P+sdiw9vYdaaTd7+d5eLCkmXvPds2Ze8/pg9Ach2PvuWHtGbmgZUxqBLzLdCjrn3gxz+xoM2YlqKAxtcGqrAaET74wn0m+Ep9Nv3FSHwcREU1vTA4QEZFkfrd7B548eljuMEZ0WXccCos6YYrQIX1BHEoMfWjxDYx6zuraaGh0KuxMHno39gIxFeU7R15CHxWpR/0SLwbEoZ0RLnakouxQM/wS/PmNidJj7VIB6xYVY0n2NqiUI3dh8PqU+Ppj30d5TeASBJEmHfqtoZkcCkeCQkDOZWnY62iedGHPKJ0WSxZVwCsMfp9nGjJx/4JfSBkmERFNE9xWQEREkrlqTm7IJgfM0MA2ICLn/FQc9LehXGgGxtGJUK1VAclnF4UTekc/WbfMjAFfx1nPb9Y3Q71OQJrKjHhRD029DzXVE9tmcMvlWqxbdBzz03ZBMc7SwiqlD1ee2wEgARW1FgTi1oDZpGdyQEKiX0T1xkYsyYtB2ywfmmwTT+yoFcrTiQEAqLfXw+KxwqwOny4aREQUHEwOEBHRjDA3KQ570DJYN2AC3fZUGiVOKnpwZm25zuaRL9TmrUzDZt/I++89EFHrtaBTcCClbWKt/5bOM+ObV/9xQueccv05z+L6cwCrIwbHa9fgN/9Oh8M18mqDiTLqNZKNRZ9oKeuBuk6Jcy5Nxb7+idV16LTbsWJgJazGg4jwZaKnPRN1mTYsTGRygIiIhmIrQyIikozd45E7hBH1uCZ3R9sbr0C3f+i5yUoDunuG346QlhaNHfrxFWZc7UqYcPeCy1ZPvRuASd+DWUmlkiYGAECj5j2HQPE4fWh8vxnJxolf1G8otKGreg02HjLiQEMX1AplACIkIqJwx+QAERFJZsDjHvsgGWRHRaGmd+TOAqM5grO3BmSL5mGP1WpU6Jzrhwdjr9mPVmhRe2xihQl1WhXWL9gwoXNGcqjiHEnG+TSFYmKrIGhici5MReuAdVLnlnb2nv63iskBIiIaBpMDREQkmVBdORBnME76XLt49t11vXP4i6uMcxJR6xvfvvDF3jg4nBP7fK1brodBK01BwZPV8ZKM82lSFFmk4UXE6HBUlKYFZvuATZJxiIhoemFygIiIJBOKyQG1QoGyri5JxyzX9yPSrD/9OCnRjPxz07BDHP9+8GOqLphNugnNe9nKkxM6fjT3fu5RvPbgZjz4zVZ87kqNJHf93Z5xVHikSYlZGwubRCtznj1xTJJxiIhoeuHmQCIikkwoJgdyY+NQ1Hn21oCpaPLZELtMhwJfGmpVVhz1WQBYMZFKh31+FxanJcBSOr5aCDkZJizN2TK5gIchCEBiVA0So2qwdh6QFHs7Hn1OP/aJo/D7/GMfRBOWlBuDA33jq2MxHgeam1DX14usqGjJxiQiovDHlQNERCQZewjWHCjq7MCKlFTJx+32O7FdaEb9OLcRnOlcRTIqSsdXcyAh1oA/3P0alIrAXXxft/o5fP6qs1s2jle0WY+evuGLNNLkiQAGchXjqGIxfvlx8XipSLpVKEREND0wOUBERJIZcIfeygEAONTSjJUpaXKHcVqiwoDOA93jOtZk1OCP39yChMiGAEcFfPXyJ3DF5XGYtyoN8XER4z5Pp1UhwqhDVy+TA1KbvT4F5f3j+14Zr8KONpi1Olgm2cGDiIimJ24rICIiyWRERsodwogOtjRhRUoqDrVMrE/8VEUrtFjiiQMA+JQiPAo/lE1eVNvHLi6n0Sjx0LeOIyuxMNBhAgAa3BfgP44uQCdAM0+Btf401B5qh9M1ctJHIQAZKTGoqJV268ZMlrYwHiqtAoJSwDF1NyBxzs3h9UIpCCjp7MTqtHRpByciorAliCJLCxMRkTREUcTX3nsbm2ur5Q5lRMuSU3C0tUXSZdrDiVXosMQei+rjbXC5zu54MBaFQsBvvtGM8/LfC0B0Z2v3noPz3yqAxz+0bkK8Qo+FvdEoPT58UqUgLwWFZdLthydg1vmp6DC7JF8x8GmpJjNeuvFmiCKQHsJJPSIiCh5uKyAiIskIgoDfX3wZkiPGvyQ92I60tmBRYjLUisD9CVSKQE65FiUHmiaVGACA3GxT0BID/f7FuOydsxMDANDpd2BLZAsiL4pFVlbskNcWz0tjYiAAqrc3IxYT62QxUc1WC5xeL5qtFri8k/seJSKi6YXJASIiklS0Xo8/XXYVFMLUW+MFyvH2VuTGxkGrVAZk/PX+VDS39E1pDJNRmlhGIyICFfZLcMX7K2Hzjv71KvX2YG9GN7IvSEFMtBEFeak4XtIU+CBnIIVKQLWnL+DzVHR3Y0lSMv519FDA5yIiotDH5AAREUluZWoavrfqXLnDGFVRZweyoqJhVE++Qv9wFivjUXuwbcrjmAyB3fhQaLsCy9/6HK58LwcdjnEmcgQBe/yt0Cw2wuv1YdG8NORkxCFvViIWz0tDenIUFs9LQwjnhcKC3ysirVqN1ZEpSI0wBWyeyp4uaFUqVHR3YU9jfcDmISKi8MCChEREFBBfX74S+5oasa8p8FX2J6u8uws5UdHodjjQP8XK7bEKHRb3RKP0hDTL7Mvr/Gjvy0RilPQXbSKM+Pq2dPS7J34VH6vQwXnUhtJ++7CvN7b2YW52Alo6+mEbcE011BmrtaIXqOhF9uokNGutAZmjonuwpsFF2bPwfx9+gA2fvwNROn1A5iIiotDHlQNERBQQSoUCf7rsCkRoNHKHMqqavl7MjomZ2iCiiNlVeskSAwDQ1DaAbz56PWrbF0o25iknrevRNt7VAmcoaDOjb4TEwCkVtR3Q69TIyYiDXiftyoyZpruqHxHqwPwMVXZ3AQAuyZmNeKMRP938Ibx+f0DmIiKi0MfkABERBUyCMQJXz82TO4zAEwTY5iokr7PQ0W3HNx9Zh8L6tfAKSdjVfQOu+uireLbuNriRMeHxRCixq+cG3PxB6qRjUhnGt+iws9uGmoYuOJweaDVKJMaZkJMRh3lzk7EoPw0FeZOPYaZIyo1B93IlbB53QMav6++D2+eDUaPBs9fdhBabFV97723YPRL3TiQiorDAVoZERNNUTW8P3q8sx7z4BFyQlSNbgcBDLU245fVXZJl7PAQAJq0WFtfUl8DPOaTGgF36C7mcnFjsy+iCT/wkp68U/Lh3pQO3ZO6EBmNv3fAKKbj3yBV4vWpqOwrzVDGwbJGmxd78ucmoquuEy81q+Z9mTjDAulyFLqcdLp8voHNt/PwXkBsbBwDodzpx+1uvQwDw72uuR7whCFUxiYgoZDA5QEQ0DflFEYv/8dfTdxyvyc3DY5ddJUssoiji/Gf+g0ZLvyzzjyU/Lh6lXZ2SjJW5RwGPV/qLuXnnpGOzZvjOAGqFiNvzPMiPcSIjwoZEXT+i1N3QKzqgFAc/rkbXetzyYe74Cw+ORhSxojoKzc19Ux8LQHpKNBwON7p6ByQZL9zFXJuAdpcdnY7gfD4evfQKXJc37/TjUwmCfqcTT117A3Kip7jlhoiIwgaTA0RE09Tn/vcq9jc3nn78yk23YEVKmiyx/Gn/Hvzl4H5Z5h7LipRUHGppnvpAooiUnVMfZjjxF8XjhLdrwudFqETMjhJxvEu6XYRqCFhcZZYsOQAA5ggd4mNNqK4fX5JGoRBQkJsCr29wf7wgCFApFais6wjIyo2xaDRKrFpoxL7jNni9k9+zH5loQGmeQ8LIxjYvLh7v/L/bh6ws6nc6cfubr6HZasG/rr4Oy5K5BYSIaCZgzQEiomlqYWLikMdPHTsqUyTATfkLkGiMkG3+0dT39UkyjlYIXAOgWKcWGnHif7JtXkHSxAAArHemSJoYAACLzYnaxi4syh/fRej8uck4UdqM4opWFFe0oqi8BcdLmqBUKFCQmyJpbGOJMGjwwi834MEv/RHL5k+t7WBUmgnB3vxT0tWJN8tKhjwXqdPh2etvQqrJjNveeB2bqiuDHBURTReiKKLEUoq9XftxqOcwjvYex8m+QlRYK+HwBS4ZKvoHINpfhb/7Nvitf4DoDd3OSaGEKweIiKapTdWV+Pr775x+/NM163DXshWyxePwePDf40fxz8MHA1ZgbSIUABYlJeNYW+vUBxNFXOxKQ8mB4Zf+SyEuNgLmAjP2+FsgylQ/YokyHu1bOwI6R0FeKqrrOmB3Dl8Ub/H8NBwvHv3znJUWgwiDFmXV7adXFwSCVqPCD27rxhXLBmtqvH3gNjzyrGFKY6YVxKEp3Y2WgcC0LxxOkjECW+74MvTqoZ0l+pwO3P7m6yjp7MAv11+IOxYtCVpMRBT6RFFEu6sDdq8dJrUJZpUJWqX29Ottjja83fIuKqxVcPjscPic8OOT38kCBGQY0jEnYjbmmGZjTsQcxGontpVJFN3AwH8BZRqgng/4LRAdrwGurYDoAsRTv0sFQLMWQtQjEBSRUnz40xKTA0RE09ihlib85cB+7G6sx4e3fRGzY2LlDglddjv+cnAfXio6KWvbtAUJCSjv6obHP8UaAaKIix1pKDkUuMTAp83JS8SOxMBeoA8nQlAj45hqzDaGUtBpVcjNSUJrZz86uj65SF6Qm4Ki8vG3izRH6JCTEYem1t5x1TRYMs+MdUs68ecXtRjt3VFmSgT+9oOnEaHrwafzNN3WFNzws8+Meu54aPRKJF+SjH39Emx3GacfrF6Db61cfdbzfU4Hrn7pecQbjHjjls8FLR4iCk0tjhac7CtEpa0KFdYqWLyWIa9rFVqY1SaoBBU6XJ3wieP7G2tQ6rE4ahEWRhYgQZeABG08IlQR8MMPpaAc9hxRdELs/SagTISgmgfRtR3wVkEwfBYwfA4QIiB2Xgz4P3UTQH8zFJG/meyHP+0xOUBENAMUdrRjbkws/n3sCHQqFcxaLaK0OlycMwuCTHehOwcG0O2w48XCE3i+8IQsMaSbI6FTqVDZM/7q+wuUMWgSB9Dndw0mBmypKDkavIu4ectSsTli/BfIUtEJSiTuFgNScHE0ebMSodWqIfpFFFe2wOeb+NsWQQDyZiXB5/ejomb4xMrqRWb8/qt/hCAAL+24E39/dfg3owDwsy9ZcMXyl4d97RuP/QhFlZZhX5so6yU6WN1T76IxHga1GtvuuBPxxqEdCvyiiJVP/h2r09Lx1yuvDkosRBSatnfswLP1L4z7gn8yknVJWBe/FvHawS4q+7sPosfdgxR9MmZHzMb66BQIqlkQBAVEvx1wvgPobxn2vYwoOiC2LwYw9O+GEP0cBO2qgH0M4SxwGySJiChkFCQk4vEDe/H4gX1Dnn/u+puwJj1TlpjijUbEG434v3PXYmNVJbodgb8jfaZTHRRWpqThRHvruNrG6QQVkg4B+cuTYOgVUHI8eIkBAOiP9AHBvT4HADhFH9Kz4lBTJU1nh/Eqq26f8hiiCJRWtQEAEuNMSEowo7quCzb7Jxfen7/04OlVALeu+w8a2r+P93ecvdogMc6Aixc/PeJca5f0oqhy5MTCRJjVmqAlB+weD659+XkkRERgTkwsHr7kcoiiiA+qKtHjdCDNbA5KHEQUerx+L15oeAlbO7YHfK5WZxteaXztrOdrBmqxu2sv1vkPQYj4NkTjbRAUBsBw67DjiN4qiNbHcGZiAABEy31A3DsQBJ3E0Yc/JgeIiGYAURSRFGHCpbNmY29jAyAC962/AOemZcgdGkxaLZYmJ+OjmmrZYjjY0oSUCBPMOh3KxmhrWObrRaTNDcs2CWoVTJBarUShf+JdC6SiSdQCVbJNL4n2Livau6xQq5UoyEtFv9UBs8GLhZmftJoQBOAHNzyB1s7voLnDi/mzlZif3YP5mWWYk3wEatXINTPOm78Hf8c6SWI1qNRjHyShtgEb2gZs6HM48L/SYvzryKHTq2quyc0PaixEJC+/6EeToxllljLs7T6A2oFauUP6mAjR9jBgexiiEAUoEwFlEqBIgqBMAhSJEN37Aee7GC4xAADw1Q0mDoy3A6IfUCZBEIL7+zZUMTlARDQDCIKAW+YX4Jb5BfD6/bC5XYjS6eUOCwBwvK1V1sTAKS02K1psVqxISUVRRwcc3uEL4tlED+alRqOpqTfIEQJZOXGoF4Nfb+CUFl1w2+wFksfjQ2HZ4KqPR3/QjTNXpKpVbjzy9UehVEysLkZ6XBmy065CbdPUCwoaFfK8WXX7fDjS0nw6MXBOWgbmxSfIEgsRBZYoirB5behwdaLd2YEOVwea7E0os5bD6rXJHd4wPnXBL/YB3j7AW37mK2Oz/xei/b8AACH2HUCdJ1WAYY3JASKiGUalUIRMYkAURfxm5za5wxjiUEszEoxGqBSKEZd0KxTBr9MwJy8R7akewBv0qU8r93RjjlEL20BwlroHS49l+IvwiSYGTlm31IHaKdSn1OvUmJUZj/YTA9DnqEdMVAWKze3G1XPz8HJxIQDgK0uXBXV+IpKWX/Sj192HDlfHxwmATnS4OtDhHPx/IFsKSi8A5fLE4HWHCXVMDhARkWxqentwVIpWghLrczjhFYe/MMxUmtHQ0BOwuQUBMOg1GLC7YTRokVkQj3JjP3b4OmRNDACAKAhIzY5BeVHofc2moqldO/ZBE3DegkN45p3Jtf1LTYyE2+M73ZVh4cJUHOgLbgFKm8eNBks/MsyR0CiVWJ+ZHdT5iWjivH4vulxdaHd1ouPjFQAdH/+709UJjyjzH5BQ5mdy4BQmB4iISDYZkVHQKlVw+ULrTUtGVCSqeoZPAMy2m1CKfknny52fjJb6XgAiDKsicczbCYOgRpfoRSWaZSlAOJxZyki01AV/O0WgnahUQ7xcAQHStNacm3IIiXFr0N71SZFNhSDAP44GUXGxJpwo+WTZgVuQp93nE4f249rcfKSazFDI1NGEiIZy+pynL/jbP3Xnv8PZiW53N8RA3FUPOVw5EEhMDhARkWzUSiUWJCTgSGvwW/ONRKtUQqsc/s+jIIpoL5f24jg7Jw7b4togxIqIUGhh9Q4WRLSH2F2ebKUZ6kNOWGxOuUOR3LEyBfaW3YA1ea9LMp4gAA99fQde2XYZWnv06O2zw+X2orPHBr9/9De24hmvD/iDu6XglCaLBQpBwHV5LERIJBe/6EeJpRRbO7ajylaFfo80bVLpDH5+Xk9RyB0AERHNbAsTk+QO4TSjWo2sqGgUdw5f9G+ZKhE9vQNQCAJy5ychId405Tn9mYP73UVBgFUcuQq+bEQRq5SJ0B9xw2KdfomBUx54MhoeUbruHbOSjmHd4iKcKGlGQ0sv2rusmD8neczznK6hyQCtcHZbxCitDsog3M3/X2kxFALfKhIF24B3AB+0fYifnrwXD5c/iiO9R5kYCCQxFAsvyoMrB4iISFYen7xr5pMjIpBgjIBWpUKbzYry7pFbBdaKViw6Lw2l6j5s87cjJ9EM434NjBFa+H0iuron9gYjJtqIg742IBRXbYsiVqiSoKh0o7GxTe5oJBFhEHHdBR6cqFChsFLAqU/8lWu9+MEtW6EWGiSdL9LYDyDl9OP65h4snpeG7r4BNLb0QqVUIDHOjEizHmq1Ej6fH9X1Q1tpunb1I3m1Ca0Dnyx7XTAQBUGlwC4EdsVNi9WK10qK8PmCRQGdh4gG1Q3UY0vHNuzvPgC3PwSTxSFB+m0Fot8Skn+G5cDkABERyWq0i/FASY6IQIRGiyaLBa02G1pt47uo7/Y7sFXZjFNb02t8FgjLRYiCBxBFzFJHIdMVAVeLE/W13WPuMY+M1sMn2Ec9JuhEEcvUidBUeVFfPz2SAgCQleLH0/e8DgX6gCsBPyJhc+XA7opAonk3BAnfcLb3ZeJ/u6+BQecBPlXHwGJz4vjH9QTMETpYB5xobu9Dc3vfiGPZepyIK9JgIFcLi9uFVKMJtR+0IeMzqZC49MWw/nZoP27Knw+tim8ZiaTm9rtR3F+Cov5iFPYXo93VLndIYSAANQecGyCq0gDddRAURunHDyP8TU9ERLIRRREV3d3Bnxc43cN9ymOdWt4tCKj29qNa2Q+kA+ZMDRYgBvoeAY1V3cO2/2tu7IUqXYA3hIpIrRNSUbWlWe4wJHfpOe7BxMDHFOiHWXsM5ik0KnC4IvD39+7Ejes2IzO+GBUty/DKtvOx9cAAfL7R2z1OpHZDd4MF0R1KJBm08HmdcPhFqDzAqv44iH6gML4/YO0OW202vFJciDsWTa77AhGdTRRFHO49gpcaXkG3O3Ddb6ajgNzh97dCtPwacB+HEPVwIGYIG0wOEBGRbNoHbOh3BX8fe68j8D2dLX439qINiAIUy4D56jgkDujQ32BDc0sfAMDt8WGOKhal3tB5c6jqDZ1EhZSW5EqXhHJ5dDhQcSkOleXg7a12vL1tDbLTLkdNoxVAYKpee5w+eJyfbMGp3vhJR4OChXEfJwgCU8Ty74cP4pb5BVw9QCSBJnszXmh4ESWWMrlDCVOB+xsl6K8K2Njhgr/liYhINodb5LlD7fL5oFepA3a39Ux+ASj0dqNQC2AOkJwbgVx/FMR2D0SvCqVBiWJsqxVJKDsZOp0jpPKtW+2Yl7pFsvE0Kide2zoXJ8oGC4SJIj5ODMij6WQXll+Shl0IzM9T+4ANLxWdxBcXLw3I+EQzwYDXjrea38bm9q3wS9Q2dWYKUHJAEQ9ozgvM2GGEyQEiIgo6q8uFPx3Yi2dPHJMthiidDg6bPG3iWv0DaMUAkIjBK8sQ6COfrTKjc0/w6z8E2iWrfbh57fOSjikIwNol3ThRppZ03MnSRqjRb/AAAaxf9vfDB3HrggLoVKHxMROFC1EUsbNrN15r/B+sXvmSiNNDoFYNCBAMX4Ag8NKYnwEiIgoqm9uN6199ATW9vZM6f2lyMtptAxAAJEZE4Ejr5O50R2g0kzpPciGQGDAKKkQXA21OeZIlgbRmcWBaVO0+HgtA/tZiMWkmVOc6Uds3fPtNqXTaB/BC4UncuWRZQOchmm5KLKX4b+3TcocxLXw+wRyQcYWYlyFoWFcFANi8loiIgkYURdyz9aNJJQYKEhKRFRWNo62taLZa0GS14EhrC1ampE4qlmBtKQh5ooiVnXFoawtC6XsZzE2T/qK505JxekuB3MRl+oDVGjjTPw4fhN3Dnxui8RJFEW80vy13GNOCSanAhfpD0g+szALUi6UfN0xx5QAREQXNS0Un8W7F6EWYYvX600uXBQEwaXTwi34Udgzf4ulgSzNWpqSiuKMDA+O84F+WnDLpFQfTzYX+NJQVN419YAhZMd+PL1/TBqPegX++kY3yegFdvcBwdazjIxskn3/riYsxRpfK4BCAkr7OoE3X7bDjhcLj+OrSFUGbkyicFVtK0GhvlDuMaeE7KUooxAD8vtNeCCEEVvCFCiYHiIgoKIo72nH/zm2jHpMdFYVWmw3dQ7oJjH2H9uDHhQ3VCiVSzWZ02+2wuodvJadVKlHf3zfesKe1xap4VOwMr7aFcVHAw994AwoMdnj43VcHnxehgR+xcPui4HCZYXVEoM9mgEZRK+n8DZ3z8MomE4DAd7wYizFSBxGjt0yU2r+OHMLnFiyCMVS25RCFsG0dOzDXNAeF/UVyhxLW8g16zBK2BmRsQXdRQMYNV9xWQEREAWd1ufCtje/B7fONeEyUVge7xwvnFJZIe/w+1PX1IiMycsRjFiUmo8tun/Qc00Wy0gDnQQv8IXELfPwe/Gbz6cTApwlwQ4lW6JWliDEcQGbsFizKfBeChFXBq9sX49t/uhhdvfIkBrRGFVTqT966GSK1QY+h2+HAcyePB31eonBj99qhU+rQ75meW7aC6e6ETggIwPYpIQpQs9bApzE5QEREASWKIn6+9cNR79YrACSZTGgfkKZ4XHFnB1ampA37mssXnP3ZoUwjKpBZpYXF6pQ7lAlZNs+PvJRNssxd1rQK3310LXr75fmcqbQKKC+MRMt5AvRXxyDjmjREFJhkieXJo4dgcwewNQLRNFBiKcUq7Vo0cFvBlFwXa4LZH6DORvrr2aHgDPxsEBFRQHh8PmyoqsC/jx5GcefoReGWpaTiUIu0y9sPtjQhPy4evU4H2myfJB1co6xemCnO8yWjrCG86gwAwL1fKgzM3aNxuP+pc2GxDcgyt6AQkHR5Mg72DdbJqLb0ohoTK+q5WhUDzYAPXoMSTo2AZjjQ7pjcCppepxMbKstx8/yCSZ1PNBMkahLx5LNHgHPljiR86QQBV5lOQMIFYJ/QnAPB9KMADBzemBwgIqKAyYqMwtVz85BojEBJZwcSIyKQFRWN6p5uFH2cMFieLH1i4JTSrk7oVWosT0nF4Y/ncLDaOvx94bd64v9d7kas4YAsc7f15qCpLfiJgZhUEyKXRKLU03M6MTBZyg/r0PxOyenHcx65HO3KyW+vOdHexuQA0Shee7kMJ4qbEcXkwKR9M0UHlT8A7w+U2RCi/gxBUEs/dphjcoCIiAJCrVRiUVIyFiUl465lQ6ubN1stuOKFZ5ASYcKJ9taAxuHwenC4pRnz4uLR5bBjwMPl0LWJDqjKFPD6AnE7RnpqlYg7r9oh2/zHqlfKMm9Mrhk7rdK8MXY1Dd337NMogCksojneFtifW6Jw9u7mk3hj43HExxnlDiVsZWq1mK/cKf3AQhSE6H9BUIxcm2gmY80BIiIKulSTGfeffxG6HHZ4/MG5QC3p6oTN7UavQ/4q83Kr91kwZ2WK3GGM2/dvs0nedWAi0hLk2YJRt7cNeaV6nIfkKY2zVB8DS9nQrT2eKd4wq+jugp2rcIiGtW1vBQBAqeSl1mR9K8kGAVLXeFFDiH4CgipT4nGnD37HEhGRLK7Nzcey5OBeoNo9HvjCrDp/oOzStCIxwSx3GOPyz9cj0Ny3Xrb581IOIist+MX/vE4ffB4/irTjqy+QaIhAvH7oncr1ZUD/1zbAZx96Ie+a4jtAnyjixcITUxuEaJqqb+4GACgUgsyRhKcb4kyIE/dLPq4Q+QAEzYqxD5zBmBwgIiJZCIKALyxaKncYM5YbfogLdHKHMS79NgH/75652HTsVojQBG1eqyMGL2z/Km751ddR12QN2ryfFrUuBn2use+e5ZijEXnAA9UHNqxVpZ5+vuXpw8Mer3z0MM63RSDVEDHp2H67ewdeKS6c9PlE05Hd4UZ71+DvCyYHJiZVo8EfMr242rBB+sGNX4Ogv0H6cacZ1hwgIiLZ9DnDq5XedHPc14kL5iehvLhN7lDGQcCD/zbD9+UbceWylwI6U0vPbLy+60q8v8MLh8sLQJ6tKFkrk7C3b+y9/bmRsfBs64fN6oEAwD/gBbRApEYLv3P44pPWsg5Y790MLYA1182H7+JMHPT1wj/BlTU/3/Ih9CoVrsnNn9B5RNNVY+snK30USiYHxkMJ4GvJRizX7IYgStPS+BNqCKYfAoYvjnmkKLogCFqJ5w8vTA4QEZEsGvr78FIRlyXLaZYyEo01PXKHMSG7jhpx5bLAjF3SuBqvbF2DHYdt8PvlTVzpTGpUxljHzEssiIqH7cNuuB2fVBdUmlWAC4hWj/0mVwDQ9lYx8FYxkv51MVrsE3tjLgL44YcboVepccms2RM6l2g6qm/+5Heq3yfCbEuCIKqg8Csh+JUQBR96o+pljDC0rI2MwG3RFdD4qwd/oUhJlQsh8o8Q1LlnvSR6awFfI6BZDYhuwP4soIgFDLdIHER4YXKAiIiCyuJy4W+H9uPp48fg9k+hXDpNSYJSD8NxD7od4dW94WCRABEaCJAmbr8f2FN2NV7ZnIuT5RYA8mwfOFPCBQmo6R+9feGSqCR0b2iH1zO0qKdXB8AFmEUVJtKA0SRM7m2hTxTx7Y3v4cmrr8PazKxJjUE0XTR+KjnQ1NyPpieih7y+eHkccBGTAwlqFb6X7EUyNgKS1yUWAONXIER8F4Jw9lY00X0IYs+XALgBwQRACShTIMS+LnUgYYfJASIikpzP78ehlmY0WfrRZrOh1WZFq82KNpsNDf19rHIuM6OgQlaFFk094yt0F0o8XgFOXzb0ynJJxnvn4O149Dk9AIsk40nBEKnFIcvo2wlWRCWj9b1W+H1Db7WptAo0+WxYoY2F8zd7JjSvTpx8KSq334evvf82nr72RqxMTZv0OEThzmzSj/q6IcUDiwgIn9pxIIqA3hUJp65/5BOnCQEivpxkxhrtHghiID5eBYTof0LQDl/EVhT9EC2/A04lmEXr4DmR/4UwyQTpdMLPABERSWpPYz0e3LUDZV2dcodCI1jZFYfypvDtU9/Zn4aMGGmSA3ZX6O0vtfe7sCIyDfv7mod9fXVkChreaR52Ce6sC1Lg21OP5qeGL0R4imluPCLvWITe/xzFQG0PUm5djD2OqSWLnF4vvvLOm3juhs9iUWLSlMYiClfz5ozeenTvO/1I2LcCmfk6qLJ60B1fibjKpWgrUkBxw36IyuC095XDSpMRX4qtg86/W/otBKcY7xoxMQAAcL4PeIuGPmf4IgT1ggAFFF6YHCAiIkl02+34yeZN2FpXI3coNAqdoER1abvcYUxJVXMcMmKkGcvpUiEAa1qnrGdXF4xL1Rj4eJXNGlMqxHYPBJUCNe80Y7gyZ/Oj9Gi+9wO4OkffTBB/4Wwcvi4BXr8N8T9ZjPnH7Di6SAu/2zXluG0eN7741v/w4o03Iz8ufsrjEYWb2VnxUKkU8HpH/r3S0WlDR6cN2Amo1XNR7bfC5/Nj9clz0LlkYit+wkGUUonvp4pIx4cQ/AH8fataACHiWyO+LIouiNZHhz6pTIMQ8Z3AxRRm2MqQiIgk0WS1MDEQBpbaTZinVWG5SoHlbk9YvhE4VmaUbCynOzTvk9h6nFimTAAApEeY0bCpGXWH2lG7r3XYxIBOIaBv04kxEwMAoNAo4f34DXqn047t+YBFgsTAKf0uJ+5483XU9IZXsUsiKWg1KqQlRY994Mc8Hh98vsGfxwMf9SCu8+zieeFLxO0JJjySdhIZ2AEhoIlYHYSoh4etMXCa43XAP3RFlmC+H4LCEMC4wks4vicgIqIQlGGORKx+9L2WJBNRxIpuLS75Xw/af/YBKl/YheLX9qH4/aNYpFMj2zDKm6kQ9NF+JVr6R1k2OgGuEE0OAEDNlmasFZKRVK+GzzP6GtwCvx89LePbFuC1B74IZbfDjtveeA2N/dN/DzXRmSy2ybU/FUWg8s0IaF0miSMKvkVGA/6a1YcLdRugEAOfKBTMP4OgmjXGUWf8vtddB0F7XsBiCkeh+xeRiIjCSrRejz9ecgW+9M4bcocy45i9Cqw57IKnoR9+jw+i1w+f1we/1w+/2wfXgBM9bf0Y7u1Zw4ajyF4/D7VK5ZjzRKiVSNSoYBRFqD0+CC4PjikE+Ia9lx04dqeAW3+eiz//OBKLM9+Z0lhOd+jeJ/F7RVRvH7ljgRIiEnQaxCkElL26d/zjDgSnIGjbgA23v/kaXr7pFiRFhP/FDtF4uD1e9PTZJ31+T68dKdsXQ7x015CiheHCpFTguylK5AhbIPi9wZlUez6gv3Xs49TzP/m37koIkb8JWEjhiskBIiKSzPqsbNy1bAX+deSQ3KHMDKKI85s16H/6OCq6JteCz95vh6OlF0iPG3OutLJm1J8c2oIr//NrURSEO9HDiYqY/BvwU1zuMHz3/bElbi+K3zyIvgme57MHr1tIg6Uft7/5Ol6+8RbEGrh0l6a/zm7blMcoOt6FNTkr0TbnoAQRBYuIz8abcZnhCJRiEOvaKGIgmH8LYTyZFNVcAGrAcAsE070QhNBNDsuFnxEiIpLUD1evwZKk0as109TNtmtw4UudaPzjLlgmmRg4pa2iZXA96yjmG3VnJQYAQKiRr7jhNx7KRkXbFRM+r78nBvu3n4unHrkG3kJL2L4Z8vRPbumyq8c+rrUeCwwxWOc0Y55x/Punh1Pd24M73nod/U7nlMYhCgcd3VP7fXzKwXftiLKER1vQXIMOj2cN4Er9huAmBgAI5t9BUI6R3D51rKCBEPkHCKb7mBgYgSCKY7wbICIimqAmSz+ufOFZ2Dzy3FGermI8CszpUyGmyoaq14/D75OuuFPk585Dm2P4O8oCROQUN6Kl4uz2h4IgwHDLuehyBWn56DBuucyNu6/ZCCXGflO6d8t5+PXtQ9+856yYhcbsRFg8vkCFGBBLbU6UfnRiUuemPXgJdhhHvohZs82KtreLAQx2HEu5sQC9l6eheGDy7Q4XJybj2etvQoQmvGpcEE3Eph0leODPGyQZKy01EoZbj8CnCt5qn4nQCQK+m6pBrmInBMjw915/KxSR9wd/3mmMyQEiIgqIb7z/Dj6orpQ7jLCW4lIhrwXQVPajt7gVXfVdAZsroyADptwUDFS3o6uuAzGpsTAkREIZZQC8PhS/c3jEc+ffsAqHZX43sThJje/f8hGy51aMetwbT1+Bf/787H38sakxUJ0/H3UybZGYLINKgWSNCtE2J4rfHv92HlEAIv55JU7az65EkWOMBL66adjVBcnXL0DflekommSSYFVqGv57zQ3Qq9WTOp8o1D33xgH884Vdko23Ym0ces6VbjypXB1rwjWmE1CdUf0/eAQI8bsgfNzVhaTBmgNERBQQS5NTmByYhGSXCotL3LDsb0RbeSvOXsgfGA2FDUBhw+nHtt6xW+Kd4usdAKKkay84GUJZL+6/Mw1/fq8dpsiRK+R3tw1/Udrd3AP16/ux5IZVOOYMzbt0w7F7/aj2uqFSKhATa4J1nEuaBRFwfu8jrFiUAl16FNouSUblQB8AILPBg4YRzmt9swh4swhrrp0Py1WZKBwmuTCaA81N+MaGd/Hk1ddBpeCyXpp+2jstko53aFcXzs0sQHtqoaTjTlaOTotvJfYjWtyFgHYmHItmJRMDAcDfykREFBBLk1PkDiGszLNqcPmHA4j4+V5UPHMQbeVnL+EPVaoInazzJ+rUqNhRgpbqbjz03XXw+YbfUe/3A+VHR9464HF5UPbSbmSfrEPawUrEbD6BuZWtiNaE/r0Urwhkrs2b0Dk+uwc9++rR8uoJGB8+ghitHimGCHQ/d2zMc9veLsbA1zYgWjvxr/2O+lr8cd/uCZ9HFA6kqjnwaYVvKWFwxEg+7kRoBAHfTzHg3oTdiBblLzos6K6SO4RpickBIiIKiPnxCdAoxm6PN9PNtWlw4QvtcN23E5UbCiWtIxAsom7kJeJGpQJpBg1UAWwKkNY3AL9/cF/D4Q8b8NzjVw973LOPXYPC3U1jjtdW3Y7u5h44rE40FjXAsKsEafrQ3ycvqiefxLBWdCLhZ/uhu2szBurGt2Ug465V6HVNrsjgv44cwiauLKJpqGsCq67Gy2pzwbUpH/DL013lkmgT/ppZj4WqTRAQIoVFtevljmBaYnKAiIgCQqtSYUECl/yNRu8TEPtUGeoP1codypS07S1H8hkJAr1SwHKFAN1HJ9D9wi5o3zqIzGO1WNTZjxV+P+YbNFBL0MQ7TqtC5daiIc+9+lgTujsShzy35Z0L8dIfJ7dJo6elFzEh3vEwTqtC1ftHpzSGp88xri4GABCzKgMHC6aWMPm/jz5Abd/kCxwShaKlC9IDMm5FeQ8Sis8JyNgjSddq8IdMLz5n2gC1P1ib3MbJ1yZ3BNMSkwNERBQwazOz5A4hpK0v9KOjukPuMKasu7kHvk3HsaTfjhUAlguAaVsxiv+3H/Z+OwDA7xfRUdeBit1lKHr7EGpe2AXTR8cRO4Ul+0alAuYjNfC4htYI8Hl92PjqytOPS44vwp++M3IdgvGon0AnA51CwGKDGvMbu7CkfwDx2gBvSxBFpDZ1w2V3BXaej6mj9Oi4Mw9279RqM9jcbnzj/Xfg8IRPjQeisVx36aKAjX3ggz7Eds8K2PinKAF8M9mIXycdQLy4L+DzTYqnWO4IpiUmB4iIKGDuXrYSc2PH1394JupN1SJjWRYECe6gy83aY0PZ1kIUvXkAxW8cGFdhPIfViST18FtPjCrFqHv91YKAzJp2tFYOX5thw9P98HqUaG9Oxa+/aILHPflWi6m5KegfKzkgiphj1GKZ3QX9B8dQ/sJu1ByuRtnWIrjePIhFAdyWUGDUoWJ3WcDG/zQRgOl3F6DeLk3RtfLuLty7bTPYPIumi7TkaKxakhWQsf1+EbVvRUPjCVwB2LWREfhbVguWqz+AINoCNs9Uid4SuUOYlpgcICKigNGqVHj88qugVYZ+QTc5HIh3Y9vtSUjOSwYACIIAU6xJ5qiCS/+pu/4aASgwaLCoywLFWwfhfm0vFnVZMN+oHfqGRRQxv8eK2qM1I47b3dKPHRvX45dfmo++jqkVCIvMGnt7zGKDFk3P70TJpuNwDgy9g+9xeRCoS1+9UoGuzScCNPrZMu+5AIdcE+tQMJY3y0rwUtFJScckkovH40OfxRGw8Tu7BqDZuRRS59MS1Gr8NkPElyM3QuOvlnbwQODKgYAQRKZqiYgowJ47eRy/3L5F7jBC1hU7nHC3WtH0mVQ4lSLmH7eja28duhu75Q4t4LQGLdIXZkIdoUXdgUo4rMMXu4pKjETauXmo16qRMeBA8btHxhw7ISMOPq8P3S1T29cuCALmXb8SR0QR4nC78kUROUUNaK0aeQ+s5uZzx159MAnL3R4UT7HWwHglXT0PBy6JgtcvfdFMjUKJVz57KxYlJkk+NlEw/eXpbXhlHL+fpurcmw1oz576PAJEfDnJjDXaPRDEqW2/ChpFAqBZDSHytxCE0C8WG06YHCAiooATRRF3vfcWttSOfKd3JovxKNCj8gGf3l4giphl1yClHzAc7UbVZi6hnIzoxEhoDVq01U69tkPOilmoz06E7YyL/AUGLapf2Dniean5qajKS5vy/GfFY9Cg7cXdQVuS73vyUtQNSNvD/dNSTCa8e+vtiNbrAzYHUSDtPVKNH//2zaDMpdOqkH9nFyymybe9XWky4kuxddD5g7MtSUpC1OOAag4E1Wy5Q5lWuK2AiIgCThAEPHTRZYg3BG6fZDjrUfuHJgYAQBBQbfRgV4oHH11phs6olSe4MKZQKpA2NwWWLmn6jtccqkbemXf/RRGek3WjnmeIiTj97yi1Ehl6DeK0KhhUCkx6bbAoQnGkJqh79U0I7PagFqsVv9qxNaBzEAWCKIp49b0j+Pkf3g7anE6XFz3vZ0HwTfznMkqpxK8zlLg7+sOwTAxAkQSI7sEVBCQpJgeIiCgoYg0G/PHSy+UOI2zFZLKw40ToTTrEp8WicFcp7Fbp9v827Cz5pAWjKGKxQYOGwoZRz6k/WguNQkC0RgnTvnJ0vrgLAy/vgfjaPhjePoTYrYVYNkJhxhEJAkwp0ZP8KCYn0hb4RMRHNVXsXkBhxTrgxL0Pv4M/P7UNXq/0W25GU1/fh5ijqydwhojbE0x4JO0kMrAdAoIbrzR0EMz3QnQfgKAwyx3MtMPkABERBc3ajCx8delyucMIKwv7NVjzn0a0lDTLHUpYSZubgvb6TsnHtXZbsVClwDKNEpnH61D+4u4xz3E73DBuOg7lB8fRdUYdCVEUYe+3o+TVvVjh9U1oJUF1nBnmuOAVsFS32gM+h9Prxe6GEOunTjSC8pp23Pl/z2HHgUrZYji4tRvxbfPGPG6R0YAnsvpwoW4DFKK0RUWDQnsRhOj/QIh7F9CuhaC/Re6IpiXWHCAioqBy+3y46dUXUdQ59T3g093lx0VUPn1A7jDC0sJ183ByZ/jVacg9fz5KYiLgHue7swKDBlUv7ApsUB9Lvmkhdp9nCPg8N+bPx8OXcJURhbaquk589SfPw+OVvtDoREWZ9Uj7Ug0cur6zXjMpFfheihLZwk4ImHxLV3kJEOI2QlDlyB3ItMeVA0REFFQapRKPXX4V9Cq2NxyL0BO4dljTna1/QO4QJqVqdxmitGP/bCiVArQaJQrtbuRdMD8IkQGqhcHZ37u1tjogHRGIpFRc0RISiQEA6LM44Nuy4IyFRyJujjfhsbRS5AhbwzgxAEB7KRMDQcLkABERBV1OdAx+uf5CucMIeX3zo+QOISwJCgFNFZOv4C2nvEsXosM59pv4+XNTAEHAgtwU+JbNginWBEGlhC7SAFNKNPSxEWOOMSEKATVJw7RxDIBepxNHWriNhkJbbYi1mi0t6kZS2WD9gTyDHn/OsuEK/QYoxDBdpScYAEUcIJghRHxV7mhmDN62ISIiWdw8vwBJESb8ZPMmtA/Y5A4nJO1LcOGCpZloOMo92BORNjcFjWXhd3Gp1qpRYzYArsHkgFqlgF8U4fMN3WNQkJeCk6WDH19ReQsAQFg/D6IInKoKsDTaiNL/Slf5P/1XF2G7XZquD+PxYU0VVqWlB20+oomqbeySO4SzHHzfiofPicNS8/sQ/G65w5kSIeZVCOq5EF3bIagXyh3OjMGVA0REJJt1mVn44PNfwLW5+XKHEpoEAb3XZModRdgJ13JKcy9dhB6XF3OyE1CQlwK1Sgm9ToNF+anITI0BAESb9aisPbvQ4pkfst+gQf7dl065o4GgEpB292rsjgp8McJP+6imKmy/jjQzhGJywOvzY462DgLCOzEAAPC3D/5fc+6wL4uiD6KnKIgBzQxMDhARkawidTr86bIr8dcrrka0Tid3OCHneJQb6UuYIJiI5spWqLVqucMYt8j0WMy+Zjn8CzIQHWlAZW0HCstaYHd6YBtw4URpM+qbe5CSGInoKCOcrrFb/R1v7sXR9n64Ll6InCuWTCqu1DuWof+vF2BHHoJeA6DJYkFZl/TdJoik0Gexo6cvuAmz8RKE6ZFUEx3/g+hrhiBohj4veiH6OgH3IcB9XJ7gpjEmB4iIKCRcOWcuXvvs/5M7jJCkz4iSO4SwIvpFpM5JkjOCCR2tUKvQGBWBo2XN6O0f+YKjpb0fNQ0Tu1vZb3WiWKdB3jcvh0I9sd2kTc8ewbyDVqQbgtcu8dM+rKmSZV6isYRavYGhpkdyAM4NEDsvhujcAgAQXfvgt/wKsD8DeE4CCjMgKGUNcTpicoCIiEJGTnQMZkfHyDJ3bmwclEJwCq5NlBirlzuEsGOKlrgg3zglpGvwzBE9JvIGvbemHQk17VCrA/dGV/D64fNMrFq5AKDpv4eQ+GRZYIIaw0fVTA5QaArFLQWnTJeVA4N8gK8J/p4vQ+z9AmB/EaL19xD7vg6x+zpAc47cAU47TA4QEVFIWZeZHdT5onU6LExIQnl3F+KNRixLTsF4UgR6lQpGVXCWrg/EqpGcl4xZF+Rh7i3LMPvO1UGZN5x5ZWgxplIDf/3IhaTkA7j2rrgJndu4uxTzASiVgXlr5rcMjOv7ejj9ha2TPncqSro60WTpl2FmotGF8soBYbqsHPiYaH0QcO8++wXNGgiqrKDHM90xOUBERCHl4pxZQZ0vxWTGyY42AECbzYYjrS1IMZmxJCl52OONajVWpaZBrVQixWwOSoJgV6oHu+/OxIfXRmHjOWpsKgCyz5sT8HnDWecEl99L4bFNkYg0nwQAfP1XO/Bi4cSW8auauxG9oxhLDBrkpsVAoZDukrzNqIcx3oy5N67G7GuWT+hcv9OLRL1Rslgm4qOaalnmJRpNKK8cgBDc+iDyECAYvyB3ENMSkwNERBRSVqel47PzFgRtPqP67Iv7ZqsFx9pakRkZhUWJg3vXTRoNVqamQRAEHGhugsXlQmVPN1LNZuhVwe8MPLBu+OQFDXI5XNDogleU8Id/icecvJ2nHwvwITb2CNTa8V3gq7UqtFS1YaDTgrIXdqHhLxsRu6cMS5OiJImvrduKrvPyccIvolCpRP6XLpzQ+XGCVpI4JopbCyjUiKKI2oZQXjkwHSkA7UWA7npAkQwh5jkI2vPlDmpaYnKAiIhCzq/WX4i5MbFBmm3kt1L1/X040d6GzMgo+EURB5ubYHMPbRFV0dONjMgo6JTBLYxk6p3Y/vGZIiLSgIJ1+fC4vHA7x67qPxVqrYC7fhOP/1X6cOmNm4c9JjJmfImjiCgjetuHLqG3tfWhe09g9vsf7RtA3jcug1I7vvjUjx3B+d0GzDNOrTXiRB1saUKvwxHUOYlG09tvR781lL8np9/KASHmOSii/w4h4msQ4jZC0KyUO6Rpi8kBIiIKOXq1Gn+98mpEagPX2nBefDzmxMTiYEvTmMfW9/dhwDPyhWZ5dxeyo2OgUQQnQRDlUaL1xeNBmStc6E06LFw3Dz6/H4U7S+EccAV0vpQcLd6pacKNX96MCOPIvbYffFWH8RQn7G3vh1J19vdPR2ED5qcFJlF2rLUPnutWYda3rxwzQktJOxof2ArXVzdivcMckHiG4xdFbK2rCdp8RGMJ5XoDwHQrSAhAfxMEzQoAgKDKgaAwyBzQ9MbkABERhaTZMbHYfPuXcLOEWwxUgoBFiUnIjY1DSWcnKnuke5NX2tWJxcnBWep/zlEX7KO0vJuJZi/JxsmdJXBYnUGZr6XGifFc9GfN2o2H3xnfxX30cFsIRBF1//gQ+WmB6eLhcnuh7rVNaCly488+xHliNJL0RiTrjUgxRCBWF7iOGm+WlcDrn353Qyk8HS9ulDuEMUyn5IAagulHpx+J7qPwWx6A6OuGKAbnd/1MI4iiOJ2+g4iIaBo62tqCFwtPIEqnh1/04+kTx8Z1XmZkFHQqJfx+IEqvQ3l3FyyuwN1RXpmSioMtzQEbHwAyHWpo79sLnwzV+ENZ7srZKD8Y3P3pzxzRISn5wJjHidDgMxn58I6xE2TWoixUn6gb9jWVTo3kr1yMiuaeSUQ6KCMxEjFqJSACgihC8IuAx4uSf2+Z8j5lQSUg9cFLsVPbH5BLk3PSMvDny69CrIF3DUkefr+IJ1/ajefeGPtnXk4f/nk7dMoKucOQhioXirh3AQCitwpi982A6IIQ8W3AeBcEgfe5pRb8CkpEREQTtDQ5BUuTUwAAG6sqRk0OFCQkYsDtRp/LiQG3G/Wn7rD3Bj5Ol0/aC3a1D1jdpoZuwIfiTAVatF7kbetBFRMDZ9HqNEGf88ReM5JuHPs4AW4UnGfCse3WUY/TGUcu+ud1etD+9DbM+sL5qG6Z3DdzrM2Jsud3nvW8FAXMRK8Iz55GaC6JlvznAAD2NTXgmpefw9+uvAaLRugkQhQoA3YX7n98A/YcDoPuGdNpW4Fghij6AbEfYu/XANEGKLMBw+eZGAgQJgeIiCisZEZG4R9XXYMYvQH379yGoo7206+ZNBpU9/bA7vFAr1LBMdatWolZXNIsc8xxqJFb6EDrB2Vo6bEBAPQA1s5PRVVxYFcmhKN5587FyZ0lQZ/3g+cHcNk4kgMAsGSdbszkwHA1Bz7NbXOi+7kdyL5tHWpb+8YZ5SdcXZYJnzNecetzUHhZHFwe99gHT1KrzYZbXn8FS5KTcW1uPm5dsDBgcxGd0tTai58+9BbqmkK71sApwnTaVuA5BLHvm4NJAV8jAAFC9BMQFCa5I5u2mBwgIqKwMi8+AfPiEwAAL994C76/6f3TvdDz4xJOFxgMdmIAADoGBqZ0/nktami3N6PuYA2GWxTawsTAWWYvzUbZAXna3ZUcGIDXnwyVonXMY+csGvtuum8cd9xdFgf6Xt6NjJvXoOGM7gan6HVqZHVZoDbp0R1nRnOnBUsTI1Hyjw8lWSUQtTwNETfOQ1+sCgYXoLF4UBjjhdUV+Arubr8PB5qbMODxMDlAAXf4ZD3ue+RdWG3htL99GiUHAMC15ZN/q+ZBUM2WL5YZgMkBIiIKWwa1Gv+46locaW3B2+Wl2CZjVXOTRgure2r1DCz/OoKBPhYaHK/0vBQ0lbfA75OvWN3JukXIy7bDIAx/oX5Kas44EkfjfE/v7BmA8o0DSLt+JZo6hq4GMEfokFDZgrr9lYNPCAJyluWg9M0DkiQG0u+/GNvNNgAW4NS3qhFAYJtDnKW4ox19TgeiAlgIkWYuURTx+oZj+OvT2+Dzh9fFtjANWxmexhaGAcfkABERhTVBELA8JRXLU1Lh8nqxo74Wb5WVYmttDdz+4O3NjzcappQcUPnBxMAExKXFoL/TGvCWhaNJOz8J/1J74GpciBi1GWm6CKRqRJyjL0S6onTIsWVHzQA6Rx1vrG0FnzbQ0Q/Fu4eRfNUy9FgcSI8zwSSK6NpejOaST7XnFEW0SrhPWgiRCyURwP6mJlw+e47codA0M2B34fH/bsWGbcVyh0JnEDSr5A5h2mNygIiIpg2tSoVLZ83BpbPmoN/pxMn2NmiUSujUavQ47LjznTcDNrdJM3IxubHMGlBj9s4eyLM4PvyYYoxQKBSwdI++hz/QMn6eiDqxFgDQ47Ggx2PBSQAfIB7nRi3CdRF7oIUdu13rcKBTDwido64OcLs8E5rf2tIL7St7oLS70RykIpVilx2ICspUY3pw13bkxsUhOypa7lBomth3pAYP//MjdMj8u2UqBGG6rhwQAM1yuYOY9pgcICKiaSlSp8PazKzTj90+HxSCAH+AOvg2WyxQCgJ8w4x/xX4PPLE6bJ7tBYRPFndnOtTI392Hqg1FqGJn4XHR6jWIToxCQ6n89ReEDgVgPvt5ESL29DXjQP/g3liv2AWcDyzbm4v+PzlR9Wr9sONNJtnhsgR+n/+neVqswOyIoM45kmarBde/8gKyo6IRpdPj31dfB6WCFcxp4ixWBx5/ahs27Qh+YVPpTdO/Jap5EBTD/MIlSfE3KBERzQgapRKLEpMCNn6Xw46Fw4y/skuDipePoPaJPbj0XQuivYN/epV+EYl/K0Hl+4UQmRgYF0EhIGNeWkgkBgDAXjr6lgav6IVX/KQwZqvQCvsPenHuh4sQt/Dsu92djaFfDd3TbpM7hCEsLhdOtLdhR30t9jY2yB0OhRlRFLF9XwVu+95T0yQxAGC61hxgvYGg4MoBIiKaMV7/7P/DsbZWvFVWgvcqy9HnlLYC9YDbjSivEhE+BfReAQYP4P/PydOvV28txazSKPjuWgiTXURzGFwMhpKC8/JlaVk4kr6TFuDqiZ9XZ66F8Uk1ciuWoOXVTiRfHw9PthOHLigd+2SZ+VzB7wIyXm+UlQxZLUQ0kgG7C5t2luCtTSdQ09AldziSkqLwaChivYHgYHKAiIhmDEEQsDQ5BUuTU3Dvuguw8+PihZtrq+EeRxu50agUCqQc7YfvsT0ABu/dDHePtbe1D8L9uyDGhMbS7HAihtBy2dk3Z0L7I8A1yZt0HtGD2jnVwD1AHSwQRREqjQped+hefAOA6Apekc+J2lRdCZvbjQiNRu5QKERV13fizU3HUV7djvKadvhDpMCmpKZlzQHWGwgWJgeIiGhG0iiVuDhnNi7OmQ2Ly4UPqirwdnkp9jc1TvgS1KhWY8kOCxpfPTGu40VRhDWMC17JwRwbgfriprEPDDBBKeCcfy9CQ34d7H5p34TrIrSw9YR2csDnnFjRxGByer34oKoCN81bIHcoFEI8Hh+276/Am5uOQ/SLWFqQgcaW3umZGAAghFASVTKsNxA0TA4QEdGMZ9ZqcfP8Atw8vwBFHe24+/230WId++JdIQhYV6uE43ATWnfXBiHSmSspOxEVErbkm6xV2+ajTlMj+bhpb2fjUM/JsQ+UmXlpqtwhjOrVkiJcm5sPtXL8bSFp+hqwu/CdX72KqrpO/PJ7V6Gjy4q/Pbdj2iYGBk3Dj431BoKGBQmJiIg+ZUFCIt6+5TasTk0f89hMgwmNj+1GFxMDkipYmw+FcvAtikqtHHysEDB/TR40OrVscaWuT0SDRvqid0lHU3H494WSjyu1yIJkFK6PkjuMERnUamiUSlz2wjN4qegkXN7QXoVBgeVye/Gz37+F8up2fOmz52D/0Rr89Znt0zwxAIR8ckCZDuiumtAprDcQPEwOEBERnSHWYMAz192ILy5eOupxSU4uwJNael4KinaXYf65uYhLiUHyrCQU7ipF2cEqFO8pg9agxYLz8mSJLfO2ZMnHjG6KRemPa0O+Y4Um1oCe7xSgzz16hwY52T0eFLa346tLl+NISzMuef4p/OfYEVhc0hYepfBw8HgdFs1Lwz3fvgLdfQPYsK1Y7pCCJLRrDgimn0BQL5nIGaw3EER8V0NERDQMtVKJX6y7APPjE3DP1o+GFCw0a7RY2qlC/8tHZIxweopKiERjWQvKD1dDrVGhq6VnyOvWHhtqTtbLEpt7gfQXmaLCD7/EtQsCQf/g+Sgd6Bn7QJlZ3S78Yttm/GL9hfjaspX40/49yImOxptlJfj2inMwJzZW7hApQERRRHl1OzZuL8aC3BRcsjYfa1fOBgBcvn4ezls+Cy+8dRBHixpljjSwQrPmgAJQ5QIKM6C9BPAcHv+pqnzWGwgiJgeIiIhGcWP+fMyOicU33n8brbbB/gNLjjnQ+ORBmSObnnzewSSM2+GG2+Ee9hi7xYHUOclormyVfP641BhoDRrEJkejcHcZxI+XIEfNNaNVkH6+vpReLPzVXBz6cZHkY0tJE7pNCs5i1mohAPCJflydm4cUkxkOjwdXvPgMrpg9B99aeQ5yY+PkDpMk4vH4sGlHCd7ZfBJGgwZJ8Wa4zmi5KQgCVi3Jxqol2SipbMWjT25GWXW7TBEHWoglB4QoCFGPAf5OQDUXgiBAVOWP82QFBNP/BTI6OgOTA0RERGNYlJiEt269Dd/c8C7U7Q40PblB7pCmrf4Oy7iOi06KlDw5kDonGba+AXQ196C5sg1pc5MhKAQ0lrVg7ley0IQ6SecDgORDafAb/VhwXS6K3iqXfHypuP5+FOq7cuAJg1UOvU4n3i4vxR/37YbFNbgNYnlKKm6ZX4C6vl5c9eKzWJuRhQSjESqFYsT/lIICaqUCOdExuDArB4IwXTvIhwaL1YH65h40tPSgvrkHjc29qG/uwdycBNz77SugUg0tMulyefDulkK8+PYhdPfY8PA9N2Ll4qwx55k3JxlGgzZAH0UoCKWfURWgWQ5Bey5E0Q1BGGwzKigiICqzAF/dqGcLET+EoF0T+DDpNCYHiIiIxiHeYMTz138WD33xz+iQO5hprLW2Ayq1El7P6LeqvS5pb2XPWpSJlpp2OKyfbB1oqmiFQiEMFkRcEpi7cYJPwOFvF58uwBiqLEVtWOVbgt1CryTjzTNGo2RAmrGGc6S1Zcjjwy3NONzSDLVCgXRzJPY1NsDtH//30LqMLPzq/AuRFRUtdagzitfnR2t7/ycJgI//39Dcgz6LY9hzGlp64HB6cP8Pr4ZWo4Ld4cabm45jx/5KnH/OXGjUKvzf3ZeOKzEAALYBF46XyN8WdWbwAn4LROcWCLqLhr6kiB09OaC9DDB+JaDR0dkEMdQr4BAREYUQp92F/7vo1yg7UCl3KNNW2txkNFWMvirAFBMBa49tQuNGJUYiOScBSqUSlm4rzLEm+H1+CAoB5QerRk1IzL0gB/YHeuBXSXtXTmvTof7SzrCooG7IiEL/vSugF5Qw+BXQeoCTsMLu9Ux4rNXvdEEdb0T7xcmoGOiTPtgA0CiVuHvZSty9fAV0Kvm6ZoQDa68NjeUtaCpvQWNZM+wqBQ5YHGhq64PXO7mfoRWLMvHbH1+LXQeroNWosGbFbAgAOntsSIof/570bfvK8ZentsPj9cFidcAXBj97E7HjiVcgoF/uMD6hiIEQ+w4EZcLpp0RPCcTu60Y9TYh6AoLukgAHR2dicoCIiGiCDm48hnuu+q3cYQSEIAAGkwG6CC20Bg00Og3UWjVUGhVaq9rQ1zm+Zf9TMX9NLor3jL3EPjknEa01o+8bzi7IgMFsQGdjFzoauqYUV8ENeej6UTMEhbTLy7XfiULtQelbJAZDxs/Px7aEiRdqvKDLgIbfbIUIIP3LK1B/TjTqBgL/vSWFDHMknr7uRq4iGMZLv3sTbzz+Pvo6hl6cmmJN6Fk/D94JXnXMm5OMH951MZ56dS92H6rGFefPxz3fvmLS8fn9In792HvYe6QGDufEk1rhYMcTL0GAVe4wThOi/w1Bu27Ic/6+7wLOjaOfF/smBPX8QIZGwwjtNWxEREQhyGFzQiHxBWKoSM9Lw4DFju6WXrRUtaOuqBGVR2pQuq8CKbOTghKDQjG+tyexKWNfnHncXhTvKZtyYgAACt8oQ/J/MyVvOxh3XpSk4wVTw0M7kGuMmvB5ljQ9AEAA0PTfQ1B+7SOcXyUg1RAhbYAB0GDpx693bAv59pPB5PP6sOWFXchdOfusxAAAWLutmKfTTGjMO285F7//2fWIjTYi0qTHdZctwv+7dsWU4vxgezG27CmftomBQSH0fWn48lmJAdFbBTg/GPtcpfStY2lsrDlAREQ0Qes/ew6SshPw6Ff/jpoT8rTVC4S81XNQtn/k7RIl+yqQnpuCxvKWEY+JiDTA5/cP2bs/UQMW+7iO841RlyAuNQZNo8Q6GUf/XYQVsQVovv6Mr7sP0NsMgCDCYR5+7/RIXMsndnxI8YuIfK4cqpuS4T2jWKFCEDDPEIW4GgdKshTocHzyda322xCDweTAqXEa/7oPerUS5//wPGxPcgXtQ5iMHfW1uOKFZzAnNhazY2IxJ2bw/1lR0dAolWMPMI00lDXjkTv/hrIDlXij5+kRa4Z4y5qBzPhxj9vWacE7H52EUikgLTkaz7y+D1dfvHBCsfl8fhRVtGDP4WrsPVyNuqbQb8c5dSGSHFAtgGD6wVlPi7Z/YOwYtYDAlTlyYHKAiIhoEnKXz8ITBx/C64+8i6fuexl+XyhViJ4ctXrstwUDFjtyV8xC+aHq08/pI3TIWZgJt9ON6hP18Pv8iEowIzY5BgaTDhAEOGxOqNQKaHRaeNxelO6vGHGOuqJG5K6cjfKDVaPGUn2iDjHJUehp7Rv29cSsBHQ1S38xcOj3hVgRvQDN5w9uBdBZ9Wi+phcuhwUJOXHQPq2Eb4zef6Ionq5+35XZDlNsBKzdE6uhECq6d9bi3M/MxU5NPxSCgPmGaMRVDaD7lZMYqOtFI4B5912IjthPzskVjehWCRDPWGcuenxofGgHcp68DDUDIbRvehgVPd2o6Oke8pxSEHBJzmw8ceXV0767gd3qwAsPvI7/Pfb+6RakRbtKR6zdUXu0BsuSoiAoFZ/KCmFwL9PHitUqOD7+Xfr+1k/ae6pUCmSmxODDnSXQaVTITPvUN9MI3ttSiH88v3PEQofTVwj8LRKMEKL+dLo7wSmiKAIKMwA1gFFWbyiTp/3PT6hicoCIiGiSVGoVbv3p9XA53Hj+gdflDmfKxpPg6GntQ09rHzLnpcEYZYTf60P1iXoU7x1aI6Cvw4K+EdoSKlVKzFqcherjdVhwXt5g32u/Hx6PD+UHq+D3+VFxuBr5q+egdJSVDG6nB4mZ8WclBzQ6NbILMlG8p2zsD3qSjtxTgiV/ykfH4hbEfpSAGsdg7YOOmi4sf7MALbcMv6JEFEWkbcpG88vtSPphNNoKWgAlkLU+DYVvBC7eQGv79Tac/7WV6HqtCPbGPpxZQaHtL/tg/u1KDHjcWNeuQ/1vN2C0t/7pHX7UGAMZcWD4RBEfVFfi1eJC3LJgYne5w4Uoitj64m7868fPoad1aMeJAxuOjXpuyYajo76uv2XN6eTAp3m9flQ3dKG6oQs+nx+fvWoZXn73MFITo5CWHIWUxCikJkZCqx0sFNnc1oeIad2ucDRBXDkgREAwfhUQNAA0gKAd/LcqB4Iq8+zDBQGC+RcQjXdCtP0dcLwBwHv2uNxSIBsWJCQiIpoir8eL75x7DyqP1MgdypTkrZqNsgOj362XisGkx6wlWag92QBb38Dp5+cuy0FzZRsGLHYIApC/Ohcl+0YvTpizMBM1Jwcvxs2xJkQlmNFQ2hzQ+Eej1qox67UkWBKG3vlWudSIfDx+SBKg4PpcOL5mQfT2OBx6qDDYoQZV9q8ugfNEK1rfLBrz2LjzsnHgpsQgRBUYEWoNNt72BaSaxl9FPxhEUYTH5YHL4YbL7oLTPvj/U49dHz+etSQbdosdtt4BWHsHMNA3AFvf4L8Ld5WMWDA0MTMe7fWdk45Pc/O56B9lu5BSIeC1f9yFo4UN+M8re9F6Rn2DuJgIpCVFISUpCqmJUXj7oxPo6Aqd4nzBsOOJZyAgSNtyjHdDMczWgfESvY0QrQ8Crq1DX9DfAEXkQ1MMjiaDyQEiIiIJ1Jc24RvLfgx3GBe6OnU3X27x6bFQa9VoqWoDAOSvmoPSUVpHpsxOQntdB1JmJcFhcwZkK8FE5V08C/0PdEAQBOisesTuT0DT8x1oLT+7u4LBrIfb6YHXPcwdtGnEaDZAhAj7OJZ5iwDc/7oETfbwvbBbk56BZ6+7Sbbl0V6PF3vfPoSak/V4/1+b4RxwwmV3j6uQ4j+OPQyv24sHbn50Shf7E6W8+VzYxqgl8rlrV6Clox/b9428NWkm2/HEUxBGW7IvFUEPIX4bBEXMlIYZrq2hYP4lBMPnpzQuTQ67FRAREUkgMz8Nd/4uvN/MhEpio7OxG13NPShYlw+j2YDeYaqff1pLVRtEEWgsbwmJxAAAlG2uRvbbc2C6Jx51l3fi0H2FwyYGAMBucUz7xAAwWK8iNmV8FxICgJyd3WFd3G9PYwNeKjoZ9Hm7W3ux9+1D2P7KXuStnI0rv3ox+jr64RxwjSsxoNaosOHJzTi+rfisbQOB5h9HfC++fQiHT06fQrDSC9J9X/0tU04MAABUeYAQ9clj9WJAf+vUx6VJ4coBIiIiifj9fvzk0gdwfOvYy6ZDUUJmPDqCeJdwPDR6DdwOt9xhTErBunwU7iyVO4xRpeeloL/TAksQiiHOX5M74nL0kSTftBBHzjfD4Q3P5IlRrcbGz38BaebIgM4jiiK6W3rQ12nByR0lUGvV6GjoQmdjFxpKm1B5tHbCY5piImDtCW6RTPHG1XD6eWkyFTue+A8EjL76YurUEOK3QFBK097W3/ttwLUJgA5C3NsQVNmSjEsTx4KEREREElEoFPjJs9/G64+8i4Mbjo7a8i8UOQcm334wUMI1MQAAHmfoXtDGJEXBHGdGXVED5izLCXhywGg2TKoOROvrJ7HEno/Cq+Jh9YTf98KAx4OfbP4Qz11/ExQB2F7Q3doLfYQOSpUCsSkxeOdvm/DS796UZOxgJwaA8a0coNEJwehWoL9BssQAAAjacyB6SwDd1UwMyIzbCoiIiCQUlxKDux/5Av5b+jieqfwLvvHYl7D0koVQa0I7H69SK5GRlyp3GNOKpSd098snZiWgrmiwp0BrzfDbHaQyd8UsxKbGTPpis31DKZZadBJHFTz7mhrwYuEJycaz9tqw8T9b8ONL7se3V/8MWv1gu7jdbxyQLDEgl0Df754ZAp1gUQx2KJCS7mrA3w9BvUjacWnCuK2AiIgoCBw2B45uLsSB94/iwIajQd/LO5q03BT4vD60Vgf2InGm0ejUSM5JRH1Jk9yhDJE5L21ITHOXz0LF4WrJ55m7fBb6OvrR0dA15bFSb12Enav1EkQlD4NajY2f+wLSIye3vcBpd2H/u4ex9aXdOLTxGLwfF+1Ta9VQqZVw2EJv1c9kOK5bCbC//RSI2PnEk4GdwvB5KMy/lHRI0VsF0fIbCOb7IagyJB2bJobJASIioiATRRFVx2pPJwrKD1aNq1CYlNRaFZKyExCVEIniPeXwD9NbnKQRlxaL5JwElB+sComij5nz01Ff3Hj68cJ1+TgpcW2ErPnpaKpslazQotqsg+ORdagfsEgynhxWp6bj+Rs+O67tBaIoostux4n2VhRtOIktP3sDzoEgtaeTkeP6VXKHENZUShFb/xyg5IAiAYL5PkB7aUA6cIjeWkCZAUEI3yKk0wGTA0RERDLraOjE209swoYnN8PWNxCweWYtzoJaq0ZvWx86GrqCnpCY6XJXzkb5wSpZY8hemIHakw1Dnpt/bi6K945dKFAQgOyCTEREGSFChKXLOuyqiLiUGLhdHli6pd1WYcyOgWlhMro+k44ahwWxWj3aHIH7eQmEeXHx+MLipbhmbh60KtXpJEBFTxeqerpR0d2Nyp5uVPV0o885uBogUqPF7H9UoO9kq8zRB5ZCqcDANSvkDiOsadQiNj8WmOSAEL8bgjIhIGMDgwkxudp+0ieYHCAiIgoRjgEnNj+7A2/+eUNAihkuOC8PRbvLJB+XxmfeOXPR1dwDU0wEqo/XyRKDMcoIh9UxZKWIzqhFUlYC6j61muBMqXOSoVAIZ31fRidFIW1OMgRBgN/nh9vpRkdjF/o6AneHP+GyXFhL2uFo7IM2wYiYtTlQzYuHI1mHNrUXjXZryBe2i9XrkR0dMyQJMJr1DjOafvZhECKT17wrluCEXgNvaH/5QpZeK2LTowFIDihnQRG/UfpxKeQwOUBERBRi/H4/Dm86gTf//D4Ob5KukNnsJdmoOjbxlmYkvXnnzkXJ3gpZ5p61OOus5IQuQofEjLhhVwIUrJuH4j1lYbP1RGXSIPL3F+Ogu0fuUCSzzh2J5h9vkjuMoMhYmImu/DR0T2JLSopOA4NSgCACCgFQiECnz48ul/zbeYLBqBex8Y8BSA7ob4Ei8gHpx6WQE9qlk4mIiGYghUKBlVcswcorlqC+pBFv/WUjCneVoqmiFT7v5Ot593WG737t6aa1pgNqrQoeV/DbHepNZxf2c9qc6GzsRnpeKhrLPmk5OHtJFgp3lgQzvCnzWt3o+9FHyHv8YpQNhE7hz6nwaWdOg7GGk/UwNfdg7uVLUGGfWJ0F/ZEqNFecvf0ie3YSYvNSMRBlQKnNNW2LHioD9G0iaFYGZmAKOVw5QEREFCa8Hi+aK1tRX9KE+pImNJQO/r+xrPl09fKRKJQKQBTh9/PPfqgoWJePQgkKAQoCEBlnhkqrglqjhkqjhFqjhkKlQE9LL3ra+oYcH5UQib6O/mHHMpj1iEmORlN5CzQ6NSLjzOhs6p5yjHJIvn4Bdq+PkDsMSUSoNcj67Qk4mof/uk1HCoWA/JvOwWG3d3wX86KI6M0n4Ryjc0PO8lnompOM9hAoDiq1KJOIdx6SeOWA/rMQzA9AEGZOgmomY3KAiIgozDkGnDjw3hHseG0fDm44OmxF/ISMOElaypF0dEYt5iybBYfVjvqSpmFXERjNBvh8vlEr1ReszUfhruGTDFkL0tFQ2nzWloCM/FQ0lDYPe05ElBGR8WbEJEdJkryQS/yFs7H/mji5w5DMeb4otP7wg4CNLwhAKF4V5KyYhYG5Kaizu0c9zqhSwv/a3nGNqdFrMPvq5Tjq8ULE9FlFEBMp4q3fjjM5IBgB7SWA6yNAHKGwp/5zEMy/YGJgBmFygIiIaBqxWx3Y/+5hbH91Lw5/cByej/ftzlmajcqjg/UGVn9mGb7/r6/B6/Gho6ELpfsq8PwDr8NudcgZ+oym0qiQkZ8Kg0kPj8sDW98Aetv6Ybc6kJSdALvFMWz1/7xVs1F2YPQOCHOXz0LNyXp43d7BhMTSHBTtLhu1W0VElBH2MwoXhpvoZWk4fHua3GFIZqUmBt3f2CD5uFq9BrOXZKOhrBnZCzLQ0dCJtrpOyeeZqrzz56MtORqtI9zxz9Br0PnirgmNmb4gHab0OAhqJaBUAioFRIUAt0qJwjGSEaEoPkbE/x4YIzmgiIFg+AJg+BwERSREXzPE/nsB956hxxnugGC6hx0EZhgmB4iIiKYpW98A9r1zGNtf3QO3w42SfRW46+E7cM03LjvrDV9XSw/+9r2nsOv1/TJFS6NJnpWIgb4BWLptp59LyIiDtdcGh3Xsavc5izKh0anR0dCFnta+AEYaOpKunoc9F5nlDkMy53fp0fibbZKPO++cuSjZN7Q4ZtaCdJhiIuDz+mDttqG9vnPYFUnBplAqEJkQCeCTnQanfpd53V70S1RXJWlWEmoXZkoyVjAlxYp49f7RkwOC6ScQjHcOeU4URcDxP4jW3wGiFdBdBSHyUSYGZiAWJCQiIpqmIqKMuOSO9bjkjvUQRREelwcanWbYY+NSYvCLV3+IA+8fwV++9R+014fencOZrLW6HSmzEpGRn4aaE/WIToqEy+EZV2IAAGpO1Ac4wtCiNuvQcHUqYD97tUW4ch9tC8i4ymGq2NUVDW1rKQgCzLERQ5JTwZC3ajY0Wg1KD1TA4/JC9Pth7bKMWWNl6sLz3qmgGM/F/NkfmyAIgOEmQHseRMsvIKjnMzEwQ3EDCRER0QwgCMKIiYFPW3XVMjxZ9ChWXLEkCFHRRLRUt6OnrRcOmxPNlW3oCtNCgcEQ85sL0TiNEgMAIF6RjeilqZKP231GwcrhCAKCnhhYcF4eyg9W4+TOEuSvmguNXgNRBLweHwrW5Qd07nBdV60az5XdKB+coEyCEPVPQH+TdEFRWGFygIiIiIbQG3X4yTPfQlxqjNyh0BnUGvWotQIISLtzBfb6e+QOQ3L7fD04ckc6ov5xJcwLkiQZ02DWo6Vq7BUJ5jiTJPON14Lz8obUxTi5swRuxyc1AAp3liIi2hiw+UW/CIVCOP2fIGDIf6FKoRjP74bR64gIggBBESVJPBR+uK2AiIiIzhIZZ8bPX/wefnTBL9n+MISYY4N7kRZuTHPjcXyZAXCP3N0hnIkAjjh7sPxby4C735/yeGlzk1FxuGbM40zREejrkGY//2gioo2AXxzX8vj49FjYekeosj9FarUSO1/74aTPPzOB9+mHZ7129smjPYSIUV4XRQiab5854BmPeflHI+N3BxEREQ2rYG0+7vjVLXj6Fy/LHQp9rKU6MPvOp4uoz+Sif5omBj7tsLMbqy+ag84tlVMaR2fQjes4vUk/pXlGk56bgujESDRXtaG7pRcAxtVCU61RByymqTpzv/7Qh4FeehC6nxcKfdxWQERERCO69WfXYfGFC+QOgwBk5Keevnii4TX/bT/idQbJxlMrFEjUB275+lRU3JQG578uRsb/rZv0GNbe8dURUGukvZ+YMjsRC9fNQ0JGHBrLW3ByZ+mEvrf1Jh36OvoDtsQ/lLcOEAUSkwNEREQ0IqVSiZ8+9x1ExU+flnDhKpJfgzH5nV4saJBmG8xifQwWPlWPOfaxC3nKocflQLPdhm2pbmievAIZ91yAiDnx4z5fpVaisbxlXMe6XdK1MZx3bi5aqtpxcmcJOhq6JjWGw+pER0MXBIUCc5bmSBYb0UzH5AARERGNKjY5Gj9/6XswBbAAGI3N4/LKHUJYaH58D2J1k18Gn6yPwPrjXli+tgF9x5qhdI1ewC0UlA70Ylu8Aye/OQsxqzLGdU5abgq87vF9T/V3SlNvwGDWo7e9T5KxAMDv86PyaA1mL8mSbEzg7G0BRDMFkwNEREQ0piUXFuA/JY/h/FvOhVKlZKKAQpZvwI2FzRO7uFuqj8H5vUasLwNMP9iJpqcPQwCgMmnQGhs+F4oiAM3n5o/rWFPM+ItbdjX3jKtI4GiSsuIREW1Ea3X7lMYZjnactRPGjckBmqFYkJCIiIjGJToxCve89H2Iogi/34+fX/Egjm4ulDssorO0PLYbMX84Fz0u56jHCQDW9xrR8L0N6B/m9ZjfXox9A+HVFvGo0orsBCNcHSNX8o9LjUFn4/iX9Pt9fiRkxE16G8CcZTloqmiBwzr614OI5MWVA0RERDQhgiBAqVTiZy98F/FpsXKHQ3QWr9WNRe3KUY8xqtVYe9SDxl9vGbF+vGpnU8Bry0vN4fUi4ZvnjPh63qo5sFscaKvtmNC4k615UbAuH1VHawOaGJD6a8SFAzRTMTlAREREkxIVH4l7X/0BVOrRL8JIGkoVP88T0frYXqQaIoY8p1YoMMsYiXNUMZj/QgOanz0y6hgtr53EOldkIMMMiN3RdqTcunjIc2qtCgvOy0PZgUrYrY4Jj9nfacH8NblYcF7euI5Xa1XIXz0XhTtLIYrSFIkckcQX86w5QDOVIAb8p5WIiIims6bKVjz/wGvY+sLuwF8EzGAxyVEY6LfDZXfLHUrYEAUg+dr5UGdHw3G8FT376uF3Tqywo6ASoP775SgdCK82kud3G9D4wNbTj2ctzkL18TpJxs5dMQvlh6pHfD06MRIR0RFoLGuWZL6xJGUnICE9FpYeG5rKW+D1+KY0Xua8NPy76E8SRUcUPpgcICIiIknUlzbh+ftfw/ZX9sodyrRVsDYfhbtK5Q5jxjHnJ6L623mwuF1yhzJu5+22o/X1kwCA7IIM1BY2SDZ2QkYcult64POe3ckha346etv70N9llWy+iVCplUibmwKf1zfuVo1nypqfjicLH5U4MqLQx20FREREJInM/DTc89L38a8Tf8R5N6ySO5xpqWh3KdLzUuUOY8axlLZjyWG73GFMSP+laVCZNAAAtUbaGuQdDV2Yf27uWc/PX5OLpooW2RIDAOD1+FBX3IiohClsB+GuApqhmBwgIiIiSWUXZOKXr/8Ifz/yB6y+epnc4UwrogiYYyLGPpAk1/TfQ1iDaLnDGLdCew/Uj16EjCWZqDhSI/n4FUdqkLdqDgBAUAgoWJuP4j3lU17SL5Wu5h4UrM1HUla83KEQhQ1uKyAiIqKAKjtYib997ymU7q+UO5RpYe6KWagYZb83BY7SoIbv8QtRPTBc48PQdP4JHxqfOhSw8WcvyYYoipLVM5Ca1qCBKSoCXS3jb0mZXZCBf514JIBREYUmrhwgIiKigMpbOQe/eO2H0Efo5A5lWnA7WJBQLj67B6ofbMM573djrTdK7nDGlGeMRkMAEwMAUHWsNmQTAwDgsruRkBk3oXPYrYBmKiYHiIiIKODiUmNxx69uljuMacFhC1y/eBqb1+pGx0eV6Pvz/pDemp5njIbxbydDOsZg8fu5UJpoPKStTkJEREQ0guu+fQW6mnuw5YVd6OsIn2XZocbWF16F8aYre0Mf5hqjUD7QJ3coQxjVaqxoVKDh9xvh4TUxchZlouzA2VuaFEoFtHoNNDo1NHoNNDrN6cdZ89NliJRIfqw5QEREREHl8/pwdPNJbH5+J/a8eRAuLpOfsNwVs9DR2I3etj65Q5nRMn64Fg15Blj9HvS5XXD75C3Gt1QfA/8jh2Ct6JQ1jlCyYG0e7v7jFxCdGDkkCaBUKeUOjSjkMDlAREREsrFbHdjz5kFsfmEnjm8p5PLfCdAZtZizNAdFu8vAt3PyEwFoI/XQp0VCm2yCOiECylg9YNbCb1LDq1fBrRXgUPoxAD+sPjf63S54/P4pzx2r02PBkQE0PnmQ2wiGkZQVj3tf/SFyl8+SOxSikMbkABEREYWErpYebHtpD7a8sDOkC5yFmoz8VPi8fjRXtsodCk2QCEAba4AhNRKaJBNUkTooTFoIRjVgUEPQq+DXKuHTKuBXK+BRAR4F4FaIcMEPp+hDpkuDvgd2wNUxIPeHE9KUKiVMMRHwuDy46w+348qvXix3SEQhh8kBIiIiCjm1RQ3Y8vxObH1xNzqbuuUOJ+QJCgEL1uSh/HA1uxnMMKbYCFi7bXKHEVYMZj3+XfQnxKfFyh0KUUhhcoCIiIhClt/vx8kdJdj83E7s+t9+2K0OuUMKaVkL0tFU0Qqv2yt3KBQksSkx6G7pkTuMsLP6M8tw/9s/YdtCok9hcoCIiIjCgsvhwr53DmPLC7tw6IPj8HnlLf4WqvJXz0Xp/gq5w6AgScpJQFtNh9xhhKWfv/g9XHDrGrnDIAoZTA4QERFR2Onr7Mf2V/Ziywu7hm1TNtOZY02wdFvlDoMCTKVRISkrAU0VLXKHEpZM0Ubc/H/X4uI71iMuJUbucIhkx+QAERERhbWmihZseWEXtrywC6017XKHI7vUOcksTjhDRMab0d9pkTuMsKfRqfFM1V+ZIKAZj8kBIiIimhZEUUTJvgpsfXEXqk/Uoa22A90tvXKHFXQFa/NRuKtU7jAoCIyRBgz02+UOY1q45huX4dt//YrcYRDJiskBIiIimrbcTjcOvH8Ub/11I07uKJE7nKCYtTiLrSBnCI1ODbfTI3cY04JKrcTTFX9BYma83KEQyYbJASIiIpoRak7W462/bMSmp7fB7/PLHU5AaHRq+P0iuxXMAIJCAMTBFTMkjdlLsnH7Lz+L1NlJKN1ficu/fKHcIREFFZMDRERENKM89+vXcHJnMdpqO9BW1yl3OJLKWpCOuqJGucOgAMtakA63w42WatbYCARzrAl5q2bjl6//CBqdRu5wiIKGyQEiIiKaUbweL9rqOmHpsuC7a+6VOxxJsd7A9BYRbURmfhqK95bLHcqMkL96Di649TzkrpyN2YuzmCigaU8ldwBEREREwaRSq5A2JxmtKsW027Pt8/rkDoECSB+hY2IgiEr3V6J0/2CrVKVKiavvvhR3/+kLUCqVMkdGFBgKuQMgIiIikkNydiKeq3kCN3z3Kmh0arnDmbK4lBi01nbIHQYF0HStlREOfF4f3vrrRtx/0yNw2l1yh0MUENxWQERERDNed2svXvn9W3jvnx/B4wq/lQTz1+Sh+kQdnDan3KFQACVlJ6CNCSDZzTs3Fw9v+SU02vBPKhJ9GpMDRERERB9zOVxoLGtBXXEj6ooaUF/ShLqihpAsXJhdkAGPywuf14fWGhammwnS5qagqaJF7jAIwK0/vR53/vZzcodBJCkmB4iIiIjG4LA5BhMFxU0fJw0aUVfUiK7mHlnjyi7IQG1hg6wxUPCkzU1GU0Wr3GEQAIVCwJ92/wbzVs+VOxQiybAgIREREdEY9BF65K2cg7yVc4Y8b+sbQF1xI+qLB5MFdR8nDfo6+gMeU/7qOag+UR/weSg0zFmWg8ojNXKHQR/z+0VUHa1lcoCmFSYHiIiIiCYpIsqIBWvysGBN3pDn+zr7UVfUiB2v7sXm53ZKXsBs4bp5OLmzRNIxKXSpNKqgJJxoYvq7LBjoH4Ax0ih3KESS4LYCIiIiogCy9Q3gw2e2452/bUJz5eCS8JikKMQkR6PqWO2ExtLqNcicn46Kw9WBCJVCFJNBoevFhn8gPi1W7jCIJMHkABEREVEQ+P1+HN1cCKVKgYXr58Hn8eG+a3+Pox+dHPcYqXOSTycYaGaIT49Fb3s/vG6v3KHQGbR6DR7Z/mvkrpgtdyhEkmBygIiIiEgmTrsL937mdzixvXhcx6fMSkRLNTsTzCSxKdHobumVOwwawfqbz8HqzyyHKIpYclEB4lJi5A6JaNKYHCAiIiKSkcPmwM+ueBDFe8rHPJZ97mem2UuyJ7wFhYJPoVTgsz+8Gl956Da5QyGaFIXcARARERHNZPoIPR58/+fIWzVnzGN5Tyc0CYKAa795OQxmfUDG1+jUARmXpOX3+fHRczvx5E+ex7t/34Su5m65QyKaEK4cICIiIgoBtr4B/PjiX6Py6Cd3iNPzUhCVEAmfxw9b/wA6G7vgsDpljJLOFJMUhZ8+/x0subAARbtL8dPLfgOXwy3pHCqNChqdGnaLQ9JxKbBu/tE1+Oofbpc7DKJx48oBIiIiohAQEWXEQx/eh5yFmQCAgnXz0FzZhsKdpSjZV46GkiYmBkLM0ksW4h/HHsaSCwsAAAvOy8d9r/0QSpUSAKCP0OGuh+/AvHNzpzSP1+3FrEVZUw2XgigyzoRlly2WOwyiCeHKASIiIqIQ0tfZjxd+8z+8948P4fX45A6HhqFQKvDF+2/FLT+5FgrF0HttAxY77l78I/i8fjzw7k8xa1EWRFHE0c0ncc9Vv4PPO7mvaXpeKhrLmqUIn4IgMTMefzv8e5hjTXKHQjRuTA4QERERhaD+Lgu2vbQHHz67HZVHauQOhz5mMOvxi9d+iGWXLDrrta6WHrz7t004/OEJ3P/2TxCbHH36tTcefx9///7TQ46PjDPhijsvgkqjwvMPvD7m3OxcEB7UWjUe2/0A5i6bJXcoRBPC5AARERFRiKsrbkTZwSo0ljahobwZjWUtaK1ug9/Pt3FyiYwzISEjDknZCVhz3Spk5Keir6Mfs5dkQ2/SQ2fQAhgsIrn9lb34013/gMM2dFtI3srZ+Mv+3wEA3njsffz9B0+POF9UQiT6Oy0sShkGzr91DX7+wnchCILcoRBNCJMDRERERGHI7fKgtboNDWUtaCxrRtWxGuz63wG5w5qxIqKMiE2JRmxqDG76/mew4vIlKNlXjn/88BmU7q8c9py41Bi81PjP0483Pb0Nm5/fiZK95RBF4KLPr4XD5sCOV/ehYG0+CneVBuvDoSmYsywHTxx8iMkBCjsquQMgIiIioonTaNXInJeOlNlJ0Oo1sPbYkLUgHXVFjXKHNi3d8cubcctProXX44PX7YXX44XX7YXH7f3kuY//rTVo4PP6ICgGaxM4bE7YrQ44bU4MWBzobOxCW10HOuq78LvbHsc137gciVnxOO/6lbjsixfA7XTD5XDDFB0Bh82ByiM16Ovol/tTQOOUnJMIr8cLtYYtKCm8cOUAERER0TRg6bbi3X98iLf/uhG97byQlEJMUhSuuusSzF0+CwVr82CMNEo+h9vlwe43DqBoVyn2vnMIzgEX0vNScd+rP0BCehwAoPRAJb533r3w+/ySz0/SU2vVeLriz6e/fkThgskBIiIiomnE7XRjywu78Noj77K6/RRc+Lnz8M0/fxnmmOBVm28sb8b7/9qMD5/Zjqh4Mz53z41YfOECxKXEwNJtxbEthTj84Qkc+fAEOpu6gxYXTcyVX7kI3/3HXWd1siAKdUwOEBEREU1Dfr8fBzccw2uPvIOTO0rkDidsRMWb8Z2/34W1N6ySLQa3043dbxzAe//6CIU7S5Gel4prv3k5rv3m5QAGixw2lrfglT+8hQ+f3i5bnHIzRRuRlJMozWASXhJlLcjAD568Gyo1d3BTeGFygIiIiGiae+xr/8T7T26WO4yQZzDp8UzVXxAVHyl3KKfVlzZh45Ob8eGzO3DJ7evxtUfuOH1H2jHgxJfzvouu5h6Zo5THbzfegxWXLZY7DKJpg2tdiIiIiKa5pZcshD5CJ3cYIW/JxQUhlRgAgMz8NNz96BfxctM/MWdZDt7+6wdwO90oP1QFl92FvFVz5A5RFmuuW8HEAJHEuHKAiIiIaAboau7G33/wDHa9vh98+zdUUlY8rvv2lbjuO1dAqVTKHc6YfD4fKg7X4NGv/n1GdqfQ6NT4d/GfkJwt0ZYCIgLA5AARERHRjOLz+tDfZUFPWx962/rQ09aHntY+9LT1ore9b8jzdotD7nADJm/VHJxz9XKcc81yZM1PD8ue9F6PF//70/t4/v7X4LS75A4naO745c24/ZeflTsMommHyQEiIiIiGpbT7kJv+yfJglP/ry9twp43DsDvD5+3kRqdGksvWYhzrl6B1Z9ZipikaLlDkkx7fSee+O5/se+dw3KHEnBJWfH4d/GfoNVr5Q6FaNphcoCIiIiIJqy+pBHP/PIV7PrfAblDGVF0YiRWf2ZwdcCSiwqgM0zvC8q97xzCE9/5LzoauuQOJWB+/eaPce61K+QOg2haYnKAiIiIiCat8mgNnrrvZRzaeEzuUAAAWQvSP94usAK5K2bNuF7zjgEnXnjgdbz+6HvweX1yhyOpFZcvxoPv/zwst4AQhQMmB4iIiIhoyor2lOGpe1/CyR0lQZ/bFG3ETT+8BhfcugbJUvW9D3O1RQ34yzf/jcJdpXKHIgmVWoknCx9F2twUuUMhmraYHCAiIiIiSYiiiKObT+Kpe19C+aHqgM+n1Wtw/XeuxC0/uQ4RUcaAzxduRFHEh89sx5M/fg79XVa5w5mSW358Lb7y0G1yh0E0rTE5QERERESSEkURe98+hKd/8XJAWu0plApccedFuO0XNyEuJUby8aeb/i4Lfnfbn3HkwxNyhzIpsSnReKrscegj9HKHQjStMTlARERERAHh8/lQfqgaxXvKUby3DMV7ytHX0T+lMdfffA6+eP+tXF4+QT6fD0/f9wpefuhNuUOZsJ+/+D1ccOsaucMgmvaYHCAiIiKioBBFES3VbYPJgj1lKN5bjvqSptOvLzgvD3f86mYoVUoolAoolAooP/6/QqmAMdKApKwEGT+C8LfrjQN4+It/hcPmlDuUcVm4fh7+uPVXLEJIFARMDhARERGRbCw9VpTuq0DZwSpc/90rYY4xyR3StFdf2oRf3/AwGstb5A5lVAqlAv84+gdkF2TKHQrRjMDkABERERHRDDNgsePhL/4Ve946JHcoI7r+O1fiG499Se4wiGYMJgeIiIiIiGYgv9+PV37/Np669yWE2iVBVEIknip7nF0oiIJIIXcAREREREQUfAqFAv/vZ9fjwQ0/hyk6tC7Cv/LQ55kYIAoyJgeIiIiIiGawFZctxhOHfo+cRaGxtz9/9Rxccsd6ucMgmnGYHCAiIiIimuGScxLx+J4Hce61K2SNQxAEfOsvd0Kh4GUKUbDxp46IiIiIiKAzaHHvK9/H6quXyRbDlV+5CHOXzZJtfqKZjAUJiYiIiIjoNLfLg1/d8DAObTwW1HlN0UY8Vf5nRMaZgzovEQ3iygEiIiIiIjpNo1XjV//7EZZesjCo837pN/+PiQEiGTE5QEREREREQ2h0Gvz6zR9j8QXzgzLfrMVZuPKui4MyFxENj8kBIiIiIiI6i86gxf3v/BQF6/IDPte3/nInlEplwOchopExOUBERERERMPSG3X4zbs/w/w1uQGb46Lb1mLBmryAjU9E48PkABERERERjchg0uP3H96Hz99zI1Rq6e/u1xU1wml3ST4uEU0MuxUQEREREdG41Jc24fGv/wsOqxMdDV2wdFslGffi29fhx09/C4IgSDIeEU0ckwNERERERDRuoiiiobQJogjs+t9+PPurVyUZ91t/uRPXfvNyScYiooljcoCIiIiIiCbE5/Xh++vug1avQX1JE3rb+6c8plKlxB+3/Yr1B4hkwpoDREREREQ0IUqVEj997juoOdkAlVolyZg+rw8PfPYRdLX0SDIeEU0MkwNERERERDRhKbOS8PuP7pO0mGBPWx+2vrBLsvGIaPyYHCAiIiIiokmZvTgbf/joFzBFGyUZ7+qvX4bP/ugaScYioolhcoCIiIiIiCZt9pJs/F6CBMHVd1+Kb//1TnYsIJIJkwNERERERDQlc5bm4KEP70NE1OQTBOfdsIqJASIZMTlARERERERTNnfZrCklCPo6pt7xgIgmj8kBIiIiIiKSRO7yWXho070wRhomfK7d6gxAREQ0XkwOEBERERGRZHJXzMZDm+6Fwawf9zlzluXgkjvWBTAqIhoLkwNERERERCSpvJVz8NCm+8adIPjGY1+CVq8NcFRENBomB4iIiIiISHL5q+bgdx/cC4Np7ARBe11nECIiotEwOUBERERERAExb/Vc/O6De6CP0I16XPXx2iBFREQjYXKAiIiIiIgCZt45ufjdB/eOmiCoPlEXvICIaFhMDhARERERUUDNPzcXv914D3TG4esKVB+vgyiKQY6KiD6NyQEiIiIiIgq4BWvy8NsNwycIXHY3vB6vDFER0SlMDhARERERUVAUrM3Hg+///KwEwdqbVkOtUcsUFREBTA4QEREREVEQLVw3D79572fQGT5JEFz6hfPlC4iIAACCyM09REREREQUZCe2F+PxbzyJr/7+Npxz9XK5wyGa8ZgcICIiIiIiWYiiCEEQ5A6DiMBtBUREREREJBMmBohCB5MDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQzHJMDRERERERERDMckwNEREREREREMxyTA0REREREREQz3P8HIBaJYhfbFzgAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -443,12 +447,25 @@ "source": [ "------------------------------------------------\n", "\n", - "### 2. Classic Gini Coefficient" + "### 2. Classic Gini Coefficient\n", + "\n", + "The Gini coefficient can be expressed as the relative mean absolute difference in incomes between pairs of observations:\n", + "$$G = \\frac{\\sum_i \\sum_j \\left| x_i - x_j \\right |}{2\\bar{x}n^2}$$\n", + "where $x_i$ is the per capita income of area $i$, $\\bar{x}$ is the mean of the area per capita incomes, and $n$ is the number of areas.\n", + "\n", + "The numerator, $\\sum_i \\sum_j \\left | x_i - x_j \\right |$ is a measure of inequality in the data set. The Gini normalizes this measure relative to the mean income and the number of pairwise comparisons. As a result of the normalization, the Gini coefficient is bounded between 0 (perfect equality) and 1 (maximum inequality)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Focusing on 1940, the Gini coefficient for Mexican state per capita income is:" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 77, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:02.985182Z", @@ -459,10 +476,10 @@ { "data": { "text/plain": [ - "0.3537237117345285" + "np.float64(0.3537237117345285)" ] }, - "execution_count": 9, + "execution_count": 77, "metadata": {}, "output_type": "execute_result" } @@ -472,9 +489,14 @@ "gini_1940.g" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 78, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:02.993505Z", @@ -488,7 +510,7 @@ "range(1940, 2010, 10)" ] }, - "execution_count": 10, + "execution_count": 78, "metadata": {}, "output_type": "execute_result" } @@ -500,34 +522,57 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 79, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.010083Z", "start_time": "2023-01-17T02:01:02.996515Z" } }, + "outputs": [], + "source": [ + "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", + "import pandas as pd\n", + "ginis_df = pd.DataFrame(data=ginis, columns=['Gini'], index = list(decades))" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "[0.3537237117345285,\n", - " 0.29644613439022827,\n", - " 0.2537183285655905,\n", - " 0.25513356494927303,\n", - " 0.24505338049421577,\n", - " 0.25181825879538217,\n", - " 0.2581130824882791]" + "
" ] }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "image/png": { + "height": 413, + "width": 556 + } + }, + "output_type": "display_data" } ], "source": [ - "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", - "ginis" + "ginis_df.plot();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Interpretation XXX\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Spatial invariance" ] }, { @@ -536,12 +581,24 @@ "source": [ "--------------------------------------\n", "\n", - "### 3. Spatial Gini Coefficient" + "### 3. Spatial Gini Coefficient\n", + "\n", + "To introduce the spatial dimension into the analysis of income inequality, the spatial Gini makes use of a decomposition of the numerator of the Gini:\n", + "\n", + "$$ \\sum_i \\sum_j \\left | x_i - x_j \\right | = \\sum_i \\sum_j \\gamma_{i,j} \\left | x_i - x_j \\right | + \\sum_i \\sum_j(1-\\gamma_{i,j}) \\left | x_i - x_j \\right |$$\n", + "\n", + "where $\\gamma_{i,j}$ is a binary indicator taking on a value of 1 if areas $i$ and $j$ are considered spatial neighbors, and 0 otherwise. \n", + "The first term in the decomposition is the contribution to overall inequality due to inequality between pairs of spatial neighbors, while the second term is the contribution due to inequality between pairs of \"distant\" observations.\n", + "\n", + "The relative contribution of these two inequality components will be a function of two factors:\n", + "- the number of neighboring (distant) pairs\n", + "- the inequality between each set of pairs\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 81, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.023820Z", @@ -555,7 +612,7 @@ "inequality.gini.Gini_Spatial" ] }, - "execution_count": 12, + "execution_count": 81, "metadata": {}, "output_type": "execute_result" } @@ -566,7 +623,161 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_891467/40166334.py:1: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", + " wq = libpysal.weights.Queen.from_dataframe(gdf)\n" + ] + } + ], + "source": [ + "wq = libpysal.weights.Queen.from_dataframe(gdf)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.234210Z", + "start_time": "2023-01-17T02:01:03.204552Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.01)" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numpy.random.seed(12345)\n", + "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], wq)\n", + "gs.p_sim" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(4735906.0)" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gs.wcg" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13.4765625" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wq.pct_nonzero" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 546, + "width": 846 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import gaussian_kde\n", + "\n", + "# Data array\n", + "data = gs.wcgp\n", + "\n", + "obs = gs.wcg\n", + "\n", + "# Kernel Density Estimation\n", + "kde = gaussian_kde(data)\n", + "maxd = max(max(data), obs)\n", + "x_range = np.linspace(min(data), maxd, 1000)\n", + "kde_values = kde(x_range)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", + "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs}')\n", + "plt.title(\"Kernel Density Plot with Vertical Line\")\n", + "plt.xlabel(\"Values\")\n", + "plt.ylabel(\"Density\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(4510351.818181818)" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gs.wcgp.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 88, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.029897Z", @@ -580,7 +791,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 89, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.038550Z", @@ -591,22 +802,22 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "w = libpysal.weights.block_weights(regimes, silence_warnings=True)\n", - "w" + "wb = libpysal.weights.block_weights(regimes, silence_warnings=True)\n", + "wb" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 90, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.201808Z", @@ -616,7 +827,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -639,7 +850,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 91, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.234210Z", @@ -650,23 +861,164 @@ { "data": { "text/plain": [ - "0.01" + "np.float64(0.01)" ] }, - "execution_count": 16, + "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "numpy.random.seed(12345)\n", - "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], w)\n", + "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], wb)\n", "gs.p_sim" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "20.1171875" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wb.pct_nonzero" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(4353856.0)" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gs.wcg" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(4156997.4545454546)" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gs.wcgp.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABpwAAARFCAYAAACjc2H6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3hUVf7H8c+k954QSkjoXZqEKsVeQEGsoDSx66qrrv6suLquva8dAQVBVLCAnd577z0EAiSB9J65vz9YZnPTSL8p79fzzMOdc8499zuTuTPD/c45x2YYhiEAAAAAAAAAAACggpysDgAAAAAAAAAAAAB1GwknAAAAAAAAAAAAVAoJJwAAAAAAAAAAAFQKCScAAAAAAAAAAABUCgknAAAAAAAAAAAAVAoJJwAAAAAAAAAAAFQKCScAAAAAAAAAAABUCgknAAAAAAAAAAAAVAoJJwAAAAAAAAAAAFQKCScAAAAAAAAAAABUCgknAAAAAAAAAAAAVAoJJwAAAAAAAAAAAFQKCScAAAAAAAAAAABUCgknAAAAAAAAAAAAVAoJJwAAAAAAAAAAAFQKCScAAAAAAAAAAABUCgknAAAAAAAAAAAAVAoJJwAAAAAAAAAAAFQKCScAAAAAAAAAAABUCgknAAAA1ElTp06VzWaTzWbTuHHjrA4HxRg8eLDjb7R48WKrw6mVzj0/NpvN6lDqpOp6H1i8eLGj38GDB1dZv6iYqKgox9/j8OHDVodTbrU1/kmTJjnimjRpktXhAACAeoCEEwAAQCUUvKBe1os1W7duVaNGjRz7BQUFad26ddUbKM6r4IXrwjdnZ2cFBgYqKipK3bp106hRo/Tmm29qxYoVMgzD6tBRg0p6jRR8nXTo0EG33367vvvuO+Xl5VkdMuqI06dPy93d3fF6+uKLLyrc1+OPP+7op2XLlrxP1TMFE1hTp061OhwAAAAHEk4AAAA1aMOGDRoyZIhOnTolSQoNDdWiRYvUq1cviyNDaex2u5KSknTkyBFt2bJFM2fO1GOPPaYBAwaobdu2ev3115WRkWF1mHVSffqF/bnXye7duzV9+nTdeOON6tixY61LKDe00TuHDx92PN6oqCirwylRUFCQhg4d6rj/5ZdfVqif/Px8zZgxw3F/zJgxtWoEXW0d7QMAAIDKc7E6AAAAgIZi1apVuuqqq5ScnCxJaty4sRYsWKAOHTpYHBkK8/X11ZgxY0xl6enpSkpKUmxsrLZs2aLc3FxJ0v79+/WPf/xDkydP1vTp03XhhRdaETIsMHz4cDVt2tRxPz8/XydPntTy5csVHx8vSdq3b5+GDBmipUuXqkePHlaFijpi7NixmjNnjiRp6dKlOnLkiCIjI8vVx59//qm4uDhJZ0fkFX4vAwAAAKoLCScAAIAasGTJEg0dOlRpaWmSpIiICC1cuFCtW7e2ODIUJygoSB988EGJ9VlZWfrrr7/09ttva+HChZKkPXv2aMCAAVqwYIH69+9fU6HWavV93aaHHnqo2BFCOTk5eu211/Tcc8/JMAylp6dr3Lhx2rJlS60aaVIfjBs3rl6t4XbVVVcpNDRU8fHxMgxD06dP19NPP12uPgqOjBowYIBatmxZ1WHWOEZCVY9JkybV+ZGlAACgdmFKPQAAgGr2559/6uqrr3Ykm1q2bKlly5aRbKrDPDw8NHToUC1YsEBTpkyRp6enJCk7O1sjRoxQTEyMxRHCSm5ubnrmmWf06KOPOsq2bdumP//808KoUBe4urpq1KhRjvtfffVVufZPTU3VDz/84Lg/duzYqgoNAAAAOC8STgAAANVo3rx5GjZsmGN9n3bt2mnp0qXlniIJtde4ceM0bdo0x/34+Hh+MQ5J0pNPPiknp//9l+uvv/6yMBrUFQWTRHv27NGaNWvKvO+3336rzMxMSZKnp6duvPHGKo8PAAAAKAkJJwAAgGoyZ84cXX/99crOzpYkderUSUuWLDGt+VKa3NxcffXVV7rpppvUsmVL+fr6ytvbWy1atNCtt96quXPnyjCMUvtYvHixY3H2glN//fLLL7r11lvVpk0b+fj4yGaz6Z133pF0duqic/tERUU59lm/fr0mTpyotm3bysvLS4GBgYqOjtbLL7+s9PT0cj03iYmJevPNN3XZZZcpIiJCHh4eCggIUMeOHXX//fdr/fr15erPajfeeKNpVML06dN15MiR8+6Xnp6ujz76SMOGDVNkZKS8vLzk6+urNm3aaMKECY7p+kozdepUx9+r4NRic+fO1bBhw9S8eXO5u7srLCxMl19+uaZPn37e180569at0wMPPKAePXooMDBQLi4u8vT0VOPGjdWnTx/de++9mj17dol//8GDBztiKzy93rm6F154wVH2wgsvONoXvJ17XG+//baj7IorrijTY5CkRYsWOfYLDw93rL9V3YKDg9WuXTvH/YMHD1a6zx07dujxxx9X9+7dFRISInd3dzVp0kSDBw/Wq6++qsTExBL3nTRpkmw2m4YMGeIoW7JkSbHPecFzv6xWr17t2L9Pnz4ltsvKypKHh4ejbWnrnuXk5MjLy0s2m03u7u6OZMo5Jb3+C9a1aNHCUXbkyJFiH29ZpzpcuHChbrnlFrVs2VIeHh4KDg7WwIED9cEHH1TZ66p79+7q0qWL4355RjkVnE5vxIgR8vPzK7bdrl279NRTTyk6OlqNGjWSm5ubQkND1bt3bz333HM6fvz4eY9V3PkdFxenl19+WdHR0QoPD5ezs7MCAgJMnysF3xtbtGhR7N+i8PtFVFSUo64s0+vl5+dr9uzZGjNmjNq1a6fAwEC5uroqODhYvXv31kMPPaQFCxaU+F5ot9u1bNkyPffcc7r88svVvHlzeXl5yd3dXY0bN9bFF1+sf/3rX0pISDhvLLXZufcEm81W4g8lqvMz5pyqeD0CAIBawgAAAECFDRo0yJBkSDKef/55R/nXX39tuLi4OOq6d+9uxMfHl7nfRYsWGa1atXLsX9KtT58+RmxsbKn9nGs7aNAgIykpyRgxYkSxfb399tuGYRjGoUOHHGWRkZGG3W43nnvuOcPJyanEOFq0aGEcOHCgTI/tgw8+MPz9/Ut9XDabzZgwYYKRnZ1dYj9TpkxxtB87dmyZn9uy9BcZGVnu/Tds2GB6DG+99Vap7WfPnm2Eh4ef9288dOhQIykpqUxxjx071khKSjKuvfbaUvu88sorjYyMjBL7zM3NNe66667zxnbu9vTTTxfbT8HzY9GiRSXWne927u+bkJBguLu7G5IMJycnIyYmptTn+JzRo0c7+nr88cfLtE9JCsZV+DEVp1+/fo72l112Wan9lSY3N9d48MEHDWdn51Kfq4CAAGPq1KnF9vH888+X+TmvyDmQm5tr+Pj4GJIMFxcXIzU1tdh2CxcuNB3L2dm5xNf40qVLHe0GDBhQpL6094GCdWW5FVT4vTM7O9u48847S92/R48e5XqfL80bb7zh6Dc4ONjIyck57z6HDx82bDabY7/ff/+9SJusrCzj7rvvPu/ryNPT03j//fdLPV7h8/uHH34wAgMDi/Tl7+9v+lwpy63wuRUZGemoO3ToUKlxLV261Gjbtm2ZjvPEE08U2T8nJ8do2rRpmfb39vY2vvrqq/P+bcoTf1kU7G/KlCkV7qfge0LB7zAFVcdnzDlV+XoEAAC1g4sAAABQpaZMmaKJEyfKbrdLknr37q3ffvtNAQEBZdr/22+/1ejRox2/lvf09FSfPn0UFRUlJycn7d27V6tWrVJeXp5Wr16tvn37at26dWrUqFGp/RqGodtuu03z5s1zjCro2LGjDMPQ9u3bS/yF/wsvvKB//vOfkqRu3bqpS5cucnV11ebNm7Vx40ZJ0qFDhzR8+HBt3LhRLi4lf8V8+OGH9e677zruh4SEqG/fvgoPD1dWVpY2bdqk7du3yzAMffHFFzp+/Ljmz59vmpasturRo4datmzpGMWybNkyPfLII8W2ffvtt/Xoo486fgXu5+envn37qlmzZsrPz9eOHTu0fv16GYahefPmafDgwVqxYoW8vLxKjSEvL08jR47UggUL5Obmpn79+qlVq1bKysrSsmXLHGtL/fbbb/r73/+ujz76qNh+Hn/8cX366aeO+02bNlV0dLRCQ0Nlt9uVmJionTt3as+ePeV+ns4ZMWKEOnfurLVr12rdunWSpF69eik6OrpI23OjZYKDg3X99ddr5syZstvtmjJlip577rlSj5OUlKTvv//ecX/ixIkVjrkizpw549j29/evUB92u10jR47UTz/95CgLCgrS4MGDFRQUpKNHj2rRokXKyclRUlKSxo0bp6SkJD300EOmfqKjo3X//ffr2LFjjnV+mjRpohEjRhQ5ZnBwcLnjdHFxUf/+/fX7778rLy9Py5Yt01VXXVWkXeHRK/n5+Vq6dKmGDRtWatuCozTLokOHDrr//vuVmprqGPnj6+urMWPGlKsfSbrrrrs0bdo0OTk5qXfv3mrfvr3sdrtWr17tOA82btyoMWPG6Jdffil3/4WNHj1aTzzxhPLz85WYmKj58+dr+PDhpe7z1VdfOd5TmjZtqksvvdRUn56eriuuuEIrVqxwlLVq1Uo9e/ZUYGCgTp8+rRUrVuj48ePKzMzUgw8+qJSUFD311FPnjXflypWaNGmScnNzHaO+QkJCdOrUKW3atEl+fn66//77JZ0dhZWamipJGjNmjHx9fYv0V9aRwIXNmjVLY8aMMY02a9u2rbp37y5/f3+lpKRox44d2rFjh+x2u7Kysor0kZ+fr2PHjkmSfHx81KlTJ7Vs2VJ+fn7Kzc1VbGysVq9erZSUFKWnp+v222+Xq6urbr755grFXJdU1WeMVL2vRwAAYCErs10AAAB1XeERTh999JHpF+YXXXSRkZKSUub+tm/fbnh6ehrS2VE+jz32mHHmzJki7Q4cOGAMGDDAcZyrrrqq2P4K/kr/3IirLl26GFu3bi3SNisryzAM8wgnNzc3w2azGa1atTLWrFlTZJ/Zs2cbrq6ujvbTpk0r8bFNnjzZ0c7Pz8/47LPPiv3V/sKFC02/Ln/11VeL7a+2jXAyDMO49dZbHX00bty42DZ//fWXY7SYm5ub8corrxjp6elF2m3atMno2LGjo7977733vHGfG/1z1VVXFRn5lpubazz22GOOtjabrdhf2ickJDheK87OzsbUqVMNu91e7LGPHz9uvPfee8bnn39ebH1pI5zOKcsv7Asq+JqOiooqMbZz/vOf/5jOx8o611dpj+mchIQE08jA4kZXFeyvJK+++qqp3ZNPPllk9F9cXJxx+eWXm8731atXF9tf4dE7Venf//53qY/XMAxj4MCBhiQjJCTE8X75yCOPFNv24osvdvT3119/Fakvy/tA4VGbZVHwOTp3XvXq1cvYtWuXqZ3dbjfeeecd099nyZIlZTrG+Vx99dWOPq+//vrzti84qqe4kTtjxoxx1Ldt27bY129eXp7x4YcfOh6zs7OzsXLlymKPV/D8dnFxMWw2m/Hiiy8WeV8/99lyTkVG+5Rln40bNxoeHh6Odt27dy/xHIiLizNef/31Yj9fsrOzjfHjxxuLFi0qcWRZVlaW8dprrzneKwMCAkoc0VfW+MvDqhFOVfEZc05Vvx4BAEDtQMIJAACgEgpecGvfvr3pouMll1xSbCKhNAUvrp5vSra0tDRTQqK4C2sFL5pKMsLDw8875VPhqY+Cg4ONY8eOldi+4AWmK6+8stg2KSkpRkBAgCPJUtJFwHN27tzpuHAYHBxc7PNYGxNOkyZNMl2ALSw/P99o06aNo82cOXNK7S8uLs5o1KiRIclwdXU1jh49Wmrc55Iqubm5xfZnt9uNXr16Odq+8sorRdr8/PPPjvrRo0eX8ZEXrzoSToZhvrD+559/ltq2R48ejralJUTLqjwJp4LnhiTjt99+K7W/4iQnJzumqZNkPPbYYyUeLysry/T3HTJkSLHtqjPhtHr1akffvXr1KlKfmZnpuHg8ZswYo3Pnzo7kQGHZ2dmOBLybm1uxU3TVRMJJktGmTZtSEwo33HCDo+0999xTpmOczzfffOPo083NzTh9+nSJbVetWmWKd+fOnab6glMTtmrV6ryfAwWf15Le1wtPi/nSSy+V6XFVV8Kpf//+jjYXXnhhqX+vqvLKK684jvnhhx+W2K6+JJyq4jPGMKrn9QgAAGqH2j83CQAAQB2xe/dux3bnzp01b968806BVtCWLVu0cOFCSWcXjX/44YdLbe/t7a1nn33WcX/GjBnnPcZzzz2nkJCQMsckSU899ZSaNGlSYv2ECRMc2+emRivsiy++UFJSkiTpvvvuU+/evUs9ZocOHTR27FhJUmJion777bdyxWyVglOm5eXlKSUlxVT/888/a9++fZKk4cOHFzuVWUHh4eGO10Fubq5mz5593hjeeeedEqc1tNlsGj9+vOP+2rVri7QpGHNoaOh5j2eFgtPiTZ48ucR2Bad99Pf314033ljtsUlSTk6O/vWvf+nNN990lHXq1EmXXXZZufv6+uuvlZaWJklq1KiRY3rL4ri7u+uDDz5w3F+0aFGlpj2siJ49ezqmSNu4cWORc2DlypXKzs6WdHaKvCFDhkg6+/5XcPpBSVq9erUyMzMlnZ2a1NPTs7rDL9Err7wiHx+fEusLvg8Wd15VxLXXXuuYijUnJ0ezZs0qse25KQOls1NTdujQwVT/1ltvObbffPPN834OjBs3Tu3bt5ck/f7770pMTCy1fZMmTfTEE0+U2qY6rVmzxjE1m81m07Rp00r9e1WVgu+nf/31V7Ufrzao7GeMVP2vRwAAYB0STg3UqVOnNG/ePD333HO66qqrFBISIpvNJpvNpnHjxlkdXrXYtWuXHn/8cV1wwQUKDAyUp6enoqKidOmll+rll1/W4cOHrQ4RAFCP7NixQ1999VW59im47sett95a4ppKBV188cWO7eXLl5+3fUXWmDjfRfr27ds7LgQnJiY61uYoqOBjGzVqVJmOW97HVhsUvsBZ+Lmo7uehZcuW6tGjR6ltunfv7tgu7vtPRESEY3vOnDk6depUmeKsSePGjZObm5skae7cuTp9+nSx7Qomo0aNGlXlCYt3331XDzzwgON23333aeTIkWrWrJmeeeYZx3o6Xl5emjJlSoXWIjuXhJbOvi+c7zFER0erS5cujvuLFi0q9zEr49w6TtL/1mYqqOCaTEOGDHGsy2S327VkyZIS25Z3/aaq5OHhUez6UgWd77yq6HELvmcXTCoVlJOTo2+++cZx/1yy/py8vDz9+eefks6uFzd06NAyHf9cMtAwDNM6O8W54YYbSl2/r7oV/FHCJZdcoo4dO1ZJv3a7XevWrdNnn32m559/Xo888ojpnC+YAN68eXOVHLM2q4rPmJp4PQIAAOtY940QljrfouL1iWEYeuaZZ/Taa68pLy/PVHfkyBEdOXJECxYskJeX13l/SQ4AQGkmTpyohQsX6uDBgzIMQ3fffbfc3d3LvED9qlWrHNuLFi3SkSNHzrvPuQvaknT06NFS27Zo0UJBQUFliuUcf39/UwKiODabTYGBgY6RCCkpKUUWgS/42D799FNNmzbtvMeOjY11bJ/vsdUWhRNMfn5+pvsFn4fvv/++yAX24iQnJzu2z/c8FEw0lCQ4ONixXXj0iST16dNHEREROnr0qGJiYtSpUyeNHz9ew4YNU+/evR2JHiuFhoZq+PDhmj17trKzszVjxgw9+OCDpjZZWVmmUX8FR0VVlR9++OG8bVq1aqXp06erV69eFTrGpk2bHNv9+vUr0z79+/fXtm3bJMkxwqsmDR482JEAWLRokemC8rkkUlRUlKKiouTr6yubzSbDMLRo0SINHz68SNtzfVqlXbt2cnV1LbXN+c6riho7dqw++eQTSWdHfO3fv1+tW7c2tZk3b54j6erm5qZbb73VVL9161alp6dLklxdXfXQQw+V6dgFR6ye772nZ8+eZeqzuqxevdqxfS4xURl5eXl677339Pbbb5s+i0qTkJBQ6ePWdlXxGVMTr0cAAGAdEk5Q8+bN1b59e/3xxx9Wh1It7rrrLn3++eeSzv5HaMKECerSpYt8fHx06tQprV27Vt9//32ZfkUOAEBpmjZtqoULF2rgwIGKiYmRYRiaMGGC3N3dyzSy6Pjx447tX3/9tdzHLzwdVWEVmR6t4BRxpSl4MTY3N9dUl5aWZkrEnPtcLo/zPbbaomByyNXVtUjireDfuOCIhLI63/NQlr9XaX+rc/VfffWVhg4dqrS0NCUkJOj111/X66+/Lg8PD1144YUaOHCgrr76avXr18+y71B33XWXY4rByZMnF0k4zZ071/F8de/e/by/yq8KTk5O8vX1VePGjdWzZ09dd911Gj58+HmTFaWJj493bEdGRpZpn6ioKMe2FRfBCyaHCiaNMjMzHVNsnWsTHBysLl26aOvWraa22dnZjiSCu7u7+vbtW91hl6i851XhH7lVRt++fdW2bVvt3btX0tlRToWnVSyYwB86dGiRHxYUfN9JTEzUf/7zn3LHUR2fL1Xp5MmTju2WLVtWqq/s7Gxde+215f7/cXGje+ubqviMqYnXIwAAsA5T6jVQzz33nH7++WedOHFCR44ccfxqrr754osvHBe1nnrqKa1bt0733XefLrroInXv3l1XXHGFnn32WW3evFn33nuvxdECAOqDyMhILVy40LHmUX5+vm677TbNnTv3vPsWTFZURH5+fqn1FZlOrCqSCZV9XFLVXsCtTgXX8SpuRHlln4vzPQ9VlfwZNGiQtmzZojFjxpheN1lZWVq+fLlefvllDRgwQO3bty/TKJ/qcPHFF6tVq1aSzq7/s2HDBlN9wen0qmN0k3R29I5hGI5bfn6+kpKStGvXLk2fPl033nhjpZJNkhzrN0ln120ri4LtrLgIXnAdp82bNzvWb1u1apVj/aaCo1DOJZ+2bdvmWJtlzZo1tWb9Jqt/mFZwlOz06dNNI1sTEhJMP1AoPJ2eVDPvwVb+fSTz67yyaze98MILjmSTzWbTzTffrNmzZ2vXrl1KTk5WTk6O6bw/p+B2fcV3AgAAcD4knBqoF154QUOHDq3XU+ulpqbqsccekyRdc801+te//lXqF+TaMD0MAKB+aNWqlRYuXOj4nM3Ly9PNN9+s+fPnl7pfwYvEc+bMMV3QKuutNip8kfz06dPlflwFRz7UZmvWrHFs9+nTp0h9wedi48aN5X4eanLNyZYtW2ratGmKj4/Xb7/9pmeeeUZDhgwxXVjeu3evRowYYVoAvqbYbDZTIqlggunQoUOOtY88PT01evToGo+vqhS8eH5uGqrzKdiu8Ci7muDi4qIBAwZIMq/NVHA9qYIJp4Jrs5w71wu2tXI6vdrg9ttvd/w/5tChQ6a13GbOnOkYRRIaGqqrrrqqyP4F33cuuOCCCn22TJo0qXofZCUVfJ0XTNKWV3Z2tt5//33H/alTp2rWrFm68cYb1b59e/n5+ZmSyA1hVFNVawivRwAAGjISTqi0rKwsffDBB7rkkksUHh4uNzc3hYWF6dJLL9XkyZMt+/XRjBkzHEPtn376aUtiAAA0XO3atdOCBQsUEhIi6ey0MiNHjnQslF2cgj8EOXHiRLXHWFMCAgLk7u7uuF+fHltB69evNyWEBg4cWKRNXfwbe3t764orrtCLL76ohQsXKjExUd9++61pLY//+7//07Fjx2o8tvHjxzsu/n799deOETFTpkxxJGBvuOGGMk8NWRsVnKosJiamTPsUfB2eew+qaQWTROeSR+eSSa1atTKtDTdw4EBHQqVw28J9NUTNmzc3Jei+/PLLYrdHjRpV7Ii6uvi+U14FH+OhQ4cq3M/atWsdCatOnTqddw3Gsqy1CLOG8HoEAKAhI+GEStmyZYvat2+vBx98UAsXLtTJkyeVm5ur+Ph4LViwQBMnTlS/fv1Mc2rXlG+//VbS2f9kF5zz/dSpU9q/f3+VLuYLAEBxOnXqpD///FOBgYGSzv5y+rrrrnP82r+w3r17O7ZXrFhRIzHWlOjoaMd2fXts5xQc5ePm5qbrr7++SJv68Df29PTUDTfcoMWLFzsuHObk5Oj333+vUH+VmaKpUaNGuvbaayWdnabp+++/l91u19SpUx1t7rjjjgr3Xxt0797dsb1y5coy7VOwXXFrV9XEFHGF13Eqbv2mc4KCgtS1a1dH26pev8nqKfGqQsGp8r799ltlZWVp165dWr9+fbFtCurWrZsj6X/u/0JWqo6/R8ERpedGN1ZEwfWFCibVS7J06dIKH6uhqm2vRwAAULVIOKHC9u/fr0GDBunIkSPy8/PT//3f/2nu3Llav369fv/9d91///1ycXHRunXrdN111xW7YGh1sdvtWrdunaSz/1EwDEPvv/++WrZsqUaNGqlNmzby9/dXt27dNHnyZNnt9hqLDQDQsHTr1k2///67/Pz8JEmZmZkaOnRosReOhw4d6tieM2eOJT/YqC4FH9tHH31Ua6f/q6hvv/1WM2fOdNwfN26cmjZtWqRdwefhiy++UFZWVo3EVx2CgoLUv39/x/2Kvl49PDwc2xX5vnjXXXc5tidPnqw//vhDR48elSS1adNGgwYNqlBctcXFF1/s2J41a9Z5XzPr16/X1q1bHfcLjow5p7LPeVkUXMdp69at+vnnn5WTk1NiTOeSUDt27NBPP/3keJy9e/c2xVsRNfF4q9vIkSMd0ysmJyfrp59+Mo1u6tKliyk5WZCnp6fpdfThhx9Wb7DnUR1/j4JTCS5YsEC7du2qUD9OTv+7RJKRkVFqW7vdrk8//bRCx2nIatvrEQAAVC0STqiwsWPHKjk5Wd27d9eBAwf08ssva/jw4erZs6cuv/xyffDBB/r555/l5OSkNWvWmH5pWt2OHj3qmE87KChII0eO1N/+9rci0yts2bJFEydO1PXXX+/4DzAAAFWtV69e+vXXXx0XC9PS0nTVVVc5fhxxTnR0tOOia2Zmpm6//fYyfz7l5OQ4ppKtje6++24FBARIOrt20QsvvFDmfRMSEpSfn19NkVXetGnTTCMLwsPD9dxzzxXbduTIkWrdurUkKS4uTvfdd1+Zk29paWllXsOnMhITE8vc9lxiR5LCwsIqdLzg4GDHdkWm5bvsssvUokULSdKSJUv0/PPPO+rq+ugm6ew0aefeO+Li4ko9d3JycvTggw867g8ZMkTt2rUr0q6yz3lZODs766KLLpJ0dm2mF1980RRXYQXL/vnPf5batrwCAgIciYT4+Pg6mXTy9vbWyJEjHfenTp2qGTNmOO6XNLrpnCeeeMKx/f777+uvv/4q87Gretqz6nj9RUdHOxLghmFozJgxFVrLqWXLlo7tJUuWKDk5ucS2r7/+urZs2VL+YFGrXo8AAKBqkXBChSxbtszxy+xp06aVODf8lVdeqRtuuEGSajThdPr0acf2/PnzNXfuXLVt21Y//fSTUlJSlJqaqnnz5ql9+/aSpB9//FFPPvlkjcUHAGh4+vXrp3nz5snT01OSlJKSoiuuuEKbN282tXv//fcdF5f//PNPDRw4UGvWrCmx37179+rFF19UVFRUrZ6izd/fX2+//bbj/gsvvKCxY8eWuCaNYRhasWKF7rvvPjVv3tyxNk9tkZWVpfnz5+uyyy7TuHHjHPF5enrqxx9/LHZ0k3T2IvxHH30kZ2dnSWfXGrrmmmtK/TX+5s2b9cQTTygiIqJSa5OU1fvvv69u3brpo48+KvHCXlpamp5++mlH0tTZ2VmXX355hY7XuXNnx/Yff/xR6gXe4thsNkdiyTAMx7RtLi4uGjduXIViqk38/Pz07LPPOu6/8sorevbZZ4sko0+ePKnrrrvOMRWdi4uL/v3vfxfbZ4sWLeTl5SXp7Bo0hZPfVaXg1Hnbt2+XdHbUWZMmTYq0HThwoCMpdK5t4T4qyt3dXW3atJF0dkTNDz/8UOk+rVAwqfTrr786Er7Ozs4aPXp0qfsOGjTIsX9eXp6uueYa/fvf/y4xKZOVlaUffvhB1113nWPayqpS8Jw/Nw16VXjvvfccU7WtX7++1M/PEydO6I033tDrr79uKu/evbvj/Ts5OVk33nijaZo96ez0uM8995yefPJJeXt7V1n8DUltej0CAICq5WJ1AKibfvrpJ0lnF0Q/39zWAwcO1OzZs7Vu3Trl5eXJxaX6X3YFf/2blZWl8PBwLV++3LTo8jXXXKPevXura9euOn78uD744AP9/e9/V7Nmzao9PgBAwzRo0CD9+OOPGjZsmLKzs3XmzBlddtllWrx4sTp16iTp7IW4mTNn6uabb1ZGRobWrFmjPn36qFWrVurRo4eCgoKUlZWlU6dOaevWrdU2OqE6jBs3TgcPHnSMdPjyyy81Y8YMdevWTe3bt5ePj4/S0tIUGxurzZs3lzvxUJVOnz6tBx54wFSWkZGhpKQkR3yFR0l06tRJ06dPV7du3Urt+9JLL9VHH32ke++9V/n5+fr111/122+/qWPHjrrgggvk5+enjIwMxcXFacuWLYqPj6/qh3deW7Zs0X333af7779frVq1UufOnRUSEqLc3FzFxcVp5cqVpguDTz75pCIiIip0rOjoaEVEROjo0aOKi4tT+/btdfnllyskJMSx1kuvXr108803l9jHhAkTNGnSJOXl5TnKhg4dalqcvi577LHHtHz5cv3888+SpJdeekkfffSRhgwZosDAQB09elSLFi1Sdna2Y5/XX3/dtGZYQc7Ozho+fLi+/vprSWeTOldeeaWaN2/uSIYGBQXpqaeeqlTcxSWLShqxFBAQoG7dumnjxo2OMnd3d9PaPJUxcuRIvfzyy5Kk0aNHa+rUqWrdurVcXV0dbd54440qOVZ1GTx4sCIjI3XkyBFT+RVXXKHw8PDz7v/JJ58oLi5Of/zxh3JycvTUU0/ppZdeUu/evdW8eXO5u7srKSlJBw4c0Pbt2x2vp549e1bp4xg5cqQ++eQTSWenU9uwYYN69OjhSIJK0r333qtWrVqVq98ePXpo8uTJGjdunPLy8rRp0yb16dNH7dq1U/fu3eXv76/k5GTt3LlT27dvl91u10MPPWTqw8nJSS+++KImTJgg6ewPP9q2bat+/fopMjJSiYmJWrx4sWNE8aeffnreZF91e+655/TOO++Uuf3nn3+uCy+8sPoCKqPa8noEAABVzAAMwzh06JAhyZBkjB079rztBw8e7GhfntvJkydN/UyZMqVC/RS+FbZu3TpT/VtvvVXiY/nggw8c7d59991yP3cAgIZt0KBBjs+R559/vkz7zJs3z3Bzc3PsFx4ebuzZs8fUZvPmzUbPnj3L/FkYFRVlbNq0qcixFi1a5GgzaNCgMsVX8HtBZGRkmfaJjIx07HPo0KFS237zzTdGkyZNyvzYoqOjjaysrCL9FPweUZbvL+dT0e8lbdu2Nd58800jMzOzXMdbuHCh0aZNmzIfp1OnTsaxY8cq/Tyc7+/7xhtvlDkmNzc344UXXijxWAXPj0WLFpXY7ueffzadE4VvZXlcw4cPN+0zb9688+5TEQWPUdpjqkh/pcnNzTUeeOABw9nZudS/ib+/vzFlypTzHvfw4cNGeHh4if2U9dwvTV5enuHn52fqd+bMmSW2//vf/25qW5b3rLK+/pOSkoz27duX+f8UFXnvLOvfsjKeeeaZInF/8803Zd4/Ly/PePbZZw0vL68yneOurq7G/fffX2xfZT2/i3PrrbeWetzC/ZXnM2bBggVGixYtyvT4nn766WL7eOqpp0rdz8PDw/j4448Nwyjb37088ZdFwf7Keyv43D7//POO8pK+w1T1Z0xBVfl6BAAAtQMjnFAhp06dqtB+51t4taqcW6D4nNKmeLniiisc29U1nQgAAAVdc801mjVrlm666Sbl5eXpxIkTuvjii7V06VLH+hFdu3bV+vXr9ccff+iHH37QihUrdPz4cSUlJcnd3V2hoaFq166devfurSuuuEJ9+/Z1jAap7W666SZdd911mjVrln7//XetW7dO8fHxSktLk7e3t5o2baoOHTrooosu0tVXX622bdtaHbKcnJzk6+srPz8/BQYGqmPHjrrwwgvVr18/9e3bt0J9DhkyRLt27dIPP/yg+fPna/Xq1Tpx4oRSUlLk5eWlRo0aqX379urXr5+uuuqq846cqiqPPvqoRo4cqT///FMrV67Utm3bdPjwYaWkpMjJyUkBAQHq0KGDLr74Yo0ZM0aRkZGVPubQoUO1fv16/ec//9Hy5csVExOjtLS0Mq9vJUnXX3+9Y6q0Zs2a6corr6x0XLWJi4uL3n//fd1zzz364osvtGDBAse6pUFBQWrbtq2uvvpq3XnnnaY1ckoSGRmpLVu26IMPPtAff/yhvXv3KjU11TRKrLLOreM0f/58R1lpU+QNGTJEb731Vpnalpe/v7/WrVunDz/8UPPnz9euXbuUlJRU59ZzGjt2rF566SXH/YCAgHJNMebs7Kx//vOfevDBB/Xll1/qr7/+0s6dO5WQkKDc3Fz5+fkpMjJSXbp00ZAhQ3T11VebZomoKjNmzNDQoUM1c+ZMbd68WQkJCcrKyqqSvi+++GLt2bNHs2bN0rx587R+/XqdOnVK2dnZ8vf3V+vWrdW3b1+NGDHCsc5YYf/617901VVX6YMPPtDy5csVHx8vX19fx3vLHXfc4ZimERVXW16PAACg6tiM8vwvDvXW4cOHHYstjx079rzrLbVv31579uxR165dNX369DIfp127dqZpK5KTkxUXF1ehmAvHU1B6erp8fX0dFymSk5Pl5+dX7L7Z2dny8PCQdDb59Ntvv1U6HgAAANSs8ePHO77DPvPMM46pGwEAAAAANYMRTqiQc7+aTEtLMy36Wl7+/v7y9/evqrAcvL29FRkZqcOHD0uS8vPzS2xbsK4m1pcCAABA1UpNTdW3334r6exotHPrrwAAAAAAao6T1QGgburevbsk6eDBgzpx4oTF0RRv4MCBju2DBw+W2O7AgQOO7aZNm1ZrTAAAAKh6kydPVnp6uqSzI9bPjdwHAAAAANQcEk6okHPzhBuGoXfffdfiaIo3cuRIx/bcuXNLbDdnzhzHdklzeAMAAKB2Onz4sGlNm0ceecTCaAAAAACg4WINJ0gq/xpOktS7d2+tXbtWzs7O+vrrr3XTTTeV2PbcYtPDhg2rqpDPy263q2vXrtq+fbu8vb21Zs0aderUydRm165dio6OVlpamkJDQ3X48GF5eXnVWIwAAAAov4cffliSdPz4cc2fP18ZGRmSpIsvvlgLFiywMDIAAAAAaLhIODVQy5cv1/79+x33ExIS9Pjjj0uS+vfvr4kTJ5rajxs3rkgfBw4cUHR0tE6fPi1JGjZsmG6++Wa1adNGzs7OOnXqlDZt2qSff/5Zq1ev1qOPPqo33nij+h5UMZYvX65LLrlEOTk5CggI0D/+8Q8NGTJEkrR06VK98sorOnPmjCRp1qxZuvnmm2s0PgAAAJSfzWYrUhYWFqbVq1cznR4AAAAAWISEUwM1btw4TZs2rcztS3qZ7N27VyNHjtT27dvP28cLL7yg5557rszHrCrff/+9xo8fr9TU1GLrXV1d9d577+mee+6p4cgAAABQEecSTs7OzmrUqJGuvPJKTZo0SRERERZHBgAAAAANl4vVAaBua9u2rTZv3qzZs2fr+++/17p16xQfH6/8/HwFBwerXbt2GjBggEaMGKEePXpYEuPIkSPVq1cvvf/++5o/f76OHj0qu92uiIgIXXrppXr44YfVunVrS2IDAABA+fGbOQAAAACofRjhBAAAAAAAAAAAgEpxsjoAAAAAAAAAAAAA1G0knAAAAAAAAAAAAFApJJwAAAAAAAAAAABQKSScAAAAAAAAAAAAUCkknAAAAAAAAAAAAFApLlYHgOqXlZWlbdu2SZJCQ0Pl4sKfHQAAAAAAAACAhiovL0/x8fGSpC5dusjDw6PSfZJ5aAC2bdum6Ohoq8MAAAAAAAAAAAC1zNq1a9WrV69K98OUegAAAAAAAAAAAKgURjg1AKGhoY7ttWvXqnHjxhZGUzdkZmZq6dKlkqSBAwfK09PT4ogA63FeAEVxXgBFcV4ARXFeAMXj3ACK4rwAiuK8qB5xcXGOmdEK5hAqg4RTA1BwzabGjRurWbNmFkZTN2RmZiokJESS1KxZM97EAHFeAMXhvACK4rwAiuK8AIrHuQEUxXkBFMV5Uf0K5hAq1U+V9AIAAAAAAAAAAFBbnD4tXXSRuWzZMikoyJp4GgASTgAAAAAAAAAAoH7Jz5d27ixahmrjZHUAAAAAAAAAAAAAqNtIOAEAAAAAAAAAAKBSSDgBAAAAAAAAAACgUkg4AQAAAAAAAAAAoFJIOAEAAAAAAAAAAKBSSDgBAAAAAAAAAACgUkg4AQAAAAAAAAAAoFJIOAEAAAAAAAAAAKBSSDgBAAAAAAAAAACgUkg4AQAAAAAAAAAAoFJIOAEAAAAAAAAAAKBSSDgV44knnpDNZnPcFi9eXCX9zpw5U5dffrnCw8Pl4eGhyMhI3XbbbVq1alWV9A8AAAAAAAAAAGAFEk6FbN68WW+99VaV9pmZmalrrrlGo0aN0p9//qmTJ08qOztbMTExmjFjhgYMGKAXXnihSo8JAAAAAAAAAABQU1ysDqA2sdvtuuuuu5SXl6ewsDCdOnWqSvqdMGGCfvnlF0nSkCFD9NBDD6lJkybatm2bXn75ZR04cECTJk1S48aNddddd1XJMQEAAAAAAAAAaLA8PKT77itahmpDwqmA9957T+vWrVP79u01YsQI/fvf/650nwsXLtSsWbMkScOGDdPcuXPl7OwsSerVq5euvfZa9ezZUzExMXriiSd04403KjAwsNLHBQAAAAAAAACgwfL1lf7zH6ujaFCYUu+/YmJi9Oyzz0qSPv74Y7m5uVVJv2+88YYkycXFRR9++KEj2XROSEiIXn31VUlSUlKSPv/88yo5LgAAAAAAAAAAQE0h4fRf999/v9LS0jR27FgNGjSoSvpMTU3VggULJEmXXnqpmjVrVmy766+/Xn5+fpKkuXPnVsmxAQAAAAAAAAAAagoJJ0mzZ8/WvHnzFBQU5BiRVBXWrVunnJwcSSo1ieXm5qY+ffo49snNza2yGAAAAAAAAAAAAKpbg084JSUl6aGHHpIkvfrqqwoJCamyvnfu3OnYbt++faltz9Xn5eVp3759VRYDAAAAAAAAAABAdXOxOgCr/eMf/9CJEyfUv39/3XHHHVXad2xsrGO7pOn0zomIiHBsHz16VB07dqzQcYoTFxfn2M7MzFRmZmaZ+26osrKyit0GGjLOC6AozgugKM4LoCjOC6B4nBtAUZwXQFGcF9WjOvIEDTrhtGzZMn3++edycXHRxx9/LJvNVqX9p6amOrZ9fHxKbevt7e3YTktLK9dxCiarzmfp0qVVOoqrIVi6dKnVIQC1DucFUBTnBVAU5wVQFOcFUDzODaAozgugqPKcFy5paer973+bytb83/8p7zzX6huKhISEKu+zwSaccnJydNddd8kwDD3yyCPq3LlzlR+jYLbVzc2t1Lbu7u6ObUYgAQAAAAAAAABQcU75+QrZsaNIGapPg004vfzyy9q9e7eaN2+u559/vlqO4eHh4djOyckptW12drZj29PTs1zHOXr0aKn1cXFxio6OliQNHDjwvNP74Wyy8Fy2fODAgaa/JdBQcV4ARXFeAEVxXgBFcV4AxePcAIrivACKqvB5ER9fpGjw4MFSaGgVRld3nW+pnopokAmn3bt369//HUr3/vvvm6azq0q+vr6O7fNNk5eenu7YPt/0e4WVJ4Hk6elZ7oRWQ+fh4cFzBhTCeQEUxXkBFMV5ARTFeQEUj3MDKIrzAiiqXOdFMe08PT2LLW+IquP9pUEmnN5++23l5OSoZcuWysjI0KxZs4q02b59u2N74cKFOnHihCRp2LBhZU5QFUwExcbG6sILLyyxbcFRSuVZkwkAAAAAAAAAAMBqDTLhdG76uoMHD+rWW289b/sXX3zRsX3o0KEyJ5w6duzo2N69e3epbc/Vu7i4qE2bNmXqHwAAAAAAAAAAoDZwsjqA+qxXr15yc3OTJC1ZsqTEdjk5OVq9erVjH1dX1xqJDwAAAAAAAAAAoCo0yITT1KlTZRhGqbfnn3/e0X7RokWO8qioqDIfx9fXV5dccokk6a+//ipxEa45c+YoJSVFkjRixIiKPzAAAAAAAAAAAAALNMiEU1WZOnWqbDabbDabJk2aVGybxx57TJKUl5en+++/X/n5+ab6hIQEPfHEE5KkgIAATZw4sVpjBgAAAAAAAAAAqGoknKrZxRdfrFtuuUWS9NNPP+myyy7TTz/9pPXr12vKlCnq06ePYmJiJEmvvvqqAgMDrQwXAAAAAAAAAACg3FysDqAh+OKLL5SSkqJffvlFixYt0qJFi0z1Tk5OevbZZ3XXXXdZFCEAAAAAAAAAAEDFMcKpBnh6emr+/PmaMWOGLrvsMoWFhcnNzU0REREaNWqUli9fXuKUfAAAAAAAAAAAALUdI5xKMGnSpPMmgcaNG6dx48aVuc9Ro0Zp1KhRlQsMAAAAAAAAAACglmGEEwAAAAAAAAAAACqFhBMAAAAAAAAAAAAqhSn1AABAtTAMQ3HJWTqRkqX41GwlpGUrITVHqVm5ys23KyffUG6+XXa7IXdXZ3m6OsvLzVmebs4K8XFTIz8PNfb3VLifh/w8XWSz2ax+SAAAAAAAoK5wc5NuuKFoGaoNCScAAFBpadl52nI0SZuPJmnfyVQdiE/Xgfg0ZeTkV0n/vh4uahPmo7aNfNWmka/ah/uqa0SAfNz5KgMAAAAAAIrh7y99+63VUTQoXKUBAADllpadp+X74rVif6I2HDmj3SdSZDeq73ipWXnaGJOkjTFJjjInm9Qu3E89IwN0YWSQ+rUKVpifR/UFAQAAAAAAgBKRcAIAAGVyLClTf+44oQW7T2nNwdPKybdbGo/dkHbFpWhXXIqmr46RJHVq4qch7cI0pH2oukUEytmJafgAAAAAAABqAgknAABQorTsPP2yLU7fb4jVmkOnK9SHu4uTQnzcFeLjphAfdwV4ucnd1Uluzk5ydbbJyWZTVm6+MnLylZGbr/TsPJ1KydbJlCwlpueU61g7jqdox/EUfbBov0J83HRV58Ya1rWJLowMlBPJJwAAAAAAgGpDwgkAABSx+WiSvlx5WL9uP6HM3LKtw+TqbFOnJv7q0tRfrcN81DrMR61CfdTIz102W8WSPdl5+TqZnK0D8WnaezJVe0+e/Xf3iRTl5pc+h19CWo6+Wn1EX60+onA/Dw3r2lg394pQ6zDfCsUCAAAAAACAkpFwAgAAkqS8fLv+2HlSk5cf0oYjZ87b3sXJpt4tg9S/dYgujAzSBc385eHqXKUxubs4q3mwl5oHe2lI+zBHeVZuvrYdS9aGI2e0/vAZrTmYqNTsvBL7OZGSpc+WHdJnyw4pOipIt/aO0FWdG1d5vAAAAAAAAA0VCScAABq4nDy7vll/VJ8sOaDYM5mltvXzcNGlHRvp0g6NNKBNiPw8XGsoSjMPV2f1igpSr6ggaZCUm2/XhiNntHhPvBbvOaXdJ1JL3Hft4dNae/i0Jv20U7dER2h8vxYK9/eowegBAAAAAEC1S06WJk40l33+ueTvb008DQAJJwAAGqi8fLvmbDqmd//ap2NJJSeanJ1sGtw2VCN7NtMlHcLk7lL7RgW5OjupT8tg9WkZrCevaq/DCemat/W4ft4Spz0ni08+JWfm6pMlBzV52SEN69pEEy9qoU5N+NIJAAAAAEC9kJMjffeduezDD62JpYEg4QQAQANjGIbmb4vTW3/s1cGE9BLbhft5aGy/KN3Qs5lCfd1rMMLKiwrx1gMXt9EDF7fRnhOpmrMxVt9tiFViek6Rtnl2Q3M3HdPcTcc0sG2oHr60jXo0D7QgagAAAAAAgLqLhBMAAA3IrrgUTfpph9YcOl1im67N/DVhQAtd3aWxXJ2dajC66tEu3Ff/d3UHPXp5O/2166Rmro3Rsn0JxbZdujdeS/fGa1DbUD1E4gkAAAAAAKDMSDgBANAAJGfk6q0/9+ir1UdkN4pvc2FkoB69vJ36tAySzWar2QBrgJuLk67u0lhXd2msg/Fp+mLFIX27PlbZefYibZfsjdeSvfEa3C5UT1zZXh0a+1kQMQAAAAAAQN1BwgkAgHrs3PR5z/+4o9jp5CTpgmb+evTydhrYJqReJpqK0zLURy8N76K/X9ZO01cf0ZerDishrejzs3jP2cTTyB7N9PfL2qpJgKcF0QIAAAAAANR+JJwAAKin4lOz9dyP2/Xr9hPF1jcN8NTT13TQVZ3DG0yiqbAgbzf97ZI2uvOilpqx5og+XnJQCWnZpjaGIX23IVY/bzmuCQNa6P4hreXjzlcoAAAAAACAgrhaAgBAPWMYhn7eGqfnf9yuMxm5RerdXZx07+BWumdQK3m4OlsQYe3j6easiRe11OjekSUmnrLz7Ppo8QHN2Rirp67uoGu7NrEoWgAAAAAAgNqHhBMAAPVIalaunp67XT9tOV5s/WUdG+m5oR0VEeRVw5HVDecST6N6N9fnyw7pkyUHlJ6Tb2pzMiVbD83arJlrY/TUFa0tihQAAAAAAKB2IeEEAEA9sS02WQ/M3KgjiRlF6oK83fTP6zrpmi6NG+z0eeXh5eaiv13SRrdGN9d7C/bp67UxyrcbpjarD57W9Z+s00WNnHRlhN2iSAEAAAAAAGoHJ6sDAAAAlWMYhiYvP6TrP1pRbLLpmgsa689HBmroBU1INpVTqK+7XhzeWX88MlAD24YWqc+zG1oU56SXNztr0d4ECyIEAAAAAACoHUg4AQBQh6Vl5+me6Rv04rydys03j8Dx83DRf0b10H9G9VCwj7tFEdYPrUJ9NG18L318W081DfAsUp+cY9N9M7fqkW8260x6jgURAgAAAAAAWIuEEwAAddSRxHRd/+EK/b7jZJG6Hs0D9MtDF+maCxpbEFn9ZLPZdGXncP3190F6YEhruTkX/Ro1d9MxXfb2Ev2yLc6CCAEAAAAAAKxDwgkAgDpo+b4EXfvBCu09mVak7t7BrfTN3X3VLNDLgsjqP083Zz12RTv9/shA9WsZWKQ+IS1H983YqHu+2qD41GwLIgQAAAAAAKh5JJwAAKhDDMPQlBWHNHbKWiVn5prqArxcNW1CtJ64sr1cixl9g6rVIsRbn9/WTbe2ypens1Gk/rcdJ3TlO0u1YFfREWgAAAAAAAD1jYvVAQAAgLKx2w29OH+npqw4XKSuXSNffTbmQjUPZlRTTbLZbOoTZqhDQL4Wp4Vr4Z4EU31ieo7umLZeo3s31zPXdJSnm7NFkQIAAAAA0MC4ukqDBhUtQ7Uh4QQAQB2QlZuvR2dv0fxi1ga6olMjvXVTN3m787FuFX836YObu+ivfUma9NMOnU7PMdXPWBOjVQcT9e7N3dWlmb9FUQIAAAAA0IAEBEiLF1sdRYPCfDsAANRyyRm5GvPF2mKTTQ9d0kYfje5JsqkWsNlsurZrE/35yEBd1rFRkfqD8eka8eEK/WfRfuXbi07BBwAAAAAAUJeRcAIAoBY7kZylGz9ZqbWHTpvKXZ1teufmbnrksrZycrJZFB2KE+zjrk9v76l/X99Fnq7mKfTy7IZe/32Pxn6xVvGp2RZFCAAAAAAAUPVIOAEAUEvFnsnQTZ+s0t6TaaZyH3cXTRkXreHdm1oUGc7HZrPp1ujmmv+3AepazBR6y/cn6Or3lmnVgUQLogMAAAAAAKh6JJwAAKiFDiek66aPVynmdIapPMzXXd/c3UcD2oRYFBnKo2Woj767t58eGNJahQeixadma/Tnq/X+gn2yM8UeAAAAAACo40g4AQBQy+w7maqbPlml48lZpvKWId6ac18/dWpSdMQMai9XZyc9dkU7zbyzjxr5uZvq7Ib05p97NXbKWiWkMcUeAAAAAACou0g4AQBQi+yKS9Etn67WqULr+7QP99U3d/dVs0AviyJDZfVuGaz5f7tIFxUzOm3ZvgRd894ybYo5Y0FkAAAAAADUQ6mp0v33m2+pqVZHVa+RcAIAoJbYfypVt32+RonpOabyzk39NPPOPgr1dS9hT9QVIT7umjY+Wo9d3rbIFHsnU7J18yer9c26GGuCAwAAAACgPsnKkj780HzLyjr/fqgwEk4AANQChxPSNeqzosmmHs0DNGNiHwV6u1kUGaqak5NND1zcRl/f2UdhhZKIOfl2PfH9Nj3zwzbl5NktihAAAAAAAKD8SDgBAGCx2DMZGv35miLT6EVHBenLO3rL39PVoshQnfq0DNYvD12kvi2Di9RNXx2jUZ+t1qlUfnkFAAAAAADqBhJOAABY6ERylkZ/vkbHkjJN5T2aB+iL8b3k4+5iUWSoCSE+7vrqjmjdMaBFkbr1R85o2PvLtZF1nQAAAAAAQB1AwgkAAIskZeTo9slrdCQxw1TeuamfpoyPJtnUQLg4O+nZoR31zs3d5O5i/mp2MiVbt3yyWrPWsq4TAAAAAACo3Ug4AQBggazcfE2ctl77TqWZyts18tVXE5hGryEa3r2pvr+3n5oGeJrKc/LtenLONv3z553KtxsWRQcAAAAAAFA6Ek4AANSwvHy7Hpy5SeuPmKdKaxnirekTeyvQ282iyGC1zk399fODA9S/ddF1nb5YcUh3frleqVm5FkQGAAAAAABQOhJOAADUIMMw9NxPO/TnzpOm8nA/D301sbdCfd0tigy1RZC3m6aNj9ZdA1sWqVu4+5Ru+GiVjp7OKGZPAAAAAAAA65BwAgCgBr2/cL++XmNej8fXw0XTJkQXmUoNDZeLs5OeurqD3ryxq1ydbaa6PSdTNeLDFdpQaIQcAAAAAACAlUg4AQBQQ+ZuitVbf+41lbm5OOmzMReqXbivRVGhNhvZs5m+vrOPggpNs5iQlqNbP1utHzcfsygyAAAAAAAAMxJOAADUgPWHT+uJ77aZymw26d2bu6lPy6Lr9QDn9IoK0g/39VfrMB9TeU6eXQ/N2qy3/twrwzAsig4AAAAAAOAsEk4AAFSzo6czdPdXG5STbzeVTxrWSVd1aWxRVKhLmgd7ac59/XRRm5Aide8t2KdHv92inDx7MXsCAAAAAADUDBJOAABUo9SsXN0xbZ0S03NM5eP6RWlsvyhrgkKd5Ofhqinjemls38gidXM2HtOEqeuUkpVrQWQAAAAAAAAknAAAqDZ5+XY9OHOT9p5MM5UPahuqZ67pYFFUqMtcnJ30wnWd9c/rOsnJZq5bvj9BN328SieSs6wJDgAAAAAANGgknAAAqCav/b5Hi/fEm8raNvLR+6O6y8WZj2BU3Ji+Ufp87IXydHU2le8+kaoRH67QnhOpFkUGAAAAAEAt4ewsdexovjk7n38/VBhXuwAAqAbzth7Xp0sPmsqCvd00eWwv+Xm4WhQV6pOL2zfSN3f3UYiPm6k8LjlLN3y8UisPJFgUGQAAAAAAtUBQkLRjh/kWFGR1VPUaCScAAKrYnhOp+sd3W01lrs42fXJ7T0UEeVkUFeqjC5oFaM69/dUyxNtUnpqVp7FfrNWPm49ZFBkAAAAAAGhoSDgBAFCFkjNzdfdX65WRk28qn3RtJ10Yxa9oUPWaB3vp+3v7qWdkoKk8N9/QQ7M26+MlB2QYhkXRAQAAAACAhoKEEwAAVcRuN/TwrE06nJhhKr/5wgiNim5uUVRoCAK93TRjYm9d0alRkbpXft2tF37eKbudpBMAAAAAAKg+JJwAAKgi7y3cp0V74k1lXZv564XrOslms1kUFRoKD1dnfTi6p8b1iypSN3XlYT38zWbl5NlrPjAAAAAAANAgkHACAKAKrNyfoHcX7DOVBXu76aPbesrD1dmiqNDQODvZ9Pywjnr66g5F6n7aclwTv1yvjJw8CyIDAAAAAAD1nYvVAQAAUNedSs3S32ZtVsFlcpydbPpgVA81CfC0LjA0SDabTXcObKlG/h56dPZm5eb/74W5dG+8Rn22RlPG9VKgt5uFUQIAAAAAUM3S06XXXzeXPf645O1tTTwNAAknAAAqId9u6OFZm5WQlm0qf/yKdurbKtiiqADp2q5NFODpqnumb1BGTr6jfPPRJN34ySp9OSGahCgAAAAAoP7KyJBeeMFcdv/9JJyqEVPqAQBQCe8v3KeVBxJNZYPbhequi1paFBHwPwPbhmrGxN4K8HI1le8/laYbPlqp/afSLIoMAAAAAADUNyScAACooOLWbQr389BbN3WTk5PNoqgAs+7NA/XdPX3V2N/DVH48OUs3frxSm48mWRMYAAAAAACoV0g4AQBQAafTc/TQN0XXbXp/VHcFsTYOapnWYb76/t5+ahVqnjbgTEauRn22Wsv2xVsUGQAAAAAAqC9IOAEAUE6GYeiJ77cqPtW8btNjl7dTr6ggi6ICStckwFPf3tNPXSMCTOUZOfmaMHWd5m09bk1gAAAAAACgXiDhBABAOc1ce1R/7jxpKhvYNlR3D2TdJtRuQd5u+npib13UJsRUnptv6MGZmzR99RGLIgMAAAAAAHUdCScAAMrhQHyaXpy301QW7O2mN268gHWbUCd4u7to8theGnpBY1O5YUjP/LBdHy0+YFFkAAAAAACgLiPhBABAGeXk2fXwrM3KzM03lb92wwUK8/WwKCqg/NxcnPTuLd01pm9kkbpXf9ut137bLaPgAmUAAAAAAADnQcIJAIAyevuvvdp2LNlUdnufSF3SoZFFEQEV5+xk0wvXdtJDl7QpUvfh4gN6/qcdsttJOgEAAAAAgLIh4QQAQBmsP3xaHy8xTzXWOsxHT13dwaKIgMqz2Wx65LK2euaaoq/jL1cd0aPfblFevt2CyAAAAAAAQF1DwgkAgPPIzMnXY99uUcEZxlydbXr3lm7ydHO2LjCgiky8qKVeHdlFhZchm7vpmO6dsVFZhaaRBAAAAAAAKIyEEwAA5/Ha77t1ODHDVPbY5e3UqYm/RREBVe/mXs31/q095Opszjr9ufOk7pi2TunZeRZFBgAAAAAA6gISTgAAlGL1wURNWXHYVNajeYAmXtTSmoCAanTNBY316ZgL5e5i/oq4Yn+ibp+8RskZuRZFBgAAAAAAajsSTgAAlCAjJ0//+G6rqczdxUlv3NhVzoXnHgPqiSHtwvTlhGj5uLuYyjfGJOmWz1YrPjXbosgAAAAAAEBtRsIJAIASvPrrbsWcNk+l9/gV7dQy1MeiiICa0btlsL6+s7cCvVxN5bviUnTzJ6t0LCnTosgAAAAAACgjm00KCTHfbPyAuDqRcAIAoBgrDyRo2qojprJeUYEa37+FRREBNeuCZgGafXdfhfm6m8oPJqTrxo9W6mB8mkWRAQAAAABQBiEhUny8+RYSYnVU9RoJJwAACknLLjqVnoerk16/gan00LC0aeSr7+7pp4ggT1P58eQs3fTJKu2KS7EoMgAAAAAAUNuQcAIAoJBXft2l2DPmKcOeuLK9okK8LYoIsE7zYC99e3c/tQkzTyWZkJajmz9ZpY0xZyyKDAAAAAAA1CYknAAAKGD94dOavjrGVBbdIkhj+0ZZExBQC4T7e+ibu/vqgmb+pvKUrDzd9vkaLd+XYFFkAAAAAACgtiDhBADAf+Xk2fV/c7aZyjxdnfXGDV3lxFR6aOCCvN00Y2JvRbcIMpVn5ORrwtR1+mPHCYsiAwAAAAAAtQEJJwAA/uuTJQe071SaqezRy9uqebCXRREBtYuvh6u+nBCtIe1CTeU5+XbdO2Oj5myMtSgyAAAAAABgNRerAwAAoDY4GJ+m9xftN5V1buqncf2irAkIqKU8XJ31ye0X6pHZmzV/a5yjPN9u6O+ztyg9O0+3MwUlAAAAAMBqmZnSF1+YyyZMkDw9rYmnASDhBABo8AzD0FNztyknz+4oc7JJr1x/gVycGQwMFObm4qT3bukuX3cXzVp31FT37I87lJKVp/sGt5LNxlSUAAAAAACLpKVJDzxgLrvpJhJO1YiraACABu/bDbFaffC0qWxC/xbq3NTfooiA2s/ZyaZ/X99Fd17Uokjd67/v0Su/7ZZhGBZEBgAAAAAArEDCCQDQoCWkZevlX3aZypoGeOqRy9paFBFQd9hsNj11dQc9Wsz58smSg3r6h+3Kt5N0AgAAAACgISDhBABo0F6at1NJGbnmsuGd5e3OrLNAWdhsNj14SRs9P6xjkbqv18TokW82KzffXsyeAAAAAACgPiHhBABosJbti9cPm4+byoZe0FhD2odZFBFQd43v30Jv3NhVToWWbfppy3Hd89UGZeXmWxMYAAAAAACoESScAAANUnZevp7/cYepzM/DRc8VM0oDQNnc0LOZPhzdQ67O5qzTgt2nNG7KWqVl51kUGQAAAAAAqG4knAAADdIXyw/rYEK6qezJqzoozNfDooiA+uHKzo01eWwvebo6m8pXHzyt0Z+t1pn0HIsiAwAAAAAA1YmEEwCgwYlLztT7C/eZyrpGBOiWXhEWRQTULwPbhuqrO6Ll62FeC21LbLJu/nSVTqVkWRQZAAAAAACoLiScAAANzkvzdykj53/rydhs0ovXdZJT4cVnAFTYhVFBmnVXHwV7u5nK955M0w0fr9LR0xkWRQYAAAAAAKoDCScAQIOyYn+C5m+NM5Xd0qu5LmgWYE1AQD3WqYm/Zt/TV038zVNVxpzO0A0fr9S+k6kWRQYAAAAAAKoaCScAQIORk2fX8z/tMJUFeLnqH1e0sygioP5rFeqjb+/tpxYh3qbykynZuumTVdoWm2xRZAAAAAAAoCqRcAIANBjTVh7W/lNpprLHLm+nwEJTfgGoWk0DPDX77r5qH+5rKj+TkatbP1utNQcTLYoMAAAAAABUFRJOAIAG4WRKlt75a6+prHNTP90a3dyiiICGJdTXXd/c1VfdmweYytOy8zTmi7VatOeUNYEBAAAAAIAqQcIJANAgvPzLLqXn5JvK/nldZzk72SyKCGh4/L1cNf2O3urfOthUnp1n153T1mve1uMWRQYAAAAAACqLhBMAoN5bf/i0ftxsvpB904XN1KN5oEURAQ2Xt7uLJo/tpcs7NjKV59kNPThzk75afcSiyAAAAAAAQGWQcAIA1Gt2u6EX5+00lfl5uOgfV7a3KCIAHq7O+nB0D13fvamp3DCkZ3/Yrrf/3CvDMCyKDgAAAABQL4SGnv2PZsFbaKjVUdVrJJwAAPXaj1uOaUtssqns4UvbKsTH3aKIAEiSi7OT3rixq8b2jSxS9+6CfXrmh+3Kt5N0AgAAAACgriDhBACotzJz8vXab3tMZS1DvHV7MRe4AdQ8JyebJl3bSQ9f2qZI3Yw1MXrg643Kys0vZk8AAAAAAFDbkHACANRbny49qLjkLFPZU1d3kKszH39AbWGz2fTwpW310vDOstnMdb9uP6FxU9YqJSvXmuAAAAAAAECZccUNAFAvnUjO0sdLDpjK+rcO1iUdwiyKCEBpbusTqf+M6iG3Qgnh1QdP65ZPVutUalYJewIAAAAAgNqAhBMAoF56/fc9yiwwFZeTTXrmmo6yFR5CAaDWuLpLY02d0Es+7i6m8p1xKbrho1U6kphuUWQAAAAAAOB8SDgBAOqdbbHJ+n5jrKns5l4R6tDYz6KIAJRVv1YhmnVXH4X4uJnKY05naORHq7T9WLJFkQEAAAAA6pTsbOnbb8237Gyro6rXSDgBAOoVwzD04rydpjIfdxf9/bJ2FkUEoLw6N/XXd/f0U/MgL1N5Qlq2bvl0tVbuT7AoMgAAAABAnZGSIt10k/mWkmJ1VPUaCScAQL3y2/YTWnv4tKnsviGtFOrrblFEACoiKsRb393bVx0LjUxMy87T2Clr9ePmYxZFBgAAAAAAikPCCQBQb+Tm2/XKb7tNZc0CPTWhfwuLIgJQGWG+Hpp1dx/1aRlkKs/NN/TQrM36z6L9MgzDougAAAAAAEBBJJwAAPXGrLUxOpKYYSp78qr28nB1tigiAJXl5+GqqeOjdWWn8CJ1r/++R0/N3a68fLsFkQEAAAAAgIIaZMIpJSVFs2bN0qOPPqpBgwapdevW8vf3l5ubm8LCwjR48GC99tprSkxMrNRxpk6dKpvNVqbb1KlTq+bBAUADlZadp3cX7DOVdYsI0DVdGlsUEYCq4uHqrP+M7qFx/aKK1M1cG6M7v1yv9Oy8mg8MAAAAAAA4uFgdgBXWrl2rW2+9tdi6+Ph4LVmyREuWLNHrr7+u6dOn64orrqjhCAEA5fX5soNKSMsxlT15VXvZbDaLIgJQlZydbJp0bSc1C/TUv37ZpYIz6S3aE6+bP12lL8b1Upivh3VBAgAAAADQgDXIhJMkRUREaMiQIerZs6ciIiLUuHFj2e12xcbG6rvvvtOcOXOUkJCga6+9VmvXrlXXrl0rdbzff/9dTZo0KbG+WbNmleofABqy+NRsfbb0oKns4vZh6tMy2KKIAFSXiRe1VJMATz38zWbl5P1vKr3tx1I04j8rNW1CL7UO87UwQgAAAAAAGqYGmXAaMmSIYmJiSqy/6aab9MMPP2jEiBHKycnRCy+8oDlz5lTqmG3btlVUVFSl+gAAFO+DhfuUnpPvuG+zSU9c2d7CiABUp6u7NFaYr7smfrleSRm5jvJjSZm6/sOV+mzMhepNwhkAAAAAgBrVINdwcnY+/+Lxw4cPV7t27SRJy5Ytq+6QAAAVdCQxXTPWmH9EMLJHM7ULZ4QDUJ9dGBWkOff2U/MgL1N5Slaebp+8VnM2xloUGQAAAAAADVODTDiVla/v2YuVWVlZFkcCACjJ67/vUZ79f4u5uLk46ZHL2loYEYCa0jLUR3Pu66euEQGm8px8u/4+e4te+2237AXeHwAAAAAAQPUh4VSCPXv2aPPmzZKk9u2ZlgkAaqOtsUmatzXOVDauX5SaBnhaFBGAmhbi465Zd/bRZR0bFan7cPEB3TtjgzJy8iyIDAAAAACAhoWEUwEZGRnat2+f3nrrLQ0aNEh5eWcvTjz88MOV7nv8+PFq0qSJ3NzcFBISoj59+uiZZ57RsWPHKt03ADREhmHolV93m8r8PFx03+BWFkUEwCqebs76+LaemtC/RZG633ec1I0fr1JccqYFkQEAAAAA0HC4WB2A1aZOnarx48eXWP/kk09q1KhRlT7O4sWLHduJiYlKTEzUmjVr9Oabb+qdd97R3XffXeG+Y2NLX6MgLu5/v/7PzMxUZiYXXM6n4DSKTKkInFXbzosVBxK18kCiqezOAZFyt+XzPocaU9vOi4bu8UtbqHmAm176da9pqs0dx1N07fvL9Z9bLlCXpn4WRtgwcF4ARXFeAMXj3ACK4rwAiqrweZGZqcJz4GRmZkpcN5Kkarl+ZjMMo0FPbF9Swqlbt2769NNP1atXr0r1/eKLL+r6669X3759FRERIUk6ePCgvv/+e3333Xc69/R/8sknuuuuuyp0HJvNVua2n3/+uUJCQip0HACoLQxDemubs2LS//f+5+9m6Jlu+XJztjAwALXCnmSbpuxxUma++TuSq83Q6DZ2dQ9u0F9/AQAAAKBBcEtO1lVjx5rKfp02TTn+/hZFVLskJCRo4sSJkqSjR4+qWbNmle6zwSeckpKSHCOEMjMzdeDAAc2ePVtz585Vq1at9M4772jo0KEV6js5OVl+fn4lJoTmzZun66+/Xrm5ufLy8tKBAwcUHh5e7uOQcALQ0Gw7bdPne8yZpVta5qtvowb9kQaggJOZ0me7nRWfVfR70uVN7boqwi6nsn+FAgAAAADUMSScSkfCqQZ99dVXGjt2rGw2myZPnqxx48ZVy3FeeuklPfvss47tp59+utx9lGVKvejoaEnS3r17q+SFU99lZWVp6dKlkqSBAwfKw8PD4ogA69WW88JuGBrx8VrtPZXuKGse5Kn59/eWixNLE6Jm1ZbzAsVLyszVw7O3ac3hpCJ1A9sE6/XrO8rPw7XmA6vnOC+AojgvgOJxbgBFcV4ARVX4vLDbpUTzcgwKDpa4fiTpbF6hbdu2kqou4dTg13Aqye2336558+Zp9uzZeuCBB3TttdcqKCioyo9z11136bnnnpNhGFqyZEmFEk7leSF4enrK07PwzJUojYeHB88ZUIiV58XPW46bkk2S9Ojl7eTr7W1JPMA5fF7UPp6enpp+Z1899+N2zVx71FS3dF+ibpm8UZ/e3lNtGvlaFGH9x3kBFMV5ARSPcwMoivMCKKrc5wXXi0pUHe8vpPJKcd1110mS0tPT9dtvv1XLMcLCwhQcHCxJOnbsWLUcAwDqi7x8u97+a6+prG0jHw29oIlFEQGo7VydnfTyiC6aNKyjnAvNoXcoIV3D/7NCv+84YVF0AAAAAADUHyScShEaGurYPnLkSLUdpzxrMAFAQ/bD5uM6GG8e3fT3y9oVuYgMAAXZbDaN699CMyb2VrC3m6kuPSdfd3+1QW/9sUd2OzNNAwAAAABQUSScSlFwxJGPj0+1HCM+Pl4JCQmSpCZN+IU+AJQkJ8+udwqNburc1E9XdGpkUUQA6po+LYP104MD1KVp0QVi31u4XxO/XK/kjFwLIgMAAAAAoO4j4VSKb7/91rHdpUuXajnGp59+KsM4+2vaQYMGVcsxAKA+mL3+qGLPZJrKHr28HaNEAZRL0wBPfXtPX13fo2mRuoW7T+ma95dpy9Gkmg8MAAAAAIA6rkEmnKZOnaqsrKxS27z99tv65ZdfJEktWrTQRRddZKpfvHixbDbb2Slaxo0rsv/hw4e1adOmUo8xb948/fOf/5R0doGu8ePHl+NRAEDDkZWbr/cX7jOV9YwM1OC2oSXsAQAl83B11ps3dtXzxazrFHsmUzd8vFLTVh52/CgIAAAAAFAH5eRIixebbzk51sZUz7lYHYAVJk2apEcffVQjR47UgAED1KpVK/n4+Cg1NVXbtm3TjBkztGLFCkmSm5ubPv30Uzk7O5frGIcPH9aQIUPUt29fDRs2TF27dlVYWJgk6eDBg/ruu+/03XffOS5kvPHGG2ratOgvbQEA0ow1MTqZkm0qe/TytoxuAlBhNptN4/u3UIfGfrp/xkYlpv/vPx25+Yae/2mH1h46rVdGdpGvh6uFkQIAAAAAKiQ5WRoyxFx26pQUyg+Yq0uDTDhJ0unTp/XZZ5/ps88+K7FNs2bN9MUXX+jSSy+t8HFWrVqlVatWlVjv5eWlt99+W3fddVeFjwEA9VlGTp4+WrzfVNa/dbD6tQqxKCIA9UmflsGa97cB+tvMTVp3+Iypbv62OO04nqz/jO6hTk2KrvsEAAAAAAD+p0EmnH7//XfNnz9fK1as0P79+3Xy5EklJibK09NTYWFh6tatm4YOHaqbbrpJXl5eFTpGz549NX36dK1atUrr169XXFycEhISlJeXp8DAQHXq1EmXXHKJJk6c6Bj5BAAoasbqGCWkmYc7//2ydhZFA6A+auzvqa/v7KM3/tijT5YcNNUdTszQiA9XatKwTro1OoKRlQAAAAAAlKBBJpzatWundu3a6e9//3uF+xg8eHCp8/r7+vpq9OjRGj16dIWPAQANXWZOvj5ZesBUNrhdqHpGBloUEYD6ytXZSf93VQdFRwXp77O3KDkz11GXk2fXU3O3acX+BL08oov8vZhiDwAAAACAwpysDgAAgJLMWHOkyOimhy5pY1E0ABqCSzo00vy/DVDXiIAidfO3xenKd5dq1YHEmg8MAAAAAIBajoQTAKBWysrN1ydLzVNbDWwbqu7NGd0EoHo1C/TSt3f31YT+LYrUxSVnadTnq/Xqb7uVk2e3IDoAAAAAAGonEk4AgFrp6zUxik/NNpUxuglATXFzcdJzwzrqk9t7KqDQFHqGIX20+IBu+HilDsanWRQhAAAAAAC1CwknAECtk5Wbr4+XmNduuqhNCGs3AahxV3QK128PDVT/1sFF6rbGJuvq95Zp6opDsttLXtsTAAAAAICGgIQTAKDW+WbdUZ1idBOAWiLc30NfTeitp65uL1dnm6kuK9euST/v1K2frVZMYoZFEQIAAAAAYD0STgCAWiU7L18fLTaPburXKlgXRgVZFBEASE5ONt01sJXm3tdfLUO9i9SvOXRaV767VF+tPsJoJwAAAABAg+RidQAAABQ0e91RnUjJMpUxuglAbdG5qb/mP3iR/v3rLn256oipLiMnX8/+sF2/bovTqyMvUESQl0VRAnWPYRjKzM1XWlaeUrLylJWbrzy7oXy7XXn5hvLthvLshpydbHJ1dpKbi5NcnW1yd3GSm7Oz/D1d5evhIicn2/kPBgAAAKBakHACANQa2Xn5+rDQ6KY+LYPUu2XRtVMAwCqebs7653WddWXncP3ju62KPZNpql95IFGXvb1ED1/aVncMaCFXZyYVQMNkGIZSMvN09EyGYs9k6lRqlhJSsxWflq341LO3hLQcpWXnKS07T/mVHB1os0l+Hq4K8HKVv6ergrzd1NjfU00DPNTY31NNAjzVJMBDTQI8OS8BAACAakDCCQBQa3y7PlZxyYVHN7W1KBoAKF2/ViH67eGB+vcvuzRjTYypLivXrld+3a0fNh3TKyMvULeIAGuCBGpAUkaO9p9Kc9wOJ2Yo9kyGjp3JVGp2Xo3FYRhScmaukjNzS23n4mRTixBvtQ7zUZswH7UK81GbMF+1aeRDIgoAAACoBBJOAIBaITffro+XmEc3RbcIUt9WjG4CUHv5uLvoXyO66MrO4Xriu606XihpvvtEqkZ8uEJj+kTqsSvaydfD1aJIgcrLyMnTrrhU7TyerD0nU/+bYEpXQlq21aGVS57d0L5Tadp3Kk2/Fih3d3FS56b+6tosQF0j/NUtIkDNg7xkszFNHwAAAFAWJJwAALXCz1uOF5mWirWbANQVF7UJ1e+PDNTrv+/RV6uPyCgwM5hhSNNWHdFvO07oqas76NquTbiAjVovOTNXO44la8fxFG0/fvbfg/FpquSsd2Xm4mSTi7NNLk5O//3XJiebTXbDUE6eXbn5hnLy7ZWehq+g7Dy7Nhw5ow1HzjjKgrzd1LdlsPq1Dla/ViGKCiYBBQAAAJSEhBMAwHJ2u1Fk7abuzQPUj9FNAOoQXw9X/fO6zhrevamemrNNu0+kmupPpmTroVmb9dWqI5p0bSd1bupvUaSAmd1u6EB8mjYcOaONMWe0MSZJ+0+lVVn/Tjapsb+nwv09FOrjrlDfs7cQH3eF+LjJ39NVPh4u8nU/+6+Pu4vcXMo2tV2+3VBWbr5jKr2kjFwlZ+YoKSNXp1KzFZecqeNJWTqelKnjSZlKz8kvV+yn03M0f1uc5m+LkyQ1DfBU31bBGtQ2VIPbhTJqEQAAoDYLDJS2by9ahmpDwgkAYLk/dp4scmHr/sGt+QUxgDqpR/NA/fzgAH2+7JDeXbBXWbl2U/36I2c07IPluqVXhB67vJ2CfdwtihQNVXp2njbGnPlvgilJm2POKCWrcmstuTrbFBV8dl2kVqE+ah7kpWaBnmoW6KXGAR7VtjaSs5NN3u4u8nZ3UZMAz1LbGoah5MxcHYhP076TZ9eb2vffdaeOJWWWuu85x5Iy9d2GWH23IVauzjb1axWiyzs10mUdGinMz6MqHhIAAACqiouL1KmT1VE0KCScAACWMgxDHy7ebyprH+6ri9uHWRQRAFSeq7OT7h3cStd0aaxnftyupXvjTfWGIc1ce1Tztsbpbxe30e19I+Xh6mxRtKjvcvPt2nI0SSv2J2rF/gRtOnpGufkVm4rOySa1DvNRx8Z+atPIV63DfNQ67GyCqbqSSlXFZrMpwMtNPSOD1DMyyFR3Jj1HW48la8vRJG05mqTNR5OUmJ5Tan+5+YaW7I3Xkr3xenrudnVvHqChFzTRtV2bKNSXRDIAAAAaHhJOAABLLd+foK2xyaayewe3kpMTo5sA1H3Ng700bXwv/bnzpF6av0sxpzNM9alZefrXL7s0deVhPXJZW43o3lTOvP+hkgzD0N6TaVqxP0Er9ido9cHEck8lJ0luzk5q39hXnZr4qVMTf3Vq4qf24X7ydKt/ydFAbzcNahuqQW1DJZ19Do+eztSqgwlasT9RKw8kKiEtu9Q+NsUkaVNMkl7+ZZcuahOiEd2b6vKO4fXy+QIAAACKQ8IJAGCpDxaaRzdFBnvpmi6NLYoGAKqezWbT5Z3CNbBtqCYvP6T/LNqvjEIX/48lZeqxb7fos6UH9Y8r2+ni9mFMK4pyOZaUqRX7E7Ryf4JWHEhUfGrpyZHiNPH3UPfIQPVoHqiekYHq2NivzGsp1Tc2m03Ng73UPLi5bu7VXIZhaN+ps0m8xXvitfJAQomjxPLthhbvidfiPfHycXfRVZ3DNbJbIxmGxGkNAACA+oyEEwDAMusPn9aaQ6dNZfcMaiWXWj4lDwBUhIers+4f0lojezTTK7/u0g+bjxdps+dkqu6Ytl69ogL1yKVt1bdVMIknFCs5I1erDiZo+f6zI3AOJaSXa38XJ5s6N/VXz/8mmHpEBqixf+lrIDVkNptNbRv5qm0jX43v30KpWblavCdef+w8qUW7Tyktu/g1sNKy8/Tthlh9uyFWEd7OGhBu10W5+fLkqQYAAEA9RMIJAGCZDxcfMN0P9/PQ9T2aWhQNANSMcH8PvXNLd43tF6VXft1dJPEuSesOn9Goz9eoZ2SgHry4tQa1DSXx1MBl5eZr/eEzWnHg7DR5244lyyjnMkztw33Vv3WI+rcOVnSLYPm489/BivL1cNWwrk00rGsTZefla+WBRP20+bh+235CmbnFT194NN2mmQec9ctbK3TjhRG6vW+kIoO9azhyAACABiQvT9qzx1zWrp3kwvfg6sIzCwCwxI7jyVq4+5Sp7M6BLeXuwjoHABqG7s0DNeuuPlq8N16v/bZHu+JSirTZcOSMxk1Zpwua+evBi9vo0g5MtddQ5NsNbT+WrOX7E7TyQILWHT6jnDx7ufpoGuCp/q2D1b91iPq1ClGor3s1Rduwubs4a0i7MA1pF6aXhufp9x0nNGfjMa04kFBsUjA5K0+fLz+kL1Yc0lWdG+ueQa3UpZl/zQcOAABQ3505I3XubC47dUoKDbUmngaAhBMAwBIfFRrdFOjlqlujIyyKBgCsYbPZNKRdmAa1CdVPW47rjT/2KPZMZpF2W2OTdeeX69Wuka/uGNBC13ZrIg9XEvT1iWEYOpSQrhX7z06Tt+pAolKyip+mrSQBXq7q1ypY/VqFaEDrEEUGe5GgrGHe7i66vkczXd+jmU4kZ+n7jbH6ek2MjiUVPa/thjR/W5zmb4vTRW1CdM+gVurHNJoAAACow0g4AQBq3KGEdP2yLc5UNqF/C3m58bEEoGFycrJpePemuqpLuL7bEKsPFx0o9gL1npOp+sf3W/Xqb7s1uk+kbu8TyaiVOuxUapZW7k/87zpMCYpLzirX/u4uTopuEXR2mrxWIerYxE/OTiQraotwfw/dP6S17hnUSr9vjdV7v27W7uTi16lcti9By/YlMJoRAAAAdRpX9gAANe6zZQdlLzDFjI+7i8b0jbIsHgCoLdxdnDW6d6RuujBCczcd04eL9utwYkaRdonpOXpvwT59vPiAhnVtotv7RqprM38uUNdyqVm5WnPwtGMdpr0n08q1v5NN6tIsQAP+O01ej+aBjHSrA5ydbBrSLkS5R+yKz7Qr1qOFvtsUp7TsoiPYzo1m7BoRoMcub6sBrUM4rwEAAFBnkHACANSo+NRsfbch1lQ2uk9z+Xu5WhQRANQ+rs5OuunCCF3fvanmbY3TB4v2a/+posmJnHy7vt8Yq+83xqp9uK9u7hWhEd2bKsDLzYKoUVhWbr42HjmjlQcStfJAgrbEJivfXsyiPqVoFep9dgRT6xD1aRksf08+L+uyUE9p9OVt9MgVHTR99RFNWXFICWk5RdptOZqk2yevVXSLID1+RTv1igqyIFoAAACgfEg4AQBq1JerDpsWPXd1tmlC/xYWRgQAtZeLs5OGd2+qa7s20eK9pzR5+SGt2J9YbNvdJ1L1ws879e9fd+vKTuG6uVeE+rQMZoq1GpSTZ9fW2CRHgmljTJLpM68swnzdNaB1iPq1DlH/1sFq7O9ZTdHCSv6errp/SGvdMaCFvtsQq0+XHlTM6aKjGdceOq0bP16lQW1D9X9Xt1f7cD8LogUAAADKhoQTAKDGpGfn6ctVR0xlI7o3VSM/D4siAoC6wcnJpovbN9LF7Rtp94kUfbH8kH7YfLzYZEZOnl0/bTmun7YcV6ivu67uHK6hXZuoZ/NAOZF8qlI5eXZtP56stYdOa+WBRK07dFqZufnl6sPX3UW9WwZrQOtgDWgTolahPkyh1oB4uDrrtj6RuqVXhOZtjdM7f+0tdhrNJXvjtWxfvG6Jbq6/X9ZWIT6s3QYAAIDah4QTAKDGzF5/VMmZuaayuwa2tCgaAKib2of76bUbuuofV7bXzDUx+mb9UcWeySy2bXxqtqatOqJpq46osb+Hru7SWFd2Dlf3iAC5ODvVcOR1X3JmrjbGnNH6w6e1/vAZbT6apOxyjmByc3ZSj8gA9W8Vov5tQnRBU3/+FnCMZrzmgsb6fkOs3luwT8eTs0xt7Ib09ZoY/bz5uB68pLXG9ouSuwtreAEAAKD2IOEEAKgRefl2fb7skKnskvZhah3ma1FEAFC3hfi468FL2uj+Ia218kCiZq2L0R87Tionv/gESFxyliYvP6TJyw/J39NVA9uGaki7UA1qG6pgRksUYbcbOpyYrq2xyVp/5GyCac/JVBnlW4JJTjapS7MA9W0ZrL6tgtUrKlBebvw3DMVzdXbSLdHNNaJHU81cE6MPFh1QQlq2qU1qdp5e/mW3ZqyJ0VNXd9DlHRsxKg4AAAC1Av/TAQDUiPnb4nQsyfwL/LsHtbIoGgCoP5ycbBrQJkQD2oTodHqO5m46pu83xGpnXEqJ+yRn5urnLcf185bjstmkC/6bEIluEaiekUHy93StwUdgPcMwdDw5S1uPJmlLbLK2xiZp27FkpWblVai/Do391K9V8NnntGWQ/Dwa1vOJynN3cda4/i10U68Ifbr0oD5eckBZueZk8pHEDN391QZd0j5Mk67tpIggL4uiBQAAAM4i4QQAqHaGYejTpQdNZd0iAtQrKtCiiACgfgrydtMdA1rojgEtdDA+TfO2xmne1uPaezKtxH0MQ9pyNElbjibp4yWSzSZ1CPdTdIsg9YgMVKcmfmoR7F1v1n9Kz87TvlNp2nMiRbtPpGrPf2+J6TkV7rNNmI/6/HcEU5+WwQrydqvCiNGQebm56OFL2+rmXhF67bc9mrvpWJE2C3af0soDiXro0ja6Y0ALuTJFIwAAACxCwgkAUO1W7E/UjuPmX9rfM6gl078AQDVqGeqjv13SRn+7pI32nkzVvC3H9cfOk9p9IrXU/QxD2hmXop1xKZq68rAkydvNWR0a+6lTEz91auKvVmE+ahHirUAv11r5Xp6Xb1dccpYOJ6brcGKGjiSk63BiuvaeTFPM6YxK9e3m4qSuzfx1YVSQekUFqkfzQAV4kWBC9Wrs76m3b+6msf2i9M+fd2hjTJKpPjM3X6/8ultzNx7Tv0Z01oVRQdYECgAAgAaNhBMAoNp9svSA6X5UsJcu6xhuUTQA0PC0beSrv1/eTn+/vJ3ikjO1aHe8Fu05pRX7E5SRk3/e/dNz8rX+yBmtP3LGVO7n4aIWId6KCvFW8yAvhfl5KMDdpsOpkr+blJNvl2cVPg7DMJSWnafkzFydTs/RyZRsnUjJ0qmULJ1MydKJlGwdPZ2ho6czlGcv52JLJQj1dTclmDo39Ze7i3OV9A2UV7eIAH1/bz/9uPm4Xpq/q8j6TntOpuqGj1dpVO/meurqDvJx57/8AAAAqDl8+wQAVKudx1O0bF+CqWziRS3lXE+mZgKAuqaxv6dG9W6uUb2bKzsvX+sOndGaQ4lac+i0Nh9NUk6e/fyd/FdKVp62xCZrS2xyoZqz/82YtHGxfNxdzt48XOTt7iJfdxd5uTnL2ckmJyebnG22s9s2m+yGoZw8u7Lz8pWdZ1dOnl1ZeXalZuYqKTNXyZm5yq+iRFJx/DxcdEGzAF3QzF8XNAtQ1wh/hft51MpRXGi4bDabhndvqiHtw/T677s1Y02MjEKnxddrYrRkT7xeu+EC9W8dYk2gAAAAaHBIOAEAqtWnhUY3BXu76YaezSyKBgBQkLuLswa0CdGANmcvSGfl5mtrbLLWHT6tdYdPa8fxFMWnZp+nl9KlZecpLTtPSjl/25riZJOiQrzVrpGv2oX7qn24r9qH+yky2IvkEuoMf09XvTS8i0b2aKan527XzjjzSXYsKVOjP1+j0b2b6/8Y7QQAAIAawDdOAEC1iT2ToZ+3xpnKxvaLkocrUxEBQG3k4eqs6BZBim7xv/VfTqVkacfxFO04nqwdx1O052Sqjp7OUG5+9Y00qiq+7i6KCvFWZLCXIoO91CLER+3DfdU6zIfPItQb3ZsH6qcH+mvqysN684+9ysw1T5M5Y02MluyN12sjL1A/RjsBAICGxN9fWrSoaBmqDQknAEC1+WL5YdPUR56uzrq9T6SFEQEAyivMz0Nhfh4a0j7MUZaXb9fxpCwdTEjT4YR0HU7MUFxypk6lZutEcqZOpWQp36jekUIuTjaF+borzM9DjfzcFf7fOJsEeCgy2FtRwd4K9HJlxBIaBBdnJ028qKUu7xiux7/bojWHTpvqY89katTnazShfwv948p2JFwBAEDD4OYmDR5sdRQNCgknAEC1SM7I1ax1Maaym3tFKNDbzaKIAABVxcXZSc2DvdQ82EtqZ67LzMzU77//oYw8qVOvfsqTs1Kzzk6rl/bff9Oz82U3DNkNQ/l2Q/mGIbvdkJOTTe4uznJ3cZK7i5Pc/vuvr4er/D0L3Lxc5ePmIifWAwRMmgd7aeadffTV6iN65dfdRUY7fbHikFYeSND7t3ZXm0a+FkUJAACA+oqEEwCgWsxYe0QZOf+7yOFkk+4Y0MLCiAAANcVmk7xdpbZhPvL09LQ6HKBBcXKyaWy/KA1uF6rHv9uqtYVGO+0+kaqh7y/XM0M76rbezRkFCAAAgCrjZHUAAID6Jzffri9XHjGVXd2lsSKCvCyKCAAAoGGJDPbWrDv76PlhHeXmYv6vf3aeXc/+sF13frlBiWnZFkUIAACA+oaEEwCgyv2yLU4nUrJMZXde1NKiaAAAABomJyebxvdvoZ8fGKB2xUyh99euk7rq3WVaczDRgugAAABQ35BwAgBUKcMw9MXyQ6ayCyMD1TUiwJqAAAAAGrh24b768YH+GtcvqkjdqdRsjfp8jT5afEB2u1HzwQEAAFQXu12Kjzff7Haro6rXSDgBAKrUhiNntCU22VTG2k0AAADW8nB11qRrO2nKuF4K8XEz1eXbDb36227d+eV6JWXkWBQhAABAFUtMlMLCzLdERnZXJxJOAIAqNbnQ6KamAZ66rGMji6IBAABAQUPah+nXhwbqojYhReoW7D6la95bri1Hk2o+MAAAANR5JJwAAFXm6OkM/b7jhKlsfP8ouTjzcQMAAFBbhPq6a+r4aD1yaVvZbOa6Y0mZuvHjVZq++ogMgyn2AAAAUHZcAQQAVJmpKw+r4NT/3m7OuqlXhHUBAQAAoFjOTjY9dGkbTb+jd5Ep9nLy7Xrmh+16au42ZeflWxQhAAAA6hoSTgCAKpGalatv1h01ld3UK0J+Hq4WRQQAAIDz6d86RPP/dpGio4KK1M1ce1S3frpap1KyLIgMAAAAdQ0JJwBAlZi9PlZp2XmO+zabNL5fCwsjAgAAQFk08vPQ13f21t2DWhap2xiTpKHvL9fGmDMWRAYAAIC6hIQTAKDS8u2Gpq48ZCq7vGMjNQ/2sigiAAAAlIeLs5P+76oO+mBUd3m6OpvqTqVm65ZPVmt2odHsAAAAQEEknAAAlfbnzpM6ejrTVHbHgKK/kAUAAEDtNvSCJppzXz9FBHmaynPy7frH91v1z593Kr/gop0AAADAf5FwAgBU2hfLzaObOjf1U6+oQIuiAQAAQGV0aOynn+4foP6tg4vUfbHikO76cr1pKmUAAABAIuEEAKikbbHJWnv4tKnsjgEtZLPZLIoIAAAAlRXo7aZp46N150VF1+RcsPuUbvx4lY4nZRazJwAAABoqEk4AgEqZvPyg6X6Yr7uu6dLEomgAAABQVVycnfT0NR315o1d5eps/jHRrrgUXfefFdpyNMma4AAAAFDrkHACAFTYieQszdsaZyob2y9Kbi58vAAAANQXI3s204yJfRTo5Woqj0/N1s2frtKv2+JK2BMAAAANCVcEAQAVNn31EeUVWDTaw9VJo6KbWxgRAAAAqkN0iyD9cH9/tQr1NpVn5dp139cbi6zpCQAAgIaHhBMAoEKycvM1c22MqWxE92YK9HazKCIAAABUp8hgb825t7/6tw42lRuG9M95O/XyL7tkL/BjJAAAADQsJJwAABUyf2ucEtNzTGXj+0dZEwwAAABqhL+Xq6aOj9atxYxq/3TpQT0ye7Ny8uwWRAYAAACruVgdAACg7jEMQ9NWHTaV9WsVrLaNfK0JCAAAADXG1dlJL4/orIggT7322x5T3Y+bjyshLVsf39ZTvh6uJfQAAABQA/z8pNmzi5ah2pBwAgCU29ZjKdoam2wqG9M3yppgAAAAUONsNpvuG9xajXw99MT3W03req7Yn6ibPlmtaeN7KczPw8IoAQBAg+buLt14o9VRNChMqQcAKLcZa2NN95sGeOrSDmEWRQMAAACrjOzZTJPH9ZKXm7OpfFdcikZ8uFL7T6VZFBkAAABqGgknAEC5pORIv+04ZSq7rU+kXJz5SAEAAGiIBrUN1Td39VWIj5up/FhSpm74eKW2HE2yJjAAAADUKK4OAgDKZeVJm3ILTJni7uKkW3pFWBgRAAAArNalmb/m3NtfUcFepvKkjFyN+my1Vh1ItCgyAAAA1BQSTgCAMsuzSytOmj86ruvWRIHebiXsAQAAgIaiebCXvr+3n7pGBJjK03PyNXbKWi3YddKawAAAAFAjSDgBAMps62mbUnJtprKx/aKsCQYAAAC1TrCPu2be2VsD24aaynPy7Lr7qw36cfMxiyIDAABAdSPhBAAos6UnzB8bvaIC1amJv0XRAAAAoDbycnPRZ2N66qrO4abyPLuhh7/ZrOmrj1gUGQAAaFDi4yWbzXyLj7c6qnqNhBMAoEx2xqXqUCqjmwAAAHB+7i7Oev/W7rqxZzNTuWFIz/ywXR8tPmBRZAAAAKguJJwAAGUyY22s6X4jP3dd0Sm8hNYAAABo6FycnfTqyAs0oX+LInWv/rZbr/62W4ZhWBAZAAAAqgMJJwDAeZ1Oz9G8beZFnkf3jpSrMx8jAAAAKJmTk03PDu2gRy5tW6Tuo8UH9OK8XSSdAAAA6gmuFAIAzmvWuhjl5Nsd912dbbo1urmFEQEAAKCusNlseujSNnpuaMcidV+sOKRJP+0g6QQAAFAPkHACAJQqL9+u6avMCztf2SlMob7uFkUEAACAumjCgBZ67YYL5GReFlTTVh3R0z9sl91O0gkAAKAuI+EEACjVX7tO6XhylqnstugIi6IBAABAXXbThRF6++Zuci6Udfp6TYyenLNV+SSdAAAA6iwSTgCAUn21+rDpfqSPoQua+lkTDAAAAOq867o11Xu3dJdLoaTT7PWxevzbLSSdAAAA6igSTgCAEh2MT9OK/YmmsovC7SW0BgAAAMrmmgsa64NRPeTqbE46zdl0TI98s1l5+XznBAAAqGtIOAEASjRjTYzpvreLoW7B/OIUAAAAlXdl53B9NLqn3JzNlyZ+2nJcD83arFySTgAAAHUKCScAQLEyc/L17fqjprLeYYZc+eQAAABAFbm0YyN9Mqan3FzMXzLnb4tjpBMAAEAdw2VDAECxft56XClZeaay/o34Dz8AAACq1pB2Yfp8zIVyL5R0mrc1To9/t5U1nQAAAOoIEk4AgGLNWH3EdP+i1kEK8bAoGAAAANRrA9uGasq4XvIoNJx+7qZjevL7rbKTdAIAAKj1SDgBAIrYGpukLbHJprJbLmxqUTQAAABoCPq1DtHksb2KjHT6dkOsnv5hO0knAACAWo6EEwCgiOmFRjc18ffQoDYhFkUDAACAhqJ/6xB9OuZCuTmbL1fMXBujST/vkGGQdAIAAKitXKwOAABQuyRn5OqnLcdNZaN6N5ezk82iiAAAANCQDGobqo9u66F7pm9Qbv7/EkxfrjoiFycnPTu0g2w2vpsCAIDz8PGRPvigaBmqDQknAIDJdxtjlZVrd9x3cbLppl4Rkvg1KQAAAGrGJR0a6YNRPXT/jI3KKzCV3hcrDsnVxaYnr2xP0gkAAJTO01O6/36ro2hQmFIPAOBgGIZmrDFPp3dl53CF+XpYFBEAAAAaqis6hevdW7qr8ED7T5Yc1Ft/7rUmKAAAAJSIhBMAwGHVgUQdjE83ld3WJ9KiaAAAANDQXXNBY719c7ciSaf3F+7Xewv2WRMUAAAAikXCCQDg8NVq8+imNmE+6t0iyKJoAAAAAOm6bk312g1dVXgGvbf+3Ksvlh+yJigAAAAUQcIJACBJOpmSpT92njSV3dYnkrnxAQAAYLkbejbTv0d0KVL+z3k7NXv9UQsiAgAAQGEknAAAkqSZa2OUX2BBZk9XZ43o0dTCiAAAAID/uSW6uV68rlOR8ie/36pftsVZEBEAAAAKIuEEAFBevl2z1pp/GTq8e1P5ebhaFBEAAABQ1O19o/SPK9uZyuyG9NCsTVq855RFUQEAgFopIUEKDTXfEhKsjqpeI+EEANBfu07pREqWqey2Ps0tigYAAAAo2X2DW+vewa1MZbn5hu6ZvkFrD522KCoAAFDrGMbZBFPBm2Gcfz9UGAknAIC+Xhtjut+9eYA6NfG3KBoAAACgdP+4ol2RH0hl5do1Yeo6bYtNtigqAACAho2EEwA0cEdPZ2jZvnhT2W29Iy2KBgAAADg/m82mf17bWcO7NTGVp2XnacwXa7TvZKpFkQEAADRcJJwAoIGbtS7GNJrYz8NF11zQ2LqAAAAAgDJwcrLp9Ru76rKOjUzlZzJyddvkNTp6OsOiyAAAABomEk4A0IDl5ts1e32sqez6Hs3k4epsUUQAAABA2bk6O+n9W7urf+tgU/nJlGyN/nyNThVapxQAAADVh4QTADRgC3adUnxqtqns1ujmJbQGAAAAah8PV2d9evuF6t48wFQeczpDY75Yq+TMXGsCAwAAaGBIOAFAAzZzbYzpfs/IQLUL97UoGgAAAKBivN1dNHVctNoX+i67+0Sq7vxyvbJy8y2KDAAAoOEg4QQADdTR0xlaui/eVMboJgAAANRV/l6u+uqO3ooK9jKVrz10Wn+buUl5+XaLIgMAAGgYSDgBQAP1zbqjMoz/3ffzcNHQCxpbFxAAAABQSaG+7vpyQm+F+rqbyv/YeVLP/LBdRsEvwAAAAKhSJJwAoAHKzbdr9vqjprLrezSTh6uzRREBAAAAVaN5sJemjY+Wr7uLqXzWuqN684+9FkUFAABQ/5FwAoAGaOHuUzqVmm0quyU6wqJoAAAAgKrVsYmfPht7odxczJc9Pli0X1NWHLIoKgAAgPqNhBMANEAz18aY7vdoHqD24X4WRQMAAABUvT4tg/X+rd3lZDOXv/DzTv24+Zg1QQEAANRjJJwAoIGJPZOhJXvjTWW3Rje3KBoAAACg+lzRKVwvj+hSpPyxb7doaaHvxAAAAKgcEk4A0MDMXndUBddK9v1/9u48PKr6fP/4fWaykpAEsgAJiyyyLwmbiMqiiKKyySJuCIii1aq1Wttva8XWtlq11lq1ImDEKiqLILigVllEkDXs+yKQBEhYkgBZZ+b3Bz8DJyFAQpLPTOb9uq65rjnPnDPnxvYEMs98nhMSoFs6xpsLBAAAAFShUd0b64n+LW21QpdHD/x3tVL2HzcTCgAAoAYKuPAuAICaosjl1ker9ttqQ5MSFBrkNJQIAAAAqHoP9W2hzBMFSv5hb3HtVIFLY99ZoZkP9lTz2HBz4QAAQNWoVUt65pnSNVQZGk4A4Ee+3XpYh7LzbbVR3RinBwAAgJrNsiz98Za2OnqyQJ+uSyuuHztVqNFTVmj2L3qqXkSIwYQAAKDShYVJEyeaTuFXGKkHAH5k+op9tu3ERlFqGx9hKA0AAABQfRwOSy+N6KRrLo+x1VOP52rMOyuVk1doKBkAAEDN4JcNp+zsbH344Yf69a9/rd69e6tFixaKjIxUUFCQ4uLi1KdPH/3973/XkSNHKu2cX3zxhYYOHaqGDRsqODhYDRs21NChQ/XFF19U2jkA4HxSj+dqYYkbI99xBaubAAAA4D+CAhz6z11d1KlhpK2+JT1bD/53jQqK3IaSAQAA+D6/bDitWLFCt99+u/7xj39o8eLF2rVrl7Kzs1VYWKiMjAwtWrRITz31lFq3bq0FCxZc0rncbrfGjx+vm266SXPmzFFqaqoKCgqUmpqqOXPm6KabbtJ9990nt5t/1AKoWh+t3C+P58x27eAA3dKxgblAAAAAgAFhwQGaOqabmsaE2erf78zUb2etl+fsfzQDAADgovllw0mSGjVqpNGjR+vVV1/V7NmztWzZMi1dulQfffSRRowYIafTqczMTA0aNEjr1q2r8Hl+//vfa8qUKZKkpKQkTZ8+XStWrND06dOVlJQkSZo8ebL+8Ic/VMqfCwDOpcjl1scr99tqQ5ISVCuIW/kBAADA/0SHByt5bDdFhwXZ6rPXpuqlr7YZSgUAAODb/PKTxr59+2rfvn1lvj5y5EjNmTNHQ4cOVUFBgZ599lnNnj273OfZvn27XnrpJUlS165dtXjxYoWGhkqSunXrpkGDBql3795atWqVXnzxRY0bN04tWrSo2B8KAM7ju20ZOpidZ6vd3p1xegAAAPBfTaLDNHVMN42atFy5ha7i+uvf7VKDyFDd1aOJwXQAAAC+xy9XODmdzgvuM2TIELVq1UqStGTJkgqd55///KeKiookSa+99lpxs+lntWrV0muvvSZJKioq0iuvvFKh8wDAhUxfYW+yd2oUpbbxEYbSAAAAAN6hU6MovX5nkpwOy1b/49yN+mrTQUOpAABApTh6VGrXzv44etR0qhrNLxtOF6t27dqSpLy8vAvsWZrH49HcuXMlSa1bt1aPHj3OuV+PHj2KG1tz585lVjSASpeelauF2w7band0b2QoDQAAAOBdrm1dT88NaW+ruT3SIx+u1Zp9xwylAgAAl8zlkjZvtj9crgsfhwqj4VSGbdu2KSUlRdLphlF57dmzR2lpaZKk3r17n3ffn19PTU3V3r17y30uADifmasOyH1WLzs8OEC3dIw3FwgAAADwMrd3b6xHrrWPuM8rdOve5JXanXHCUCoAAADfQsPpLKdOndKOHTv0j3/8Q7179y4eh/fYY4+V+702b95c/PxCDauzX9+yZUu5zwUAZXG7Pfp49X5bbWCneIUF++Ut/AAAAIAy/er6lhrRpaGtduxUoca8s1IZOfmGUgEAAPgOv//EMTk5WWPHji3z9d/+9re64447yv2+Bw4cKH7esGHD8+wpNWp0ZrTV/v37z7Pnhc91Lunp6cXPc3NzlZubW+5z+JuzxyhWZKQi4C2W7T6q/Uft1/yQjnEV+jnAdQGUxnUBlMZ1AZTGdeE7nh7QQgezTmnJzjP3d9h39JTGvvOjku9JUliQ33+MUqm4NoDSuC6A0ip8XeTmKrRUKVfi83FJqpI+Af9SKkNiYqImTZqkbt26Vej4nJyc4ufh4eHn3TcsLKz4+YkT5V+qf3bD6kIWL16smJiYcp/Dny1evNh0BKDC3t3u0NmLWRuEepS+cbkObrq09+W6AErjugBK47oASuO68H4D60p7wpw6cNIqrm1My9HoNxdqfGu3nNZ5DkaFcW0ApXFdAKWV57oIysrSgBK1hQsXqiAysnJD+ajMzMxKf0+/H6k3ZMgQbdiwQRs2bNCKFSs0ffp0DR06VCkpKbr99ts1f/78Cr3v2Z3WoKCg8+4bHBxc/JzVRwAqy6kiaf1R+2/DPeq5ZfELMgAAAFCmYKc0obVLdYM9tvrm4w7N2O2Qx1PGgQAAAH7O71c4RUVFKSoqqni7W7duGjVqlN577z3dc889Gjx4sKZMmaIxY8aU631DQkKKnxcUFJx33/z8M7OgQ0NLLvK7sAuN4UtPT1f37t0lSb169brgiD+cbhj+3C3v1auX7X9PwFe8v+KAijzbi7cDHZaeHNFbdWqdvwleFq4LoDSuC6A0rgugNK4L39Slx0ndPnW1snKLimvLDjvUtW1z/aJ3U4PJag6uDaA0rgugtApfFxkZpUp9+vSRYmMrMZ3vutCteirC7xtOZbn77rs1f/58ffzxx3r44Yc1aNAg1a1b96KPr127dvHzC43JO3nyZPHzC43fO5fyNJBCQ0Mr1NTyZyEhIfw3g0+anXLQtt2/XX3FR1fOkmGuC6A0rgugNK4LoDSuC9/RtlGopo7ppjve/lH5Re7i+msL96h5vUgNSUowmK7m4doASuO6AEor13Vxjv1CQ0PPWfdHVfHzxe9H6p3P4MGDJZ1uCH355ZflOvbsJtCFOoVnr1Aqz/2YAKAsG1OztDk921a7rRs/XwAAAIDy6NKkrl4dlVRqLPVvZq7X8t1HzIQCAADwUjScziP2rKV1P/30U7mObdu2bfHzrVu3nnffs19v06ZNuc4DAOfy0Ur7qM2EqFBd3SLGUBoAAADAd93Yvr6evrmtrVbgcmvCe6u18/D5J5oAAAD4ExpO55Gamlr8vLyj7po2bar4+HhJ0qJFi86778/zJxMSEnTZZZeVLyQAlJBX6NKclFRbbXiXhnI4rDKOAAAAAHA+465uqjE9L7PVsnILNTZ5hTJP5J/7IAAAAD9Dw+k8ZsyYUfy8Q4cO5TrWsqzikXxbt27V8uXLz7nf8uXLi1c4DR48WFbJdfoAUE5fbExXTt6ZGxtbljSi68Xf6w0AAABAaU/f0lb92tSz1fYfzdX4d1cpr9BlKBUAAID38MuGU3JysvLy8s67zyuvvKLPP/9c0unVStdcc43t9YULF8qyLFmWpTFjxpzzPR577DE5nU5J0i9/+Uvl5ubaXs/NzdUvf/lLSVJAQIAee+yxCvxpAMCu5Di9q1vEqGGdWobSAAAAADWD02HpX7cnqmPDSFs9Zf9xPfZhitxuj6FkAAAA3sEvG04TJ05UQkKC7r//fk2bNk1Lly7VunXr9P333+vNN9/U1Vdfrccff1ySFBQUpEmTJhU3jsqjZcuWevLJJyVJq1at0lVXXaWPPvpIq1at0kcffaSrrrpKq1atkiQ9+eSTuvzyyyvvDwnAL/105KSW7z5qq43s2shQGgAAAKBmqRUUoMn3dFVCVKit/uWmg/rbF1sMpQIAAPAOAaYDmHL06FG9/fbbevvtt8vcp2HDhpo6dar69etX4fP85S9/0eHDhzV16lStXbtWo0aNKrXPvffeq+eee67C5wCAn328yr66KapWoPq3q1fG3gAAAADKK652iN4Z203D3vzBNsr67SV71KhuLY2+8jJz4QAAwBkhIdIvflG6hirjlw2nBQsW6LPPPtPSpUu1c+dOHTp0SEeOHFFoaKji4uKUmJioW265RSNHjlStWpc2hsrhcGjKlCkaNmyYJk2apJUrVyozM1MxMTHq1q2bJkyYoAEDBlTSnwyAPytyuTVz9QFbbWhSgoIDyr9CEwAAAEDZWtarrbfu6qLRU1eo6KxRehM/3aSEqFBd14YvfQEAYFzt2tLrr5tO4Vf8suHUqlUrtWrVqnhsXkX06dNHHs/Fz2e+6aabdNNNN1X4fABwIYt3ZOhQdr6tdls3xukBAAAAVaFnixg9P6yjnpixrrjm9ki/nL5WH0+4Uu0TIs9zNAAAQM3jl/dwAoCa6KOV9nF6nRpGqnX9CENpAAAAgJpveJeGeuQ6+/2YTxW4NC55pVKP5xpKBQAAYAYNJwCoATJy8vW/LYdttZGsbgIAAACq3K/6Xa5bkxJstcM5+Rr3zkpl5xUaSgUAAFD9aDgBQA0we80B2+z4kECHBnaKN5gIAAAA8A+WZen5YR3Vo1ldW33boRw99P4aFbrchpIBAABULxpOAODjPB6PPlplH6d3c4d4RYQEGkoEAAAA+JegAIfeuqurmseG2epLdmTqD59sLNc9oAEAAHwVDScA8HGrfzqm3RknbbXbGKcHAAAAVKvIWoFKHttdMeFBtvpHq/brjYW7DKUCAMCPHT8u9eljfxw/bjJRjRdgOgAA4NJ8XGJ1U7OYMHW7rI6hNAAAAID/alS3libf002jJi1TXuGZUXovLtimhnVCNTgx4TxHAwCASlVYKC1aVLqGKsMKJwDwYacKivTZ+nRbbUTXRrIsy1AiAAAAwL8lNorSP29LUsl/kj85Y71W7DlqJhQAAEA1oOEEAD7siw0HdbLAVbztsKRbO/OtSQAAAMCkG9vX1x9ubmurFbjcum/aKu3OOGEoFQAAQNWi4QQAPmzm6gO27V4tY1UvIsRQGgAAAAA/G3fVZRrT8zJbLSu3UGOTV+rIiXwzoQAAAKoQDScA8FH7j57Sst1HbLURXRoZSgMAAADgbJZl6elb2qpfmzhb/acjp3T/e6uVV+gq40gAAADfRMMJAHzUrDX21U2RoYG6rsQvswAAAADMcTosvToqSe0TImz11T8d069nrJPb7TGUDAAAoPLRcAIAH+R2e0qN0xucGK+QQKehRAAAAADOJSw4QFPv6ab4SPvo68/Wp+vFr7YZSgUAAFD5aDgBgA/6cc9RHTiWa6sN79LQUBoAAAAA5xMXEaKpY7spPDjAVn9z4S59uGKfoVQAAACVi4YTAPigGav327Zb1autDgmRhtIAAAAAuJDW9SP0xp2d5XRYtvrv52zUkh0ZhlIBAABUHhpOAOBjTuQX6YsNB2214V0ayrKsMo4AAAAA4A16tYzVX4a0t9Vcbo9+8d812nYwx1AqAACAykHDCQB8zOfr05Vb6CredjosDUlKMJgIAAAAwMUa1b2xHuzT3FbLyS/S2HdW6HB2nqFUAAAAl46GEwD4mJmrD9i2+7aKVWztYENpAAAAAJTXk/1b6ZaODWy1tKw83fvuKp0qKDKUCgAA4NLQcAIAH7I386RW7D1qqw3v0tBQGgAAAAAV4XBYemlEJ3VpUsdW35CapUemr5XL7TGUDAAAoOJoOAGAD5m1xr66qU6tQF3bup6hNAAAAAAqKiTQqUl3d1HjurVs9W+2HNaf5282lAoAAKDiAkwHAABcHJfbo1klxukNTkxQUADfHQAAAAB8UXR4sN4Z2023vvGDsnILi+vJP+xVk+haGntVU4PpAADwcUFB0vDhpWuoMjScAMBHLNt1RGlZ9psIj+jKOD0AAADAlzWPDdeku7vo7ikrVOByF9f/NH+zGtappevbMtEAAIAKiYyUZswwncKv8LV4APARM1bvt223aRChdvGRhtIAAAAAqCxXNIvW34d3tNU8HumR6Wu14UCWoVQAAADlQ8MJAHxAdl6hvtx40FYb0YXVTQAAAEBNMSQpQY9f39JWyy10ady7K5V6PNdQKgAAgItHwwkAfMD8denKLzozXiPAYWlwYrzBRAAAAAAq2y+vbaHhJb5YlpGTr3HvrFR2XmEZRwEAAHgHGk4A4ANmlhind12bOEWHBxtKAwAAAKAqWJalvw7toJ7No231bYdy9ND7a1R41j2eAAAAvA0NJwDwcjsPn9CafcdtteFdGpkJAwAAAKBKBQU49OZdXdQiLtxWX7IjU0/P2SiPx2MoGQAAwPnRcAIALzdrzQHbdkx4kPq0ijWUBgAAAEBViwwN1DtjuikmPMhW/3Dlfr25aJehVAAA+JisLGnECPsjK8t0qhotwHQAAEDZXG6PZpdoOA1JTFCgk+8LAAAAADVZo7q19Pborho1abntfq5//3KbGtWppYGduKcrAADnVVAgzZxpr73xhpksfoJPLAHAiy3ZkaFD2fm22vCuDcvYGwAAAEBNktS4jl4dlSjLstd/PWOdVu09aiYUAABAGWg4AYAXm7HavrqpQ0KkWtePMJQGAAAAQHW7sX0D/d+ANrZaQZFb901bpb2ZJw2lAgAAKI2GEwB4qaxThfp60yFbbQSrmwAAAAC/M/6aprqrR2Nb7dipQo1LXqljJwsMpQIAALCj4QQAXurT9WkqcJ2Z1R7kdGgQc9oBAAAAv2NZliYObKe+rWJt9d2ZJzXhvdXKL3IZSgYAAHAGDScA8FKz19jH6fVrG6eoWkGG0gAAAAAwKcDp0Gt3dFabBvYR2yv2HtVvZq6Xx+MxlAwAAOA0Gk4A4IV2Z5zQ2n3HbbVhnRmnBwAAAPiz8OAATR3TVfUigm31uSlpeuXr7YZSAQAAnEbDCQC80CdrU23b0WFB6tUytoy9AQAAAPiLBpGhmjqmm8KCnLb6v77dqRmr9htKBQAAQMMJALyO2+3R7DX2htOgxHgFOvmRDQAAAEBqFx+pf9/RWQ7LXv/d7A36YWemmVAAAMDv8eklAHiZFXuPKvV4rq3GOD0AAAAAZ+vbOk7PDm5vqxW5PZrw39XacSjHUCoAAODPaDgBgJeZveaAbbtlvXC1i48oY28AAAAA/uruHk103zVNbbWcvCKNTV6pjJx8Q6kAAIC/ouEEAF4kt8ClzzcctNWGdW4oy7LKOAIAAACAP/vdgDa6sV19W+3AsVyNn7ZKuQUuQ6kAAIA/ouEEAF7kq80HdSK/qHjbYUlDkhIMJgIAAADgzRwOS6/clqhOjaJs9XX7j+tXH6XI7faYCQYAAPwODScA8CKz16Tatq9qEaN6ESGG0gAAAADwBaFBTk0e3VUN64Ta6l9uOqi/fbHFUCoAAOBvAkwHAACcdjg7T0t2ZNhqwzo3NJQGAAAAgC+JrR2sd8Z0061v/qCcvDNTE95eskeNo8N0d48mBtMBAGBAYKDUu3fpGqoMDScA8BJzU9J09rSLsCCn+rerZy4QAAAAAJ9yeb3aeuuuLho9dYWKzvrl4pm5G9UwKlR9W8cZTAcAQDWLipIWLjSdwq8wUg8AvIDH49GsNQdstQEdGqhWEN8LAAAAAHDxeraI0fPDOtpqbo/08AdrtCkty1AqAADgD2g4AYAX2Jyera0Hc2y1WzsnGEoDAAAAwJcN79JQj1zbwlY7WeDSuOSVSs/KNZQKAADUdDScAMALzF6TatuOjwxRj6bRhtIAAAAA8HW/ur6lhiTG22qHsvM1LnmVTuQXlXEUAABAxdFwAgDDilxuzU2xN5yGdk6Qw2EZSgQAAADA11mWpReGd1T3pnVt9S3p2Xr4gzUqcrkNJQMAADUVDScAMGzJjkxlniiw1YYmNTSUBgAAAEBNERzg1KS7u6hZTJitvnBbhibO2ySPx2MoGQAAqIm4Gz0AGDZrzQHbdqdGUWoRF24oDQAAAICaJKpWkN4Z201D3/hBR0+e+aLbf5fvU0JULT3Yp7nBdAAAVKGcHOm3v7XXnn9eql3bTB4/QMMJAAzKyi3UV5sP2WrDOicYSgMAAACgJmoSHaa3R3fR7W//qIKiM6P0XvhyqxpEhmhIEr+DAABqoLw86Y037LWJE2k4VSFG6gGAQV9sSLf9whfotHRLx/jzHAEAAAAA5delSV39Y2SnUvUnZ67T0p2ZBhIBAICahoYTABg0e02qbbtvqzjVDQsylAYAAABATXZLx3j9/qY2tlqhy6MJ763W5rRsQ6kAAEBNQcMJAAzZd+SUVuw9aqvd2rmhoTQAAAAA/MH4a5pq7FWX2Won8os0NnmFUo/nmgkFAABqBBpOAGDIJ2vtq5uiagWqb+tYQ2kAAAAA+APLsvT0zW11U4f6tvqh7HyNmbpCWacKDSUDAAC+joYTABjg8Xg0e+0BW21gx3gFBzgNJQIAAADgLxwOS/8Ymajul9W11XccPqH73lulvEKXoWQAAMCX0XACAAPW7Dumn46cstVu7ZxgKA0AAAAAfxMS6NSk0V3UIi7cVl+x56h+PWOd3G6PoWQAAMBX0XACAANmrbGP02sWE6bERlFmwgAAAADwS1G1gvTuuO6Kqx1sq3+2Pl1/+XyLoVQAAMBX0XACgGqWV+jS/HVpttqwLg1lWZahRAAAAAD8VUJUqJLHdld4cICtPuX7PZq8ZLehVAAAwBfRcAKAavbt1sPKziuy1YYkMU4PAAAAgBlt4yP0n7u6KMBh/xLcc59t0fz1aWUcBQAAYEfDCQCq2ew1B2zbVzaLVkJUqKE0AAAAACBdfXmM/j68Y6n64x+t04+7jxhIBAAAfA0NJwCoRpkn8rVwW4atdmtnVjcBAAAAMO/Wzg315A2tbLUCl1v3TVul7YdyDKUCAAC+goYTAFSjT1PSVOT2FG+HBDo0oEMDg4kAAAAA4Ixf9Gmuu3o0ttWy84o0ZuoKHczKM5QKAAD4AhpOAFCNPlmbatu+sV39UjfnBQAAAABTLMvSs4Pa6/q29Wz1tKw8jXlnhbJyCw0lAwAA3o6GEwBUk52Hc7QhNctWG9q5oaE0AAAAAHBuToelf41KUlLjKFt968Ec3TdtlfIKXWaCAQBQHk6n1Lat/eF0mk5Vo9FwAoBqMmdtmm07tnawrmoebSgNAAAAAJQtNMipKfd0U7OYMFt9xZ6jemT6WrnOGhUOAIBXqltX2rTJ/qhb13SqGo2GEwBUA7fbozkp9nF6gzrFK8DJj2EAAAAA3qluWJDeHdddsbWDbfWvNh/SH+ZslMdD0wkAAJzBJ50AUA1W7zumA8dybbWhSQmG0gAAAADAxWlUt5beHdtdtUvce3b6in165evthlIBAABvRMMJAKrBJ2vtq5taxIWrXXyEoTQAAAAAcPHaxkfo7Xu6KijA/jHSv77dqWnL9poJBQAAvA4NJwCoYvlFLn22Pt1WG5qUIMuyDCUCAAAAgPLp0Sxa/xqVKEeJX2Oe+XST5q9PO/dBAADAr9BwAoAqtnBbhrJyC221QZ3iDaUBAAAAgIq5sX0DPTekg63m8Ui/+ihFS3dmGkoFAAC8RcCFdwEAXIo5Jcbpdb+srhrVrWUoDQAAAABU3B1XNFbmiXz946z7NxW6PJrw3mp9eH8PtU+INJgOAICznDwpvfiivfbkk1JYmJk8foCGEwBUoazcQv1vy2FbbUhSgqE0AAAAAHDpfnltC2Xk5Ou95T8V107kF2nMOys084GeuiyGD/IAAF7g1Cnp2WfttYceouFUhRipBwBV6IsN6SpwuYu3g5wO3dyhgcFEAAAAAHBpLMvSxEHtdFOH+rZ65okCjZ66Qodz8gwlAwAAJtFwAoAq9EmJcXp9W8cqslagoTQAAAAAUDmcDkuv3Jaons2jbfV9R09pzNSVys4rLONIAABQU9FwAoAqkno8Vz/uOWqrDWWcHgAAAIAaIjjAqbfu7qJ28RG2+ub0bN0/bZXyCl2GkgEAABNoOAFAFZmbYl/dFBESoL6t4wylAQAAAIDKVzskUMlju6tJdC1bffnuo/rl9LUqOmvEOAAAqNloOAFAFfB4PPpkjb3hdHPHeAUHOA0lAgAAAICqEVs7WNPGdVdMeJCt/vXmQ/rNrPVyuz2GkgEAgOpEwwkAqsCmtGztOHzCVmOcHgAAAICaqkl0mJLHdlft4ABbffaaVP1p/mZ5PDSdAACo6Wg4AUAVmLPWvropISpUXZvUMZQGAAAAAKpe+4RITRnTTcEB9o+bkn/Yq39+s8NQKgAAUF1oOAFAJXO5PZq7Ls1WG5IUL4fDMpQIAAAAAKpH96Z19Z+7uiigxO8/r/5vh6Z+v8dQKgAAUB1oOAFAJfthV6YycvJttSGJjNMDAAAA4B/6to7TP25LlFXiO3d/mr9ZM1cfMBMKAABUORpOAFDJPikxTq99QoQur1fbUBoAAAAAqH6DOsXruSHtS9WfmrVeCzYdNJAIAABUNRpOAFCJThUUacFG+y9PrG4CAAAA4I/uvKKJfnNjK1vN5fbolx+s1dKdmYZSAQCAqkLDCQAq0debD+lkgat422Gd/mYfAAAAAPijX/RpoQm9m9lqBS637pu2SusOZBlKBQAAqgINJwCoRHNKjNO7qkWM4iJCDKUBAAAAAPN+e2Nr3d69ka12qsClCe+vU9opQ6EAAEClo+EEAJUk80S+Fu+wj4UYmsQ4PQAAAAD+zbIsPTekg27u2MBWz8or0pubncrMMxQMAFCzWZYUE2N/WJbpVDUaDScAqCTz16XJ5fYUb4cGOnVDu/oGEwEAAACAd3A6LL0yMlG9W8ba6tmFlt7Y7NThnHxDyQAANVZMjJSRYX/ExJhOVaPRcAKASvJJSpptu3+7egoLDjCUBgAAAAC8S1CAQ/+5q4u6Nqljqx/JtzRu2lodOUHTCQAAX0bDCQAqwe6ME1q3/7itxjg9AAAAALALDXJqyphuatsgwlbflXlKd01ZoaxThYaSAQCAS0XDCQAqwZy1qbbtmPAgXd2CJboAAAAAUFJkaKDeHdddl0XXstW3pGdr9DsrlJNH0wkAAF9EwwkALpHH49EnKfaG08BO8Qpw8iMWAAAAAM4ltnaw3hmdqOhgj62+bv9xjUteqVMFRYaSAQCAiuLTUAC4RGv2HdP+o7m2GuP0AAAAAOD86keE6KG2LkUG2ZtOK/ce033TVimv0GUoGQAAqAjuZg8Al+iTEuP0msWGqUNCpKE0AAAAAOA7okOkh9u69NaOWso8WVBcX7rziH7x/hr9564uCgrg+9IAgArIzZWmTrXXxo2TQkPN5PED/I0NAJegoMit+evTbbWhiQmyLMtQIgAAAADwLXGh0pTRiapTK9BW/3brYT364VoVudyGkgEAfNqJE9LDD9sfJ06YTlWj0XACgEuwaHuGjp+y39B2cCLj9AAAAACgPFrGheu9e69Q7RD7MJ4vNh7UEzPWyeX2lHEkAADwFjScAOASzCkxTq9rkzpqHF3LUBoAAAAA8F3tEyKVPLa7agU5bfU5KWn6/Scb5PHQdAIAwJvRcAKACsrOK9TXWw7ZakOSWN0EAAAAABXVpUkdTbmnm4JL3Lfpw5X79ey8zTSdAADwYjScAKCCvtxwUAVFZ2aJBzot3dyhgcFEAAAAAOD7rmwerUmjuyrIaf/YKvmHvXrhy200nQAA8FI0nACgguaus4/T690yTnXCggylAQAAAICao3fLWP37jiQ5HZat/p9Fu/Tq/3YYSgUAAM6HhhMAVMCh7Dz9sOuIrTaUcXoAAAAAUGn6t6uvf96WqBI9J/3zmx36F00nAAC8Dg0nAKiAeevSdPYUh/DgAF3XJs5cIAAAAACogQZ2itcLwzqWqv/j6+3697c0nQAA8CY0nACgAuampNm2b2hXXyGBTkNpAAAAAKDmGtG1kf4ytH2p+ktfbdfr3+00kAgAAJyL3zacVq1apT/96U/q37+/GjZsqODgYIWHh6tly5YaO3asvv/++0o5z8SJE2VZ1kU9Fi5cWCnnBFC1dmWc0IbULFttcGK8oTQAAAAAUPPdeUUT/XlI6abTiwu26c2FuwwkAgAAJQWYDmBCr169tGTJklL1goIC7dixQzt27FBycrJGjx6tt99+W0FBQQZSAvBWn5ZY3RQTHqyezaMNpQEAAAAA/3B3jybyeDz649xNtvoLX26Vw5Im9G5uKBkAAJD8tOGUlnb6w+L4+HiNGDFC11xzjRo3biyXy6Vly5bp5ZdfVmpqqqZNm6bCwkJ98MEHlXLeDRs2nPf1pk2bVsp5AFQdj8ejuSmpttotHRsowOm3C0YBAAAAoNqMvvIyud0eTZy32Vb/2xdb5bAs3dermaFkAADALxtOrVu31l//+lcNGzZMTqf9nis9evTQ3Xffrauuukrbt2/X9OnT9cADD6hXr16XfN727Usv/QbgW9YfyNLeI6dsNcbpAQAAAED1GXNVU7k90p/m25tOf/l8iyxLGn8NTScAAEzwy6/kz58/XyNHjizVbPpZTEyMXn755eLtmTNnVlc0AF5uTonVTU2iaymxUZSZMAAAAADgp8Zd3VR/uLlNqfpzn23RO0v3GEgEAAD8suF0Mfr27Vv8fNcubj4JQHK5PZq3Lt1WG9wpXpZlGUoEAAAAAP5r/DXN9PubSjednp23We/+sLf6AwEA4Of8cqTexcjPzy9+XtZKKAD+ZdmuI8o8kW+rDUpMMJQGAAAAAHBfr2Zyezz62xdbbfVnPt0kyzp9zycAgJ+KjZU8HtMp/AornMqwaNGi4udt2pT+tkxF9O/fX3FxcQoKClJcXJz69Omj559/XseOHauU9wdQtUqO02ufEKEWceGG0gAAAAAAJGlC7+Z66sbWpep/nLtJ7y3/yUAiAAD8EyuczsHtduv5558v3h45cmSlvO/XX39d/DwjI0OLFi3SokWL9MILLyg5OVmDBw+u0PseOHDgvK+np58ZAZabm6vc3NwKncef5OXlnfM5/FdeoUtfbLCP07upbZxfXU9cF0BpXBdAaVwXQGlcF8C5Vea1MeaKeBUUFOiVb3fb6k/P2ai8vHzddUWjS3p/oLrwdwZQGtdF1aiKzzUtj4c1ZSW9/PLLeuKJJyRJt956q2bNmlXh95o4caJmz56tIUOGqHv37oqPj1dhYaG2bdum999/X1999ZWk02P75s2bpwEDBpT7HOW5f8zkyZMVExNT7nMA/i7liKV3tp8Zr2nJo4mdXYoKNhgKAAAAAGDz1QFLn+0vfWuEIU1c6hvPR2AAAPwsMzNT48ePlyTt379fDRs2vOT3pOFUwqJFi9SvXz8VFRUpLi5OGzZsUFxcXIXf7/jx44qKiirz9bfeeksPPPCAJCk+Pl67du1SSEhIuc5BwwmoelO2ObT+6JkppJdHuPVwO7fBRAAAAACAc1lwwNLn52g63dLYpesT+BgMAACpahpOjNQ7y6ZNmzR06FAVFRUpJCREM2bMuKRmk6TzNpskacKECVq5cqWmTJmitLQ0zZo1S3feeWe5zrF///7zvp6enq7u3btLknr16lUp/8ep6fLy8rR48WJJp/+blbcJiJolO69QT6z4XtKZX0xG926r/p3jzYUygOsCKI3rAiiN6wIojesCOLequjb6S2q5ZK/+WWK83vx9Tl3WrKke6t20Us4DVAX+zgBK47qoGhe6VU9F0HD6//bs2aP+/fvr2LFjcjqd+vDDD9WrV69qOfeECRM0ZcoUSadXWJW34VSeBlJoaKhCQ0PL9f7+LiQkhP9mfu7TjRkqdJ1pNgU5HRqU1FihoYEGU5nFdQGUxnUBlMZ1AZTGdQGcW2VfG4/1b6NaIUH66+dbbfV/L9wjy+HU49e3LNfEGMAE/s4ASivXdZGfL336qb02aJAUzD0yJFXJzxcaTpLS0tLUr18/paWlybIsTZ06VYMHD66287dt27b4eWpqarWdF8DFmZuSZtvu0ypWkbX8t9kEAAAAAL7g/l7NFeh06Nl5m231177dqQKXW7+9sTVNJwCoybKzpZEj7bXDh6XYWDN5/IDjwrvUbJmZmbr++uu1e/fpZdavvfaaRo8eXa0Z+McN4L0OZuVp2e4jttqQpARDaQAAAAAA5TH2qqb685D2pepvLdqt5z7bIm5tDgBA5fHrhlNWVpZuuOEGbd58+psuzz//vB566KFqz/Hz+SUpPt6/7gkDeLv569N09u8f4cEBurb1pd3bDQAAAABQfe7u0UQvDOugkt/3nfL9Hj3z6Sa53TSdAACoDH7bcDp16pRuvvlmrVmzRpL0+9//Xk899ZSRLG+99Vbx8969exvJAODc5qTYx1ze2L6+QgKdhtIAAAAAACritm6N9dLwTnKUaDpNW/aTfj9nI00nAAAqgV82nAoKCjR06FAtXbpUkvToo4/queeeK/f7JCcny7IsWZaliRMnlnp9w4YN2rlz53nfY9KkSZo8ebIkqX79+ho6dGi5cwCoGjsPn9DG1GxbbXAiqxABAAAAwBcN69JQr9yWWKrpNH3FPv1m1nq5aDoBAHBJAkwHMOH222/XV199JUm69tprde+992rjxo1l7h8UFKSWLVuW+zyrV6/W+PHj1bdvXw0YMEAdOnRQdHS0ioqKtHXrVr3//vvFOZxOpyZNmqSwsLCK/aEAVLpP16XZtmPCg9WzeYyhNAAAAACASzU4MUEBDoce+XCtrcE0c/UBFbncemlEJwU4/fL72QAAXDK/bDjNnj27+Pm3336rjh07nnf/Jk2aaO/evRU6l8vl0jfffKNvvvmmzH2io6M1ZcoUDRw4sELnAFD5PB6P5pYYpzewUwM5S34VDgAAAADgU27uePp3u19OX6NC15mm05yUNOUVuvXq7YkKDmCUOgAA5cVXNqrQTTfdpClTpmj8+PHq0qWLGjZsqNDQUIWEhCg+Pl4DBgzQq6++qt27d2vw4MGm4wI4y7oDWfrpyClbbXBigqE0AAAAAIDKdGP7+vrPXV0UVGI105ebDur+aauVW+AylAwAAN/llyucPJ7Kmck7ZswYjRkzpszX4+LiNG7cOI0bN65Szgeg+sxZa1/ddFl0LXVqGGkoDQAAAACgsl3Xpp7evqer7p+2SvlF7uL6ou0ZuuedFZpyT1fVDgk0mBAAAN/CCicAKKHI5db89em22qDEBFkW4/QAAAAAoCbp3TJWyWO7KyzIPkJvxZ6jumvyjzp+qsBQMgAAfA8NJwAoYdnuI8o8kW+rDU6MN5QGAAAAAFCVrmwerf+Ov0IRIfZBQOsOZGnUpOXKyMkv40gAAHA2Gk4AUMKctWm27Q4JkWoeG24oDQAAAACgqiU1rqMP779S0WFBtvrWgzka+dYypR7PNZQMAADfQcMJAM6SV+jSgk0HbTVWNwEAAABAzdc2PkIfP3ClGkSG2Op7Mk9q5H+WaW/mSUPJAADwDdXecHr44Ye1du3a6j4tAFyU/205rBP5RcXbliUN7ETDCQAAAAD8QfPYcH084Uo1rlvLVk89nqsRby3TtoM5hpIBAOD9qr3h9MYbb6hr165KSkrSa6+9pqNHj1Z3BAAo09yUVNv2lc2iVS8ipIy9AQAAAAA1TaO6tTTjgSt1eZx9tHpGTr5um7RM6w8cNxMMAAAvV+0Np8DAQHk8Hq1bt06PPfaYEhISdNttt+nLL7+Ux+Op7jgAUCzrVKEWbsuw1YYkJhhKAwAAAAAwpV5EiD6acKXaxUfY6sdPFeqOt3/Uyr18gRoAvF50tHT4sP0RHW06VY1W7Q2n9PR0/fOf/1RiYqI8Ho/y8/M1c+ZM3XzzzWrSpImefvpp7dq1q7pjAYC+2JiuApe7eDvI6dAN7esbTAQAAAAAMKVuWJA+uK+HujSpY6ufyC/S3VN+1KLtGWUcCQDwCg6HFBtrfziqvSXiV6r9v27dunX1yCOPaM2aNVqzZo0efvhh1a1bVx6PRwcOHNBf//pXtWzZUn369NF7772n3Nzc6o4IwE/NTUmzbfdtHavI0EBDaQAAAAAApkWGBuq9e7vrqhb2b8TnFbo1/t2VmrcurYwjAQDwP0bbeYmJifrXv/6ltLQ0zZgxQwMGDJDD4ZDH49GSJUs0ZswYNWjQQBMmTNDy5ctNRgVQwx3MytPyPUdsNcbpAQAAAABqBQVoyj3d1K9NnK1e6PLokQ/X6v0ffzKUDAAA7+IV68cCAwM1bNgwffbZZ9q3b5/++te/6vLLL5fH41F2drYmT56sq666Su3atdPLL7+sw4cPm44MoIaZty5NZ99GrnZwgPq2jiv7AAAAAACA3wgJdOrNu7poUKd4W93jkX7/yUa9/t1O7k0OAPB7XtFwOluDBg3029/+Vlu3btUXX3yh+vVP3z/F4/Fo69at+s1vfqNGjRpp1KhRSklJMRsWQI0xd12qbfvG9vUVEug0lAYAAAAA4G0CnQ7987ZE3d2jSanXXlywTX/5bIvcbppOAAD/5XUNJ0lavHixxo4dq+HDh+vQoUPF3xAJCwuTx+NRYWGhZsyYoa5du+rRRx+V2+02nBiAL9t5+IQ2pmbbaoMZpwcAAAAAKMHhsPSnwe30yHWXl3pt8vd79OTM9Spy8TkVAHiFggJp4UL7o6DAbKYaLsB0gJ/t379f7777rpKTk7Vnzx5Jp1c1WZal66+/XuPHj9eQIUP0008/acqUKXr77bd19OhR/fvf/1bz5s31yCOPGP4TAPBVn6bYVzfF1g7Wlc2jy9gbAAAAAODPLMvS49e3VJ1agXp23mbba7PWHFB2XqFeuz2JqRkAYFpWltS3r712+LAUG2smjx8wusIpPz9f06dPV//+/dW0aVM988wz2r17tzwejxISEvT0009r9+7dWrBggUaMGKHAwEC1aNFCf/vb37Rr1y716dNHHo9HkyZNMvnHAODDPB6P5qSk2WoDO8bL6bAMJQIAAAAA+IKxVzXVK7d1KvX749ebD2nMOyuUk1doKBkAAGYYWeG0YsUKvfPOO/roo4+UlZUl6fSHvoGBgbrllls0fvx43XjjjbKssj/wjYyM1LPPPqvevXtr165d1RUdQA2Tsv+49h09ZasNTowvY28AAAAAAM4YmtRQtYMD9dAHa5RfdGaU3vLdR3XH2z8qeWw3RYcHG0wIAED1qfaGU7t27bR161ZJKr43U8uWLXXvvffqnnvuUVxc3EW/V3z86Q+FC5i7CKCC5pZY3dQ0JkwdG0YaSgMAAAAA8DX92tbTtHHdNf7dVcrJLyqub0jN0oi3lum9e69QQlSowYQAAFSPam84bdmyRZIUGhqq4cOHa/z48brmmmsq9F4REREaPXr0eVdCAUBZilxuzV9vbzgN6hTPzxQAAAAAQLlc0Sxa0+/voTHvrFDmiTNfjN6dcVLD3/xB7917hVrEhRtMCABA1av2hlNSUpLGjx+vO++8UxEREZf0XrGxsUpOTq6cYAD8zg+7jth+EZAYpwcAAAAAqJj2CZGa8UBP3TX5R6Uezy2up2flacR/ftC747qrY8MocwEBAKhijuo+4erVq/Xggw9ecrMJAC7VnJRU23bHhpFqFss3zgAAAAAAFdM0JkyzHuypy0usZjp2qlC3T1qu73dkGkoGAEDVq/aG05/+9Cf96U9/Umbmxf8Fe+zYseLjAKAy5BW6tGDjQVttUCdWNwEAAAAALk39yBB9POFKJTaKstVPFrg0NnmFPl2Xdu4DAQDwcdXecJo4caKeffZZHT58+KKPOXr0aPFxAFAZvtlySCcLXMXblkXDCQAAAABQOeqEBen98Vfo6hYxtnqhy6NHpq/VO0v3GEoGAEDVqfaGEwB4g7kp9m+U9WwerbiIEENpAAAAAAA1TVhwgKaM6aqbOzYo9dqz8zbr719ulcfjMZAMAICq4RMNp8LCQklSYGCg4SQAaoKsU4VauM2+ynJwYoKhNAAAAACAmio4wKnXRiXpniublHrtjYW79NSs9SpyuQ0kAwCg8vlEwyklJUWSFBsbazYIgBrh843pKnSd+RZZUIBDN7avbzARAAAAAKCmcjgsTRzUTk/e0KrUax+vOqAJ761W7lkj3wEA8FUBVX2CadOmnbM+d+5crVq16rzH5ufna9euXZo6daosy1K3bt2qIiIAPzM3JdW2fW2rOEWEsIISAAAAAFA1LMvSQ31bKDosSP/3yQa5z5qk97+th3Xn5OWaOqabomoFmQsJAMAlqvKG05gxY2RZlq3m8Xj0hz/84aLfw+PxyOFw6NFHH63seAD8THpWrn7cc9RWG5IUbygNAAAAAMCfjOreWNHhwXr4gzXKLzozSm/NvuMa/p9lmjauu+KjQg0mBACg4qplpJ7H4yl+nKt2vkdgYKCuuuoqffrpp+rdu3d1xAVQg81bl6az78laOyRAfVrFmQsEAAAAAPAr17etp/fHX6GIEPv3wHcePqFhb/6g7YdyDCUDAODSVPkKpz179hQ/93g8atasmSzL0oIFC3T55ZeXeZxlWQoJCVF0dLScTmdVxwTgJ+ampNm2B7Svr5BAfsYAAAAAAKpP18vqauaDPTV6ygodzM4rrqdn5WnEf5Zp6piu6tKkrsGEAFAD1KkjbdxYuoYqU+UNpyZNmpyzHh8fX+ZrAFAVdh7O0aa0bFttcGKCoTQAAAAAAH/Wsl5tzfpFT90zdYV2Hj5RXM/KLdQdb/+o1+/orH5t6xlMCAA+LiBAatfOdAq/Ui0j9c7mdrvlcrnUtm3b6j41AD9XcnVTXO1g9WgWbSgNAAAAAMDfJUSFasaEK5XUOMpWzy9ya8J/V+vjVfvNBAMAoAKqveEEACZ4PJ5SDaeBneLldFiGEgEAAAAAINUJC9L746/Qta3t9xd2uT36zcz1ev27nbb7ogMA4K1oOAHwC2v3H9e+o6dstcGJ8YbSAAAAAABwRq2gAL11dxcN69yw1GsvLtimZ+dtlttN0wkA4N2q7B5O48aNkyRZlqUpU6aUqldEyfcCgIs1d22qbbtZTJg6JEQaSgMAAAAAgF2g06GXRnRUXESw3ly4y/Za8g97lXEiX/8Y2UnBAU5DCQEAOL8qazglJyfLsk6Pqjq7SXR2vTw8Hg8NJwAVUuRya/76dFttUGJ8hX4WAQAAAABQVSzL0lM3tlZMeLD+PH+z7bXP1qfr2MkCvXV3F9UOCTSUEAB8SFGRtG2bvdaqlRRQZW0Rv1dl/2UbN258zg9zy6oDQFVZuuuIjpwssNUGJyYYSgMAAAAAwPnde3VTxYQH6YkZ61ToOjNK74ddR3TbW8uVPK6b4mqHGEwIAD7g2DGpfXt77fBhKTbWTB4/UGUNp71795arDgBVpeQ4vU4NI9U0JsxQGgAAAAAALmxwYoLqhgXpgfdW62SBq7i+OT1bw978QdPGXcHvtgAAr+IwHQAAqlJugUsLNh201QaxugkAAAAA4AOuuTxWH95/pWLCg2z1/UdzNezNH7Ru/3EzwQAAOAcaTgBqtG+2HLJ9E8xhSQM7NjCYCAAAAACAi9ehYaRmPdhTTaJr2epHTxZo1KTlWrjtsKFkAADYeW3DKT8/X4cOHZLb7TYdBYAPm5uSZtvu2TxGcRHMuQYAAAAA+I4m0WGa+UBPtU+IsNVzC10a/+4qzV5zwFAyAADOqPaG04kTJ/T555/r888/14kTJ0q9npmZqWHDhikiIkLx8fGqU6eOfv3rXys/P7+6owLwccdPFWjRdvs3vQYnxhtKAwAAAABAxcXWDtaH91+pq1vE2OpFbo8e/3id3lq0Sx6Px1A6AAAMNJxmzZqlW265RQ888IBq1bIvBXa73RowYIDmzJmjwsJCeTwe5eTk6J///KfuuOOO6o4KwMd9vuGgCl1n/rEdFODQDe3rG0wEAAAAAEDFhQcHaOqYbhrUqfSXKf/2xVY999kWud00nQAAZlR7w2nBggWSpKFDh8rhsJ/+o48+0urVqyVJnTt31q9+9St17txZHo9Hc+bM0ZdfflndcQH4sLkpqbbt61rHKSIk0FAaAAAAAAAuXVCAQ/+8LVH3Xt201GtTvt+jxz5KUX6R6xxHAgBQtQKq+4QbN26UZVnq2bNnqdemTZsmSerSpYt++OEHBQQEqLCwUNdcc41Wrlypd999VzfeeGN1Rwbgg9KO5+rHPUdttcGJCYbSAAAAAABQeRwOS0/f0lb1I0L0l8+32F77dF2ajpzM13/u6qLafOkSAFCNqn2F0+HDp++n0rSp/VsYhYWFWrx4sSzL0kMPPaSAgNO9sMDAQD3wwAPyeDxasWJFdccF4KPmrUuzbdcOCVCfVrGG0gAAAAAAUPnu69VMr9zWSQEOy1ZfuvOIRk1arowc7okOAKg+1d5wOnr09IqDoKAgW33lypXKzc2VpFKrmFq2bClJOnjwYDUkBFATzE2xN5xuat9AIYFOQ2kAAAAAAKgaQ5MaasqYbqoVZP+dd1Natoa9+YP2Zp40lAwA4G+qveFUq1YtSWdWOv1s8eLFkqQWLVqoXr16ttdCQ0OrJxyAGmHHoRxtTs+21QYllr6hKgAAAAAANUHvlrGafl8PRYfZv+C97+gpDXvzB60/cNxMMACAX6n2hlPz5s0lSQsXLrTVP/nkE1mWpV69epU6JiMjQ5IUFxdX5fkA+L6Sq5viagerR7NoQ2kAAAAAAKh6nRpFaeaDPdWorv2L20dOFmjUpOVavD3DUDIAgL+o9obT9ddfL4/HozfeeENffPGFTpw4oddee00rV66UJA0cOLDUMevXr5ckxcezQgHA+Xk8Hs1dl2qrDeoUL2eJedYAAAAAANQ0TWPCNOvBnmoXH2GrnypwaVzySs1Zm1rGkQAAXLpqbzg9+uijioiIUE5Ojm655RZFRkbqsccekyS1adPmnA2nzz77TJZlKSkpqZrTAvA1a/Yd1/6jubba4MQEQ2kAAAAAAKhecbVD9OH9PXRVC/ukjyK3R499lKK3F+82lAwAUNNVe8OpQYMGmjdvnurXry+Px1P8aNasmWbOnCnLsq9C2LVrl5YsWSJJ6tevX3XHBeBjPk2xf1urWUyY2idElLE3AAAAAAA1T+2QQE0d000DO5WeFvSXz7foufmb5XZ7DCQDgGoUGSl99539ERlpOlWNFmDipNdcc4327NmjpUuX6uDBg2rQoIGuvvpqBQSUjpOenq6nn35aktS/f//qjgrAhxS53Jq/Pt1WG5yYUKqRDQAAAABATRcc4NSrtyUqNjxYU5fusb02+fs9yjyRr78P76SggGr/PjoAVI+gIKlPH9Mp/IqRhpMkBQUFqW/fvhfc7+qrr9bVV19dDYkA+Lrvd2bqyMkCW21QIvd+AwAAAAD4J4fD0tO3tFFcRLCe/2Kr7bU5KWk6crJAb97VReHBxj4iBADUIHyFAUCN8WlKmm27U8NINY0JM5QGAAAAAADzLMvSA72b6+URnRTgsE8AWbIjU7dPWq6MnHxD6QAANQkNJwA1Qm6BSws2HbTVBicmGEoDAAAAAIB3GdaloSbf01WhgU5bfUNqlob/5wf9dOSkoWQAgJrC6HrZdevWacmSJdq9e7dycnLkcrnOu79lWZoyZUo1pQPgS77ZckgnC878DHFY0i0dGxhMBAAAAACAd+nTKk7T7++hcckrdfSskfQ/HTmlYW/+oOSx3dU+IdJgQgCALzPScNq2bZvGjRun5cuXX/QxHo+HhhOAMs0tMU6vZ/MYxUWEGEoDAAAAAIB3SmwUpZkPXKnRU1fowLHc4nrmiQLd9tYyvXV3V119eYzBhABQSdxu6cgRey06WnIw+K2qVHvDKTU1Vb169VJmZqY8Ho8kKTw8XHXq1JGD/6EBVMDxUwVatP2wrTY4Md5QGgAAAAAAvFuz2HDNfrCn7nlnpbakZxfXTxa4NDZ5hV4a0Ykx9QB835EjUlycvXb4sBQbayaPH6j2htNf/vIXZWRkyLIsjR8/Xk888YRatmxZ3TEA1CCfbzioQpeneDsowKEb2tc3mAgAAAAAAO8WFxGijyb00APvrdYPu86sACh0efTohynKyMnX+GuaGUwIAPA11b6k6Msvv5RlWRo9erQmTZpEswnAJZubkmrbvq51nCJCAg2lAQAAAADAN0SEBOqdsd108znugfzcZ1v0t8+3yO32nONIAABKq/aGU1ra6fusjB49urpPDaAGSjueqxV7j9pqLPsHAAAAAODiBAc49dqoJI3peVmp195avFu/nrFOhS539QcDAPicam841alTR5IUFRVV3acGUAPNW5cmz1lftqodEqA+rZjDCgAAAADAxXI4LD0zsK1+c2OrUq99sjZV9767SifziwwkAwD4kmpvOHXt2lWStH379uo+NYAaaG5Kmm17QPv6Cgl0GkoDAAAAAIBvsixLv+jTQi8O7yinw7K9tnh7hm5/e7kyT+QbSgcA8AXV3nB65JFH5PF4NGnSpOo+NYAaZsehHG1Oz7bVhjBODwAAAACAChvRtZEmj+6q0BJf5lx/IEvD3/xB+46cMpQMAODtqr3hdP311+upp57Sd999pwcffFCFhYXVHQFADVFydVNc7WBd0SzaUBoAAAAAAGqGvq3j9MF9V6hOrUBbfe+RU7r1zR+0MTXLUDIAgDcLqO4TTps2TW3atFHPnj01adIkzZs3T8OHD1fr1q1Vq1atCx4/evToakgJwNt5PB7NXZdqqw3sFF9q2T8AAAAAACi/pMZ1NPPBnho9ZYVSj+cW1zNP5GvUpOV66+4uuqpFjMGEAABvU+0NpzFjxsiyznwgnJ6ertdee+2ijrUsi4YTAEnS2v3Htf9orq3GOD0AAAAAACpP89hwzf5FT90zdYW2Hswprp/IL9KYd1bo5ZGJGtQp3mBCAIA3qfaRetLplQkVfQCAJH1aYpxes5gwtU+IMJQGAAAAAICaqV5EiD5+4Er1aFbXVi90efTI9LV6Z+keQ8kAAN6m2lc47dnDX0IALk2Ry6356+0Np0GJ8bbVkwAAAAAAoHJEhAQqeWx3Pf5xij7fcND22rPzNuv4qUI91u9yfi8HAD9X7Q2nJk2aVPcpAdQwS3cdUeaJAlttMOP0AAAAAACoMiGBTr12e2fFhm/Su8t+sr326v92KCu3UH+8pa0c3FsZAPyWkZF6AHAp5qak2rY7NYxU05gwQ2kAAAAAAPAPToeliYPa6ckbWpV6LfmHvXpi5joVudwGkgEAvAENJwA+JbfApQUb7cv3B7G6CQAAAACAamFZlh7q20LPDWmvkhP0Zq9J1QP/XaO8QpeZcAAAo6p9pN7ZduzYoWnTpmnZsmU6ePCgcnNztWDBArVo0aJ4n40bN2rfvn0KCwtT7969DaYF4A3+t/WQThac+Yerw5IGdmxgMBEAAAAAAP7nrh5NFBEaqMc/SlGR21Nc/2bLIY19Z6XevqerwoONfvQIwN9FREgff1y6hipj5Ke+2+3Wb37zG7366qtyu93yeE7/pWRZlgoK7Pdl2bdvn2655RYFBARoz549SkhgJQPgz+ampNm2ezaPUVxEiKE0AAAAAAD4r0Gd4lU7OEAP/He18ovOjNJbtvuI7nh7uZLHdlfdsCCDCQH4teBgacQI0yn8ipGRehMmTNArr7wil8ul+Ph4DR8+vMx9b7rpJjVt2lQul0szZ86sxpQAvM3xUwVauO2wrTYoMd5QGgAAAAAA0Ld1nN679wrVLrGaaf2BLN321jIdzMozlAwAUN2qveH0v//9T1OmTJEk/d///Z/27t2rj0suaythxIgR8ng8+vbbb6sjIgAv9cXGgyp0nVmmHxTg0I3t6xtMBAAAAAAAujetq+n391B0idVMOw6f0LA3f9DezJOGkgEAqlO1N5wmTZok6fTKpeeee05Op/OCx3Tv3l2StGnTpirNBsC7zU1JtW1f1zpOESGBhtIAAAAAAICftU+I1IwHrlR8pH3sferxXA3/zzJtTss2lAwAUF2qveG0bNkyWZale++996KPadiwoSTp4MGDVRULgJdLz8rVj3uO2mqDGacHAAAAAIDXaBYbrpkP9lSz2DBbPfNEvkZNWqbVPx0t40gAQE1Q7Q2nw4dP33/lsssuu+hjAgNPr2AoKiqqikgAfMC8dWnynJmmp9ohAerTKs5cIAAAAAAAUEp8VKhmTLhS7RMibPXsvCLdNXmFvt+RaSgZAKCqVXvDKSzs9DccMjIyLvqYAwcOSJLq1q1bJZkAeL+5KWm27QHt6ysk8MIjOQEAAAAAQPWKDg/WB/f1UPem9s/ycgtdGvfuSn279ZChZAD8SkaGZFn2Rzn6Eii/am84NWvWTJK0efPmiz7miy++kCS1a9euSjIB8G47D+doU4lZz4MTEwylAQAAAAAAFxIREqhp47rr2tb26SQFRW7dP221Pt+QbigZAKCqVHvDqX///vJ4PHr99dfldrsvuP/mzZuVnJwsy7J00003VUNCAN6m5OqmuNrB6tEs2lAaAAAAAABwMUICnXrr7i66pWMDW73I7dHDH6zRrNUHDCUDAFSFam84PfLIIwoLC9OuXbv0wAMPnPe+TF9//bX69++vvLw81a1bV/fdd181JgXgDTweT6mG08BO8XI6LEOJAAAAAADAxQp0OvTqqCQN79LQVnd7pF/PWKf3f/zJUDIAQGULqO4T1qtXT//5z380evRoTZkyRQsWLNDNN99c/Pqrr74qj8ejpUuXauvWrfJ4PHI4HEpOTlZ4eHh1xwVg2Nr9x7Xv6ClbbXBivKE0AAAAAACgvJwOS38f1lGhgU69t9zeYPr9JxuVW+DS+GuaGUoHAKgs1d5wkqQ777xTgYGBmjBhgvbv36+33npLlnV6tcLkyZMlnV7VIEnh4eF69913bU0pAP7j0xKrm5rFhKlDQqShNAAAAAAAoCIcDkt/GtxOoUFOTVq82/bac59tUV6hSw9fe7mhdACAylDtI/V+NnLkSO3cuVPPPvusunTpIqfTKY/HU/xo166dfve732nnzp0aOnSoqZgADCpyuTV/vb3hNCgxvrhBDQAAAAAAfIdlWfrdgNZ6rF/pxtJLX23X37/cWvwldACA7zGywuln0dHRevrpp/X000/L7Xbr6NGjcrlcqlu3rgIDA01GA+AFlu46oswTBbba4MQEQ2kAAAAAAMClsixLj/VrqdBAp/72xVbba28s3KVTBS49M7AtXzYFAB9ktOF0NofDoZiYGNMxAHiRuSmptu1ODSPVNCbMUBoAAAAAAFBZJvRurtAgp/44d5OtnvzDXuUXufSXIR3kcNB0AgBfUu0NJ5fLpZUrV2rJkiXavn27jh07ppycHEVERKhu3bpq1aqVrr76anXt2lUOh7GJfwAMyyt0acHGg7baIFY3AQAAAABQY4y+8jKFBDj11Oz1OnuS3vQV+1Xk8uj5YR3lpOkEAD6j2hpORUVFev311/XSSy8pLS3tgvs3atRITz75pB544AE5nc5qSAjAm3yz5ZBOFriKtx2WNLBjA4OJAAAAAABAZRvZrZFCgpz61UcpcrnPdJ1mrD4gl8ejF4d3oukEAD6iWpYQHTlyRNdee60ef/xxpaWlyePxXPCxf/9+PfLII+rfv7+OHj1aHTEBeJG5KfbGdM/mMYqLCDGUBgAAAAAAVJVBneL15p2dFei0N5Zmr0nVEzPW2RpRAADvVeUrnFwul26++WatXLlSHo9HlmWpf//+6tevnzp37qzo6GiFh4crJydHmZmZWrt2rb7++mv973//k8fj0cKFCzVo0CAtXryYEXuAn8g6VaiF2w7baoMS4w2lAQAAAAAAVa1/u/r6z11d9OB/16jA5S6uf7I2VW6PRy+P6KQAJ58NAoA3q/KG0/PPP68VK1bIsiwlJSXpvffeU9u2bcvcv1+/fnryySe1ceNGjR49WikpKVq2bJlefPFFPfXUU1UdF4AX+HxjugpdZ769FBTg0I3t6xtMBAAAAAAAqtp1berprbu7aMJ/V6ug6EzTaW5Kmtwe6ZWRNJ0AwJtV6U/owsJC/etf/ypuNi1duvS8zaaztW/fXj/88IOSkpLk8Xj0yiuvqKioqCrjAvASc1NSbdvXtY5TREigoTQAAAAAAKC69G0dp7dHd1VQgP1jy3nr0vTohykqPGv1EwDAu1TpCqd58+YpIyNDDodD//3vfxUSUr77r4SEhOi9995Thw4dlJGRofnz52vIkCFVExaAV0jPytWPe+z3bRvMOD0AAAAAAPxG75axmjy6q+6btkr5Z610+mxDutwej/51e5ICWekE4ELCw6V//7t0DVWmSn8yf//995JOj8lr3bp1hd6jbdu2uv766yVJS5YsqbRsALzTvHVp8px1L9DaIQHq0yrOXCAAAAAAAFDterWM1ZR7uikk0P7x5RcbD+qh99fYRu4BwDmFhkoPPWR/hIaaTlWjVWnDafXq1bIsS9ddd90lvc91110nj8ej1atXV1IyAN5qbkqabXtA+/oKCXQaSgMAAAAAAEy5+vIYTT1H0+mrzYf0i/fXKL/IZSgZAOBcqrThtH//fklSx44dL+l9fj7+p59+uuRMALzXzsM52pSWbasNTkwwlAYAAAAAAJjWs0WMksd2V2iJL6N+s+WQfvFfVjoBgDep0oZTVlaWJKlOnTqX9D4/H//z+wGomUquboqrHawezaINpQEAAAAAAN6gR7NovTuuu2oF2ZtO/9t6WL+cvkaFLppOAOANqrThlJ19eqVC+CXeiCssLEySlJOTc8mZAHgnj8dTquE0sFO8nA7LUCIAAAAAAOAtujetq2njuiusRNNpwaZDeuzDFBXRdAIA46q04eRyVe4cVbebvziAmipl/3HtO3rKVhucGG8oDQAAAAAA8DZdL6urafeWXun02YZ0/XrGOrncHkPJAABSFTecAOBilVzd1DQmTB0SIg2lAQAAAAAA3qhLk7p6Z0y3Uvd0mpuSpt/MXC83TScAP8vMlGJj7Y/MTNOparSA6jjJG2+8obi4uAoff/jw4UpMc9qqVav0+eef6/vvv9fmzZuVkZGhwMBAxcfH66qrrtK9996rq6++ulLPOX36dL3zzjtav369jh8/rnr16umaa67RQw89pCuvvLJSzwX4kkKXW/PW2RtOgzrFy7IYpwcAAAAAAOyuaBatKfd01djklcovOjMRadaaAwp0Wvrr0A5yMKIfgMdTusHkoSldlaql4fTmm29Wx2kuWq9evbRkyZJS9YKCAu3YsUM7duxQcnKyRo8erbfffltBQUGXdL7c3FwNHz5cn3/+ua2+b98+vf/++5o+fbr++Mc/6plnnrmk8wC+6vudmTpyssBWG5qUYCgNAAAAAADwdj1bxOjt0V01ftoqFZzVdPpw5X4FOC39eXB7vsgKANWsykfqeTyeSnlUprS00ysp4uPj9eijj2rmzJlasWKFli1bpn/84x9KSDj9Qfe0adM0ZsyYSz7fuHHjiptNffv21Zw5c7RixQpNmTJFzZs3l9vt1sSJEzVp0qRLPhfgi+asTbVtJzaK0mUxYYbSAAAAAAAAX9CrZazeuquLAp32xtJ/l+/Ts/M2V/pnigCA86vSFU7fffddVb59hbVu3Vp//etfNWzYMDmd9nmvPXr00N13362rrrpK27dv1/Tp0/XAAw+oV69eFTrXt99+qw8//FCSNHDgQH3yySfF5+zWrZsGDRqkLl26aN++fXrqqac0YsQI1alT59L+gIAPOZlfpK82HbLVhiTGG0oDAAAAAAB8Sd/WcXrjzi568L+rVXTW/ZuSf9irQKel/7upDSudAKCaVGnDqXfv3lX59hU2f/78874eExOjl19+WQMHDpQkzZw5s8INp5deekmSFBAQoDfeeKNUgysmJkYvvPCCbr/9dh0/flyTJ0/Wk08+WaFzAb7oq80HlVvoKt52Oizd0omGEwAAAAAAuDjXt62n125P0sPT18p1VtPp7SV7FBro1OP9WxlMBwD+o8pH6vmqvn37Fj/ftWtXhd4jJydH//vf/yRJ/fr1U8OGDc+536233qqIiAhJ0ieffFKhcwG+6pO1abbtay6PUUx4sKE0AAAAAADAFw3o0ECv3JYoR4nFTP/6dqfeWlSxz/YAAOVDw6kM+fn5xc9Lrkq6WCtXrlRBQYGk86/2CgoKUo8ePYqPKSwsrND5AF+TkZOv73dk2GpDkxIMpQEAAAAAAL5sUKd4vTyyk0pO0PvbF1v13+U/mQkFAH6kSkfq+bJFixYVP2/Tpk2F3mPz5s3Fz1u3bn3efVu3bq2vvvpKRUVF2rFjh9q2bXvR5zlw4MB5X09PTy9+npubq9zc3It+b3+Vl5d3zueoXLNX7ddZK91VK9Cpq5tG8v9RL8V1AZTGdQGUxnUBlMZ1AZwb1waqwo2to5V9cys9M3+brf70nI0KtNwa1LG+oWQXh+sCKK3C10VurkJLlXIlPnuUpCr5DJaG0zm43W49//zzxdsjR46s0Puc3Qgqa5zezxo1alT8fP/+/eVqOJ197IUsXrxYMTExF70/Tv83Q9V4f71T0pmvHbWNLNT3C/9nLhAuGtcFUBrXBVAa1wVQGtcFcG5cG6hMUZKGNLE056czU4s8kn73ySZt37xBHet6yjrUq3BdAKWV57oIysrSgBK1hQsXqiAysnJD+ajMzMxKf09G6p3DK6+8ohUrVkg6fX+lLl26VOh9cnJyip+Hh4efd9+wsLDi5ydOnKjQ+QBfcihX2nfSvsa9a6xv/IMPAAAAAAB4t77xHt3Y0GWruWUpebtDW49bZRwFALgUrHAqYdGiRfrtb38rSYqLi9Obb75Z4fc6e3lfUFDQefcNDg4ufl7epWz79+8/7+vp6enq3r27JKlXr14XXG2F0//b/dwt79Wrl0JCQgwnqnn+9d1uSXuLt6PDAvXQ8D4KcNAH91ZcF0BpXBdAaVwXQGlcF8C5cW2gql3v8aj+VzuVvPzMZ2cuj6V3dgRq8t2J6tI4yly4MnBdAKVV+LrIyChV6tOnjxQbW4npfNeFbtVTETSczrJp0yYNHTpURUVFCgkJ0YwZMxQXF1fh9zv7//gFBQXn3Tc/P7/4eWhoycmS51eeBlJoaGi539/fhYSE8N+sknk8Hn228bCtNigxQbXPWukH78Z1AZTGdQGUxnUBlMZ1AZwb1waqyjODOyjfLU1fcabplFfk1oMfrNcH9/VQh4beO1qL6wIorVzXxTn2Cw0NPWfdH1XFzxeWEvx/e/bsUf/+/XXs2DE5nU59+OGH6tWr1yW9Z+3atYufX2hM3smTJ4ufX2j8HuDr1uw7rn1HT9lqQxITDKUBAAAAAAA1lWVZem5IBw3qFG+r5+QXafTUH7X9UE4ZRwIAyouGk6S0tDT169dPaWlpsixLU6dO1eDBgy/5fc9eeXSh5Wlnj8Vr1KjRJZ8b8GZzU1Jt281iwtTRi79RBAAAAAAAfJfTYenlkZ3Ur419ktGxU4W6e8qPOnDsVBlHAgDKw+9H6mVmZur666/X7t27JUmvvfaaRo8eXSnv3bZt2+LnW7duPe++P78eEBCgyy+/vFLOD3ijQpdb89al2WpDkhJkWdywEwAAAAAAVI1Ap0P/vqOz7n13pZbuPFJcP5Sdr9FTVmjGA1cqOjz4PO8AwOfUqiU980zpGqqMX69wysrK0g033KDNmzdLkp5//nk99NBDlfb+3bp1U1BQkCRp0aJFZe5XUFCg5cuXFx8TGBhYaRkAb7N4e4aOnSq01QYnxpexNwAAAAAAQOUICXRq0t1d1blxlK2+O/Okxiav1In8IjPBAFSNsDBp4kT7g3vIVym/bTidOnVKN998s9asWSNJ+v3vf6+nnnqqUs9Ru3ZtXXfddZKkb775psyxerNnz1Z2drYkaejQoZWaAfA2c1Lsq5s6N45Sk2h+0AMAAAAAgKoXFhygqWO6qWU9+z3U1x/I0oT3Vim/yGUoGQD4Pr9sOBUUFGjo0KFaunSpJOnRRx/Vc889V+73SU5OlmVZsixLEydOPOc+TzzxhCSpqKhIDz30kFwu+19amZmZxY2uqKgojR8/vtw5AF9xIr9IX28+aKsNSUowlAYAAAAAAPijqFpBmjbuCiVEhdrqS3ce0eMfrZPL7TGUDAB8m1/ew+n222/XV199JUm69tprde+992rjxo1l7h8UFKSWLVtW6FzXXnutRo0apQ8//FCffvqprr/+ej322GOKj4/Xhg0b9Je//EX79u2TJL3wwguqU6dOhc4D+IIFGw8qr9BdvB3gsHRzhwYGEwEAAAAAAH9UPzJE793bXcP/s0xHTxYU1z/bkK66YUH60+B23G8aAMrJLxtOs2fPLn7+7bffqmPHjufdv0mTJtq7d2+Fzzd16lRlZ2fr888/13fffafvvvvO9rrD4dDTTz+t+++/v8LnAHzBnJRU23bvlrHckBMAAAAAABjRLDZcyWO76fZJy3Wy4MxUoveW/6To8CA91q9iX0AHAH/llyP1qltoaKg+++wzvf/++7r++usVFxenoKAgNWrUSHfccYe+//77MkfyATXF4ew8Ld2ZaasNZpweAAAAAAAwqGPDKE0a3VVBTvvHpP/8ZofeW7bXTCgA8FF+ucLJ46mcOaxjxozRmDFjLnr/O+64Q3fccUelnBvwNZ+uS9PZI5DDgpy6vk09c4EAAAAAAAAkXdUiRq/clqiHp6/R2R8b/vHTTaoTFqRbOsabCweg4o4ela65xl5bskSqW9dMHj/glw0nANWv5Di9G9rXV2iQ01AaAAAAAACAM27u2EBHT7XX03PO3Ofd45F+9VGK6tYKUs8WMQbTAagQl0vavLl0DVWGkXoAqtzOwznamJptqw1lnB4AAAAAAPAid/dool+VuG9TocujCe+t1taD2WUcBQD4GQ0nAFVuzto023Zs7WD1bM43gwAAAAAAgHd55LoWGn1lE1stJ79IY6auVHpWrqFUAOAbaDgBqFIej6fUOL1BneLldFiGEgEAAAAAAJybZVl6ZmA7DWhf31Y/mJ2nMVNXKjuv0FAyAPB+NJwAVKnVPx3TgWP2bwAxTg8AAAAAAHgrp8PSK7clqmuTOrb6tkM5mjBttQqK3IaSAYB3o+EEoEp9sta+uql5bJjaxUcYSgMAAAAAAHBhIYFOvT26q5rFhtnqy3Yf0W9mrpPb7TGUDAC8Fw0nAFWmoMitzzak22pDkxJkWYzTAwAAAAAA3q1OWJDeHdtdMeHBtvqclDS9+NU2Q6kAwHvRcAJQZRZtz9DxU/bZxoMTGacHAAAAAAB8Q6O6tfTOmG6qFeS01d9cuEvvLf/JUCoA8E40nABUmTklxul1bVJHjerWMpQGAAAAAACg/Do0jNTrd3aW02Gf2PLM3I36evMhQ6kAwPvQcAJQJbLzCvXNFvs/uoYksboJAAAAAAD4nr6t4vTXoe1tNbdH+uX0NVqz75ihVADgXWg4AagSX248qPwid/F2gMPSzR0aGEwEAAAAAABQcbd1a6xHr7vcVssrdOu+d1dp/9FThlIBgPeg4QSgSsxNsY/T69MqTnXCggylAQAAAAAAuHSP9btcI7o0tNWOnCzQuOSVys4rLOMoAPAPNJwAVLqDWXn6YdcRW21IUryhNAAAAAAAAJXDsiz99dYOuubyGFt9x+ETeuj9NSp0ucs4EgBqPhpOACrdp+tS5fGc2Q4PDlC/NvXMBQIAAAAAAKgkgU6HXr+zs1rWC7fVl+zI1DOfbpLn7A9FAMCPBJgOAKDmmbM2zbZ9Y/v6Cgl0GkoDAAAAAABQuSJCAjXlnm4a+sZSZZ4oKK5/8OM+NYsJ0/hrmhlMB0CSFBIi/eIXpWuoMjScAFSq7YdytDk921YbmpRgKA0AAAAAAEDVaFS3lt4e3VWjJi1XftGZUXp/+XyLGtetpf7t6htMB0C1a0uvv246hV9hpB6ASvXJ2lTbdr2IYPVoFm0oDQAAAAAAQNVJalxH/xiZaKt5PNKjH6ZoY2qWmVAAYAgNJwCVxu32aG6JhtOgTvFyOixDiQAAAAAAAKrWzR0b6MkbWtlquYUu3fvuSqVn5RpKBQDVj4YTgEqzfM8RpWXl2WpDkxoaSgMAAAAAAFA9ftGnuYZ3sX8Gcig7X/cmr9LJ/CJDqQCgetFwAlBpPlljX93Uun5ttY2PMJQGAAAAAACgeliWpb8O7aArmta11TenZ+vRD9fK5fYYSgYA1YeGE4BKkVvg0ucb0m21oUkJhtIAAAAAAABUr6AAh966u4uaxoTZ6t9sOay/L9hqKBUAVB8aTgAqxVebD+pkgat422FJQ2g4AQAAAAAAPxJVK0hTx3RTVK1AW/2tRbs1e80BQ6kAP3X8uNSnj/1x/LjJRDVegOkAAGqGT9bax+ld1SJG9SJCDKUBAAAAAAAwo2lMmN66q4vumvKjCl1nRun9dvYGNY0JU1LjOgbTAX6ksFBatKh0DVWGFU4ALtnhnDwt3p5hqzFODwAAAAAA+KsrmkXrz4Pb22oFRW5NeG+1DmblGUoFAFWLhhOAS/ZpSprOvvdlaKBTN7Srby4QAAAAAACAYaO6N9aYnpfZaodz8nX/e6uUV+g690EA4MNoOAG4ZCXH6Q1oX19hwUzsBAAAAAAA/u0PN7fR1S1ibLX1B7L01Kz18ng8ZRwFAL6JhhOAS7LtYI42pWXbakM7M04PAAAAAAAgwOnQv+9IUpPoWrb63JQ0vblol6FUAFA1aDgBuCSz1x6wbdeLCFbP5jFl7A0AAAAAAOBfomoFafLorgovMQ3mxQXb9M3mQ4ZSAUDlo+EEoMJcbo/mrk2z1YYkJsjpsAwlAgAAAAAA8D6X16utf92eKOusj0w8HunRD9dq+6Ecc8EAoBLRcAJQYct2HdHB7DxbjXF6AAAAAAAApV3bup6eurG1rXaywKXx767SsZMFhlIBQOWh4QSgwkqO02vTIEKt60cYSgMAAAAAAODdJvRqpqFJ9i/r7jt6Sg99sEZFLrehVABQOWg4AaiQUwVF+nLjQVttGKubAAAAAAAAymRZlv52awd1ahRlq/+w64j+vmCbmVAAUEloOAGokK82HdKpAlfxtsOSBnWKN5gIAAAAAADA+4UEOjXp7i6qFxFsq09avFufbzxkKBUAXDoaTgAqZNYa+zi9qy+PVVxEiKE0AAAAAAAAvqNeRIjevKuLAp2Wrf6HT7co7aShUABwiWg4ASi3w9l5Wroz01ZjnB4AAAAAAMDF69y4jp4d1N5Wyy10a/I2p04VGQoFAJeAhhOAcpubkia358x2WJBT/dvWNxcIAAAAAADAB91xRWON6tbIVjuSb2naDodcZ3/4AgA+IMB0AAC+p+Q4vRvbN1BokNNQGgAAAAAAAN/17OB22nowRyn7jxfXthx36LWFu/W7m9uXfSCA8wsKkoYPL11DlaHhBKBctqRna+vBHFuNcXoAAAAAAAAVExzg1Jt3ddbA175X5omC4vpbS35S58tidEM7psoAFRIZKc2YYTqFX2GkHoBy+WRtqm27QWSIejSLNpQGAAAAAADA9zWIDNXrd3RWgMOy1X/98TrtPJxTxlEA4F1oOAG4aC63R3NKNJwGJybIUeIfQwAAAAAAACifK5pF66n+LWy1E/lFuv+91crJKzSUCgAuHg0nABdt6c5MHc7Jt9VuZZweAAAAAABApbize0N1i3HbarszTurxj9fJ7fYYSgUAF4eGE4CLVnKcXvuECLWsV9tQGgAAAAAAgJrFsiyNbOZWwzB7c+nrzYf0n8W7DKUCgItDwwnARTmZX6QvNx601YYmNTSUBgAAAAAAoGYKckr3tnIpKjTQVn9pwTb9sCvTUCoAuDAaTgAuypcbDyq30FW87XRYGtQp3mAiAAAAAACAmqlusPTy8HayzrptttsjPTJ9rQ5l55kLBviSrCxpxAj7IyvLdKoajYYTgItScpxer8tjFFs72FAaAAAAAACAmq1ns7p6vF9LWy3zRIEe/mCNCl3uMo4CUKygQJo50/4oKDCdqkaj4QTggg5m5WlpiSXbQzszTg8AAAAAAKAqPdS3hfq2irXVVu49phcXbDOUCADKRsMJwAXNSUmV56x7VdYODlD/tvXMBQIAAAAAAPADDoelV25LVEJUqK0+afHuUvfaBgDTaDgBOC+Px6NP1tjH6Q3oUF8hgU5DiQAAAAAAAPxHVK0gvXlXZwU57R/lPjljnfZknjSUCgBKo+EE4Lw2pWVr26EcW21oEuP0AAAAAAAAqkvHhlF6emBbWy0nv0gP/ne1cgtchlIBgB0NJwDnNXP1Adt2QlSormha11AaAAAAAAAA/3TXFY01JDHeVtt6MEdPz90oz9n3QgAAQ2g4AShTQZFbc1Ps4/SGdU6Qw2EZSgQAAAAAAOCfLMvSX2/toJb1wm31masP6KOV+w2lAoAzaDgBKNN32w7r2KlCW+3WzozTAwAAAAAAMKFWUIDevKuLwoLs99b+46ebtDE1y1AqADiNhhOAMs0qMU6va5M6uiwmzFAaAAAAAAAANI8N1wvDO9pqBUVuPfTBGuXkFZZxFABUPRpOAM7pyIl8fbv1sK02vAurmwAAAAAAAEy7pWO8xvS8zFb76cgp/W72Bu7nBMAYGk4AzunTdWkqcp/5B0pwgEM3dWxgMBEAAAAAAAB+9n83tVFioyhbbf76dH2wYp+ZQAD8Hg0nAOc0a419nN4N7eorIiTQUBoAAAAAAACcLSjAodduT1JESICt/uy8zdqSnm0oFQB/RsMJQClbD2ZrY6r9HyaM0wMAAAAAAPAujerW0osjOtlqP9/P6WR+kaFUAPwVDScApcxabV/dVD8iRFe1iDGUBgAAAAAAAGW5oV39Uvdz2p1xUn+Ys5H7OQGoVgEX3gWAPylyufXJ2jRbbUhSgpwOy1AiAAAAAAAAnM/vbmqt1T8d04bUrOLaJ2tTdWWzaI3s1shgMsCgwECpd+/SNVQZGk4AbJbsyFTmiXxbbXiXBENpAAAAAAAAcCHBAU69fkdn3fyvJco5a5TeHz/dqMTGUWpZr7bBdIAhUVHSwoWmU/gVRuoBsJlZYpxep0ZRahHHP0oAAAAAAAC8WePoWnp+WEdbLa/QrYfeX6NTBdzPCUDVo+EEoFjWqUJ9vfmQrTa8M6ubAAAAAAAAfMHNHRvorh6NbbUdh0/ombmbDCUC4E9oOAEoNm99mgpc7uLtIKdDAzvFG0wEAAAAAACA8vjDzW3VtkGErTZj9QHNXnOgjCMAoHLQcAJQbFaJf3j0axunqFpBhtIAAAAAAACgvEICnfr3HUkKC3La6n+Ys1G7M04YSgXAH9BwAiBJ2pVxQmv3HbfVhnVuaCYMAAAAAAAAKqxZbLj+emsHW+1UgUuPfLhW+UUuQ6kA1HQBpgMA8A6zVttXN8WEB6lXy1hDaQAAAAAAAHApBicmaNmuI/pw5f7i2sbUbL20YJt+f3Nbg8mAapKTI/32t/ba889LtWubyeMHaDgBkMvt0SdrU221wYkJCnSyCBIAAAAAAMBXPTOwnVb9dEw7D58Zpff2kj26qkWM+rSKM5gMqAZ5edIbb9hrEyfScKpCfJoMQMt2HVF6Vp6tNrwL4/QAAAAAAAB8WWiQU/8alaSgEl8qfmLGOmXk5BtKBaCmouEEQDNX77dtt20QoTYNIgylAQAAAAAAQGVpGx+h393U2lbLPFGgJ2ask9vtMZQKQE1Ewwnwczl5hfpy00FbbRirmwAAAAAAAGqMMT0v07Wt7SP0Fm3P0NSlewwlAlAT0XAC/NwXGw4qr9BdvB3gsDQ4Md5gIgAAAAAAAFQmy7L04vCOiq0dbKu/8OVWbUzNMpQKQE1DwwnwczPXHLBt92kVp5jw4DL2BgAAAAAAgC+KDg/WKyMTZVlnaoUujx6ZvlYn84vMBQNQY9BwAvzYviOntGLPUVtteJcEQ2kAAAAAAABQla6+PEb392pmq+3OPKln520ylAhATULDCfBjs0qsboqqFai+Jeb5AgAAAAAAoOb49fWt1LFhpK328aoDmr8+zVAiADUFDSfAT7ndnlINp8Gd4hUc4DSUCAAAAAAAAFUtKMChf41KUliQ/TOg383eoP1HTxlKBaAmoOEE+Knlu4/owLFcW21Yl4aG0gAAAAAAAKC6XBYTpj8PaW+r5eQV6fGPU+RyewylAuDraDgBfmrGavvqptb1a6tDQmQZewMAAAAAAKAmubVzQw1JjLfVVu49pv8s2mUoEQBfR8MJ8EPZeYX6fEO6rTa8S0NZlmUoEQAAAAAAAKrbn4e0V6O6obbaK19v14YDWYYSAfBlNJwAPzR/Xbryi9zF2wEOS0OTEgwmAgAAAAAAQHWrHRKoV0YmynHWd5CL3B49+tFa5Ra4zAUD4JNoOAF+6ONV+23b17WJU3R4sKE0AAAAAAAAMKXrZXX1UN8WttrujJP66+dbDCUC4KsCTAcAUL12HMpRyv7jttrIro3MhAEAAAAAAIBxj1x3uRZtz9D6s0bpvbf8J13bOk59W8cZTAZcAqdTatu2dA1VhhVOgJ+ZsfqAbTu2drB6t4w1lAYAAAAAAACmBTod+udtiQoNtH8Y/+TM9TpyIt9QKuAS1a0rbdpkf9StazpVjUbDCfAjhS63Zq+xN5xu7ZygACc/CgAAAAAAAPxZs9hw/eGWNrZa5ol8/Xb2Bnk8HkOpAPgSPmUG/MjCbRnKPFFgq43owjg9AAAAAAAASHd0b6zrSozQ+3rzIX20cn8ZRwDAGTScAD/y8Sr7Pw46N45Si7hwQ2kAAAAAAADgTSzL0gvDOyomPMhWf3beZu3JPGkoFQBfQcMJ8BMZOfn6buthW21EV1Y3AQAAAAAA4IyY8GC9MKyjrZZb6NJjH6Wo0OU2lAqAL6DhBPiJOWtTVeQ+M283JNChWzo2MJgIAAAAAAAA3ui6NvV05xWNbbV1+4/r39/uNJQIgC8IMB0AQNXzeDylxund1L6BaocEGkoEAAAAAAAAb/b7m9to2a4j2n3WKL1/f7dTvVrGqkuTOgaTARfp5EnpxRfttSeflMLCzOTxAzScAD+w7kCWdhw+YasxTg8AAAAAAABlqRUUoH+OStStb/xQPDXH5fbo8Y9T9Pkj1ygsmI+W4eVOnZKefdZee+ghGk5ViJF6gB+YUWJ1U6O6obqiaV1DaQAAAAAAAOALOjaM0mP9LrfVfjpySs99ttlQIgDejIYTUMPlFrj0aUqarTaiSyM5HJahRAAAAAAAAPAVD/Zpoa4lRuhNX7Ff3209bCgRAG9Fwwmo4RZsOqic/KLibcuShnVpaDARAAAAAAAAfIXTYekfIxMVFuS01Z+atV7HTxUYSgXAG9FwAmq4Gavt4/SubhGjhKhQQ2kAAAAAAADgaxpH19Ifbmlrqx3OydfTczcZSgTAG9FwAmqw/UdPaenOI7bacFY3AQAAAAAAoJxGdWukPq1ibbV569I0f31aGUcA8Dc0nIAabNaaA7btiJAA3dCuvqE0AAAAAAAA8FWWZemFYR0VGRpoq/9hzkYdzs4zlAqAN6HhBNRQbrdHM1bZG06DEuMVEugs4wgAAAAAAACgbPUiQvTnIe1tteOnCvXb2Rvk8XgMpQLgLWg4ATXU8t1HlHo811Yb2bWRoTQAAAAAAACoCQZ2bKCbOzSw1b7delgfr9pfxhEA/AUNJ6CGKvmXfKt6tdUhIdJQGgAAAAAAANQElmXpz0PaKyY82Fb/07zN2n/0lKFUALwBDSegBsrOK9QXGw/aaiO6NpRlWYYSAQAAAAAAoKaoGxakF4Z1sNVOFrj0xIx1crsZrQf4KxpOQA00b12a8ovcxdsBDktDkxIMJgIAAAAAAEBNcl2behrZtaGt9uOeo5q6dI+hRABMo+EE1EAfr7SP07uuTZyiSyxzBgAAAAAAAC7F07e0VUJUqK329wXbtPNwjqFEAEzy24bT4cOHNX/+fP3xj3/UgAEDFBMTI8uyZFmWxowZU2nnmThxYvH7XuixcOHCSjsv/NfmtGytO5Blq43o0shQGgAAAAAAANRUtUMC9eKIjrZaQZFbj3+8ToUudxlHAaipAkwHMKVevXqmIwBV4uNV9tVN9SKC1adVrKE0AAAAAAAAqMl6No/R2Ksu0ztL9xbX1h/I0hvf7dKj/S43FwywLCkmpnQNVcZvG05na9y4sVq3bq2vvvqqSs+zYcOG877etGnTKj0/ar68Qpdmrzlgq43o0kgBTr9dzAgAAAAAAIAq9tSNrbVoe4Z2Z5wsrr327Q5d1yZO7RMiDSaDX4uJkTIyTKfwK37bcPrjH/+obt26qVu3bqpXr5727t1b5Q2f9u3bV+n7Aws2HVR2XpGtNrIr4/QAAAAAAABQdUICnfrHyEQNe/MHudweSVKR26MnZqzTpw9fraAAvgwN+AO/vdKfffZZ3XLLLYzWQ43y4Qr7OL2rWkSrcXQtQ2kAAAAAAADgLxIbRekXfZrbalsP5ujf3+4wlAhAdfPbhhNQ0+zNPKllu4/Yard1a2woDQAAAAAAAPzNL6+9XK3r17bVXl+4SxtTswwlAlCdaDgBNcTHq+yrm6JqBap/W1bwAQAAAAAAoHoEBTj00ohOCnBYxTXX/x+tV1DkNpgMQHWg4VSN+vfvr7i4OAUFBSkuLk59+vTR888/r2PHjpmOBh9X5HJr5uoDttrQpASFBDoNJQIAAAAAAIA/ap8QqV/0bWGrMVoP8A8BpgP4k6+//rr4eUZGhhYtWqRFixbphRdeUHJysgYPHlyh9z1w4MB5X09PTy9+npubq9zc3Aqdx5/k5eWd87m3+m5bpg7n5NtqQzrE8b81KpWvXRdAdeC6AErjugBK47oAzo1rAyitplwX916ZoAUb07Xt0Ini2uvf7VKvFnXUrkHt8xwJlFbh6yI3V85337WVXPfcI4WGVlY0n1YVnx1bHo/HU+nv6oP27t2rpk2bSpLuueceJScnV8r7Tpw4UbNnz9aQIUPUvXt3xcfHq7CwUNu2bdP777+vr776SpLkdDo1b948DRgwoNznsCzrwjv9f5MnT1ZMTEy5zwHv9vZWhzYeO7NgsUm4R493cBlMBAAAAAAAAH924KT08gan3J4zn102qOXREx1cCmDuFqpBUFaWBtxzj632xbvvqiAy0lAi75KZmanx48dLkvbv36+GDRte8nuywqmKPfbYY5o4cWKp+hVXXKHRo0frrbfe0gMPPCCXy6Xx48dr165dCgkJqf6g8FlZBdLmY/am45VxzMQFAAAAAACAOQ3DpOsTPFpw4MznVumnLH11wKGbGvPZFVAT0XCqYlFRUed9fcKECVq5cqWmTJmitLQ0zZo1S3feeWe5zrF///7zvp6enq7u3btLknr16lUpncqaLi8vT4sXL5Z0+r+ZNzcBJy3ZK7d2F2/XCnTqiZG9FBbM5Y3K5UvXBVBduC6A0rgugNK4LoBz49oASqtp10Ufl1t7315lG633TZpT9918BaP1cNEqfF1kZJQq9enTR4qNrcR0vutCt+qpCD6R9gITJkzQlClTJEmLFi0qd8OpPA2k0NBQhTKjslxCQkK89r+Z2+3R7HUHbbWBneIVE8Vf2Kha3nxdAKZwXQClcV0ApXFdAOfGtQGUVhOui1BJL49M1JDXl6rIffrOLi6PR3/4dKs+ffhqBTFbD+VUruviHPuFhoZyD6f/ryp+vnBFe4G2bdsWP09NTTWYBL5m+Z4j+unIKVvttu6NDKUBAAAAAAAA7NonROoXfVvYalsP5ujf3+4wlAhAVaHh5AUsy7rwTsA5fLTSPk6xZb1wJTWKMhMGAAAAAAAAOIeH+7ZQ6/r2iTyvL9yljalZhhIBqAo0nLzA5s2bi5/Hx8cbTAJfcvxUgb7YaB+nd1u3xjQwAQAAAAAA4FWCAhx6aUQnBTjOfG7lcnv0xIx1KihyG0wGoDLRcPICb731VvHz3r17G0wCXzJnbartL+Qgp0O3JiUYTAQAAAAAAACcG6P1gJqPhtMlSE5OlmVZsixLEydOLPX6hg0btHPnzvO+x6RJkzR58mRJUv369TV06NCqiIoaxuPx6MMS4/RuaF9fdcKCDCUCAAAAAAAAzo/RekDNFmA6gCnff/+9rRmUmZlZ/Hznzp1KTk627T9mzJhyn2P16tUaP368+vbtqwEDBqhDhw6Kjo5WUVGRtm7dqvfff19fffWVJMnpdGrSpEkKCwur0J8H/mX9gSxtPZhjq43q1shQGgAAAAAAAODCfh6tN+T1pSpyeySdGa336cNXKyiA9RGAL/PbhtPkyZP17rvvnvO1pUuXaunSpbZaRRpOkuRyufTNN9/om2++KXOf6OhoTZkyRQMHDqzQOeB/Sq5ualQ3VFc2izaUBgAAAAAAALg4P4/W+9f/zozS+3m03uP9WxlMBuBS+W3DqTrcdNNNmjJlipYtW6a1a9fq0KFDOnLkiDwej+rWratOnTrpxhtv1JgxYxQREWE6LnzEyfwizVuXZqvd1rWRHGfddBEAAAAAAADwVg/3baGvNh20TfB5Y+Eu3di+gdrG8zkp4Kv8tuGUnJxcamxeeY0ZM+a8K5/i4uI0btw4jRs37pLOA5xt3ro0ncgvKt52WNLwLozTAwAAAAAAgG8412i9IrdHT81ar09+0VMBTkbrAb6IKxfwMR+s2Gfb7tsqTvUjQwylAQAAAAAAAMqvfUKkHujd3FbbkJqlyd/vMZQIwKWi4QT4kI2pWVp/IMtWu+OKxobSAAAAAAAAABX3y+taqEVcuK32ytfbtTvjhKFEAC4FDSfAh5Rc3dQgMkR9WsUZSgMAAAAAAABUXHCAUy8M6yjrrFuT5xe59dSs9XL//1F7QIXFxkoej/0RG2s6VY1GwwnwESfyizR3baqtdlu3RnI6rDKOAAAAAAAAALxblyZ1NKbnZbbayr3H9P6PP5kJBKDCaDgBPmLeujSdLHAVbzus0w0nAAAAAAAAwJc9eUMrNaobaqs9/8VWHTh2ylAiABVBwwnwER/8aB+nd23remoQGVrG3gAAAAAAAIBvqBUUoOdv7WirnSxw6f8+2SiPh9F6gK+g4QT4gA0HsrQhNctWu+MKVjcBAAAAAACgZriqRYxGlZjms3h7hmatSS3jCADehoYT4AM+WGFf3RQfGaLeLeMMpQEAAAAAAAAq3+9uaqN6EcG22p/nb9bhnDxDiQCUBw0nwMudyC/Spyn2b3Lc1q2xnA7LUCIAAAAAAACg8kWGBuq5IR1stazcQj0zd5OhRPBp+fnSjBn2R36+6VQ1WoDpAADOb25Kqk4WuIq3nQ5Lt3VjnB4AAAAAAABqnuvb1tPATvGaty6tuPbFxoP6YkO6BnRoYDAZfE52tjRypL12+LAUG2smjx9ghRPg5aaXGKd3bes41Y8MMZQGAAAAAAAAqFoTB7ZV3bAgW+3puZt0/FSBoUQALgYNJ8CLrT9wXBtTs221O7o3NpQGAAAAAAAAqHrR4cF6ZmBbWy3zRL7+PH+LoUQALgYNJ8CLffCjfXVTQlSoerVkyScAAAAAAABqtkGd4tWvTZytNmvNAS3cdthQIgAXQsMJ8FI5eYX69KxZtZI0qlsjOR2WoUQAAAAAAABA9bAsS88N6aDawQG2+u8/2agT+UWGUgE4HxpOgJeam5KmUwWu4m2nw9LIbo0MJgIAAAAAAACqT/3IEP3fzW1stdTjufr7l1sNJQJwPjScAC/k8XhKjdO7rnWc6kWEGEoEAAAAAAAAVL9R3RqpZ/NoW23asp+0Ys9RQ4kAlIWGE+CF1h/I0ub0bFvtjisaG0oDAAAAAAAAmGFZlp6/taNCAu0fZT81a73yCl1lHAXABBpOgBcqubopISpU11weaygNAAAAAAAAYE7j6Fp6on8rW21P5km9+r8dhhIBOBcaToCXyc4r1Kfr0my127s3ktNhGUoEAAAAAAAAmDX2qqZKahxlq01avFub0rLMBAJQCg0nwMvMTUlT7lnLgZ0OSyO6NjKYCAAAAAAAADDL6bD092EdFeg886Vsl9uj383eoCKX22AyAD+j4QR4EY/Ho/eX/2Sr9WsTp3oRIYYSAQAAAAAAAN7h8nq19Ys+LWy19QeylPz/2Lvv8Ciqt43j96YXSCGh915DB+lNikpHehFQxJ+iggUVUUCsICqiAiIKCgjSpYlI71Wl995JgIQE0nffP3izZkmvk/L9XNdezp45c+aZNSdD5tlzzs4LxgQEwAYJJyAL2X/xrk7cCLYp6/tYSYOiAQAAAAAAALKWl1qWVbkCeWzKvlh3SpfvPDAoIgAxSDgBWcicXbajm0r6uKlpOV+DogEAAAAAAACyFmcHe33Wzc+mLDQyWu8uOyyLxWJQVAAkEk5AlhEQEq4/jly3Kev/WEnZ2ZkSOAIAAAAAAADIfeqWyqcBDWxnBdp2OkDL/rlqUEQAJBJOQJbx277Lioz+71sYzg526l6nmIERAQAAAAAAAFnTW09UVKFH1j3/cNUx3Q4JNygiZDk+PtKtW7YvHx+jo8rRSDgBWUC02aJf91yyKetQvYi83Z0MiggAAAAAAADIuvK6OOrDLtVsyu4+iNSHq44ZFBGyHDs7KX9+25cdKZGMxKcLZAGbT97S1cBQm7IBDUsmUBsAAAAAAABAmyoF1d6vsE3Z8n+vadPJWwZFBORuJJyALGDO7os27/2KeqpGMU+DogEAAAAAAACyh7GdqsjDxcGm7L1lR3Q/PMqgiIDci4QTYLBLtx9oyyl/m7IBDUrKZDIZFBEAAAAAAACQPRTI66LR7SvblF0NDNUX604ZFBGQe5FwAgw2b+9FWSz/vfdwcVDHGkWMCwgAAAAAAADIRnrWLa6GZXxsymbtPK9/Lt01KCIgdyLhBBgoLDJaC/ddtinrXqe4XJ3sDYoIAAAAAAAAyF5MJpM+6eYnZ4f/HndbLNKopYcVGW02MDIYKiJC2rzZ9hURYWxMORwJJ8BAfxy5rrsPIm3K+jUoYVA0AAAAAAAAQPZU2tddw1uXtyk7cSNYM7aeMygiGC4oSGrZ0vYVFGR0VDkaCSfAQHN2XbR537icj8rmz2NQNAAAAAAAAED29XzTMqpc2MOm7OsNp3XWP8SgiIDchYQTYJCj14L096VAm7IBDUoaEwwAAAAAAACQzTna22nC036yM/1XFhFl1qilh2U2WxI+EEC6IOEEGGTu7ks27wt6OKt15YIGRQMAAAAAAABkf9WLeenZxqVtyvaev6MFj6yjDiD9kXACDHAvLFLL/7lqU9anfgk52NMlAQAAAAAAgLR4vW0FFfN2tSn79I/junkvzKCIgNyBp9uAAZYeuKLQyGjre3s7k/rUL2FgRAAAAAAAAEDO4ObkoE+6+tmUBYdFaezvRw2KCMgdSDgBmcxisWjuHtvp9NpVLaiCHi4GRQQAAAAAAADkLM0q5Fe3WkVtytYevaG1R24YFBGQ85FwAjLZ7nN3dOZWiE1Z/8dKGhQNAAAAAAAAkDO916GK8rk72ZSN+f2IgkIjDYoIyNlIOAGZbO6eizbvy+R3V8OyPgZFAwAAAAAAAORM+dydNKZDFZuyW8HhmrD2hEERATkbCScgE928F6Y/Hxm2O6BBSZlMJoMiAgAAAAAAAHKuzjWLqHmF/DZlv+65pD3nbhsUEZBzkXACMtG83RcVZbZY37s62qtb7WIGRgQAAAAAAADkXCaTSR93rSY3J3ub8lFLDyssMtqgqICciYQTkEnCo6L1695LNmVdahWVp6ujQREBAAAAAAAAOV8xbze90baiTdm5gPuauumMQREBORMJJyCTrDl8XQEhETZlAxuVNCgaAAAAAAAAIPcY1KiUahT3simbtuWsTt0MNiYgIAci4QRkktk7L9q8b1jGR5UKeRgUDQAAAAAAAJB72NuZ9Fk3PznY/beWemS0Re8sOSRzrCUwAKQeCScgE/x7OVAHLwfalA1sVMqQWAAAAAAAAIDcqHJhDz3frIxN2d+XAjV3z8UEjgCQEiScgEzw884LNu+LermqdeUCxgQDAAAAAAAA5FLDHy+vUj5uNmUT157U9aBQgyJChvH2lo4csX15exsdVY5GwgnIYLeCw7Tq0DWbsv4NSsrBnu4HAAAAAAAAZCYXR3t90tXPpiwkPErvLz8qi4Wp9XIUBwepalXbl4OD0VHlaDzxBjLY/D2XFRn9383K2cFOvesVNzAiAAAAAAAAIPdqVM5XPeoUsylbf/ym1h65YVBEQM5AwgnIQBFR6nUdJAAAgaZJREFUZs17ZA7YzjWLyNvdyaCIAAAAAAAAAIxuX1m+eWyf0Y1ZcVRBoZEGRQRkfyScgAy09ugN3QoOtykb2KiUMcEAAAAAAAAAkCR5uTlpTMeqNmX+weH67I8TBkUEZH8knIAM9PPOCzbv65XyVtUinsYEAwAAAAAAAMCqY/XCalkxv03Z/L2XtOfcbYMiArI3Ek5ABjlyNUgHLt61KWN0EwAAAAAAAJA1mEwmfdilmtyc7G3KRy07rLDIaIOiQrqJipKOHrV9RUUZHVWORsIJyCCzHxndVMjDRe2qFjImGAAAAAAAAABxFPN20xttK9qUnfO/r6mbzhgUEdLN3btStWq2r7t3kz4OqUbCCcgAt0PCteLgNZuyfo+VkKM9XQ4AAAAAAADISgY1KqUaxWyXwZi25axO3Qw2KCIge+LpN5ABFuy7rIgos/W9k72d+jxWwsCIAAAAAAAAAMTH3s6kT7tVl72dyVoWGW3RqKWHZTZbDIwMyF5IOAHpLCrarHm7L9qUdaheWL55nA2KCAAAAAAAAEBiqhTx0NBmZWzKDly8q3l7LiZwBIBHkXAC0tlfx27qWlCYTdnARqWMCQYAAAAAAABAsgx/vLxK+rjZlE1Ye1LXg0INigjIXkg4Aels1s4LNu9rFvdSjeJehsQCAAAAAAAAIHlcHO31SVc/m7KQ8CiN+f2oLBam1gOSQsIJSEfHr9/T3vN3bMoGNy5lTDAAAAAAAAAAUqRxOV91r1PMpuyvYze19sgNgyICsg8STkA6mr3jgs37/Hmd9WS1wsYEAwAAAAAAACDFRj9VWT7uTjZlY1ccVVBopEERAdkDCScgnQSEhGvZv1dtyvrWLyEnB7oZAAAAAAAAkF14uztpTMcqNmW3gsM1Ye0JgyICsgeehAPpZN7uS4qIMlvfO9nbqX+DkgZGBAAAAAAAACA1OtUoohYV89uU/brnUpzlNAD8h4QTkA7Co6I1Z/dFm7JONYsof15ngyICAAAAAAAAkFomk0kfdakmNyd7m/JRSw8pPCraoKiArI2EE5AOVh68roCQcJuyZxuXNigaAAAAAAAAAGlVzNtNb7StaFN21v++vtt01qCIgKyNhBOQRhaLRT9tP29T1rCMj6oU8TAoIgAAAAAAAADpYVCjUqpezNOmbNrmMzp1M9igiICsi4QTkEa7z93Rsev3bMqebcLoJgAAAAAAACC7s7cz6bNu1WVvZ7KWRUZbNGrpYZnNFgMjA7IeEk5AGv20w3Z0U0kfNz1eqYBB0QAAAAAAAABIT1WKeOj5pmVsyg5cvKt5ey8ZFBGQNTkYHQCQnV0IuK/1x2/alA1uVEp2sb7xAAAAAAAAACB7G9G6vP44cl0Xbz+wlk3444TaVC6oQp4uBkaGBHl6Sps2xS1DhmGEE5AGs3dekCXWyNm8Lg7qUbe4cQEBAAAAAAAASHcujvb6pKufTVlIeJTG/H7EoIiQJCcnqUUL25eTk7Ex5XAknIBUuhcWqUX7L9uU9a5XXO7ODBwEAAAAAAAAcprG5XzVvU4xm7J1x25q7ZHrBkUEZC0knIBUWrjvsu5HRFvf25mkgY1KGRcQAAAAAAAAgAw1+qnK8nG3HSUz5vejCgqNNCgiIOsg4QSkQlS0WbN2XLApe6JaIRXzdjMmIAAAAAAAAAAZztvdSWM6VrEpuxUcrglrTxgUEZB1kHACUmHdsZu6GhhqU/Zck9IGRQMAAAAAAAAgs3SqUUTNK+S3Kft1zyXtu3DHoIiArIGEE5AKP20/b/O+RjFP1S7hbVA0AAAAAAAAADKLyWTSR12qydXR3qb8nSWHFB4VncBRyHRms+Tvb/sym42OKkcj4QSk0MHLgdp/8a5N2bNNSstkMhkUEQAAAAAAAIDMVDyfm95oW8Gm7Kz/fU3ddNagiBDH7dtSgQK2r9u3jY4qRyPhBKTQzEdGNxXycNFTfoUNigYAAAAAAACAEQY3Lq3qxTxtyqZuPqPTN4MNiggwFgknIAUu33mgNYev25Q906ikHO3pSgAAAAAAAEBuYm9n0qfd/GRv99/MR5HRFr2z9LDMZouBkQHG4Ck5kAKzdlxQdKybhZuTvfrVL2lgRAAAAAAAAACMUrWIp4Y0LW1TduDiXc3be8mgiADjkHACkinoQaQW7LO9UfSqV1yebo4GRQQAAAAAAADAaCMer6AS+dxsyib8cUI3gsIMiggwBgknIJl+3XtJDyKire/tTNKzjUsncgQAAAAAAACAnM7VyV6fdPWzKQsJj9LYFUcMiggwBgknIBkiosyateO8TdlTfoVV/JFvLgAAAAAAAADIfZqU99XTtYvZlP159KbWHrlhUERA5iPhBCTDioPXdCs43KZsaLMyBkUDAAAAAAAAIKt5r31l+bg72ZSN+f2I7oVFGhQRkLlIOAFJsFgsmrntnE3ZY6XzqXoxL2MCAgAAAAAAAJDleLs7aUzHKjZlt4LDNeGPEwZFBGQuEk5AEnaeu6MTN4JtyhjdBAAAAAAAAOBRnWoUUfMK+W3K5u25pH0X7hgUEZB5SDgBSfhp5yWb92Xzu6tlxQIGRQMAAAAAAAAgqzKZTPqoSzW5OtrblL+z5JDCo6INigrIHCScgERcvS/tPHfXpuz5pmVkZ2cyKCIAAAAAAAAAWVnxfG56o20Fm7Kz/vc1bfNZgyICMgcJJyARm67ZdhHfPE7qUquoQdEAAAAAAAAAyA4GNSolv6KeNmVTN53VmVvBCRwBZH8knIAEBIZLB27bjmQa2LCUXB4ZDgsAAAAAAAAAsTnY2+mzp/1kH2umpIhos95Zclhms8XAyICMQ8IJSMCWG3YyW/67Ibg42ql/g5IGRgQAAAAAAAAgu6haxFNDmpa2Kdt/8a5+3XspgSOA7M3B6ACArCgkPEo7b9qObupZt7i83Z0MiggAAAAAAABAdjPi8Qr64/ANXbrzwFo24Y8Tal25oAp5uhgYWS7g4SEtXBi3DBmGhBMQj0UHriks+r+Ek8kkPdekdCJHAAAAAAAAAIAtVyd7fdy1mgb8uNdaFhwepbErjuj7AXUNjCwXcHaWevQwOopchSn1gEeER0Vr9m7bYa1PVC2kkj7uBkUEAAAAAAAAILtqWj6/utUualP259GbWnvkhkERARmDhBPwiN//uaZbwRE2Zc83K2NQNAAAAAAAAACyu/faV1G+R5brGLviiO6FRRoUEZD+SDgBsUSbLZq+9axNWf1SXqpdwtugiAAAAAAAAABkd/ncnTSmQxWbspv3wjVx7QmDIgLSHwknIJa/jt3QOf/7NmXPNy5pUDQAAAAAAAAAcorONYuoWYX8NmVzd1/S/gt3DIoISF8knID/Z7FYNG2z7eimom4WNS6bz6CIAAAAAAAAAOQUJpNJH3epJldHe5vyd5YeVnhUtEFRAemHhBPw/3adva2DV4JsyloXNctkMhkUEQAAAAAAAICcpHg+N73RtoJN2ZlbIXG+CI904O8vmUy2L39/o6PK0Ug4Af9v2hbbX+o+zhbV8LEYFA0AAAAAAACAnGhQo1LyK+ppUzZ101mduRVsUERA+iDhBEg6cjVI204H2JS1KmKWPYObAAAAAAAAAKQjB3s7fdrNT/Z2/z18jIg2a9TSwzKb+QI8si8SToDijm7ydXfSYwX45Q4AAAAAAAAg/VUr6qkhTUrblO27cFfz910yKCIg7Ug4Idc7H3Bffxy+blP2TINicqR3AAAAAAAAAMggI1pXUIl8bjZln605oZv3wgyKCEibXPtI/datW1q1apXGjBmjJ598Ur6+vjKZTDKZTBo0aFCGnHP+/Plq27atChUqJBcXF5UsWVL9+/fXrl27MuR8SJ4ZW88p9kjVPM4O6lW3qHEBAQAAAAAAAMjxXJ3s9XHXajZlweFRGvv7UYMiAtLGwegAjFKwYMFMO1doaKi6d++uNWvW2JRfunRJ8+bN0/z58zVmzBiNHTs202LCQ7fuhWnJgSs2Zf0alJCHi6NBEQEAAAAAAADILZqWz69utYtq6d9XrWVrj97Qn0dvqF3VQgZGBqRcrh3hFFuJEiXUtm3bDGv/2WeftSabWrZsqeXLl2vv3r368ccfVbZsWZnNZo0bN04zZszIsBgQvx93nFdEtNn63sneTs81Lp3IEQAAAAAAAACQft5rX0X53J1sysb8fkT3wiINighInVybcBozZoxWrlypGzdu6OLFi/r+++8z5DwbN27UggULJEkdO3bUX3/9pc6dO6tevXp69tlntXv3bpUoUUKS9Pbbb+vu3bsZEgfiCgqN1LzdtovwPV2nmAp4uBgUEQAAAAAAAIDcJp+7k97vUNmm7Oa9cH2+9qRBEQGpk2sTTh988IE6dOiQ4VPrTZo0SZLk4OCgqVOnyt7e3ma/r6+vJkyYIEkKDAzUzJkzMzQe/Gfu7osKCY+yvrczSS80K2NgRAAAAAAAAAByoy41i6pZhfw2ZXP3XNSBi3cMighIuVybcMoMwcHB2rBhgySpdevWKlasWLz1unXrJg8PD0nSsmXLMi2+3CwsMlqzdpy3KXvSr7BK+bobFBEAAAAAAACA3MpkMunjLtXk6vjfgAWLRXpnyWGFR0UbGBmQfCScMtC+ffsUEREhSWrevHmC9ZycnNSgQQPrMZGRzM2Z0S7feSA3JwebsheblzUoGgAAAAAAAAC5XfF8bnq9TQWbstO3QjR98zmDIgJShoRTBjp27Jh1u1KlSonWjdkfFRWl06dPZ2hckMoXzKuNbzTXN31qqUphDzUt76tqRT2NDgsAAAAAAABALja4cSn5PfKc8rtNZ3TmVrBBEQHJ55B0FaTWlStXrNsJTacXo3jx4tbty5cvq0qVKqk6T3yuX79u3Q4NDVVoaGiy287pWlfw1uPl6+heWJTN5xIWFhbvNpCb0S+AuOgXQFz0CyAu+gUQP/oGEBf9ApI0rn0F9fxhv6ItFklSRLRZby8+qF8G1ZadyWRwdJkv1f0iNFSucYpCJZ6PS1KG5AlIOGWg4OD/ss558uRJtK67+39rB4WEhKToPLGTVUnZunWrfH19U9R+brd161ajQwCyHPoFEBf9AoiLfgHERb8A4kffAOKiX+RuzQvZaeP1/yYoO3ApSB/MXa/GBS0GRmW8lPQLp6AgPflI2ebNmxXhyUxXkhQQEJDubZJwykCxs61OTk6J1nV2drZuMwIJAAAAAAAAAHKvJ4ubdfCOSbfD/xvRtOKinap5R8sz8UfN+H9RLi46NHRonDJkHBJOGcgl1g9vREREonXDw8Ot266ujw70S9zly5cT3X/9+nXVr19fktSsWbMkp/fDw2RhTLa8WbNmNv8vgdyKfgHERb8A4qJfAHHRL4D40TeAuOgXiM27wh0Nmfuv9X1YtEnbHxTW1x38jAvKAGnqFx072rwtn56BZXNJLdWTGiScMlDevHmt20lNk3f//n3rdlLT7z0qJQkkV1fXFCe0cjsXFxc+M+AR9AsgLvoFEBf9AoiLfgHEj74BxEW/QOtqRdWtlr+W/nPVWrbuuL+2nQtS26qFDIzMOPSL9JMRn6Nd0lWQWrETQUllC2OPUkrJmkwAAAAAAAAAgJzpvQ5VlM/ddg69Mb8fVXBYpEERAQkj4ZSBqlSpYt0+ceJEonVj9js4OKh8eQb2AQAAAAAAAEBul8/dSe93qGxTduNemCasTfx5M2AEEk4ZqF69enJyeph93rJlS4L1IiIitHv3busxjo6OmRIfAAAAAAAAACBr61KzqJqW97Upm7v7kvacu21QRED8SDhloLx58+rxxx+XJK1fvz7BafWWLl2qe/fuSZK6du2aafEBAAAAAAAAALI2k8mkT7r6ycXR9nH+20sOKTQi2qCogLhIOKXB7NmzZTKZZDKZNG7cuHjrvPnmm5KkqKgoDRs2TNHRtr8AAgIC9Pbbb0uSvLy8NGTIkAyNGQAAAAAAAACQvRTP56aR7SrZlF24/UBf/nXSoIiygYAAKX9+21dAgNFR5WgORgdglO3bt+vMmTPW9wGxftDOnDmj2bNn29QfNGhQqs7TqlUr9e7dWwsWLNCKFSvUpk0bjRgxQkWKFNHhw4f18ccf69KlS5KkCRMmyNvbO1XnAQAAAAAAAADkXIMaldLqQ9f096VAa9mP28/rSb/Cql2C58pxWCxxE0wWizGx5BK5NuE0c+ZM/fzzz/Hu27Fjh3bs2GFTltqEkyT99NNPunfvntasWaNNmzZp06ZNNvvt7Oz0/vvva+jQoak+BwAAAAAAAAAg57K3M2li9xp6aso2RUSZJUlmi/TW4kNa/WoTOTvYGxwhcjum1MsErq6uWr16tebNm6c2bdqoQIECcnJyUvHixdW3b19t3749wSn5AAAAAAAAAACQpHIF8mhE6/I2ZWduheibDWcSOALIPLl2hNPs2bPjTJuXUoMGDUrRyKe+ffuqb9++aTonAAAAAAAAACD3Gtq0jP44fEOHrwZZy6ZtOasnqhVStaKeBkaG3I4RTgAAAAAAAAAAZBMO9naa2L26HOxM1rJos0UjFx9SZLTZwMiQ25FwAgAAAAAAAAAgG6lc2EPDWpazKTt+/Z6mbz5rUEQACScAAAAAAAAAALKdYS3LqWLBvDZlUzae1qmbwQZFhNyOhBMAAAAAAAAAANmMk4OdPu9RXbFm1lNktEUjFx1UFFPrwQAknAAAAAAAAAAAyIaqF/PS0GZlbcoOXgnSTzvOGxQRcjMSTgAAAAAAAAAAZFMjWpdXmfzuNmVfrDulc/4hBkWE3IqEEwAAAAAAAAAA2ZSLo70mPl1dplhT64VHmfX2kkMymy3GBYZch4QTAAAAAAAAAADZWN1S+TSoUSmbsn0X7mrO7ovGBIRciYQTAAAAAAAAAADZ3Mh2FVU8n6tN2YS1J3T5zgODIkJuQ8IJAAAAAAAAAIBszs3JQRO6VbcpexARrXeWHpLFwtR6yHgORgcAAAAAAAAAAADSrlE5X/V9rIR+3XPJWrbjzG39tu+yetcvYWBkBnBzk8aOjVuGDEPCCQAAAAAAAACAHGLUk5W06cQtXQ8Ks5Z9vPq4mlfMr8KerokcmcO4u0vjxhkdRa7ClHoAAAAAAAAAAOQQeV0c9Uk3P5uy4PAovbPkMFPrIUORcAIAAAAAAAAAIAdpWbGAnq5dzKZsyyl/Ldx/2aCIkBuQcAIAAAAAAAAAIIcZ06GKCuR1tin7cNVxXQ0MNSgi5HQknAAAAAAAAAAAyGE83Rz12dO2U+uFhEfp7cWHmFoPGYKEEwAAAAAAAAAAOVCrSgXVo47t1HrbzwRo3p5LBkWEnIyEEwAAAAAAAAAAOdR7HaqosKeLTdkna47r8p0HBkWUSe7ckapWtX3duWN0VDkaCScAAAAAAAAAAHIoT1dHffZ0dZuyBxHRenPRQZnNOXhqveho6dgx21d0tNFR5WgknAAAAAAAAAAAyMGaV8ivPvVL2JTtOX9Hv+y6YExAyJFIOAEAAAAAAAAAkMONbl9ZRb1cbco+W3tC5wPuGxQRchoSTgAAAAAAAAAA5HB5nB30eXfbqfXCIs0aueigonPy1HrINCScAAAAAAAAAADIBRqV89UzDUvalO2/eFezdpw3KCLkJCScAAAAAAAAAADIJd5+opJK5HOzKZv450mduRViUETIKUg4AQAAAAAAAACQS7j//9R6JtN/ZRFRZr2x6KCios3GBYZsj4QTAAAAAAAAAAC5yGNlfDS4UWmbsoOXA/XDNqbWQ+qRcAIAAAAAAAAAIJcZ2a6iSvu625R99dcpnbwRbFBEyO5IOAEAAAAAAAAAkMu4OtlrUo/qsos9tV60WW8uOqhIptZDKpBwAgAAAAAAAAAgF6pTMp+eb1rGpuzw1SBN23zWoIiQnZFwAgAAAAAAAAAgl3qtTQWVzW87td6UDad1+EqQQREhuyLhBAAAAAAAAABALuXiaK8veta0mVovymzRawv/VVhktHGBIdsh4QQAAAAAAAAAQC5Ws7iXhrUsZ1N25laIJqw9YVBEyI4cjA4AAAAAAAAAAAAY69XHy2vTyVs6cvWetWzWjgtqXbmgGpfzNTCyVHJxkV56KW4ZMgwJJwAAAAAAAAAAcjlHezt91bOmOnyzXeFRZmv5m4sOau2IZvJ0dTQwulTIm1f67jujo8hVmFIPAAAAAAAAAACofMG8evuJSjZl14PCNPb3IwZFhOyEhBMAAAAAAAAAAJAkDWpUSo3L+diULf/3mlYfum5QRMgumFIPyRYWFqbAwEA9ePBA0dHRRoeTocxms3x8Hv5SvXTpkuzsyM0C9AtkB/b29nJzc5OXl5dcmJcZAAAAAIAUs7Mz6fPuNdRu8lYFh0VZy0cvP6y6pbxV0IO/txE/Ek5IksVi0fXr1xUUFGR0KJnGYrHI1dVVkhQdHS2z2ZzEEUDOR79AdhAVFaXw8HDdvXtXnp6eKly4sEwmk9FhAQAAAACQrRTxctWHnatpxG//WssCH0Rq5OJD+nlwPf7WRrxIOCFJt2/fjpNscnDI+T86Mb80c8O1AslFv0BWFxX13zevgoKC5OTkJF9fXwMjAgAAAAAge+pcs4j+OnZTqw//N5Xe1lP+mrvnkgY0KGlgZMiqeGKIREVERMjf39/6vkCBAvLy8pK9vb2BUWU8s9mse/fuSZI8PDyYOgwQ/QLZQ3R0tAIDA3Xr1i1Jkr+/vzw8POTk5GRwZAAAAAAAZC8mk0kfdammfRfu6FZwuLX8k9XH1bisj8rkz2NgdMkQGCh16WJbtny55OWV+bHkEjwtRKJCQkKs2z4+PvLx8cnxySYAQPZlb29vvV/FiH0vAwAAAAAAyeft7qSJ3avblIVGRuu1hQcVFZ3Fl1uIjJS2bLF9RUYaHVWORsIJibp//75128PDw8BIAABIvtj3rNj3MgAAAAAAkDItKhaIM4XewcuBmrr5rEERIasi4YRERURESHo4fNLZ2dngaAAASB5nZ2frmmMx9zIAAAAAAJA6o56qpNK+7jZlUzac1qErgcYEhCyJhBMSZTY/HBZpb29vfXAHAEBWZzKZrFPAxtzLAAAAAABA6rg5OejLnjVkb/ffM+Ios0UjfvtXDyKiDIwMWQkJJwAAAAAAAAAAkKhaJbw1rGU5m7Jz/vf14arjBkWErIaEEwAAAAAAAAAASNIrrcqpRjFPm7L5ey/pz6M3DIoIWQkJJwAAAAAAAAAAkCRHeztN7l1Lbk72NuXvLDmkm/fCDIoKWQUJJwAAAAAAAAAAkCylfd01rmNVm7K7DyL1xsKDMpstBkWFrICEEwAAAAAAAAAASLYedYvpyWqFbMq2nwnQTzvOGxQRsgISTgByjFKlSslkMmnQoEFGh5LjtGjRQvb29urQoYPRoeQ4/NwCAAAAAIDsxmQy6dNufirk4WJTPnHtSR29FmRQVDAaCScgC9m8ebNMJpNMJpPGjRuXaN0bN26oSpUq1vovvviiLBaGrKbFhQsXrJ9n7JednZ28vLxUsmRJNWjQQMOGDdOcOXMUEhJidMhIQIsWLeL9f5nYKzAw0OiwAQAAAAAAsg0vNyd92auGTKb/yiKizRq+4F+FRkQbFxgMQ8IJyIauXr2q5s2b6/jx45Kk4cOHa9q0aTLF/u2OdGOxWBQUFKRLly5pz549mjp1qp555hkVKVJEr7/+uu7fv290iIZLbqI0t4hJeLVo0cLoUDIdPwsAAAAAAOQejcr6amizMjZlZ26F6JM1xw2KCEZyMDoAAClz6dIltWrVSmfPnpUkjRw5UhMnTjQ4qpync+fO+uijj6zvHzx4oMDAQB07dkxbtmzRqlWrFBwcrK+++kqrV6/WqlWrVL58eQMjzlibN2+W2WzWvXv3jA4lxQ4fPpyseh4eHhkcSfwuXLhgyHkBAAAAAADSwxttKmrHmQAdufrfc6M5uy+qeYX8al2loIGRIbORcAKykfPnz6tVq1bWB9SjR4+2SYog/Xh5ealatWpxytu2basRI0bo0qVLGjJkiP766y+dOnVKHTp00O7du+Xt7W1AtEhMfP8fAQAAAAAAkD6cHOz0de9aaj9lm8Iizdbyt5Yc0triTVUgr0siRyMnYUo9IJs4c+aMmjdvbk02ffDBBySbDFSiRAn98ccfat++vSTp1KlTTCEGAAAAAACAXKls/jwa06GqTdmd+xF6c9Ehmc0GrTvv5CR17277cnIyJpZcgoQTkA2cPHlSzZs31+XLlyVJn376qcaMGZPkccuXL1ePHj1UokQJubi4yMvLS3Xr1tUHH3ygu3fvJnjcoEGDZDKZVKpUKUnS9evX9fbbb6tq1arKmzevTCaTNm/eHG/dwMBAjRkzRlWrVpW7u7u8vLzUrFkzzZs3L1nXGhQUpE8//VSNGzdW/vz55eTkpMKFC6tjx45avHixLBaDblDxsLe31+zZs+Xm5iZJ+uGHHxQQEJBg/bRc26Pr4uzbt099+vRRsWLF5OzsrKJFi2rAgAHWdb0SEhgYqI8//lgNGzaUt7e3HB0dlT9/flWpUkVdu3bVtGnTdPPmzTjHtWjRQvb29urQoYNNealSpWzWDvvggw+ssca8Bg0aJEnq1q2bTCaTvL29FRYWlmicUVFRKlSokEwmk5566qlE62aklH5eMf1hy5YtkqQtW7bE+Txi+kqMmM8w5nOKbfPmzdbjNm/eLIvFoh9//FFNmjSRj4+PPDw8VL9+fc2ZM8fmuIiICE2fPl0NGjRQvnz5lDdvXjVu3FgLFy5M9Hrv3r2rWbNmqX///qpSpYry5MkjJycnFSpUSO3atdOMGTMUERER77Ep+Vl41JkzZ/Taa6/Jz89Pnp6ecnV1VZkyZTRo0CDt378/0ZgBAAAAAEDW0Kd+cbV5ZAq9raf89eP288YE5OkpLVpk+/L0NCaWXIIp9YAs7tixY3r88cd148YNSdKXX36p1157LdFj7t69q+7du2vjxo025eHh4Tpw4IAOHDigqVOn6vfff1eDBg0SbWv37t3q2LFjoomUGCdPntQTTzwRZ02abdu2adu2bdq1a5e+/fbbBI/fsGGDevXqpdu3b9uU37hxQ6tWrdKqVav01FNP6bffflOePHmSjCcz+Pr6qn///poxY4ZCQ0O1bt069e3bN0699Ly2qVOnavjw4YqKirKWXbt2TXPnztXSpUv1xx9/qFmzZnGOO378uFq3bq1r167ZlAcEBCggIEDHjx/X8uXLFR0drZdffjklH0OyDBkyRMuWLVNgYKCWL1+u3r17J1h3zZo11kTOs88+m+6xJIfRn9ejIiMj1blzZ61cudKmfN++fXrmmWe0f/9+ff3117p79666dOmirVu32tTbuXOndu7cqTNnzujdd9+N9xy1atXSxYsX45TfvHlT69at07p16zR9+nStWbNGhQoVSpfrmjRpkt59911FRkbalJ8/f17nz5/XL7/8ovfee0/jx49Pl/MBAAAAAICMYTKZNOHp6jp4eatuBYdbyyesPaH6pfOpRnEv44JDpmCEE5CFHTp0SC1atNCNGzdkMpn07bffJplsCg8PV+vWrbVx40bZ29trwIABmj9/vnbv3q1t27bp448/lo+Pj27duqWnnnoq3ofLMUJCQvT0008rLCxMo0eP1ubNm7V37179+OOPKly4sE3dBw8eqGPHjrp9+7bee+89bd68Wfv379cPP/ygYsWKSZK+++47/fnnn/Gea8eOHXryySd1+/ZtFSxYUB999JFWrlypAwcOaOXKlerfv7+kh4mIgQMHpuRjzHCtW7e2bm/bti3O/vS8tj///FOvvPKKqlatqp9++kn79u3T1q1b9dprr8nOzk4PHjzQgAED4h2FMmDAAF27dk2Ojo566aWXtHLlSu3bt0979uzRkiVLNHLkSJUrVy5F175u3TodPnzY+v7FF1/U4cOHbV4ff/yxJOmJJ56w/izMmjUr0XZj9vv6+qpTp04piim9pObz+vjjj3X48GHVrVtXklS3bt04n8e6detSFc/777+vlStXql+/flq9erUOHDig+fPnq2LFipKkKVOmaP369Ro0aJB27typF198UevWrdOBAwf0448/qkiRIpKkMWPG6OjRo/GeIzo6Wo899pg+/PBDrVq1Svv27dOOHTs0d+5cPfHEE5Kkf/75J95kYUp+FmJ8/vnnGjlypCIjI1W9enVNmzZN69ev1/79+zVv3jw1bNhQFotFH374oaZMmZKqzw0AAAAAAGSefO5O+qpXTcWaBEVRZotemf+P7oVFJnwgcgRGOCHNzGaL7j6If4ql7MpsNiv4wcNfgJF24bKz+y836+3mJDs7U0KHppuDBw/q22+/1e3bt2UymfT999/r+eefT/K48ePH6++//5aXl5fWr1+vOnXq2Oxv0qSJ+vXrp4YNG+r69et69913E5zu7vbt28qTJ4+2b9+uGjVqWMvr1asXp66/v78iIiK0a9cuVa3633ytderUUYsWLeTn56ewsDBNnTpV7dq1szk2MjJS/fv3V2RkpJ544gktWbLEOk2dJNWuXVsdOnRQs2bNNHToUC1dulR//fWX2rRpk+TnkRlq165t3T516pTNvvS+tt27d+upp57SsmXL5BRrztmmTZvKx8dH7733ni5duqTVq1era9eu1v3nzp3TgQMHJD0cJffoiJz69eurW7dumjBhggIDA5N97RUqVLB5X6BAAVWrVi3eunZ2dho8eLA+/PBDrV+/XleuXLEmoGK7deuWVq9eLUnq16+fzXWmxpEjR5Ks4+3traJFi1rfp/bzKlq0qIoWLSp3d3dJkru7e4KfR0rt2bNHkydP1vDhw61ltWvXVosWLVShQgUFBwerb9++CggI0NKlS9WlSxebenXr1lWtWrUUHR2tGTNm6Ouvv45zjo0bN6p8+fJxyhs1aqR+/fpp1qxZevbZZ7VlyxZt2LBBjz/+uLVOSn4WpIejN0ePHi1JGjt2rMaOHWszJV+dOnXUu3dvDRw4UHPnztXo0aM1YMAAeXt7J/1hAQAAAAAAwzQu56uXWpTVd5vOWssu3Xmg0cuOaErvmjZ//yNnIeGENLv7IEJ1PlpvdBiZ5sB7reWTxznDz7N8+XLr9tSpU5OVbAoJCdF3330nSfrwww/jJJtilCxZUu+//75eeuklLVq0SDNmzLA+IH/UW2+9ZZNsSsyHH35ok2yKUa5cOXXp0kULFizQ9u3b4+xfsGCBLly4IBcXF/3yyy82CZnYnn/+ec2cOVN79+7V7Nmzs0zCycfHx7r96NpY6X1tLi4umjVrVrxJmFdffVXjx49XRESEtm3bZpNwipmSUVK80+3FiFljKaM8++yz+uijj2Q2m/Xzzz9bEw6xzZ071zq9WnpMp+fn55dknYEDB2r27NnW91nl84rtscces0k2xShUqJC6du2qX375Rf7+/urVq5dNsilG9erV1aRJE23dujXekXiS4k02xTZ48GBNmTJF//77r5YvX26TcEqpL774QpGRkapbt26cZFMMOzs7ffPNN1q0aJFCQkK0ePHiZP0uBAAAAAAAxhrRuoJ2n7ujAxf/e1a28uA1NS3nq571ihsYGTISU+oBWVTsh68rV66Md4q0R23ZskVBQUGSpO7duydaN+YhemRkpHUkR3z69euXnHBlMpniXbsoRkzy686dO3FG0KxYsUKS1Lx5c+XPnz/R88TEvWvXrmTFlRlir7kUHBxssy+9r61NmzYqUKBAvPvy5s1rTRicO3fOZl/sKRBjJ1YyW6lSpaxTECYUR8x0enXq1FH16tUzKzQbWeXzii2xNa9iJ4WTU+/Rn4/4WCwW3bhxQ6dOndKRI0esr5iRYAcPHkxu6PGKWYvq6aefTvSbTV5eXtakYVbq9wAAAAAAIGGO9nb6undNebjYjnkZs+KIztwKTuAoZHcknIAs6sUXX1SVKlUkPVzbp0+fPoqKikr0mP3791u3CxcuLJPJlOAr9lRXsUdzxJYnTx6VKVMmWfH6+vrajPR5VL58+azbjyZlYuL+888/E43ZZDJp0qRJicZshNjX4+HhYbMvva+tUqVKicYS8zk/+hmXLl1aTZs2lSR99dVXqlq1qsaMGaONGzfqwYMHybzS9DFkyBBJ0pkzZ+KMtNm/f791Crz0GN0kPUycJPV6NKmUlT6vGI9OWRebl5dXiuo9+vMR2+rVq9WhQwd5enqqcOHCqlixovz8/KyvmOkOAwICUnYBsVy8eFH+/v6SpFGjRiXZN2L6UVbq9wAAAAAAIHHFvN00sbvtl4nDIs16+dd/FBYZnfEBBAVJPXrYvv7/y/rIGCScgCwqf/78Wr9+vcqVKydJWrp0qQYNGiSz2ZzgMbdu3UrVuRJ6gB77IXZSEpoqLkbsdbCio21vKKmJOzQ0NMXHZJTYD95jJ9ak9L+25H7Oj37GkjR//nw1bNhQ0sP1cz788EM9/vjj8vLyUrNmzTR9+nSFhYWlON6U6tKli3x9fSX9N5opxk8//STp4dSBiY2YywxZ5fOKkdj/+9j9Kzn14vs9YrFYNGTIEHXo0EGrV69ONCklpa0PpvfvKgAAAAAAkDU9Ua2wBjQoaVN24kawPlp9LONPHhEhLV5s+0rGLFJIPdZwQpp5uznpwHutjQ4jXZnNZgWHhEiS8ubJY/Mw19st7to5GaVw4cLauHGjmjZtqosXL2revHlydXXVjBkz4p2CKnaS4e+//5ajo2OyzlOsWLF4y+3t7VMXeArFxP3kk09q4sSJmXLO9PTPP/9YtytWrGizLytdW9GiRbVz505t2LBBS5cu1ZYtW3Ts2DFFRkZq27Zt2rZtmyZNmqQ1a9YkOkomrZycnDRgwAB99dVXWrRokb755hu5u7srLCxM8+fPlyR17do1RQnPjJBVPq/M8tNPP+nHH3+UJNWsWVMjRozQY489pqJFi8rNzc36++CZZ57RnDlzZLFYUn2u2L+rxowZox49eiTruITWmgMAAAAAAFnX6PaVte/CHZ248d+XW+fuvqTGZX31pF/hRI5EdkPCCWlmZ2eSTx5no8NIV2azWY7mcEmSRx5nm4RTZitevLg2bNigZs2a6dq1a5o5c6ZcXV01ZcqUOHVjT2mXP3/+BBNJWY2Pj4+uXbumiIgIm6n+sou//vrLut2kSRObfVnx2h5//HE9/vjjkqTbt29r/fr1mjFjhjZu3KizZ8+qV69eNkm0jDBkyBB99dVXCgkJ0aJFizRo0CAtX77cur5Xek2nlx6ywueVGX744QdJUrly5bRz5065urrGW+/OnTtpPlfs31WOjo5Zpm8AAAAAAID05+Jor2/71lLHb3YoNNZUem8tOaRqRT1VPF/iM/og+2BKPSAbKFu2rDZs2KACBQpIkr755hu98847cerVqlXLur1jx45Miy+tYuLev3+/IrLZsFZ/f3/9+uuvkh6Ovmjbtq3N/qx+bT4+PurVq5c2bNigTp06SZL+/fdfnT59OkPPW6VKFet0dTHT6sVMp1eyZElrgierSe7nFd8IxKzu6NGjkqROnTolmGyyWCz6+++/03yuMmXKyNPTU1L2+l0FAAAAAABSp1yBvPqgc1WbsuCwKA1f8I8ioxNeQgTZCwknIJuoVKmS/vrrL+saQRMmTND48eNt6rRu3dq6fsuUKVPSNOVVZop5cB8UFBRnTZ+szGw2a9CgQdZ1ZYYOHRpnDafsdG2xkzyx16VKDhcXF0lSeHh4so8ZMmSIJGnbtm3atGmTNmzYIEkaNGhQtkjYJPZ5pebzMFpUVJQk6f79+wnW+f3333X9+vVE20nOtdvb2+upp56SJK1bt07Hjx9PabgAAAAAACCb6VGnmDrXLGJT9velQE1ad9KgiJDeSDgB2Uj16tX1559/ysPDQ5I0duxYffHFF9b9Xl5eevnllyVJO3fu1GuvvSazOeFvCNy8eVMzZ87M2KCTYeDAgSpevLgk6c0339TWrVsTrb99+3Zt2bIlM0JL0KVLl/TEE09ozZo1kh4mBMeOHRunXla5tn///Vf//vtvgvstFovWr18v6eHonFKlSqWo/cKFH863e/bs2WQf06tXL+XNm1cWi0V9+/aV2WyWyWTS4MGDU3TujJDWzyvm8zh37ly2SfyWL19ekrRy5cp4p807e/ashg0blmQ7yf1ZGDVqlOzt7WU2m9W9e3dduXIlwbrR0dGaN29eonUAAAAAAEDWZjKZ9FGXairpYzuF3vdbzmnD8ZsGRYX0xBpOQDZTt25drVmzRu3atdP9+/f15ptvys3NTS+++KIkafz48dqyZYv27Nmjr7/+Wps3b9bzzz+vmjVryt3dXXfv3tXRo0e1fv16/fHHH/Lz87OONDGKs7OzFi5cqBYtWigkJEStWrVS79691aVLF5UuXVpms1nXr1/XgQMHtGzZMh0+fFjffPONmjdvnmExBQYG6siRI9b3oaGhCgwM1LFjx7RlyxatXLnSOiKkYsWKWrVqlXWKsKx4bf/++68GDx6sevXqqWPHjqpdu7YKFSqkyMhInT9/XrNmzbKuRdWpUydr0iC5GjVqpPPnz2vFihX6/vvv1bhxY+tIFw8PD+t0kLG5u7urd+/e+uGHH3Tjxg1JUqtWrVSyZMk0Xq2t2P8fE1OyZEnlzZtXUto/r0aNGmnWrFm6deuWXn/9dfXv39/68+Ho6Jju15gennnmGY0cOVLXrl1Tw4YN9fbbb6tatWoKCwvTxo0bNXnyZIWHh6t27dqJTquX3J8FPz8/TZo0Sa+99pqOHTumatWqaejQoWrVqpUKFiyosLAwXbhwQbt27dLixYt1/fp1HT58ONusTQcAAAAAAOLK6+Kob/rU0tPTdioy+r8v6b6+8KBWv9pExbxZzyk7I+EEZEONGzfWihUr1L59e4WFhWnYsGFydXXVoEGD5OzsrL/++kuDBg3S0qVLdfDgQeuop/jEjJYyWoMGDbR582b17NlTly9f1rx58zRv3rwE62d03L///rt+//33ROt4eHjo+eef1/jx461TGcYnK13bvn37tG/fvgT3N2rUSD/++GOK233zzTe1ePFihYeH63//+5/NvoEDB2r27NnxHjdkyBD98MMP1vfPPvtsis+dFD8/v2TVW7Zsmbp06WJTltrPq3fv3vr000917tw5TZ48WZMnT7buK1mypC5cuJCsmDLT8OHD9ddff2ndunU6deqUnnvuOZv9rq6u+uWXX7R69epEE04p+VkYMWKE3N3dNWLECAUFBenzzz/X559/Hm+7Tk5O1sQVAAAAAADIvqoX89Lopypr3Mpj1rKg0EgN+/UfLXqhoZwcmJgtuyLhBGRTrVq10tKlS9WlSxdFREToueeek6urq3WasiVLlmj79u36+eeftW3bNl27dk2hoaHy8PBQ2bJlVb9+fbVv315t27Y1+lKsGjRooNOnT2v27NlauXKl/vnnHwUEBMjOzk758+dX5cqV1bx5cz399NOqWLFipsVlMpmUN29eeXh4qGjRoqpdu7YaNWqkrl27yt3dPVltGH1tffr0UcGCBfXXX39p3759unr1qm7evKmoqCgVKFBAtWvXVq9evdS7d2/Z2aX8pl6zZk3t2rVLn3/+uXbs2KGbN28ma/2i+vXrq0KFCjp16pS8vLzUrVu31Fxeukvr55UnTx7t3LlTn376qdatW6eLFy9a1/rKqhwdHbV69WpNmzZNv/zyi44dOyaLxaKiRYuqdevWGj58uCpVqqTVq1cn2k5Kfxaef/55derUSd9//73WrVunkydPKjAwUM7OzipatKj8/PzUpk0bPf300/L19U3vywYAAAAAAAYY2KiU9l24q9WH/1sr+uDlQH2y5rjGdapqYGRIC5MluywugVS7cuWKdQ2Zy5cvp2g6otOnTysqKkoODg7W9T1yA7PZrHv37kl6ONokNQ/ggZwmI/rFvXv3VKhQIYWGhurFF1/U1KlT09wmECMz7mGhoaFat26dJKlt27ZydXXNkPMA2Qn9AoiLfgHEj74BxEW/QG4SHBapjt9s14Xbtl/Sndqvtp7y+2/5glT3C39/6dFlHm7dkvLnT1PcOUVa8gYJ4Sk6AMAw8+fPV2hoqCTFmcINAAAAAAAAOVdeF0dN7VcnzhR6by0+pAsB9w2KCmlBwgkAYIioqCh9+eWXkqS6deuqTp06BkcEAAAAAACAzFSliIfGPzKFXkh4lF6a97fCIqMNigqpRcIJAJBp7ty5ozNnzmjPnj3q27evTp06JUl69913DY4MAAAAAAAARuhVr7i61SpqU3bs+j19sPKoQREhtUg4AQAyzZQpU1S+fHk1aNBAixYtkiR16NBBXbt2NTgyAAAAAAAAGMFkMumjrtVUvkAem/L5ey9r6d9XDIoKqeFgdAAAgNzHwcFBJUuWVJ8+fTRq1CijwwEAAAAAAICB3JwcNK1/bXX8ZodCY02lN3rZEZX3rZu6Rh0dpebN45Yhw5BwAgBkmnHjxmncuHFGhwEAAAAAAIAsplyBvPq0m59G/PavtSw0MlojFh7W0DKSi30KG/TykjZvTscIkRSm1AMAAAAAAAAAAIbrUquo+j5WwqbsbMADzT9jJ4vFoKCQbCScAAAAAAAAAABAljCmQxVVLeJhU/bvHTttum4yKCIkFwknAAAAAAAAAACQJbg42mtavzrydLVdb2nFRTvtPn/HoKiQHCScAAAAAAAAAABAllHCx02Te9eUKdagJotMen3xUV0LDDUuMCSKhBMAAAAAAAAAAMhSWlYsoNdaV7Apu/sgUi/O+1vhUdEGRYXEOBgdAAAAAAAAAAAAwKNebllO/1y8o02nAqxlBy8HatyKY/q0m1/iBwcHS++8Y1v22WdS3rwZECkkEk4AAAAAAAAAACALsrMz6bOuldX+660KCPtvfr35ey+pZnFP9apXIuGDw8KkqVNty8aNI+GUgZhSDwAAAAAAAAAAZEkeLo56rkK0nOwsNuXv/35Uh64EGhMU4kXCCQAAAAAAAAAAZFlF3KU+Zc02ZRFRZr0492/duR9hUFR4FAknAAAAAAAAAACQpdX2teiZx4rblF0NDNUr8/9WVLQ5gaOQmUg4AQAAAAAAAACALO/NNmVVv3Q+m7IdZ25r4p8nDYoIsZFwAgAAAAAAAAAAWZ6jvZ2+7VtLBT2cbcpnbD2npX9fMSgqxCDhBAAAAAAAAAAAsoUCeV00tV8dOdqbbMrfWXpY/14ONCYoSCLhBCAe48aNk8lkkslkSroyAAAAAAAAAGSiOiW99VGXajZlEVFmDf1lv27eCzMoKpBwArKAF154wZrg2bhxY4qOXbdunfXY4cOHZ1CEyAiHDh2So6Oj9f/foEGDEqx77949LViwQG+88YaaN2+ucuXKydPTU05OTipQoIBatGihiRMn6vbt24mec/PmzdbzJfUaN25cgu1s2bJFn376qbp27aqqVauqYMGCcnJykqenp/z8/PTiiy/qwIEDyfoczGazfvvtN3Xp0kXFixeXi4uL3NzcVLp0afXq1Ut//PFHplxTbJGRkZo9e7bat2+vEiVKyNnZWb6+vvLz89OQIUO0aNGiZLWTlCNHjuiFF15Q2bJl5erqqvz586tp06aaPn26oqKi0uUcAAAAAAAAOVGveiU0qFEpm7JbweEaOueAwiKjjQkql3MwOgAA0jPPPKMZM2ZIkubOnatWrVol+9g5c+bYtIPswWw26/nnn092UmHv3r3q06dPvPv8/f21ZcsWbdmyRZ9//rnmzp2rdu3apWe4cQwYMEBXr16NUx4ZGakjR47oyJEj+v777/Xyyy9r8uTJsrOL//sNd+/eVefOnbVt27Y4+y5cuKALFy5o4cKFevrppzVv3jw5OzvH00r6OnTokPr166cjR47YlN++fVu3b9/WkSNHtHjxYvXo0SNN5/nhhx/08ssvKyIiwloWFham7du3a/v27Zo1a5ZWr14tX1/fNJ0HAAAAAAAgp3qvfWWdvhWsHWf++xL2wcuBenfpYX3RsoiYvylzkXACsoDGjRurbNmyOnv2rJYsWaLvvvtOrq6uSR53//59LVu2TJJUtWpV1alTJ6NDRTr59ttvtXfvXhUoUEC3bt1K1jHFixdXy5YtVadOHRUvXlyFCxeW2WzWlStXtHjxYi1dulQBAQHq1KmT9u7dqxo1aiTa3k8//aR69eoluL9AgQIJ7nN3d1e7du3UsGFDlS9fXoULF5aHh4du3LihvXv36vvvv9fNmzf1zTffyM3NTZ999lm87fTu3duabCpdurRGjhwpPz8/RUZG6sCBA5owYYICAgK0ZMkS+fr6avr06Rl2TdLDZFPLli11584dubi4aMiQIWrbtq2KFi2qiIgInT59WmvXro03QZYSa9as0f/+9z+ZzWYVLFhQo0eP1mOPPaY7d+7ohx9+0NKlS7V371517dpVmzdvlr29fZrOBwAAAAAAkBM52Nvp2z611fm7Hbp054G1fOk/V1XTNUJ8PT9zkXACsogBAwZo3Lhxunfvnn7//Xf17t07yWOWLl2q+/fvW49H9nDlyhW99957MplM+vzzzzVw4MAkj2nZsqUuXbqU4P6ePXtq+fLl6tq1qyIiIvTBBx9o6dKlibZZunRpVatWLdE6CTl8+LCcnJzi3de+fXu9+uqrql+/vs6dO6cvvvhCI0eOlI+Pj029/fv3a926dZKkMmXK6N9//1XevHmt+1u2bKmePXuqRo0aCgwM1A8//KDx48cnmjRKyzWFhYWpR48eunPnjkqUKKH169erfPnyNnUaNGigAQMG2IxKSqnIyEi98sorMpvN8vDw0I4dO1S2bFnr/ieeeELDhg3T1KlTtX37ds2ZMyfR6RYBAAAAAAByM293J80cWFddv9uh+xH/TaU3ZcMZEk6ZjDWcgCxiwIABMpkeDvKcO3duso6JmU7Pzs5O/fv3z7DYkL6GDRum4OBgDRo0SM2aNUvWMckZ4dKlSxdVrFhRktI8AicpDg6Jf1/Bx8dHzz//vCQpKipKu3fvjlNn586d1u0RI0bYJJtilChRQoMHD5b0cBrCPXv2pCXsRE2aNEmnTp2SnZ2dFi5cGCfZFFtCybbkWLZsmc6dOydJGjVqlE2yKcbnn38ub29v6zYAAAAAAAASVqFgXk3uXUumWHPomS3GxZNbkXACsogyZcqocePGkqQ///wzyWnWrl27pg0bNkiSWrVqpaJFi1r37d69W++9955atGihQoUKycnJSR4eHqpSpYpefPFFHTt2LE2xmkwmmUwmjRs3LtF6LVq0kMlkUosWLRKtd+bMGb322mvy8/OTp6enXF1dVaZMGQ0aNEj79+9PU6xZzeLFi7VixQr5+PhkSCIhJmkTFhaW7m2nVOwEUnzxxB4lVKZMmQTbiZ2QScvIosRER0dbp+tr3bq1HnvssQw5jyQtX77cup3QyCU3Nzf17NlTknTs2DGdOnUqw+IBAAAAAADICdpUKag32lQwOoxcjYQTkIU888zDQZ5RUVFasGBBonV//fVXmc1mm+Mkafbs2WrYsKE+/vhjbdmyRTdv3lRkZKSCg4N1/PhxTZ8+XdWrV9fUqVMz7kJSYNKkSapSpYomT56sI0eO6N69ewoLC9P58+f1888/q379+hozZozRYaaLoKAgvfrqq5KkiRMnxpliLq1Onjypf//9V5JUqVKldG07pcxmsxYuXGh9H188MaOxJFlH/MTn7Nmz8R6Tnnbu3KmrV69Kkjp16mQtDwsL09mzZ3X16lVFR0cndHiKbN++XdLDaylUqFCC9Zo3b27d3rFjR7qcGwAAAAAAICcb1rKcOlQvLEmKNtnplE8JnfIpoStFSstSpYrEOtkZioQTkIX07NlTLi4ukv6bLi8hMfvz5Mmjbt26WcujoqLk7e2tQYMG6aefftK2bdv0999/a9WqVRo/frx8fX0VHR2tl19+WRs3bsy4i0mGzz//XCNHjlRkZKSqV6+uadOmaf369dq/f7/mzZunhg0bymKx6MMPP9SUKVMMjTU9vP3227p+/bqaNm1qnSYurR48eKDTp0/ryy+/VPPmzRUVFSXp4RR1SRk9erRKliwpZ2dneXt7q1atWnrttddSPZomOjpaV69e1apVq9SqVStt3bpV0sMRQ1WrVo1Tv127dipdurQk6euvv7auRxbblStXNHv2bElSkyZNklyfKbXXFHvKPz8/P50+fVpPP/20PDw8VK5cORUrVkw+Pj565plnbBJgKRUSEqLLly9LSjopGHv/8ePHU31OAAAAAACA3MJkMunz7jVUtYiHglzzqu2QqWo7ZKqaDPhG4z9bKOXLZ3SIOVrii3AAKeXvn/pj8+SRXF3j3xcQIFlSOemmm5vk7h7/vjt3pPhGLZjNMgUHP9wOD5fs7KT8+VN3/hTw9PRUp06dtHDhQu3fv18nT56Md0THoUOHdOjQIUlSt27d5B7r+p588kn17dtXbm5uNsfUqlVL7du316uvvqpmzZrp0KFDGjt2rFq1apWxF5WAY8eOafTo0ZKksWPHauzYsdY1rCSpTp066t27twYOHKi5c+dq9OjRGjBggHVdm5QoVaqULl68mKZ4x44dm+QUgonZsWOHZsyYIUdHR02bNs3mWlNq9uzZiSas3nnnHfXt2zfJdmKvoRQREaF///1X//77r6ZMmaL3338/zv+ThCRWp3bt2vr555/j3efk5KRff/1VHTt21NmzZ1WjRg2NHDlS1apVU2RkpA4cOKCJEyfq7t27KlOmjH766acMu6bY00yeOHFCTz31VJwEWFBQkObMmaPly5dr6dKlat26dZLxPOrKlSvW7WLFiiVat3jx4tbtmCQVAAAAAAAAEufqZK8Zz9RV52+3KyDkv+UZZu24oHIF8qjfYyUNjC5nY4QT0leBAql/JfYwuXLl1Leb2Do5TZvGe4xdoULyLF9enuXLy65QoYflmST29HgJjXKKXR67viQVLVo0TrIpNk9PT40fP17Sw6m9bt++nZZwU+2LL75QZGSk6tatm2ASwM7OTt98842cnZ0VEhKixYsXGxBp2kVERGjo0KGyWCx6/fXX4x3tkx5q1qypvXv36tNPP000CVS4cGENGzZM8+fP1549e3TgwAEtW7ZMzz33nBwdHWU2m/XBBx9YE4Kp4ebmpmnTpmnnzp0qUqRIgvUaNGigf/75R2+++aYuXbqk//3vf2rSpIlatmypN998Uw8ePNCHH36offv2qXz58hl2TXfu3LFuDx8+XPfv39drr72m06dPKzw8XGfPntXIkSNlMpkUHBysHj166NKlSyn+XIJjEtl6ODoxMbETySEhISk+FwAAAAAAQG5V1MtV3w+oIyd72xTImN+P6uSN4ASOQloxwknSxYsXNWXKFK1evVqXL1+Ws7OzypYtq549e2rYsGGJPrxPSlIjEWKbNWtWggvII/do166dChYsqJs3b2revHn68MMPbZIHZrNZv/76q6SHIyRatmyZaHv379+Xv7+/7t+/L8v/jxJzdHS07j948KAho5xWrlwpSXr66acTTY54eXnJz89P+/fv165du/T888+n+Fzr1q1TRERE0hUTUSANScfPPvtMx44dU6lSpdJlPaouXbqobt26kqTQ0FCdPXtWCxcu1LJly9SnTx9NnjxZHTp0iPfYevXq6eLFizY/A9LDkUhdunTR0KFD1bZtWwUFBemzzz5Tr169VKNGjUTjOXz4sKSHU+rdvHlTmzZt0vTp0/Xmm2/q5MmTmjhxYpzzxbBYLFqwYIEWLlyoyMjIOPtDQkI0b948FSlSRM8++2yGXVPs0UxhYWEaP3683n//fWtZmTJlNHHiRHl7e+vdd99VYGCgPv30U02bNi3Rz+ZRYWFh1m0nJ6dE6zo7O1u3Q0NDU3QeAAAAAACA3K5OyXya0N1Pr/12UJJkMklvtq2oCgUT/xIwUi/XJ5xWrlyp/v376969e9ayBw8eaP/+/dq/f79mzpyp1atXq1y5cgZGidzEwcFBffv21VdffaULFy5o+/btatq0qXX/hg0bdO3aNUlSv379ZGcXd6BiQECAvvzySy1ZskSnT5+2JpriExAQkP4XkYSLFy/K//+nXxw1apRGjRqVrONu3LiRqvNVqFAhVcelh5MnT+qTTz6RJH3zzTdpSmDH8PLykpeXl/V9vXr11Lt3b82ZM0cDBw5U586d9eOPP8abwHZPaHrJ/1e/fn19++23GjBggCwWi7799lv98MMPiR7z6LpKbdu21UsvvaTmzZtr8uTJOnr0qP744w/ZP7Ioo9lsVu/evbVo0SJJ0nPPPadhw4apcuXKio6O1r///quJEydqxYoVeu6553To0CFNnjw5Q64pZu00SfL19dXbb78db1sjR47UlClTdOPGDS1cuFBTp05N0fSIsc+TVBI0PDzcuu2a0HSjAAAAAAAASFDXWsV05laIftp+QZN711S7qoWMDilHy9VT6v3zzz/q1auX7t27pzx58ujjjz/Wzp07tWHDBusoilOnTql9+/Y20yCl1p9//qnDhw8n+OrSpUuaz4GcIbFp9RKbTk+SDhw4oEqVKunTTz/VqVOnEk02ScaMnLh161aqjnvw4EE6R5KxLBaLXnjhBYWHh6tr164JjjpKLwMGDFCPHj1kNpv18ssv20wTlxK9e/eWh4eHJGnLli2paqN48eL67rvvJEl//fWXfvzxxzh1pk2bZk02jRs3TjNnzlStWrXk4uIid3d3NW7cWL///rsGDBggSfr666+tI+NSKqlryps3r3W7RYsWCY4+cnBw0OOPPy7p4TR8586dS1Ecsc+T1DR5sUddJTX9HgAAAAAAAOL3RpuK+mN4U5JNmSBXj3AaPny4QkND5eDgoHXr1qlhw4bWfa1atVL58uX11ltv6dSpU/riiy80bty4NJ2vQoUKKlWqVNqCzupSmUiQJCX2QPX4cSmJxEmCEhtRsm2bFB0dp9hsNluTjHnz5o13FFFGqlmzpvz8/HT48GEtWrTIuo7R/fv3tXTpUklSnTp1VKVKFZvjIiIi1LNnT92+fVuOjo565ZVX1LlzZ1WoUEHe3t7WKbrOnTunsmXLSlKSCamMEB3rMx8zZox69OiRrOOSGsmSkFOnTqXLlHopnVZv9+7d1uRGo0aNtGDBgjh1YkZ6SdL58+etdapVqxZn5FBydO7cWQsXLtT9+/e1du1a9e3bN8VtODg4qEKFCtq/f7+uXr2a4uNjtG3bVq6urgoNDdXixYs1dOhQm/0zZ86U9LCPvfPOOwm288knn1gTrT/99JM6duyY4liSuqbixYvHux2f2Pv9/f2tfSk5ihYtat2+cuVKonUvX76c7JgAAAAAAADwiPv3pc8/l52kUjFlI0dKqXzGiKTl2oTT3r17tW3bNkkPp3GKnWyK8cYbb2jWrFk6fvy4vv76a40ePTrBdUjw//Lnz5h2fX0zpt18+eIvN5tliVk/xcNDyuSEk/Rw9NLIkSMVGBiolStXqnv37lq2bJl11EN8o5s2btxoHXExdepUDRkyJN62UzvyJYbJZJLFYpHZbE60XuwRGrH5+PhYtx0dHVOVWEmJtm3b6uLFi2lqY+zYsSlOOseeEm3kyJFJ1t+6dau2bt1qPV9qPpf8sfpgWq45JdPEJcTe3l7e3t4KDQ2NN5bjx49LkqpUqWKzXtGjihUrZl3X7MSJE6mOJ7Frqlq1qnU7Op4kdGyx9zs4pOw2mjdvXhUvXlyXL19O8lpi769cuXKKzgMAAAAAAJDrPXggffCBbdmwYSScMlCunVJv+fLl1u3BgwfHW8fOzs76UD8wMFCbNm3KjNAASQ/XZ4pZ82bu3LmS/ptOz9HRUX369IlzzNGjR63bvXr1SrDt/fv3pym2mGnB7t69m2Adi8WiM2fOxLuvTJky8vT0lCTt2LEjTbHAVuzRO6mdhi0qKkqnTp2SJBUpUiTVsURERFjXCIsvlphkTVRUVJJtRUZG2hyTUkldU7NmzazbSU2Td/bsWet27BFLydWkSRNJD9f3SmxdsthT/zVu3DjF5wEAAAAAAAAyU65NOG3fvl3Swym66tSpk2C95s2bW7d5MI7MVLhwYbVu3VqStGbNGh05ckQbNmyQJD3xxBM2I1lixH5wn9DoIrPZrB9++CFNsZUuXVpS4omrP/74Q4GBgfHus7e311NPPSVJWrdunXWkS0a5cOGCLBZLml6pmVKzRYsWSbZ7/vx5a/2BAwem6XySrGsiSZKfn1+q2vjtt98UFBQkyfZ3YEr9/vvv1qkM44sl5ufoyJEjCf6sxOyPGZUXc0xKJXVNpUuXVq1atSRJmzZtstZ9VHBwsNavXy9JKlu2rAoXLpziWGKv1zd79ux46zx48EALFy6U9HAEWIUKFVJ8HgAAAAAAACAz5dqEU8wD7nLlyiX6jflKlSrFOSa1Bg8erCJFisjJyUm+vr5q0KCB3nvvvTStkYKcLWaEXWRkpHr37m2dyiu+6fQkqXz58tbthB5kjxo1Sn///Xea4op5YL9nz554E7E3btzQK6+8kmgbo0aNkr29vcxms7p3757oejbR0dGaN29ekmve5GSzZ89WWFhYonW++uorrVmzRtLDBErTpk1t9t+9e1ebN29OtI29e/fq5ZdflvRwCroXX3wxTp3NmzcnOHotxrFjx/Tqq69a38f3MxuzFlN4eLhef/31eNcTCwsLs2mnQ4cONvvT65okWdeRun//vkaMGBFvnddff1337t2TJP3vf/+Lt47JZJLJZEpwzb6uXbuqTJkykqRPP/3UZsRUjJEjR1pHECZnOkYAAAAAAADAaLlyDaewsDDrNE/FihVLtK63t7fc3d11//59mwXcUyP2Q9Hbt2/r9u3b2rNnj7744gtNnjxZL7zwQqraTeoh/PXr163boaGhCg0NTXbbZrPZ+hA4qfV6cpLY12rkdXfu3Fl58+ZVcHCwdbo8b29vtW/fPt642rRpowIFCujWrVt67733dP78eXXp0kW+vr46c+aMfvzxR23YsEGNGze2JorMZnOctmI/+I/vPEOGDNHUqVMVFRWljh076v3331fjxo0VERGhnTt36quvvlJkZKTKly+v06dPx9tO1apV9fnnn+v111/XsWPHVK1aNT3//PNq2bKlChYsqLCwMF24cEG7d+/WkiVLdP36dR08eDBNU7xlRbE/l8TWxRo3bpzeeOMNdevWTY0bN1bZsmWVJ08eBQcH6/Dhw5o/f771/6mTk5OmT58uk8lk097du3fVsmVLVa9eXZ07d1bt2rVVuHBh2dvb69KlS1q9erXmzp1rHZX0xhtvqFatWtY2Yv67e/dude/eXa1atVK7du3k5+cnHx8fRUVF6eLFi/rrr780d+5ca4Js8ODBatGiRZxrGzFihH788UfdunVLs2bN0unTpzV06FBVqlRJ0dHR+ueff/Ttt9/q2LFjkh6uY/TMM8+k6zXF1r17dz355JP6448/NHv2bF27dk3/+9//VKJECV2+fFkzZszQH3/8IUmqVauWXnrppSR/P8S3397eXl9//bU6d+6se/fuqXHjxho9erTq1aunu3fvaubMmVq6dKmkh9Pv9evXL1f9/k1vMf0qJfe+lIidCE4qKQzkFvQLIC76BRA/+gYQF/0CiCvV/SI0VK5xikKlDHpGkN1kxLOSXJlwCg4Otm4nZ42TmIRTSEhIqs5XpkwZdevWTQ0bNlTx4sUlPVwjZMmSJVq8eLHCwsL0v//9TyaTSUOHDk1x+zFtJsfWrVvl6+ub7Po+Pj5ydXWVyWSyfqs/t0nt//f00qlTJ82bN8/6vnPnzgoPD1d4eHi89adOnar+/fsrLCxMM2bM0IwZM2z2N2nSRBMnTlSjRo0kPfwl/ej/29htx/f/vXjx4vrggw80evRo3b17V6+//rrNfm9vb82dO1effPKJTp8+raioqHjbGTx4sOzs7PTuu+8qKChIkyZN0qRJk+K9LicnpwTbyc5i/3xFRkYmeH1ms1l37tzRzJkzNXPmzATbK1KkiL799lvVr18/Tlsx5zp06JAOHTqUYBv29vYaOXKk3nrrrQTjiY6O1l9//aW//vor0XZeeukljR07Nt52nJyctHjxYg0YMEAXL17U9u3brdOdPsrPz8+axIr9D4v0vCZJmjFjhgYOHKiNGzdq3bp1WrduXZw6tWvX1q+//qqIiAhrIis+ZrM5wXM1adJEX375pd566y3dvHnTZhRXjDp16mj27NkJTo+JpEVFRVm/aHHixIkMP9/WrVsz/BxAdkO/AOKiXwDxo28AcdEvgLhS0i+cgoL05CNlmzdvVsT/ry2f28UMyklPuTLhFPthpZOTU5L1nZ2dJaUu49e1a1cNHDhQJpPJprxevXrq1auXVq1apW7duikyMlKvvfaaOnXqpEKFCqX4PMi5+vTpY5Nw6t27d6L1H3/8cW3cuFGTJ0/Wtm3bFBAQIE9PT1WsWFE9evTQgAED0mVqupdeekkVK1bUtGnTdODAAYWGhqpQoUJq06aNXn311WQnQgcOHKgnn3xSs2fP1saNG3XmzBkFBQXJ2dlZhQsXVpUqVdSiRQt16tRJPj4+aY47u1qyZInWrVunPXv26Ny5c/L399edO3fk6uoqX19f+fn5qV27durSpYvc3NzibaNQoUKaPXu29u3bpwMHDuj69eu6c+eOwsLC5OHhoXLlyqlJkyZ65plnVKJEiQRjefHFF1W+fHlt375dR48e1Y0bNxQQECCz2SwvLy+VL19ejRo1Uu/evZNcc8nPz087duzQ/Pnz9ccff+jo0aO6e/euTCaTfH19rSOXunXrJkdHxwy7phh58uTR4sWLtXTpUs2fP9+6fpSnp6f8/Pz09NNPq3fv3rK3t0+yraQMHDhQ9erV04wZM7RlyxbduHFDbm5uqlChgnr06KFnnnkm0SlfAQAAAAAAgKzEZIlv0Ywczt/fXwUKFJAk9erVSwsWLEi0fsGCBXXr1i1Vq1ZNhw8fTvd4PvroI73//vvW7dGjR6fo+ORMqVe/fn1J0qlTp5KcRjC2S5cuKTo6Wo6OjipbtmyK4srOzGazdeREnjx5ZGeXa5c7A6zoF8huzp49q8jISNnb2ycr4ZgaYWFh1m9XNWvWTC4uLhlyHiA7oV8AcdEvgPjRN4C46BdAXKnuF/7+ci1Z0qYo9OJFKX/+9A4xW7py5YoqVKggSbp8+XKK8gYJyZVfnc6bN691OznTpcVMZ5Sc6fdSY+jQoRozZowsFou2bNmS4oRTSn4QXF1d5er66MyVCbOzs7OuHZJbHy7b2dnl2msHEkK/QHZhMplkZ2eXontfarm4uGTKeYDshH4BxEW/AOJH3wDiol8AcaWoX8RTz9XVNd7y3Cgjfr/kyqeFLi4u1qm5khoddPfuXWvCKSVrJaVEgQIFrPFcvXo1Q84BAAAAAAAAAACQUXJlwkmSqlSpIkk6c+aMoqKiEqwXe5HxypUrZ1g8j67xBAAAAAAAAAAAkF3k2oRTkyZNJD2cLu/AgQMJ1tuyZYt1u3HjxhkSi7+/vwICAiRJRYoUyZBzAAAAAAAAAAAAZJRcm3Dq0qWLdXvWrFnx1jGbzfrll18kSV5eXmrZsmWGxDJjxgxZLBZJUvPmzTPkHAAAAAAAAAAAABkl1yac6tevr6ZNm0qSfvzxR+3atStOnS+++ELHjx+XJA0fPlyOjo42+zdv3iyTySSTyaRBgwbFOf7ChQv6559/Eo1j1apVGj9+vKSHi3QNHjw4NZcDAAAAAAAAAABgGAejAzDS119/rcaNGys0NFRt27bVu+++q5YtWyo0NFQLFizQjBkzJEkVKlTQG2+8keL2L1y4oJYtW6phw4bq2LGjatSooQIFCkiSzp07p8WLF2vx4sXW0U2TJk1S0aJF0+8CAQAAAAAAAADIjUwmydc3bhkyTK5OONWqVUu//fab+vfvr3v37undd9+NU6dChQpavXq18ubNm+rz7Nq1K94RVDHc3Nz01VdfaejQoak+BwAAAAAAAAAA+H++vpK/v9FR5Cq5OuEkSR07dtShQ4f09ddfa/Xq1bpy5YqcnJxUrlw59ejRQy+//LLc3NxS1XadOnU0d+5c7dq1S/v379f169cVEBCgqKgoeXt7q2rVqnr88cc1ZMgQ68gnAAAAAAAAAACA7CbXJ5wkqWTJkvryyy/15Zdfpui4Fi1aWKfDi0/evHnVr18/9evXL60hAgAAAAAAAAAAZFl2RgcAAAAAAAAAAACA7I2EExJlZ/fwRyQ6OjrR0VwAAGQlFotF0dHRkv67lwEAAAAAACDj8AQGiXJycpL08MFdeHi4wdEAAJA84eHh1i9KxNzLAAAAAAAAkHFYwwmJcnd3V0hIiCTp3r17cnFxMTgiAACSdu/ePeu2u7u7gZEAAAAAAABDhIZKP/1kW/bss5KrqzHx5AIknJCoPHny6ObNm5Kk27dvy97eXl5eXrK3tzc4MgAA4oqOjlZgYKBu375tLcuTJ4+BEQEAAAAAAEOEhEgvv2xb1rMnCacMRMIJiXJyclL+/Pnl7+8vSbp165Zu3bole3t7mUwmg6PLWFFRUZJkvXYA9AtkbbHXbYqRP39+ptQDAAAAAADIBCSckCQfHx9FREQoKCjIWvboA72cxmKxKDQ0VJLk6uqa45NrQHLQL5DdeHp6ysfHx+gwAAAAAAAAcgUSTkiSyWRSkSJFlC9fPgUGBurBgwc5PuFkNputD9bz5MkjOzs7gyMCjEe/QHZgb28vNzc3eXl5se4gAAAAAABAJiLhhGRzcXFRoUKFjA4jU4SGhurEiROSpDp16siVeT0B+gUAAAAAAACABPH1dAAAAAAAAAAAAKQJCScAAAAAAAAAAACkCQknAAAAAAAAAAAApAkJJwAAAAAAAAAAAKQJCScAAAAAAAAAAACkCQknAAAAAAAAAAAApAkJJwAAAAAAAAAAAKQJCScAAAAAAAAAAACkiYPRASDjRUVFWbevX79uYCTZR2hoqAICAiRJV65ckaurq8ERAcajXwBx0S+AuOgXQFz0CyB+9A0gLvoFEFeq+8Xt23HLrl2TwsPTMbrsK3auIHYOIS1IOOUC/v7+1u369esbGAkAAAAAAAAAAAapWdPoCLIkf39/lSpVKs3tMKUeAAAAAAAAAAAA0sRksVgsRgeBjBUWFqbDhw9LkvLnzy8HBwa2JeX69evW0WB79+5V4cKFDY4IMB79AoiLfgHERb8A4qJfAPGjbwBx0S+AuOgXGSMqKso6O5qfn59cXFzS3CaZh1zAxcVF9erVMzqMbKtw4cIqVqyY0WEAWQr9AoiLfgHERb8A4qJfAPGjbwBx0S+AuOgX6Ss9ptGLjSn1AAAAAAAAAAAAkCYknAAAAAAAAAAAAJAmJJwAAAAAAAAAAACQJiScAAAAAAAAAAAAkCYknAAAAAAAAAAAAJAmJJwAAAAAAAAAAACQJiScAAAAAAAAAAAAkCYmi8ViMToIAAAAAAAAAAAAZF+McAIAAAAAAAAAAECakHACAAAAAAAAAABAmpBwAgAAAAAAAAAAQJqQcAIAAAAAAAAAAECakHACAAAAAAAAAABAmpBwAgAAAAAAAAAAQJqQcAIAAAAAAAAAAECakHACAAAAAAAAAABAmpBwAgAAAAAAAAAAQJqQcAIAAAAAAAAAAECakHBCjvD222/LZDJZX5s3b06XdufPn6+2bduqUKFCcnFxUcmSJdW/f3/t2rUr2W08ePBAEydOVL169ZQvXz65u7urUqVKeuONN3Tx4sV0iROIT1bsFy1atLCJKbEXkBHSs19ERUXpn3/+0ffff68hQ4aoevXqcnBwsLZ94cKFFLUXEBCgMWPGqHr16vLw8JCHh4eqV6+uMWPG6Pbt26mOE0iOrNg3SpUqlaz7RalSpVIdK5CY9OwXQUFBmjdvngYPHqwaNWrI09NTjo6Oyp8/v1q2bKkvvvhCgYGByW6PewaMkhX7BfcLGC09+8X+/fv1xRdfqHfv3qpevboKFy4sZ2dn5c2bVxUrVtTAgQO1adOmZLfHMykYKSv2DZ5LZQILkM39888/FgcHB4sk62vTpk1pavPBgweWp556yqbN2C87OzvLuHHjkmzn9OnTlvLlyyfYjoeHh2XlypVpihWIT1btF82bN0/w+EdfQHpL734xbty4RH+Gz58/n+y2du/ebSlUqFCCbRUuXNiyZ8+eVMcKJCar9o2SJUsm635RsmTJVMcKJCQ9+8WaNWsszs7OSf4sFypUyLJx48Yk2+OeAaNk1X7B/QJGSu9/RzVu3DhZP889evSwhIaGJtoWz6RgpKzaN3gulfEcBGRjZrNZQ4cOVVRUlAoUKKBbt26lS7vPPvus1qxZI0lq2bKlhg8friJFiujw4cP65JNPdPbsWY0bN06FCxfW0KFD420jODhY7du31+nTpyVJzz//vHr37i1XV1dt2rRJn376qe7du6devXppx44dqlmzZrrEDmTlfhGjbt26mjVrVrrEBSRHRvQLi8Vi3XZxcVHNmjXl7++vs2fPpqidy5cvq2PHjvL395eDg4Nef/11dejQQZK0atUqffnll7p+/bo6duyoAwcOqFixYmmOHYiRlftGjM6dO+ujjz5KcL+Tk1Oq2gUSkt794vbt2woPD5ednZ3atGmjJ554QjVq1JCXl5euXLmiefPm6bffftONGzfUoUOHRP824J4Bo2TlfhGD+wUyW0b8O8rZ2VnNmzdXo0aNVLlyZRUuXFj58uWTv7+/Dh48qOnTp+v8+fNatGiR7OzstGDBgnjb4ZkUjJSV+0YMnktlIKMzXkBafPXVVxZJlkqVKllGjRqVLhnzDRs2WNvp2LGjJSoqyma/v7+/pUSJEhZJFi8vL8udO3fibef999+3tjNx4sQ4+3fs2GHN9Ddv3jzV8QKPysr9IuabJPzMI7NlRL9Yu3atZfr06Za///7bEhkZabFYLJaBAwemeBTHgAEDrMcsXLgwzv7ffvvNun/gwIGpjheIT1buGzHfWOfnHpktvfvFggULLC+88ILl4sWLCdaZMmWK9TwtW7ZMsB73DBglK/cL7hcwSkb8Oyrm304JefDggaVBgwbWcx08eDDeejyTgpGyct/guVTGYw0nZFuXLl3S+++/L0maPn16un1badKkSZIkBwcHTZ06Vfb29jb7fX19NWHCBElSYGCgZs6cGaeNyMhITZkyRZJUuXJlvfHGG3HqNGrUSM8995wkacuWLdq3b1+6xI/cLSv3C8AoGdUv2rVrpxdeeEG1atWSg0PqBo3fuHFD8+bNs7bXo0ePOHV69uypdu3aSZLmzJmjGzdupD5oIJas3DcAo2REv+jVq5emT5+uEiVKJFjnlVdeUd26dSU9/NsgICAgTh3uGTBKVu4XgFEy6t9RSf3bydXVVcOHD7e+37ZtW5w6PJOCkbJy30DmIOGEbGvYsGEKCQnRwIED1bx583RpMzg4WBs2bJAktW7dOsEpKLp16yYPDw9J0rJly+Ls37Rpk4KCgiRJAwcOlJ1d/F1t0KBB1u342gFSKiv3C8AoGdEv0suKFStkNpslSYMHD06wXsz9wmw2a8WKFZkRGnKBrNw3AKMY2S9atGgh6eHv+vPnz8fZzz0DRsnK/QIwipH9Im/evNbtsLCwOPt5JgUjZeW+gcxBwgnZ0sKFC7Vq1Srly5fPOvIiPezbt08RERGSlOgvRScnJzVo0MB6TGRkpM3+7du3W7cTa6du3bpyc3OTJO3YsSPVcQNS1u8XgBEyql+kl+TeL2Lv436B9JDV+wZgBKP7RXh4uHX70dHkEvcMGCOr9wvACEb3i9hr01SqVCnOfp5JwShZvW8gc5BwQrYTGBhoHSI5YcIE+fr6plvbx44ds24n9YspZn9UVJR1EcaUtuPg4KBy5cpJko4fP57ieIEY2aFfxHbixAk99thj8vLykouLi4oVK6bOnTvrl19+IVGFdJOR/SK9xPQvT09PFSpUKMF6hQsXto4g5H6BtMoOfSO2rVu3qmbNmsqbN6/c3NxUunRp9erVS8uXL5fFYjE6POQQWaFfbNmyRZLk6Oho/RshNu4ZyGzZoV/Exv0CmcGIfmE2m3Xz5k1t3LhRXbt21dy5cyU9/Ps7ZhrV2HgmBSNkh74RG8+lMg6TqiPbeeutt3Tjxg01btzYOt9serly5Yp1O6Fpw2IUL17cun358mVVqVIlTjvu7u7y8vJKsp1Dhw7J399f4eHhcnZ2TkXkyO2yQ7+I7ebNm7p586b1/dWrV3X16lWtWLFCEyZM0OLFi1W5cuU0Ro7cLiP7RXqJ6V9J9S3pYf86evSoLl++nNFhIYfLDn0jtkenULpw4YIuXLighQsXqnHjxvrtt99UtGhRg6JDTmF0v1i9erUOHTok6eH6TDEJo9i4ZyCzZYd+ERv3C2SGzOwXpUqV0sWLF+PdV6ZMGS1dujTedW14JgUjZIe+ERvPpTIOCSdkK9u2bdPMmTPl4OCg6dOny2QypWv7wcHB1u08efIkWtfd3d26HRISEm87SbURXzvc3JFS2aVfSJKdnZ0ef/xxPfXUU6pRo4Z8fHwUHBysv//+W99//72OHz+uY8eOqWXLltq7d2+iiwgDicnofpFeUnO/iK9vAcmVXfqG9HCq1k6dOqlt27aqVq2aPD09FRgYqF27dmnatGm6fPmyduzYoTZt2mjXrl3y9PQ0OmRkU0b3izt37mjYsGGSHk4ZNn78+Hjrcc9AZsou/ULifoHMY3S/kB6OSho3bpxeffVVm/VqYuOZFDJbdukbEs+lMgMJJ2QbERERGjp0qCwWi1577TVVq1Yt3c8Re0E5JyenROvGvgmHhobG205SbSTVDpCU7NQvJGnp0qXxfsOqadOmeumll/T888/r559/1s2bNzVixAgtXbo09YEj18qMfpFeUnO/4F6B1MpOfUOS9u7dG+89o0WLFnr55ZfVvXt3rVu3TsePH9cHH3ygL7/8MvODRLZndL+Ijo5Wv379rN/Sfe+991SrVq1463LPQGbJTv1C4n6BzGFEv1i3bp0iIiJkNpt1+/Zt7dixQ9OmTdP48eN18uRJTZ06Nd6kEs+kkJmyU9+QeC6VGVjDCdnGJ598ohMnTqhEiRIaO3ZshpzDxcXFuh0REZFo3diLl7q6usbbTlJtJNUOkJTs1C8kJTqc39HRUTNnzlTFihUlScuWLdPVq1dTGC2QOf0ivaTmfsG9AqmVnfqGlPg9I2/evFq4cKHy5csnSZoxY0ay+hHwKKP7xUsvvaS1a9dKkjp06KD3338/wbrcM5BZslO/kLhfIHMY0S8qVKigatWqqXr16mrZsqXee+89HTlyRDVq1NCcOXPUuHHjeEey8kwKmSk79Q2J51KZgYQTsoUTJ07o008/lSR98803NkN+01PsIZdJTT9x//596/ajWfOYdpIzhUVi7QCJyW79IjkcHBxs5vqNWSQYSK7M6hfpJTX3C+4VSI3s1jeSw9PTU71795b0sH/s37/f4IiQ3RjdL0aNGqUZM2ZIevit2oULF8re3j7B+twzkBmyW79IDu4XSCuj+0Vs3t7e+vnnnyVJhw4d0ieffBKnDs+kkFmyW99IDp5LpR1T6iFb+OqrrxQREaEyZcrowYMHWrBgQZw6R44csW5v3LhRN27ckCR17Ngx2b/wYi/Ae+XKFdWtWzfBurEX4C1evHicdvbs2aP79+8rMDAw0ex5TDv58+dnrlykSHbrF8lVpUoV6zbfJEFKZVa/SC/FihXTzZs3rQv7Jiamf6W2byF3y259I7m4ZyAtjOwXEyZM0GeffSZJql27tlatWpXkN8u5ZyAzZLd+kVzcL5AWWe3fUZUrV1b58uV1+vRpLV68OM6DdZ5JIbNkt76RXNwz0oaEE7KFmCG+586dU58+fZKs/+GHH1q3z58/n+xfYLF/oZw4cSLRujH7HRwcVL58+TjtLFmyxFqvQYMG8bYRFRWls2fPSnr4SxFIiezWL5IrKy9gj6wvs/pFeqlSpYoOHDigoKAg3bhxQ4UKFYq33vXr13Xv3j1J3C+QOtmtbyQX9wykhVH9YurUqXrnnXckPfyd/ueff8rDwyPJ47hnIDNkt36RXNwvkBZZ8d9R+fPn1+nTp61rncXGMylkluzWN5KLe0baMKUeEEu9evWsiyomNmQyIiJCu3fvth7j6Ohos79JkybW7cTa2b9/v3X4cuPGjVMdN5CR0qtfJNexY8es20WKFElVG0B2kdz7Rex93C+A/3DPQHYzZ84cvfzyy5KkMmXKaP369fL19U3WsdwzkFOlpV8kF/cL5DQxoy7imwaPZ1LIzRLrG8nFPSONLEAOMXbsWIskiyTLpk2bUt3Ok08+aZFkcXBwsFy+fDneOvPnz7eea+LEiXH2h4eHWzw9PS2SLJUrV7aYzeZ423nhhRes7ezduzfVMQMJyUr9IjkiIyMtlStXtrZz6dKlVMcMJCS9+kV8Bg4caG37/PnzSda/fv26xc7OziLJ0q5duwTrtWvXziLJYmdnZ7l+/Xo6Rgz8Jyv1jeQIDAy0+Pj4WCRZ3NzcLGFhYenSLhBbevaLJUuWWOzt7S2SLMWKFUtxX+CegawiK/WL5OB+gcyQkf+OetTevXut52revHmc/TyTQlaSlfpGcvBcKu0Y4YRcZfbs2TKZTDKZTBo3bly8dd58801JD4cWDxs2TNHR0Tb7AwIC9Pbbb0uSvLy8NGTIkDhtODk56dVXX5UkHT9+XJMmTYpTZ9euXfrxxx8lSc2bN1e9evVSfV1AWmRWv9i0aZMCAwMTjCMyMlJDhgzR8ePHJT2cz5d1B2CU5PSL9FCoUCH169dPkvTnn39q8eLFceosWrRIf/75pyRpwIABCU6hBGSGzOoba9euVWhoaIL7Q0JC1LNnT92+fVuS9Nxzz7HuAAyTnH6xbt069enTR9HR0SpQoIDWr1+vUqVKpeg83DOQnWRWv+B+gewkqX6xd+9e/f3334m2cfXqVQ0cOND6/plnnolTh2dSyG4yq2/wXCpzsIYT8IhWrVqpd+/eWrBggVasWKE2bdpoxIgRKlKkiA4fPqyPP/5Yly5dkvRwUVNvb+942xk5cqR+++03nTp1Sm+99ZbOnDmj3r17y9XVVZs2bdInn3yiqKgoubq6avLkyZl4hUDKpUe/+Pnnn9WpUyd16tRJLVq0UMWKFeXh4aGQkBAdOHBAM2bMsA5bLlCggL7++utMvUYgpUJCQuI87Dtz5ox1e/HixTbTwdSsWVM1a9aM087HH3+stWvXyt/fX3369NH+/fvVoUMHSdKqVav0xRdfSHo4F/VHH32UAVcCpK/06BufffaZ+vXrp27duqlJkyYqW7as8uTJo6CgIO3cuVPTp0+33ncqVqyYockvIK12796trl27KiIiQo6Ojvrqq68UGRlps4j2o4oVKxbvIu/cM5BTpFe/4H6BnOTYsWMaPHiwGjVqpI4dO6pmzZrKnz+/pIcP0zdt2qRZs2YpKChIktS6dWsNGjQo3rZ4JoWcJL36Bs+lMgcJJyAeP/30k+7du6c1a9Zo06ZN2rRpk81+Ozs7vf/++xo6dGiCbeTNm1erV6/WU089pdOnT2vGjBmaMWOGTR0PDw/Nmzcv3geQQFaTHv0iJCREv/76q3799dcE6/j5+WnBggUqXbp0usUOZISAgAANHjw4wf0jR460eT927Nh4f98XL15cK1euVJcuXXTjxg1NmDBBEyZMsKlTqFAhLV++XMWKFUuX2IGMlF59486dO5o5c6ZmzpyZYFvNmzfXvHnzlC9fvlTHC2S0tWvX6sGDB5IefnM2ZpRSYmbNmhXvgxLuGcgp0rNfcL9ATrNz507t3Lkz0TqDBg3Sd999Jzu7+Cev4pkUcqL06Bs8l8p4JJyAeLi6umr16tX69ddfNXv2bB08eFCBgYEqWLCgmjZtqpdfflkNGzZMsp1y5crpn3/+0XfffadFixbpzJkzioiIUPHixfXUU09p+PDhKlmyZCZcEZB2ae0Xb7/9tmrWrKldu3bp2LFj8vf31507d+Ts7KyCBQuqbt266t69u7p27Sp7e/tMvDLAeI899pgOHz6sr7/+WsuXL9eFCxckSaVLl1bnzp01YsQI+fj4GBskkIkmTZqkDRs2aNeuXTp58qQCAgIUGBgoNzc3FSlSRI899pj69Omjtm3bymQyGR0ukKm4ZwD/4X6BnKRXr17y9vbWxo0b9ffff+vatWu6efOmIiMj5enpqXLlyqlx48YaMGCAqlevnmR7PJNCTpFefYPnUpnDZLFYLEYHAQAAAAAAAAAAgOwr/rFlAAAAAAAAAAAAQDKRcAIAAAAAAAAAAECakHACAAAAAAAAAABAmpBwAgAAAAAAAAAAQJqQcAIAAAAAAAAAAECakHACAAAAAAAAAABAmpBwAgAAAAAAAAAAQJqQcAIAAAAAAAAAAECakHACAAAAAAAAAABAmpBwAgAAAAAAAAAAQJqQcAIAAAAAAAAAAECakHACAAAAAAAAAABAmpBwAgAAAAAAAAAAQJqQcAIAAAAAAAAAAECakHACAAAAAAAAAABIoVu3bmnVqlUaM2aMnnzySfn6+spkMslkMmnQoEGGxbV+/XoNGjRI5cqVk7u7uzw9PVWhQgV1795d06ZNU0hISIac1yFDWgUAAAAAAAAAAMjBChYsaHQINu7evavBgwfr999/j7Pv3r17On36tJYsWaKGDRuqZs2a6X5+RjgBAAAAQA4xbtw46zcqAQAAAGSeEiVKqG3btoadPygoSG3atLEmm7p27ap58+Zp9+7d2rdvn5YuXarhw4erWLFiGRYDCScAAAAASIMXXnjBmuTZuHFjio5dt26d9djhw4dnUIQAAAAAMsKYMWO0cuVK3bhxQxcvXtT3339vWCyvvPKKDhw4IGdnZ/3+++9aunSp+vbtq8cee0x169ZV165dNXnyZF26dEnVqlXLkBhIOAEAAABAGjzzzDPW7blz56bo2Dlz5sTbDgAAAICs74MPPlCHDh0Mn1pv+/bt1r8tPvroI3Xq1CnBuiaTSQ4OGbPaEgknAAAAAEiDxo0bq2zZspKkJUuWKDQ0NFnH3b9/X8uWLZMkVa1aVXXq1MmwGAEAAABkbWFhYfr222/1+OOPq1ChQnJyclKBAgXUunVr/fjjj4qKikrw2G+//VaS5OnpqZdffjmzQo6DhBMAAAAApNGAAQMkPVyIN74FeuOzdOlS3b9/3+Z4AAAAALnPwYMHValSJb3yyivauHGjbt68qcjISPn7+2vDhg0aMmSIGjVqpJs3b8Y5NiIiwvo3SJs2beTi4iJJio6O1uXLl3XhwgWFhYVlynWQcAIAAACANBowYIBMJpOk5E+rFzPlhZ2dnfr3759hsQEAAADIus6cOaPmzZvr4sWL8vDw0KhRo7Rs2TLt379ff/75p4YNGyYHBwft27dPnTt3VmRkpM3xBw8etCaU/Pz8dO/ePY0YMUK+vr4qUaKESpcuLU9PT7Vp00abN2/O0Gsh4QQAAAAAaVSmTBk1btxYkvTnn3/q1q1bida/du2aNmzYIElq1aqVihYtKknavXu33nvvPbVo0cI6jYaHh4eqVKmiF198UceOHUtTnCaTSSaTSePGjUu0XosWLWQymdSiRYtE6505c0avvfaa/Pz85OnpKVdXV5UpU0aDBg3S/v37Ez02LCxMU6ZMUYsWLZQ/f345OjoqX758qlixop588kl9+eWXunDhQsouEAAAAMhmBg4cqKCgINWqVUtnz57VJ598oi5duqhOnTpq27atvv32W61cuVJ2dnbas2ePZs+ebXN87L8RzGaz6tatq6+//lqBgYHW8oiICK1fv16tWrXShAkTMuxaSDgBAAAAQDp45plnJElRUVFasGBBonV//fVXmc1mm+Nmz56thg0b6uOPP9aWLVus02gEBwfr+PHjmj59uqpXr66pU6dm7IUk06RJk1SlShVNnjxZR44c0b179xQWFqbz58/r559/Vv369TVmzJh4j71+/brq1Kmj4cOHa8uWLQoICFBUVJTu3r2rU6dOae3atXrjjTesc9EDAAAAOdG2bdu0c+dOSdLPP/8sX1/feOs98cQT6t69uyTFSTjduXPHuj1hwgSdPn1aTzzxhPbu3auwsDDdunVL06ZNk6enpywWi955551kTwOeUiScAAAAACAd9OzZ0zpfesx0eQmJ2Z8nTx5169ZN0sNElbe3twYNGqSffvpJ27Zt099//61Vq1Zp/Pjx8vX1VXR0tF5++WVt3LgxYy8mCZ9//rlGjhypyMhIVa9eXdOmTdP69eu1f/9+zZs3Tw0bNpTFYtGHH36oKVOmxDn+lVdesX4Ts3///lq6dKl2796tffv2acWKFRozZoxq1KiR2ZcFAAAAZKoVK1ZIkipWrCg/P79E6zZr1kyStG/fPkVFRVnLY9aFlR7OItCmTRutWrVK9erVk7Ozs/Lnz6///e9/WrVqlezsHqaERo0aJYvFkt6XI4d0bxEAAAAAciFPT0916tRJCxcu1P79+3Xy5ElVrFgxTr1Dhw7p0KFDkqRu3brJ3d1dkvTkk0+qb9++cnNzs6lfq1YttW/fXq+++qqaNWumQ4cOaezYsWrVqlXGX1Q8jh07ptGjR0uSxo4dq7Fjx1rXr5KkOnXqqHfv3ho4cKDmzp2r0aNHa8CAAfL29pb08I/gmD+s33jjDU2aNCnOOTp27KgPPvjA5tuaAAAAQE4TMw31yZMnbf5NnZjIyEjduXNHBQoUkCTrl95iTJgwQfb29nGOa9Kkibp166bFixfr+PHjOnz4sKpXr57GK7DFCCcAAAAASCcx0+NJCY9yil0eu37RokXjJJti8/T01Pjx4yVJ27dv1+3bt9Mabqp88cUXioyMVN26deMkm2LY2dnpm2++kbOzs0JCQrR48WLrvjt37lgXOo75lmZC8uXLl77BAwAAAFlIUmu/JuTBgwfW7bx581q38+fPr1q1aiV4XLt27azb+/btS9W5E8MIJwAAAABIJ+3atVPBggV18+ZNzZs3Tx9++KFNQsZsNuvXX3+VJBUrVkwtW7ZMsK379+/L399f9+/ft0534ejoaN1/8OBBQ0Y5rVy5UpL09NNPJ/otTC8vL/n5+Wn//v3atWuXnn/+eUmSj4+PnJycFBERoTlz5uipp56SgwN/mgIAACD3iY6OliTVqFFDc+fOTfZxRYsWtW4XL17cul2sWLFEj4td19/fP9nnSy7+VQ8AAAAA6cTBwUF9+/bVV199pQsXLmj79u1q2rSpdf+GDRt07do1SVK/fv2sc6jHCAgI0JdffqklS5bo9OnTic6rHhAQkDEXkYiLFy9a/zAdNWqURo0alazjbty4Yd12dnZWr169NGfOHC1evFj79u1Tz5491aJFCzVq1EheXl4ZEToAAACQ5fj4+EiSQkJCVK1atVS1UbVqVet2TAIrIbH3Z8SXvphSDwAAAADSUWLT6iU0nZ4kHThwQJUqVdKnn36qU6dOJbmIb2hoaDpEmzLpMeWHJH377bfq2LGjpIdJrM8//1zt27eXj4+P6tWrp88//1xBQUFpjhcAAADIymKmvzt37pzNl7RSomTJkipRooQk6cKFC4n+HXH27FnrduxRUumFhBMAAAAApKOaNWvKz89PkrRo0SKFh4dLejhF3tKlSyVJderUUZUqVazHREREqGfPnrp9+7YcHR31+uuva8uWLbp+/brCwsJksVhksfxfe3cb2lX99wH8LWuajDkUTSyQZjq6gTCqQahMu9EojGTDFd0S1pOIpqI1qJH1IGrQjURqBrMwowiTBt0IiwUbZiw1pka5hlCx2IN5x0jy7noQG043rz/+tOvfxesFg7NzPr/v+Z7tye/wPufzPTXkBvF/C6QuhtOfiGxoaEhnZ+d/9NPU1DRknHHjxuWzzz7L9u3bs3z58tx4440pKirKyZMn09HRkZUrV6aioiLbtm37py8RAAD+Mffcc0+Sv7/bv/nmm+c9TnV1dZLk8OHDaWlpGbFu4H4kSWbPnn3e5xuJlnoAAAAX2MMPP5wVK1bk4MGDaW5uTk1NTT799NP09/cPHj/d119/ne7u7iTJ22+/nSVLlgw7bl9fX0HzGjVqVE6dOpWTJ0+es25gnmcaaPmR/L2e1Pm2/RhQWVmZysrKJMmRI0fS2tqaDRs2ZPPmzent7U11dXV++eWXjB07tqDzAADAf6P58+ensrIy3333XRobG3PDDTdk8eLFI9Z3dnZm//79g90CBtTV1WXNmjU5evRoli1blra2towbN25IzcaNG9Pa2pokufvuu4es53ShCJwAAAAusAceeCDPPvtsTpw4kY0bN6ampmawnV5xcXHuv//+IfV79uwZ3K6trR1x3I6OjoLmVVpamsOHD+fAgQMj1pw6dSpdXV3DHps2bVrKyspy6NChtLe3FzSX4ea2cOHCLFy4ME8//XRWr16dnp6etLW15Y477rig5wIAgAuhra1tyHfn09dZ7erqyoYNG4bUP/roo2eNsWnTplRWVqavry+1tbXZuHFjamtrM2PGjBQVFaW3tzc7d+5Mc3Nzvv322yxfvvyswGnq1Kl58cUXs3LlynR2dqaysjLPPPNMrr/++hw+fDibN2/OmjVrkvzdbeD111+/cH+E0wicAAAALrApU6bk9ttvz1dffZXPP/88u3fvHmxtceedd2bSpElD6o8fPz643d/fn9LS0rPGPHnyZNavX1/QvMrLy/PDDz+cM7j64osvcvDgwWGPFRUV5a677sqHH36YrVu35scff8w111xT0JyGc9ttt2X16tVJht60AwDAf5N3330377333rDH2tvbz3pIa7jA6aqrrsq2bdtSXV2d3bt3p7m5Oc3NzSOe88w3lwasWLEifX19eeWVV/LTTz/lscceO6vmsssuy5YtWzJjxoxzXNX5s4YTAADARTDQNu/YsWO57777Btc/OrOdXpIhN3xnPgU5oL6+Pjt27ChoTlVVVUmS7du3D/uG0h9//JGnnnrqnGPU19cPrrdUU1OT3377bcTaEydO5IMPPhhS093dnW+++eac59i6devgdnl5+TlrAQDg366ioiK7du3Kpk2bUl1dnalTp2bs2LEZPXp0pkyZkrlz5+a5557L999/n4aGhhHHefnll9Pe3p6HHnooV155ZcaMGZOysrLcfPPNeemll/Lzzz/nlltuuWjXMerU/8VKswAAAP/P/fnnn5k8eXKOHDkyuG/8+PHp6enJmDFjhtT29/dn2rRp6e3tTVFRUZYsWZJFixZl4sSJ6erqyvr169PS0pJZs2YNBkVNTU1nPSH5wgsvZNWqVUn+bo13pj179mTmzJk5fvx4xo8fn4aGhsyePTt//fVX2tvb89prr+XYsWOZMGFC9u3bl6qqqsE+76d74403snTp0iRJWVlZnnjiidx6662ZPHlyjh49mv3792fbtm355JNP0tPTk87OzsH1nlpbWzNv3rxce+21WbRoUW666aZcccUVSZJff/01H330UT7++OMkycyZM7Njx46MGjXqPP4DAADAP0lLPQAAgItg7NixqampSVNT0+C+xYsXnxU2JUlJSUnef//93HvvvTl69GjWrVuXdevWDamZO3du3nrrrcHg5nxcd911efXVV7Ns2bIcOHBgMDQaMGHChGzZsiXPP/989u3bN+I4dXV1KSkpSV1dXQ4dOpTGxsY0NjYOWzt69OhceumlZ+3fu3dv9u7dO+I5rr766mzevFnYBAAA/xJa6gEAAFwkjzzyyJDfh2unN2DBggXp6OjIgw8+mMsvvzzFxcWZNGlSqqqq8s4776SlpSUlJSUFz2np0qX58ssvs2DBgowfPz5jxoxJeXl5nnzyyezcuTNz5sz5j8Z5/PHH093dnVWrVmXWrFmZOHFiLrnkkpSUlKSioiLV1dVZu3Ztfv/990yfPn3wc3PmzElra2vq6+szb968TJ8+PaWlpSkuLs7kyZMzf/78rF27Nrt27dJODwAA/kW01AMAAAAAAKAg3nACAAAAAACgIAInAAAAAAAACiJwAgAAAAAAoCACJwAAAAAAAAoicAIAAAAAAKAgAicAAAAAAAAKInACAAAAAACgIAInAAAAAAAACiJwAgAAAAAAoCACJwAAAAAAAAoicAIAAAAAAKAgAicAAAAAAAAKInACAAAAAACgIAInAAAAAAAACiJwAgAAAAAAoCACJwAAAAAAAAoicAIAAAAAAKAgAicAAAAAAAAKInACAAAAAACgIAInAAAAAAAACiJwAgAAAAAAoCACJwAAAAAAAAoicAIAAAAAAKAgAicAAAAAAAAKInACAAAAAACgIP8DMxVsastnEiEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 546, + "width": 846 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import gaussian_kde\n", + "\n", + "# Data array\n", + "data = gs.wcgp\n", + "\n", + "obs = gs.wcg\n", + "\n", + "# Kernel Density Estimation\n", + "kde = gaussian_kde(data)\n", + "maxd = max(max(data), obs)\n", + "x_range = np.linspace(min(data), maxd, 1000)\n", + "kde_values = kde(x_range)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", + "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs}')\n", + "plt.title(\"Kernel Density Plot with Vertical Line\")\n", + "plt.xlabel(\"Values\")\n", + "plt.ylabel(\"Density\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the block weights matrix is more dense than the Queen weights matrix, there are more neighbor pairs in the block scheme than under the contiguity scheme. Conversely, there are fewer (more) distant pairs under the block (contiguity) scheme.\n", + "\n", + "Under the null, there is no difference in the average inequality between a pair of observations that are neighbors, and the average inequality for pairs that are not neighbors. As such, the expected level of \"distant\" inequality will be larger for the contiguity scheme relative to the block scheme." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gini polarization\n", + "$$\n", + "GP = \\frac{ \\sum_i \\sum_j(1-\\gamma_{i,j}) \\left | x_i - x_j \\right |} {\\sum_i \\sum_j \\gamma_{i,j} \\left | x_i - x_j \\right | } $$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The polarization should be related to the relative size of the two sets.\n", + "\n", + "$n_{\\text{pairs}} = n(n-1)/2$\n", + "\n", + "$n_{\\text{pairs}} = n_{\\text{neighbor pairs}} + n_{\\text{distant pairs}}$\n", + "\n", + "$E[GP] = \\frac{n_{\\text{distant pairs}}} {n_{\\text{neighbor pairs}}}$\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 97, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.388274Z", @@ -682,7 +1034,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 98, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.396504Z", @@ -693,10 +1045,16 @@ { "data": { "text/plain": [ - "[0.04, 0.01, 0.01, 0.01, 0.02, 0.01, 0.01]" + "[np.float64(0.04),\n", + " np.float64(0.01),\n", + " np.float64(0.01),\n", + " np.float64(0.01),\n", + " np.float64(0.02),\n", + " np.float64(0.01),\n", + " np.float64(0.01)]" ] }, - "execution_count": 18, + "execution_count": 98, "metadata": {}, "output_type": "execute_result" } @@ -738,6 +1096,38 @@ "wgs" ] }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": { + "ExecuteTime": { + "end_time": "2023-01-17T02:01:03.404200Z", + "start_time": "2023-01-17T02:01:03.399458Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[np.float64(2.401152449690573),\n", + " np.float64(3.0184783660479737),\n", + " np.float64(3.604975613106773),\n", + " np.float64(3.518992595881942),\n", + " np.float64(3.8302800635496137),\n", + " np.float64(3.7013778766150596),\n", + " np.float64(3.564222731553409)]" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wgp = [(1-gs.wcg_share)/gs.wcg_share for gs in gs_all]\n", + "wgp" + ] + }, { "cell_type": "code", "execution_count": 20, @@ -867,7 +1257,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.10.15" } }, "nbformat": 4, diff --git a/inequality/theil.py b/inequality/theil.py index 7d9b6294..de51f9ae 100644 --- a/inequality/theil.py +++ b/inequality/theil.py @@ -1,12 +1,16 @@ -"""Theil Inequality metrics""" +""" +Theil Inequality metrics +""" -__author__ = "Sergio J. Rey " +__author__ = "Sergio J. Rey " -import numpy +import numpy as np +import pandas as pd +import warnings __all__ = ["Theil", "TheilD", "TheilDSim"] -SMALL = numpy.finfo("float").tiny +SMALL = np.finfo("float").tiny class Theil: @@ -23,129 +27,138 @@ class Theil: Parameters ---------- + y : array-like, DataFrame, or sequence + Either an `nxT` array (deprecated) or `nx1` sequence or DataFrame. + If using a DataFrame, specify the column(s) using `column` keyword(s). - y : numpy.array - An array in the shape :math:`(n,t)` or :math:`(n,)` - with :math:`n` taken as the observations across which inequality is - calculated. If ``y`` is :math:`(n,)` then a scalar inequality value is - determined. If ``y`` is :math:`(n,t)` then an array of inequality values are - determined, one value for each column in ``y``. + column : str, optional + If `y` is a DataFrame, specify the column to be used for the calculation. Attributes ---------- - T : numpy.array - An array in the shape :math:`(t,)` or :math:`(1,)` - containing Theil's *T* for each column of ``y``. + Theil's *T* index. Notes ----- - This computation involves natural logs. To prevent ``ln[0]`` from occurring, a - small value is added to each element of ``y`` before beginning the computation. - - Examples - -------- - - >>> import libpysal - >>> import numpy - >>> from inequality.theil import Theil - - >>> f = libpysal.io.open(libpysal.examples.get_path('mexico.csv')) - >>> vnames = [f'pcgdp{dec}' for dec in range(1940, 2010, 10)] - >>> y = numpy.array([f.by_col[v] for v in vnames]).T - >>> theil_y = Theil(y) - - >>> theil_y.T - array([0.20894344, 0.15222451, 0.10472941, 0.10194725, 0.09560113, - 0.10511256, 0.10660832]) + The old API (nxT arrays) is deprecated and will be removed in the future. + Use nx1 sequences or DataFrames with a single column instead. """ - def __init__(self, y): - n = len(y) + def __init__(self, y, column=None): + # Deprecation warning for old API + if isinstance(y, np.ndarray) and y.ndim == 2 and y.shape[1] > 1: + warnings.warn( + "The nxT input format is deprecated. In future versions, " + "please provide nx1 sequences or a DataFrame with a single column.", + DeprecationWarning, + stacklevel=2 + ) + # Old API behavior + n = y.shape[0] + else: + # New API: Handle sequence or DataFrame + if isinstance(y, pd.DataFrame): + if column is None: + raise ValueError("For DataFrame input, `column` must be specified.") + y = y[column].values + elif isinstance(y, (list, np.ndarray)): + y = np.asarray(y) + else: + raise TypeError("Input must be an array, list, or DataFrame.") + n = len(y) + + # Calculation y = y + SMALL * (y == 0) # can't have 0 values yt = y.sum(axis=0) s = y / (yt * 1.0) - lns = numpy.log(n * s) + lns = np.log(n * s) slns = s * lns - t = sum(slns) - self.T = t + self.T = sum(slns) class TheilD: - """Decomposition of Theil's *T* based on partitioning of + """ + Decomposition of Theil's *T* based on partitioning of observations into exhaustive and mutually exclusive groups. Parameters ---------- + y : array-like, DataFrame, or sequence + Either an `nxT` array (deprecated) or `nx1` sequence or DataFrame. + If using a DataFrame, specify the column(s) using `column` keyword(s). - y : numpy.array - An array in the shape :math:`(n,t)` or :math:`(n,)` - with :math:`n` taken as the observations across which inequality is - calculated. If ``y`` is :math:`(n,)` then a scalar inequality value is - determined. If ``y`` is :math:`(n,t)` then an array of inequality values are - determined, one value for each column in ``y``. - partition : numpy.array - An array in the shape :math:`(n,)` of elements indicating which partition - each observation belongs to. These are assumed to be exhaustive. + partition : array-like, DataFrame, or sequence + Partition indicating group membership. + If using a DataFrame, specify the column using `partition_col`. + + column : str, optional + If `y` is a DataFrame, specify the column to be used for the calculation. + + partition_col : str, optional + If `partition` is a DataFrame, specify the column to be used. Attributes ---------- - T : numpy.array - An array in the shape :math:`(t,)` or :math:`(1,)` - containing the global inequality *T*. + Global Theil's *T*. bg : numpy.array - An array in the shape :math:`(n,t)` or :math:`(n,)` - representing between group inequality. + Between-group inequality. wg : numpy.array - An array in the shape :math:`(n,t)` or :math:`(n,)` - representing within group inequality. - - Examples - -------- - - >>> import libpysal - >>> import numpy - >>> from inequality.theil import TheilD - - >>> f = libpysal.io.open(libpysal.examples.get_path('mexico.csv')) - >>> vnames = [f'pcgdp{dec}' for dec in range(1940, 2010, 10)] - >>> y = numpy.array([f.by_col[v] for v in vnames]).T - >>> regimes = numpy.array(f.by_col('hanson98')) - >>> theil_d = TheilD(y, regimes) - - >>> theil_d.bg - array([0.0345889 , 0.02816853, 0.05260921, 0.05931219, 0.03205257, - 0.02963731, 0.03635872]) - - >>> theil_d.wg - array([0.17435454, 0.12405598, 0.0521202 , 0.04263506, 0.06354856, - 0.07547525, 0.0702496 ]) + Within-group inequality. """ - def __init__(self, y, partition): - groups = numpy.unique(partition) - T = Theil(y).T # noqa N806 + def __init__(self, y, partition, column=None, partition_col=None): + # Deprecation warning for old API + if isinstance(y, np.ndarray) and y.ndim == 2 and y.shape[1] > 1: + warnings.warn( + "The nxT input format is deprecated. In future versions, " + "please provide nx1 sequences or a DataFrame with a single column.", + DeprecationWarning, + stacklevel=2 + ) + n = y.shape[0] + else: + # New API: Handle sequence or DataFrame + if isinstance(y, pd.DataFrame): + if column is None: + raise ValueError("For DataFrame input, `column` must be specified.") + y = y[column].values + elif isinstance(y, (list, np.ndarray)): + y = np.asarray(y) + else: + raise TypeError("Input must be an array, list, or DataFrame.") + n = len(y) + + # Handle partition similarly + if isinstance(partition, pd.DataFrame): + if partition_col is None: + raise ValueError("For DataFrame input, `partition_col` must be specified.") + partition = partition[partition_col].values + elif isinstance(partition, (list, np.ndarray)): + partition = np.asarray(partition) + else: + raise TypeError("Partition must be an array, list, or DataFrame.") + + groups = np.unique(partition) + T = Theil(y).T ytot = y.sum(axis=0) - # group totals - gtot = numpy.array([y[partition == gid].sum(axis=0) for gid in groups]) + # Group totals + gtot = np.array([y[partition == gid].sum(axis=0) for gid in groups]) - if ytot.size == 1: # y is 1-d + if ytot.size == 1: sg = gtot / (ytot * 1.0) sg.shape = (sg.size, 1) else: - sg = numpy.dot(gtot, numpy.diag(1.0 / ytot)) - ng = numpy.array([sum(partition == gid) for gid in groups]) + sg = np.dot(gtot, np.diag(1.0 / ytot)) + ng = np.array([sum(partition == gid) for gid in groups]) ng.shape = (ng.size,) # ensure ng is 1-d - n = y.shape[0] - # between group inequality + # Between group inequality sg = sg + (sg == 0) # handle case when a partition has 0 for sum - bg = numpy.multiply(sg, numpy.log(numpy.dot(numpy.diag(n * 1.0 / ng), sg))).sum( - axis=0 - ) + bg = np.multiply(sg, np.log(np.dot(np.diag(len(y) * 1.0 / ng), sg))).sum(axis=0) self.T = T self.bg = bg @@ -153,77 +166,42 @@ def __init__(self, y, partition): class TheilDSim: - """Random permutation based inference on Theil's inequality decomposition. - Provides for computationally based inference regarding the inequality - decomposition using random spatial permutations. - See :cite:`rey_interregional_2010`. + """ + Random permutation-based inference on Theil's inequality decomposition. Parameters ---------- + y : array-like, DataFrame, or sequence + Either an `nxT` array (deprecated) or `nx1` sequence or DataFrame. + If using a DataFrame, specify the column(s) using `column` keyword(s). - y : numpy.array - An array in the shape :math:`(n,t)` or :math:`(n,)` - with :math:`n` taken as the observations across which inequality is - calculated. If ``y`` is :math:`(n,)` then a scalar inequality value is - determined. If ``y`` is :math:`(n,t)` then an array of inequality values are - determined, one value for each column in ``y``. - partition : numpy.array - An array in the shape :math:`(n,)` of elements indicating which partition - each observation belongs to. These are assumed to be exhaustive. - permutations : int - The number of random spatial permutations for computationally - based inference on the decomposition. - - Attributes - ---------- - - observed : numpy.array - An array in the shape :math:`(n,t)` or :math:`(n,)` - representing a ``TheilD`` instance for the observed data. - bg : numpy.array - An array in the shape ``(permutations+1, t)`` - representing between group inequality. - bg_pvalue : numpy.array - An array in the shape :math:`(t,1)` representing the :math:`p`-value - for the between group measure. Measures the percentage of the realized - values that were greater than or equal to the observed ``bg`` value. - Includes the observed value. - wg : numpy.array - An array in the shape ``(permutations+1)`` - representing within group inequality. Depending on the - shape of ``y``, the array may be 1- or 2-dimensional. - - Examples - -------- + partition : array-like, DataFrame, or sequence + Partition indicating group membership. + If using a DataFrame, specify the column using `partition_col`. - >>> import libpysal - >>> import numpy - >>> from inequality.theil import TheilDSim + permutations : int, optional + Number of random permutations for inference (default: 99). - >>> f = libpysal.io.open(libpysal.examples.get_path('mexico.csv')) - >>> vnames = [f'pcgdp{dec}' for dec in range(1940, 2010, 10)] - >>> y = numpy.array([f.by_col[v] for v in vnames]).T - >>> regimes = numpy.array(f.by_col('hanson98')) - >>> numpy.random.seed(10) - >>> theil_ds = TheilDSim(y, regimes, 999) + column : str, optional + If `y` is a DataFrame, specify the column to be used for the calculation. - >>> theil_ds.bg_pvalue - array([0.4 , 0.344, 0.001, 0.001, 0.034, 0.072, 0.032]) + partition_col : str, optional + If `partition` is a DataFrame, specify the column to be used. """ - def __init__(self, y, partition, permutations=99): - observed = TheilD(y, partition) + def __init__(self, y, partition, permutations=99, column=None, partition_col=None): + observed = TheilD(y, partition, column=column, partition_col=partition_col) bg_ct = observed.bg == observed.bg # already have one extreme value bg_ct = bg_ct * 1.0 results = [observed] for _ in range(permutations): - yp = numpy.random.permutation(y) + yp = np.random.permutation(y) t = TheilD(yp, partition) bg_ct += 1.0 * t.bg >= observed.bg results.append(t) self.results = results self.T = observed.T self.bg_pvalue = bg_ct / (permutations * 1.0 + 1) - self.bg = numpy.array([r.bg for r in results]) - self.wg = numpy.array([r.wg for r in results]) + self.bg = np.array([r.bg for r in results]) + self.wg = np.array([r.wg for r in results]) diff --git a/inequality/wolfson.py b/inequality/wolfson.py index aeffac14..ad0d4366 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -14,13 +14,14 @@ __all__ = ["wolfson", "lorenz_curve"] + @consistent_input def lorenz_curve(data, column=None): """ Calculate the Lorenz curve for a given distribution. - This function takes an income or wealth distribution as input. The input - can be a sequence, a NumPy array, or a Pandas DataFrame. If a DataFrame + This function takes an income or wealth distribution as input. The input + can be a sequence, a NumPy array, or a Pandas DataFrame. If a DataFrame is provided, the `column` parameter must be used to specify which column contains the income or wealth values. @@ -74,6 +75,8 @@ def wolfson(data, column=None): Lorenz curve at the median, :math:`G` is the Gini index, :math:`\mu` is the mean, and :math:`m` is the median. + See: :cite:`wolfson1994WhenInequalities`. + Parameters ---------- data : array-like, numpy array, or pandas.DataFrame @@ -87,6 +90,7 @@ def wolfson(data, column=None): float The Wolfson Bipolarization Index value. + Example ------- >>> income_distribution = [20000, 25000, 27000, 30000, 35000, 45000, 60000, diff --git a/notebooks/gini.ipynb b/notebooks/gini.ipynb deleted file mode 100644 index 264ad5d2..00000000 --- a/notebooks/gini.ipynb +++ /dev/null @@ -1,875 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Demonstrating the Gini Coefficient:\n", - "## Spatial Inequality in Mexico: 1940-2000\n", - "\n", - "1. Imports & Input Data\n", - "2. Classic Gini Coefficient\n", - "3. Spatial Gini Coefficient\n", - "\n", - "-------------------------\n", - "\n", - "### 1. Imports & Input Data" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:00:59.142457Z", - "start_time": "2023-01-17T02:00:59.104306Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Last updated: 2023-01-16T21:00:59.129990-05:00\n", - "\n", - "Python implementation: CPython\n", - "Python version : 3.10.8\n", - "IPython version : 8.8.0\n", - "\n", - "Compiler : Clang 14.0.6 \n", - "OS : Darwin\n", - "Release : 22.2.0\n", - "Machine : x86_64\n", - "Processor : i386\n", - "CPU cores : 8\n", - "Architecture: 64bit\n", - "\n" - ] - } - ], - "source": [ - "%config InlineBackend.figure_format = \"retina\"\n", - "%load_ext watermark\n", - "%watermark" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.756177Z", - "start_time": "2023-01-17T02:00:59.145113Z" - } - }, - "outputs": [], - "source": [ - "import geopandas\n", - "import inequality\n", - "import libpysal\n", - "import matplotlib.pyplot as plt\n", - "import numpy" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.770545Z", - "start_time": "2023-01-17T02:01:01.761777Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Watermark: 2.3.1\n", - "\n", - "libpysal : 4.7.0\n", - "inequality: 1.0.0+28.g078a825.dirty\n", - "matplotlib: 3.6.2\n", - "numpy : 1.24.1\n", - "json : 2.0.9\n", - "geopandas : 0.12.2\n", - "\n" - ] - } - ], - "source": [ - "%watermark -w\n", - "%watermark -iv" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.776633Z", - "start_time": "2023-01-17T02:01:01.772340Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mexico\n", - "======\n", - "\n", - "Decennial per capita incomes of Mexican states 1940-2000\n", - "--------------------------------------------------------\n", - "\n", - "* mexico.csv: attribute data. (n=32, k=13)\n", - "* mexico.gal: spatial weights in GAL format.\n", - "* mexicojoin.shp: Polygon shapefile. (n=32)\n", - "\n", - "Data used in Rey, S.J. and M.L. Sastre Gutierrez. (2010) \"Interregional inequality dynamics in Mexico.\" Spatial Economic Analysis, 5: 277-298.\n", - "\n" - ] - } - ], - "source": [ - "libpysal.examples.explain(\"mexico\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.962407Z", - "start_time": "2023-01-17T02:01:01.779047Z" - } - }, - "outputs": [], - "source": [ - "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", - "gdf = geopandas.read_file(pth)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.103640Z", - "start_time": "2023-01-17T02:01:01.964971Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 316, - "width": 515 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = gdf.plot()\n", - "ax.set_axis_off()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.138110Z", - "start_time": "2023-01-17T02:01:02.106331Z" - }, - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...GR9000LPCGDP40LPCGDP50LPCGDP60LPCGDP70LPCGDP80LPCGDP90LPCGDP00TESTgeometry
017.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...0.054.354.324.254.404.474.434.481.0MULTIPOLYGON (((-113.13972 29.01778, -113.2405...
127.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...0.003.984.204.224.394.464.414.422.0MULTIPOLYGON (((-111.20612 25.80278, -111.2302...
232.731957e+10MX18Nayarit1034770.3416.750785e+062731956.8594836.07515.07621.0...-0.053.683.883.884.044.134.114.063.0MULTIPOLYGON (((-106.62108 21.56531, -106.6475...
347.961008e+10MX14Jalisco2324727.4361.967200e+077961008.2855309.08232.09953.0...0.033.733.924.004.214.324.304.334.0POLYGON ((-101.52490 21.85664, -101.58830 21.7...
455.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...0.134.023.793.944.214.324.324.445.0POLYGON ((-101.84620 22.01176, -101.96530 21.8...
\n", - "

5 rows × 35 columns

\n", - "
" - ], - "text/plain": [ - " POLY_ID AREA CODE NAME PERIMETER \\\n", - "0 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", - "1 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", - "2 3 2.731957e+10 MX18 Nayarit 1034770.341 \n", - "3 4 7.961008e+10 MX14 Jalisco 2324727.436 \n", - "4 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", - "\n", - " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... GR9000 \\\n", - "0 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 0.05 \n", - "1 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 0.00 \n", - "2 6.750785e+06 2731956.859 4836.0 7515.0 7621.0 ... -0.05 \n", - "3 1.967200e+07 7961008.285 5309.0 8232.0 9953.0 ... 0.03 \n", - "4 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 0.13 \n", - "\n", - " LPCGDP40 LPCGDP50 LPCGDP60 LPCGDP70 LPCGDP80 LPCGDP90 LPCGDP00 TEST \\\n", - "0 4.35 4.32 4.25 4.40 4.47 4.43 4.48 1.0 \n", - "1 3.98 4.20 4.22 4.39 4.46 4.41 4.42 2.0 \n", - "2 3.68 3.88 3.88 4.04 4.13 4.11 4.06 3.0 \n", - "3 3.73 3.92 4.00 4.21 4.32 4.30 4.33 4.0 \n", - "4 4.02 3.79 3.94 4.21 4.32 4.32 4.44 5.0 \n", - "\n", - " geometry \n", - "0 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", - "1 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", - "2 MULTIPOLYGON (((-106.62108 21.56531, -106.6475... \n", - "3 POLYGON ((-101.52490 21.85664, -101.58830 21.7... \n", - "4 POLYGON ((-101.84620 22.01176, -101.96530 21.8... \n", - "\n", - "[5 rows x 35 columns]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gdf.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.975365Z", - "start_time": "2023-01-17T02:01:02.141021Z" - }, - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 337, - "width": 515 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = gdf.plot(column=\"PCGDP1940\", k=5, scheme=\"Quantiles\", legend=True)\n", - "ax.set_axis_off()\n", - "ax.set_title(\"PC GDP 1940\");\n", - "# plt.savefig(\"1940.png\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "------------------------------------------------\n", - "\n", - "### 2. Classic Gini Coefficient" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.985182Z", - "start_time": "2023-01-17T02:01:02.978350Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0.3537237117345285" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gini_1940 = inequality.gini.Gini(gdf[\"PCGDP1940\"])\n", - "gini_1940.g" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.993505Z", - "start_time": "2023-01-17T02:01:02.988524Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "range(1940, 2010, 10)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "decades = range(1940, 2010, 10)\n", - "decades" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.010083Z", - "start_time": "2023-01-17T02:01:02.996515Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.3537237117345285,\n", - " 0.29644613439022827,\n", - " 0.2537183285655905,\n", - " 0.25513356494927303,\n", - " 0.24505338049421577,\n", - " 0.25181825879538217,\n", - " 0.2581130824882791]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", - "ginis" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "--------------------------------------\n", - "\n", - "### 3. Spatial Gini Coefficient" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.023820Z", - "start_time": "2023-01-17T02:01:03.017957Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "inequality.gini.Gini_Spatial" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "inequality.gini.Gini_Spatial" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.029897Z", - "start_time": "2023-01-17T02:01:03.026482Z" - } - }, - "outputs": [], - "source": [ - "regimes = gdf[\"HANSON98\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.038550Z", - "start_time": "2023-01-17T02:01:03.032955Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "w = libpysal.weights.block_weights(regimes, silence_warnings=True)\n", - "w" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.201808Z", - "start_time": "2023-01-17T02:01:03.041647Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 337, - "width": 515 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = gdf.plot(column=\"HANSON98\", categorical=True)\n", - "ax.set_title(\"Regions\")\n", - "ax.set_axis_off()\n", - "# plt.savefig(\"regions.png\")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.234210Z", - "start_time": "2023-01-17T02:01:03.204552Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0.01" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "numpy.random.seed(12345)\n", - "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], w)\n", - "gs.p_sim" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.388274Z", - "start_time": "2023-01-17T02:01:03.237277Z" - } - }, - "outputs": [], - "source": [ - "gs_all = [\n", - " inequality.gini.Gini_Spatial(gdf[\"PCGDP%s\" % decade], w) for decade in decades\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.396504Z", - "start_time": "2023-01-17T02:01:03.391373Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.04, 0.01, 0.01, 0.01, 0.02, 0.01, 0.01]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p_values = [gs.p_sim for gs in gs_all]\n", - "p_values" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.404200Z", - "start_time": "2023-01-17T02:01:03.399458Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.2940179879590452,\n", - " 0.24885041274552472,\n", - " 0.21715641601961586,\n", - " 0.2212882581200239,\n", - " 0.20702733316567423,\n", - " 0.21270360014540865,\n", - " 0.2190953550725723]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wgs = [gs.wcg_share for gs in gs_all]\n", - "wgs" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.412352Z", - "start_time": "2023-01-17T02:01:03.407034Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.7059820120409548,\n", - " 0.7511495872544753,\n", - " 0.7828435839803841,\n", - " 0.778711741879976,\n", - " 0.7929726668343258,\n", - " 0.7872963998545913,\n", - " 0.7809046449274277]" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bgs = [1 - wg for wg in wgs]\n", - "bgs" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.419153Z", - "start_time": "2023-01-17T02:01:03.414765Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1940, 1950, 1960, 1970, 1980, 1990, 2000])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "years = numpy.array(decades)\n", - "years" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.733573Z", - "start_time": "2023-01-17T02:01:03.421484Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 469, - "width": 629 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax1 = plt.subplots()\n", - "t = years\n", - "s1 = ginis\n", - "ax1.plot(t, s1, \"b-\")\n", - "ax1.set_xlabel(\"Year\")\n", - "# Make the y-axis label, ticks and tick labels match the line color.\n", - "ax1.set_ylabel(\"Gini\", color=\"b\")\n", - "ax1.tick_params(\"y\", colors=\"b\")\n", - "\n", - "ax2 = ax1.twinx()\n", - "s2 = bgs\n", - "ax2.plot(t, s2, \"r-.\")\n", - "ax2.set_ylabel(\"Spatial Inequality Share\", color=\"r\")\n", - "ax2.tick_params(\"y\", colors=\"r\")\n", - "\n", - "fig.tight_layout()\n", - "\n", - "# plt.savefig(\"share.png\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "-----------------------" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:py310_inequality]", - "language": "python", - "name": "conda-env-py310_inequality-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebooks/pengram.ipynb b/notebooks/pengram.ipynb deleted file mode 100644 index a3bb08ee..00000000 --- a/notebooks/pengram.ipynb +++ /dev/null @@ -1,667 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "253bedb6-8989-4743-82d0-0636d24cfaa6", - "metadata": {}, - "outputs": [], - "source": [ - "from inequality.pen import pengram, pen" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f75933de-3bc1-4dcd-95aa-fa89b06ae83c", - "metadata": {}, - "outputs": [], - "source": [ - "import geopandas as gpd" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6bc6ebcc-6dc3-4760-9434-4497a4203522", - "metadata": {}, - "outputs": [], - "source": [ - "gdf = gpd.read_file('weighted.shp')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1fa5a919-b988-439c-a922-e4c071b53bc9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...TESTName_1PopulationNAMEppopulati_1Y2000y2000_1pStategeometry
055.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...5.0Aguascalientes944285Aguascalientes9442852.623413e+1027782.00.009647AguascalientesPOLYGON ((-101.84620 22.01176, -101.96530 21.8...
117.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...1.0Querétaro de Arteaga1404306Baja California Norte14043064.192556e+1029855.00.014347Baja California NorteMULTIPOLYGON (((-113.13972 29.01778, -113.2405...
227.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...2.0Baja California Sur424041Baja California Sur4240411.106874e+1026103.00.004332Baja California SurMULTIPOLYGON (((-111.20612 25.80278, -111.2302...
3155.016584e+10MX04Campeche1575361.1461.239620e+075016583.7233758.04929.05925.0...15.0Campeche690689Campeche6906892.497739e+1036163.00.007056CampecheMULTIPOLYGON (((-91.83446 18.63805, -91.84195 ...
4227.339157e+10MX05Chiapas1477195.1991.813538e+077339157.3762934.04138.05280.0...22.0Chiapas3920892Chiapas39208923.404903e+108684.00.040057ChiapasPOLYGON ((-91.43750 17.24111, -91.35278 17.176...
\n", - "

5 rows × 43 columns

\n", - "
" - ], - "text/plain": [ - " POLY_ID AREA CODE NAME PERIMETER \\\n", - "0 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", - "1 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", - "2 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", - "3 15 5.016584e+10 MX04 Campeche 1575361.146 \n", - "4 22 7.339157e+10 MX05 Chiapas 1477195.199 \n", - "\n", - " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... TEST \\\n", - "0 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 5.0 \n", - "1 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 1.0 \n", - "2 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 2.0 \n", - "3 1.239620e+07 5016583.723 3758.0 4929.0 5925.0 ... 15.0 \n", - "4 1.813538e+07 7339157.376 2934.0 4138.0 5280.0 ... 22.0 \n", - "\n", - " Name_1 Population NAMEp populati_1 \\\n", - "0 Aguascalientes 944285 Aguascalientes 944285 \n", - "1 Querétaro de Arteaga 1404306 Baja California Norte 1404306 \n", - "2 Baja California Sur 424041 Baja California Sur 424041 \n", - "3 Campeche 690689 Campeche 690689 \n", - "4 Chiapas 3920892 Chiapas 3920892 \n", - "\n", - " Y2000 y2000_1 p State \\\n", - "0 2.623413e+10 27782.0 0.009647 Aguascalientes \n", - "1 4.192556e+10 29855.0 0.014347 Baja California Norte \n", - "2 1.106874e+10 26103.0 0.004332 Baja California Sur \n", - "3 2.497739e+10 36163.0 0.007056 Campeche \n", - "4 3.404903e+10 8684.0 0.040057 Chiapas \n", - "\n", - " geometry \n", - "0 POLYGON ((-101.84620 22.01176, -101.96530 21.8... \n", - "1 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", - "2 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", - "3 MULTIPOLYGON (((-91.83446 18.63805, -91.84195 ... \n", - "4 POLYGON ((-91.43750 17.24111, -91.35278 17.176... \n", - "\n", - "[5 rows x 43 columns]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gdf.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "7430bd3d-7e84-49c5-9a2b-1f0bbd609ade", - "metadata": {}, - "outputs": [], - "source": [ - "col='PCGDP2000'\n", - "weight='p'\n", - "name='NAME'\n", - "figsize=(16,9)" - ] - }, - { - "cell_type": "markdown", - "id": "28d73a8e-842a-49f5-adb3-a0b90348fa2f", - "metadata": {}, - "source": [ - "## Pen's Parade" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "01ec901b-3fce-4752-8704-34ea00b8c844", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p = pen(gdf,col, name)" - ] - }, - { - "cell_type": "markdown", - "id": "710b88e2-48f5-4125-afca-1816470c6e30", - "metadata": {}, - "source": [ - "## Weighted Pengram" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "504b1f03-0b75-4ff9-8e27-8e12b07c828e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "wp = pen(gdf, col, name, weight=weight, figsize=figsize)\n" - ] - }, - { - "cell_type": "markdown", - "id": "c403fc19-e7c2-44c5-b2ce-3b3b8d27d884", - "metadata": {}, - "source": [ - "### Pen Parade Options" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "544a9020-d8ad-40ae-a93e-80ca7ebd7e8e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p = pen(gdf,col, name, xticks=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "e51eeab1-ebdc-4c53-a0f2-5d2ad8b39cc2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p = pen(gdf, col, name, ascending=False)" - ] - }, - { - "cell_type": "markdown", - "id": "9ba7b96c-c7e1-45d4-9047-8feef02e498e", - "metadata": {}, - "source": [ - "## Pengram" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "bb91fb4f-dc02-45ff-bf34-88dd67fa7987", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " )" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJoAAALVCAYAAACIt4sFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hU1doF8HWmpk8S0ggEBOkkdIGACEiXIp96UUGUq1IFRESkqBcbiAioYNcrKCLqFVBQkCYgvQYIIE06CSFt0qfu74/IyJBe90yyfveZxzvnvHPOmpQh887e+yhCCAEiIiIiIiIiIqIyUskOQEREREREREREVQMbTUREREREREREVC7YaCIiIiIiIiIionLBRhMREREREREREZULNpqIiIiIiIiIiKhcsNFERERERERERETlgo0mIiIiIiIiIiIqF2w0ERERERERERFRuWCjiYiIiIiIiIiIygUbTURERERERERV1NatW6EoClJTU2VHoWqCjSYiIiIiIiJyGyNGjICiKFAUBVqtFvXr18eUKVOQmZlZbudYsmQJunXrVurH38ynKAp8fX3Rrl07rFy5stzyEbkyNpqIiIiIiIjIrfTt2xdxcXH466+/8MYbb+DDDz/ElClTZMdy8uWXXyIuLg779+9Hy5Yt8a9//Qu7d+8u1bHMZnM5pyOqOGw0ERERERERkVvR6/UICwtDREQEhg4dimHDhmH16tUAACEE3n77bdSvXx+enp5o2bIl/ve//zkee3Mq2ebNm9GuXTt4eXmhU6dOOHXqVIHn27p1K9q3bw9vb2/4+/ujc+fOuHjxYqEZ/f39ERYWhiZNmuDjjz+Gh4cHfv75Z9hsNjz11FOoV68ePD090bhxY7z33ntOjx0xYgQGDx6MOXPmIDw8HI0aNQIALFu2DO3atYOvry/CwsIwdOhQJCQkOD32119/RaNGjeDp6Ynu3bvjwoULebLt2rUL99xzDzw9PREREYGJEyeW64gwqt7YaCIiIiIiIiK35unpCYvFAgB46aWX8OWXX+Kjjz7C8ePH8dxzz+Gxxx7Dtm3bnB4zc+ZMzJ8/HwcOHIBGo8GTTz6Z77GtVisGDx6Mrl274ujRo9i9ezdGjRoFRVGKnU+r1UKj0cBiscBut6N27dr4/vvvceLECbzyyiuYMWMGvv/+e6fHbN68GSdPnsTGjRuxdu1aALkjm15//XUcOXIEq1evxvnz5zFixAjHYy5fvowHHngA9913H2JiYvD0009j2rRpTsc9duwY+vTpgwceeABHjx7Fd999hx07dmD8+PHFfj5EhVGEEEJ2CCIiIiIiIqLiGDFiBFJTUx0jmPbt24f77rsPPXr0wH//+18EBQVhy5YtiI6Odjzm6aefRlZWFpYvX46tW7eie/fu2LRpE3r06AEgdxRQ//79kZ2dDQ8PD6fzJScno0aNGti6dSu6du1arIyKomDVqlUYPHgwTCYT5s2bh5dffhm//vor+vXrl6f+mWeewfXr1x0jr0aMGIH169fj0qVL0Ol0BZ5n//79aN++PdLT0+Hj44MZM2Zg9erVOH78uKMRNm3aNMydOxcpKSnw9/fH448/Dk9PT3zyySeO4+zYsQNdu3ZFZmZmnudPVFIa2QGIiIiIiIiISmLt2rXw8fGB1WqFxWLB/fffj0WLFuHEiRPIyclBr169nOrNZjNat27ttK1FixaO/1+zZk0AQEJCAurUqeNUFxgYiBEjRqBPnz7o1asXevbsiSFDhjgeU5BHH30UarUa2dnZMBgMeOeddxxNpo8//hiff/45Ll68iOzsbJjNZrRq1crp8VFRUXmaTIcPH8asWbMQExOD5ORk2O12AMClS5fQrFkznDx5Eh07dnQabXVrww0ADh48iLNnz+Kbb75xbBNCwG634/z582jatGmhz4uoKGw0ERERERERkVvp3r07PvroI2i1WoSHh0Or1QIAzp8/DwD45ZdfUKtWLafH6PV6p/s3HwPA0Zi52bi53ZdffomJEydi/fr1+O677/DSSy9h48aN6NixY4EZFy5ciJ49e8LPzw8hISGO7d9//z2ee+45zJ8/H9HR0fD19cW8efOwd+9ep8d7e3s73c/MzETv3r3Ru3dvLFu2DMHBwbh06RL69OnjWCy8OBOW7HY7Ro8ejYkTJ+bZd3uTjag02GgiIiIiIiIit+Lt7Y0GDRrk2d6sWTPo9XpcunSp2NPciqt169Zo3bo1pk+fjujoaCxfvrzQRlNYWFi+Gf/44w906tQJ48aNc2w7d+5ckef/888/kZiYiLfeegsREREAgAMHDjjVNGvWzDGl8KY9e/Y43W/Tpg2OHz+ebzai8sDFwImIiIiIiKhK8PX1xZQpU/Dcc89h6dKlOHfuHA4fPowPPvgAS5cuLdUxz58/j+nTp2P37t24ePEiNmzYgNOnT5d6ilmDBg1w4MAB/Pbbbzh9+jRefvll7N+/v8jH1alTBzqdDosWLcJff/2Fn3/+Ga+//rpTzZgxY3Du3DlMnjwZp06dwvLly7FkyRKnmhdffBG7d+/GM888g5iYGJw5cwY///wzJkyYUKrnQ3Q7NpqIiIiIiIioynj99dfxyiuvYM6cOWjatCn69OmDNWvWoF69eqU6npeXF/788088+OCDaNSoEUaNGoXx48dj9OjRpTremDFj8MADD+Dhhx9Ghw4dkJSU5DS6qSDBwcFYsmQJfvjhBzRr1gxvvfUW3nnnHaeaOnXq4Mcff8SaNWvQsmVLfPzxx5g9e7ZTTYsWLbBt2zacOXMGXbp0QevWrfHyyy8XueYUUXHxqnNERERERERERFQuOKKJiIiIiIiIiIjKBRtNRERERERERERULthoIiIiIiIiIiKicsFGExERERERERERlQs2moiIiIiIiIiIqFyw0UREREREREREROVCIzsAERERERFRYex2O65duwZfX18oiiI7DhFRlSWEQHp6OsLDw6FSlW5sEhtNRERERETk0q5du4aIiAjZMYiIqo3Lly+jdu3apXosG01EREREROTSfH19AeS+8fHz85Ochoio6kpLS0NERITjdbc02GgiIiIiIiKXdnO6nJ+fHxtNRESVoCzTlLkYOBERERERERERlQs2moiIiIiIiIiIqFyw0UREREREREREROWCjSYiIiIiIiIiIioXbDQREREREREREVG5YKOJiIiIiIiIiIjKBRtNRERERERERERULjSyAxARERERERERUcW6fKx7kTWGuj+V+Twc0UREREREREREROWCjSYiIiIiIiIiIioXbDQREREREREREVG5YKOJiIiIiIiIiIjKBRtNRERERERERERULthoIiIiIiIiIiKicsFGExERERERERERlQs2moiIiIiIiIiIqFyw0UREREREREREROWCjSYiIiIiIiIiIioXbDQREREREREREVG5YKOJiIiIiKiKmTVrFhRFcbqFhYU59gshMGvWLISHh8PT0xPdunXD8ePHnY5hMpkwYcIEBAUFwdvbG4MGDcKVK1ecalJSUjB8+HAYDAYYDAYMHz4cqampTjWXLl3CwIED4e3tjaCgIEycOBFms7nCnjsREcnFRhMRERERURXUvHlzxMXFOW7Hjh1z7Hv77bexYMECLF68GPv370dYWBh69eqF9PR0R82kSZOwatUqrFixAjt27EBGRgYGDBgAm83mqBk6dChiYmKwfv16rF+/HjExMRg+fLhjv81mQ//+/ZGZmYkdO3ZgxYoV+PHHH/H8889XzheBiIgqnUZ2AHIfQpgAewpgT829CWPufZUBikc/2fGIiIiI6BYajcZpFNNNQgi8++67mDlzJh544AEAwNKlSxEaGorly5dj9OjRMBqN+OKLL/D111+jZ8+eAIBly5YhIiICmzZtQp8+fXDy5EmsX78ee/bsQYcOHQAAn332GaKjo3Hq1Ck0btwYGzZswIkTJ3D58mWEh4cDAObPn48RI0bgzTffhJ+fXyV9NYiIqLKw0VQNCWEFRNo/DSNH4ygV4rb7TvuRk/dgig+UGt9XTnAiIiIiKrYzZ84gPDwcer0eHTp0wOzZs1G/fn2cP38e8fHx6N27t6NWr9eja9eu2LVrF0aPHo2DBw/CYrE41YSHhyMyMhK7du1Cnz59sHv3bhgMBkeTCQA6duwIg8GAXbt2oXHjxti9ezciIyMdTSYA6NOnD0wmEw4ePIju3bvnm91kMsFkMjnup6WlleeXhoiIKhAbTW5MCAGIzNxRRY6mkNFxX9iNf2+7uf/v+6K8/qFWQfF/D4qmQTkdj4iIiIjKQ4cOHfDVV1+hUaNGuH79Ot544w106tQJx48fR3x8PAAgNDTU6TGhoaG4ePEiACA+Ph46nQ4BAQF5am4+Pj4+HiEhIXnOHRIS4lRz+3kCAgKg0+kcNfmZM2cOXn311RI+ayIicgVsNLmIf6alGW8ZTZR7X+Q3uuhm4whWaZkV3xlQ9F2knZ+IiIiI8tev3z/LGkRFRSE6Ohp33nknli5dio4dOwIAFEVxeowQIs+2291ek199aWpuN336dEyePNlxPy0tDREREYVmIyIi18BGUwUR9izAngzYk/7+bwogkiHsyXm325MBkSU7csmoagFew4uuIyIiIiLpvL29ERUVhTNnzmDw4MEAckcb1axZ01GTkJDgGH0UFhYGs9mMlJQUp1FNCQkJ6NSpk6Pm+vXrec5148YNp+Ps3bvXaX9KSgosFkuekU630uv10Ov1pXuyREQkFRtNxfDPFLXkPDfnxlHKP/vyW8+oKlGHFvmJFxERERG5BpPJhJMnT6JLly6oV68ewsLCsHHjRrRu3RoAYDabsW3bNsydOxcA0LZtW2i1WmzcuBFDhgwBAMTFxSE2NhZvv/02ACA6OhpGoxH79u1D+/btAQB79+6F0Wh0NKOio6Px5ptvIi4uztHU2rBhA/R6Pdq2bVupXwMiIqoc1bbRJIQZsMXdNrro1sbRbTeYZUd2Laog2QmIiIiIqABTpkzBwIEDUadOHSQkJOCNN95AWloannjiCSiKgkmTJmH27Nlo2LAhGjZsiNmzZ8PLywtDhw4FABgMBjz11FN4/vnnUaNGDQQGBmLKlCmIiopyXIWuadOm6Nu3L0aOHIlPPvkEADBq1CgMGDAAjRs3BgD07t0bzZo1w/DhwzFv3jwkJydjypQpGDlyJK84R0RURVXbRhNMv0OkTpCdwn2pg2UnICIiIqICXLlyBY8++igSExMRHByMjh07Ys+ePahbty4AYOrUqcjOzsa4ceOQkpKCDh06YMOGDfD19XUcY+HChdBoNBgyZAiys7PRo0cPLFmyBGq12lHzzTffYOLEiY6r0w0aNAiLFy927Fer1fjll18wbtw4dO7cGZ6enhg6dCjeeeedSvpKEBFRZVOEEEJ2CBlEzm9sNJWAXQCX7ZE4bm6IE9k6+Osj8K+IfyFAF1D0g4mIiIiIyiAtLQ0GgwFGo5EjoYiISunyse5F1hjq/lTm19vqO6JJ4eKCJfF5+iPYnXoVQGLuhoxr2Jm0F3d41UUr/5Zo5d8Sdb3rQKWopOYkIiIiIiIiInmqb6NJdzegaQpYT8pO4vKEAI5nGPPddyHrIi5kXcTqaz/DoDWgpX8LtPJvgeZ+zeCh9qjkpEREREREREQkU7VtNCmKBvB7DSJ5CIBqOXuw2K6IZkizZhRZZ7QYsf3GH9h+4w9oFA2a+jX5u/HUEsF6Lh5OREREREREVNVV20YTACi6lhCeQ4Ds72RHcWmxpsZwTJkrJquw4pgxFseMsVh2cTlqe9ZCS/+WaOXfAg187uQUOyIiIiIiIqIqqFo3mgBA8X0ewrQRsCfLjuKSUuw1sTY5s8zHuZJ9FVeyr+KXuF/hrfZGS/8otPJviUhDJLw1XuWQlIiIiIiIiIhkY6NJ5Q/4ToUwTpMdxeUIASwx3oMs27VyPW6mLRO7kvZgV9IeqKBCI9+GjgXFwzxCoShKuZ6PiIiIiIiIiCpHtW80AQA8/g+KMEOkzwdE/oteV0d/mPvjaHr5NpluZ4cdf6afwp/pp7Di8vcI1Yc4ptg19m0EjYo/okRERERERETugu/igdwRNF6PAPpeEOlvAzmrZEeSLksY8O0NU6Wf97opARuub8SG6xvhqfZEpKE5Wvm3RAtDFPy0vpWeh4iIiIiIiIiKj42mWyjqGlD850KYH4JIeRoQ2bIjSeMJI3w0nsgxV36z6aZsWzb2Jx/A/uQDUKDgTp/6aOXfEi39WyDCszan2BERERERERG5GDaa8qHo7oLQ3gWYt8uOIo2iANF+HlhTsovNVRgBgbMZ53A24xz+d2UlAnWBaOXfAq38W6KpXxPoVDrZEYmIiIiIiIiqPTaaCqDooyGqcaMJAKL1MViDMNkx8pVsTsaWhK3YkrAVOpUOzfyaOkY7BeoCZMcjIiIiIiIiqpbYaCqILlp2Aulqqs+gjmcULmXfkB2lUGa7GTGpRxCTegQAUNerrmO00x3edaFSVJITEhEREREREVUPbDQVRNMEUAIAkSI7iVQ6lVp2hBK7mHURF7Mu4qdra2DQ+qGloQVa+rdEc0NTeKo9ZccjIiIiIiIiqrLYaCqAoqgg9B2BnHWyo0iVasmRHaFMjJY0bE/cge2JO6BRNGji2xit/FuiVUALBOuDZccjIiIiIiIiqlLYaCqEoouGqMaNJiGAVEuG7BjlxiqsiE07jti041h2aTnCPcMdU+wa+NwJteJ+o7eIiIiIiIiIXAkbTYXRdZKdQKpMUQNWYZUdo8Jcy76Ga9nX8GvcenirvdE6oCXaBLRGpF9z6NV62fGIiIiIiIiI3A4bTYVRRwAeAwHzQcB+TXaaSpeCUNkRKk2mLRM7EndhR+Iu6FQ6RPo1Q5uA1mjl3xK+Wl/Z8YiIiIiIiIjcAhtNhVAUBYr/fACAyFkHkfqs5ESVK9UWIDuCFGa7GYdSY3AoNQYKFDT2bYQ2Aa3RJqAV13UiIiIiIiIiKgQbTcWl75s7lc68S3aSShPi2wv10v7C+czzsqNIIyDwZ/op/Jl+CssvrUAdrwi08W+NNgGtUccrAoqiyI5IRERERERE5DIUIYSQHcJdCOslCOM0wHJAdpTKoYuG8JmOvWlJ+N+V1UgyJ8tO5FKCdDX+HunUGo18G3IxcSIiIqIKkpaWBoPBAKPRCD8/P9lxiIjc0uVj3YusMdT9qcyvt2w0lZAQAjD9DpHxDmA9KztOJdHDYngfG1KysPbar8ix58gO5HK4mDgRERFRxWGjiYio7NhocnFCWIHsVRAZ7wH2BNlxKp7iDSVwOdIQjlVXf8bWhG0Q4I9OfriYOBEREVH5YqOJiKjs2GhyEyLzK4j0N2THqByqUCg1foCiDsOVrKv47vIPOGo8JjuVS+Ni4kRERERlx0YTEVHZsdHkJuypk4GctbJjVB5VTUDfGYrnw1B0LXHMGIsVl37AlewrspO5BS4mThVFCDtgj//7nnLbf1HA9gL+m+fnspiP+yfNbf8t6P/n88+PKOIxigaKqnpeEZOIqDpjo4mIqOwqq9HEq86VlSVGdoLKZY8Dsv8HIXKg6BYgyhCJ5pHNsCNxF85nnkeWNRtZtiwYLWm4mHVRdlqXcynrMi5lXcbqaz9zMXEqXyId4kY32SkqhdA0h+LRD/DoC0VTR3YcIiIiIiK6hUp2AHcjbEmwp74Au3EW7OnvArZqOpLH9AeEsAEAVIoK9wTfjSfuGI6xDUbh+caT8FrkK5jc6FkE64MkB3VdieYkbLi+CW/9OQ8TDj2Hz/76AgdTDsFkM8mORu5IWGUnqDzW4xAZ70Ak9oQ98QGIjM8gRLbsVERELm3OnDlQFAWTJk1ybBNCYNasWQgPD4enpye6deuG48ePOz3OZDJhwoQJCAoKgre3NwYNGoQrV5z//k1JScHw4cNhMBhgMBgwfPhwpKamOtVcunQJAwcOhLe3N4KCgjBx4kSYzeaKerpERCQRG00lpKhrQPEaAuSsAjI/lB1HHmEscjRXS/8WeDPyNQyoeR9H6xQh05aJHYm78P6ZDzD+8CS8d3oR/rixA+mWdNnRyG1Uo0bTrayxEBnzINLflZ2EiMhl7d+/H59++ilatGjhtP3tt9/GggULsHjxYuzfvx9hYWHo1asX0tP/+ftj0qRJWLVqFVasWIEdO3YgIyMDAwYMgM1mc9QMHToUMTExWL9+PdavX4+YmBgMHz7csd9ms6F///7IzMzEjh07sGLFCvz44494/vnnK/7JExFRpeMaTaUkTLsgUkYBqMafxHiPgcp3crFKr2RdxdKLX+N0+pkKDlW1cDFxKi5hu1Ztps7lT4ESuByKrq3sIERELiUjIwNt2rTBhx9+iDfeeAOtWrXCu+++CyEEwsPDMWnSJLz44osAckcvhYaGYu7cuRg9ejSMRiOCg4Px9ddf4+GHHwYAXLt2DREREfj111/Rp08fnDx5Es2aNcOePXvQoUMHAMCePXsQHR2NP//8E40bN8a6deswYMAAXL58GeHh4QCAFStWYMSIEUhISCjWGiBco4mIqOwqa40mjmgqJUXfCYrPGNkx5DJtL3Zpba9amNHkRTxV79/w0fiU+pQh+pBSP9YdCQj8mX4Kyy+twJQj0/By7CysuvITLmZeAnvE5KQ6TZ3Ll4AwTocQObKDEBG5lGeeeQb9+/dHz549nbafP38e8fHx6N27t2ObXq9H165dsWvXLgDAwYMHYbFYnGrCw8MRGRnpqNm9ezcMBoOjyQQAHTt2hMFgcKqJjIx0NJkAoE+fPjCZTDh48GC+uU0mE9LS0pxuRETkHrgYeJlU8y+fvmuJyhVFwT3Bd6O1f0t8d/kH/JG4s0SPVytq3B8+AJ+d/2+JHleVcDFxKlh1bzQBsF2ASF8IxW+67CRERC5hxYoVOHToEPbv359nX3x87pVKQ0NDnbaHhobi4sWLjhqdToeAgIA8NTcfHx8fj5CQvB8EhoSEONXcfp6AgADodDpHze3mzJmDV199tThPk4iIXEw175SUjRBZsiPIo64NxWdsqR7qq/XF0/WfxN1BnbH0wte4lhNXrMfV966HdoFtEeIRgmB9EP7KPI91cb/hTMbZUuVwdzcXE99wfRO81d5oHdASbQJaI9KvOfRqvex4VNmEreia6iBrCYRHHyi6NrKTEBFJdfnyZTz77LPYsGEDPDw8CqxTFMXpvhAiz7bb3V6TX31pam41ffp0TJ78zxINaWlpiIiIKDQXERG5BjaaSklkfQdkfiE7hjSK78tQlIL/aCmOJn6N8XrkLKyL/w0/XV0Di7AUWp9qScXBlMPoHBQNAGirC0DbgDY4m34W6+J/w8GUwxContPJbi4mviNxF3QqHSL9mqFNQGu08m8JX62v7HhUKTiiKVfuFDoE/VTm1ygiInd28OBBJCQkoG3bf9aus9ls2L59OxYvXoxTp04ByB1tVLNmTUdNQkKCY/RRWFgYzGYzUlJSnEY1JSQkoFOnTo6a69ev5zn/jRs3nI6zd+9ep/0pKSmwWCx5RjrdpNfrodfzgzMiInfENZpKS+UHwC47hRz6nlA8il5ErDg0Kg0GhvfH7KjXEWWILLRWq2jR0j8qz/YGvg0woeEzmNviTfQI6Q6dSlcu2dyV2W7GodQYfH7+S0w4/BzmnHwbv8VvxA3TDdnRqEKx0eRgO8+r0BFRtdejRw8cO3YMMTExjlu7du0wbNgwxMTEoH79+ggLC8PGjRsdjzGbzdi2bZujidS2bVtotVqnmri4OMTGxjpqoqOjYTQasW/fPkfN3r17YTQanWpiY2MRF/fPKPYNGzZAr9c7NcKIiKhq4FXnykBkr4UwTkF1azgpfrOheD1U7scVQmB/ygFsv7EDRosRRosRaZZ06FV6dAu5B/3C+sJfZyjyOOmWdGxJ2IqN1zch3ZpR7jndWR2vCLTxz13XqY5XRJFD48l9CHMMRPIQ2TFciAIl8FtOoSMit5OZmYnly5dj165diI+Ph6IoCA0NRefOnfHoo4/C29u71Mfu1q2b46pzADB37lzMmTMHX375JRo2bIjZs2dj69atOHXqFHx9c0dEjx07FmvXrsWSJUsQGBiIKVOmICkpCQcPHoRanbs+ZL9+/XDt2jV88sknAIBRo0ahbt26WLNmDYDckVStWrVCaGgo5s2bh+TkZIwYMQKDBw/GokWLipWdV50jIiq7yrrqHKfOlYHiOQC50zReRLUaTaAKrJDDKoqC9oF3oX3gXY5tNmGDXdihVWmLfRxfrS/urzUQXhovLLu4vCKiui0uJl6VVaPXoGIREMZpgP9CKNrmssMQERXLiRMn0KtXL2RlZaFr166oU6cOhBBISEjACy+8gFmzZmHDhg1o1qxZuZxv6tSpyM7Oxrhx45CSkoIOHTpgw4YNjiYTACxcuBAajQZDhgxBdnY2evTogSVLljiaTADwzTffYOLEiY6r0w0aNAiLFy927Fer1fjll18wbtw4dO7cGZ6enhg6dCjeeeedcnkeRETVWXGaRxFRv1dCkn9wRFM5ELZ4iMylQPYKQGTKjlPhlMDvoehayY5RpFPppzH75FzZMdyCt9obrfxzFxOPMnAxcXckTHsgUh6XHcM1aZpD8foX4DEQioprlhGR6+revTvCwsKwdOlS6HTOSwGYzWaMGDECcXFx+P33yn3D4Ao4oomIKH8laTRxRJMbUdRhUPxehPAZB5GxAMj6RnakiqUKKLrGBUR41pYdwW1k2jKxM2kXdibtglbRIsrQHO0C26KVf0t4a0o/RJ8qE686VyDrcYi040D6XAiPflA8/wVo23DqKBG5nL179+LAgQN5mkwAoNPpMGPGDLRv315CMiIiouJjo6kcKSpfwPclCOtZwLy36Ae4qwqaOlfevDReCNYH4YYpUXYUt2IRFhxKjcGh1BioFTWa+TVF24A2aBvQGn5afoLoujh1rkgiG8heCZG9ElDfCfhMgOJ5n+xUREQOAQEBOHPmTIFT486ePet09TciIiJXxEZTOVMUNWCYD5F0P2BPkh2nAmgBxUd2iGIRQqCWZy02msrAJmw4ZozFMWMsll74Go18G6JdQFu0DWiDGnr3aDhWG4IjmkrEdg7COAkQaVC8HpGdhogIADBy5Eg88cQTeOmll9CrVy+EhoZCURTEx8dj48aNmD17NiZNmiQ7JhERUaHYaKoAijoEMLwDkfIkgCq2BJYqwG2mm5jtZtwTfDcCtP44ajyGJHOy7EhuTUDgVPppnEo/jW8ufYv63vUQZYiEVqWF+Pvn/OaSb+Lv/9388Xfsv2X7P9v+2XNz+63Hc9qfzzaRuxHC6fhOR4FwnK/gbQLi7/y3bBW3Per2/Y484p+ttzy3gowOvgp/pTiN6BK8foiU4teSg0h7BRBWKN6PyY5CRIRZs2bB09MTCxYswNSpUx1/cwkhEBYWhmnTpmHq1KmSUxIRERWOi4FXIHv6QiDzI9kxypemMVRBa2SnKDEhBOJy4nA09RiOGmNxKv00rIJTjajyNfIOw/QaP8iOQbdRfKdD8f637BhERA7nz59HfHw8ACAsLAz16tWTnEguLgZORJQ/LgZezSg+EyDM+wHLAdlRyo+brM90O0VREO4ZjnDPcPSt2Qcmmwkn0//E0dRYHDUeww3TDQBAlCES7QPb4euLy2G2myWnpqqopy9HHrkikT4HEGYoPqNlRyEiAgDUq1ev2jeXiIjIPbHRVIEURQP4L4BIvL/qTGtx00bT7fRqPVr5t0Qr/5YAgPic6ziWGovzmRdg0PpjWpMX8O7pRUizpklOSlVJgNYPrbW/yY5BBRAZ8wFYoPiMlx2FiKqxK1eu4KOPPsKuXbsQHx8PRVEQGhqKTp06YcyYMYiIiJAdkYiIqFBsNFUwRR0G+M+FSBklO0r5UFXNK52EeYQiLCzUadsrzWdg0ZmP0CesF3JsOfjq4jJJ6aiq6ObvAY3CKZuuTGS8DyGsUHyedZv16Iio6tixYwf69euHiIgI9O7dG71794YQAgkJCVi9ejUWLVqEdevWoXPnzrKjEhFRBSrJdDhXxEZTZdB1BVS1APtV2UnKTKkiI5qKI1gfjBebTIHRYkS4Z02Y7CZ8d5lr61Dp1dbkLkh/w1YX8fbaiNLulJyI8pX5IQTMgM8LbDYRUaV67rnn8PTTT2PhwoUF7p80aRL2799fycmIiIiKTyU7QHWgKAqg7yI7RvlQqtfii94aL4R71gQA3FezL3w0PpITkTtbFGfF1+kPY3FyW1yxhsiOQ4XJ/BwidTyE9azsJERUjcTGxmLMmDEF7h89ejRiY2MrMREREVHJsdFUSRT9PbIjlAuR/R2EqJ6LZGdas5BhzZAdg9zclpRruJR9A8k2newoVBTTRojE/rCnPg9h/Ut2GiKqBmrWrIldu3YVuH/37t2oWbNmJSYiIiIqOU6dqyy6jgC0ACyyk5SN9QxExmIovpNlJ6l013Ouy45AVUiKlVOy3IMActZA5PwC4TEIis8zUDR1ZYcioipqypQpGDNmDA4ePIhevXohNDQUiqIgPj4eGzduxOeff453331XdkwiIqJCsdFUWRRPQNECws0bTQCQ+RmERy8o2ijZSSqFXdihUlSIZ6OJylGylYuCuxc7kLMaImcNEPAlFH1H2YGIqAoaN24catSogYULF+KTTz6BzWYDAKjVarRt2xZfffUVhgwZIjklERFR4dhoqizWM4DIkp2inNgA01agmjSa/sr4C8EewYjPiZcdhaqQFEtVeT2obmwQ6W8BupVQFM4+J6Ly9/DDD+Phhx+GxWJBYmIiACAoKAharVZyMiIiouJho6myWI7ITlC+NI1lJ6g0EV4R+Ojcp9Co+OtC5cdoyYBVaKBROLLJ7VhPADk/A56DZSchoipMq9VyPSYiInJL/Di2kogq1mgS5n0Q9kzZMSqFXq2HVqXFgeSDsqNQFSIgkCr4BsJdibQ5EDm/y45BRFXQ/v37MWzYMNSrVw+enp7w8vJCvXr1MGzYMBw4cEB2PCIioiKx0VRJFJ/xUAzzAI8BsqOUj6yvIBL7QGSvhBB22WkqXPvAdhAQsmNQFZNiD5UdgUpLpECkjoY9dQqEPVV2GiKqIlavXo3OnTsjOTkZzz77LP773//i888/x7PPPouUlBR07twZP/30k+yYREREheJcoEqiqMMBz/sBj0EQsAE562RHKjt7AoRxGpC5DDC8CUXbVHaiCmMTNtkRqApKFv6yI1BZ5fwMYd4F+P0Hikcf2WmIyM299NJLeO211zBt2rQ8+yZNmoS5c+dixowZuP/++yWkIyKisrp8rHuh+yOiqsaIeY5oqmSKokDxexNQ15cdpfxYYyFy1stOUaFijcdlR6AqKMXqIzsClQd7IkTqBNiNed8YEhGVxNmzZ/HAAw8UuH/w4ME4d+5cJSYiIiIqOTaaJFBUPlBq/AB4DQegyI5TPkS27AQVRgiB42knZMegKijFppcdgcpT9koIyxnZKYjIjd15551YvXp1gft/+ukn1K9fhT6sJCKiKolT5yRRVL5Q/F6G8BwMYXwFsLr5iJkq3GiKy4lDsjlFdgyqgpJtVaTRTA4ibSbg+wKgbQdFUSCEgKLw+0xExfPaa6/hkUcewbZt29C7d2+EhoZCURTEx8dj48aN2LBhA1asWCE7JhERUaHYaJJM0UYBNf4HZH0DkbEQEG56Jbcq3Gg6m8Eh6lQxki1W2RGovFliIJKHAdo2EIoPFH00hNdjgPUcFG0z2emIyMU9+OCD2L59O9577z0sWLAA8fHxAICwsDBER0dj27ZtiI6OlpySiIiocGw0uQBFUQPejwPqCIjU0bLjlE4VbjTV864nOwJVUSmWqvt7U+1ZDgEAhPkPIGMxIDIhvEZA8Z0KReE/vURUsOjoaDaTiIjIrXGNJlei8pedoPSqcKOptmctBOuDZMegKijVkg6b4Mtw1Sb+GamatQQi5UkIO6fiEhEREVHVxXc4rkTxlp2g9Kpwo0lRFLT2by07BlVBAgKpoqbsGFSZzHsgkh6EsPwpOwkRuagjR47gjTfewIcffojExESnfWlpaXjyySclJSMiIioeNppciYqNJlfVsUZ72RGoikoRobIjUGWzXYFIfhgi+1cIIWSnISIXsmHDBrRv3x4rVqzA3Llz0bRpU/z++++O/dnZ2Vi6dGmxjvXRRx+hRYsW8PPzg5+fH6Kjo7Fu3TrHfiEEZs2ahfDwcHh6eqJbt244ftz54jQmkwkTJkxAUFAQvL29MWjQIFy5csWpJiUlBcOHD4fBYIDBYMDw4cORmprqVHPp0iUMHDgQ3t7eCAoKwsSJE2E2m0v41SEiInfBRpMr4Ygml3WnT30MCh8gOwZVQSm2QNkRSAaRDWGcBHG9OezX20NYz8pOREQuYNasWZgyZQpiY2Nx4cIFTJ06FYMGDcL69etLfKzatWvjrbfewoEDB3DgwAHce++9uP/++x3NpLfffhsLFizA4sWLsX//foSFhaFXr15IT093HGPSpElYtWoVVqxYgR07diAjIwMDBgyAzWZz1AwdOhQxMTFYv3491q9fj5iYGAwfPtyx32azoX///sjMzMSOHTuwYsUK/Pjjj3j++efL8JUiIiJXpgh+nOoyhDBDXI+UHaN0FC8owTuhuPOorCLYhR0LTr+HY8ZY2VGoCnk4uAb6eq6WHYNk834GKt9nZacgIskMBgMOHTqEO++807Ht22+/xciRI/Htt9+iffv2CA8Pd2r0lERgYCDmzZuHJ598EuHh4Zg0aRJefPFFALmjl0JDQzF37lyMHj0aRqMRwcHB+Prrr/Hwww8DAK5du4aIiAj8+uuv6NOnD06ePIlmzZphz5496NChAwBgz549iI6Oxp9//onGjRtj3bp1GDBgAC5fvozw8HAAwIoVKzBixAgkJCTAz8+vWNnT0tJgMBhgNBqL/Rgiospw+Vj3QvdHRP0zMrW4tUXVVWStoe5PZX695YgmF6IoOgBa2TFKR2QBOT/LTlGhVIoKY+qPRJCOC4NT+fk1JQeX7U1lxyDZMj+A3TgNwp4lOwkRSaTX6/NMO3v00UfxxRdf4JFHHsGqVatKdVybzYYVK1YgMzMT0dHROH/+POLj49G7d2+nc3ft2hW7du0CABw8eBAWi8WpJjw8HJGRkY6a3bt3w2AwOJpMANCxY0cYDAanmsjISEeTCQD69OkDk8mEgwcPlur5EBGRa2OjydW48fQ5kbWsyq834qP1wYSG46BV3LQhSC4n3ZqJefF1ccXeRHYUki17JUTS/0FYTspOQkSStGrVymlNppsefvhhfP7555g4cWKJjnfs2DH4+PhAr9djzJgxWLVqFZo1a4b4+HgAQGio8zqBoaGhjn3x8fHQ6XQICAgotCYkJCTPeUNCQpxqbj9PQEAAdDqdoyY/JpMJaWlpTjciInIPGtkB6DYqH8CWKjtF6VjPAOY9gD5adpIKdYd3XTxxx2P4/PyXsqNQFZFuzcTmzFZ4wpdXIqv2bOchUp+BErxFdhIikmDs2LHYvn17vvseffRRAMCnn35a7OM1btwYMTExSE1NxY8//ognnngC27Ztc+xXFMWpXgiRZ9vtbq/Jr740NbebM2cOXn311UKzEBFVlJJMR6O8OKLJ1bjxiCYAEFlfy45QKboE343uId1kx6Aq5HyORXYEchW2KxC2JNkpiEiC//u//8PChQsL3P/oo4/mO+KpIDqdDg0aNEC7du0wZ84ctGzZEu+99x7CwsIAIM+IooSEBMfoo7CwMJjNZqSkpBRac/369TznvXHjhlPN7edJSUmBxWLJM9LpVtOnT4fRaHTcLl++XOznTUREcrHR5GocjSYPqTFKzbQFwnZVdopKMazOI7jTu77sGFRFXMlJhEXoZMcgV2E5KjsBEUnyww8/YNiwYRgyZEiJRi8VhxACJpMJ9erVQ1hYGDZu3OjYZzabsW3bNnTq1AkA0LZtW2i1WqeauLg4xMbGOmqio6NhNBqxb98+R83evXthNBqdamJjYxEXF+eo2bBhA/R6Pdq2bVtgVr1eDz8/P6cbERG5BzaaXI3ilftf3V2AtoXcLKViB2w3ZIeoFFqVFuMbjoWfhn/4UNnZhB2X7M1kxyAXIdhoIqqWPv30Uzz88MM4cOAATp06hbFjx2L69OmlOtaMGTPwxx9/4MKFCzh27BhmzpyJrVu3YtiwYVAUBZMmTcLs2bOxatUqxMbGYsSIEfDy8sLQoUMB5F4B76mnnsLzzz+PzZs34/Dhw3jssccQFRWFnj17AgCaNm2Kvn37YuTIkdizZw/27NmDkSNHYsCAAWjcuDEAoHfv3mjWrBmGDx+Ow4cPY/PmzZgyZQpGjhzJ5hERURXFRpOrUUcAHvdB0UdD8XtNdprSUYcXXVNFBOoCMa7BaCgofD0DouK4YI2QHYFcBRtNRNXSokWLMHPmTJw6dQpHjhzBF198gcWLF5fqWNevX8fw4cPRuHFj9OjRA3v37sX69evRq1cvAMDUqVMxadIkjBs3Du3atcPVq1exYcMG+Pr6Oo6xcOFCDB48GEOGDEHnzp3h5eWFNWvWQK1WO2q++eYbREVFoXfv3ujduzdatGiBr7/+ZykFtVqNX375BR4eHujcuTOGDBmCwYMH45133inlV4mIiFydIqr6ZcLcjLAlAuZdgL4HRPIjgPWU7EglpIMSehSKUr16mHP/nIcTaVzImcqms38tPO23QnYMcgWKP5SQvUUuyktEVYu3tzeOHTuG+vVzp+bbbDZ4enri0qVLjnWVqqu0tDQYDAYYjUaOhCKiUinJAt/lWXvrouHFrZWVFQAMdX8q8+tt9eoGuAFFHQRoWwOKDor/IigBn0PxfQXQNJYdrXjU4dWuyQQA7QIKXmOAqLgu5JhkRyBXIVIhjC9AmA/JTkJElSg7Oxs+Pj6O+2q1Gnq9HllZWRJTERERlYxGdgDKS9H8PX1Gc0fuTQ9A3w0i6QFApMoLVhzVaNrcrdoGtMHXF5dDgAMEqfSu5SQhR3jDQ8mUHYVcQc7PEKpAKLo2spMQUSX6/PPPnZpNVqsVS5YsQVBQkGPbxIkTZUQjIiIqFjaa3ISiqQ34vgCRNlN2lMJV00aT+Pt/RGUhIHDR1gyNNftlRyFXkbUcQn83FP09spMQUSWoU6cOPvvsM6dtYWFhTmseKYrCRhMR0d8mbH62yJpFPd6rhCR0Kzaa3ImutewERVLUtWRHkCLWeFx2BKoiLlhrsdFEtzBDpIwDAj6Cou8iOwwRVbALFy7IjkBERFRm1W8xHXemrgfAQ3aKwlXTRlOkoTlebjoddb3qyo5Cbu68ycV/x0kCM0TKWAjTDtlBiIiIiIiKxEaTG1EUNaBtIjtG4appoylAF4AGvg0wpfEkhOpDZMchN3YhJ1t2BHJJfzebLMdkByGiCma32/Hf//4XAwYMQGRkJKKiojBo0CB89dVX4MWiiYjIHbDR5G60zWQnKFw1XaPpJj+tH15oMhlahbNSqXSum5KRafeXHYNckgki60fZIYioAgkhMGjQIDz99NO4evUqoqKi0Lx5c1y8eBEjRozA//3f/8mOSEREVCQ2mtyMonHxRpNpt+wE0gXrg+Gt8Sm6kKgAF+wu/ntO8pg2QQi77BREVEGWLFmC7du3Y/PmzTh8+DC+/fZbrFixAkeOHMGmTZuwZcsWfPXVV7JjEhERFYrDLtyNtrnsBIUSGfMBj75QVNW70aJX6WVHIDd23hKG5nx1pvzYEwDrKUDbVHYSIqoA3377LWbMmIHu3bvn2Xfvvfdi2rRp+Oabb/D4449LSEdEVHoluTocryTn/jiiyd1oGsKl+4P2JIiMD2SnkE6v1smOQG7sgok/P1QIdZjsBERUQY4ePYq+ffsWuL9fv344cuRIJSYiIiIqOTaa3I4WUFx8tEzWVxDW87JTSOWh4pXDqPTOZ2fIjkCuStMAiipAdgoiqiDJyckIDQ0tcH9oaChSUlIqMREREVHJsdHkbuzxgMiUnaIIFoj0t2SHkEqvdvFmILm0ZIsRRhEsOwa5Im1b2QmIqALZbDZoNAWPXFer1bBarZWYiIiIqORceA4W5ct6RnaC4jH9DmHaDkV/j+wkUnCNJiqrC7amaKm5ITsGuRyb7ABEVIGEEBgxYgT0+vz/jjCZTJWciIiIqOTYaHI31rOyExSbSJsN1GgHReUlO0qlY6OJyuq8ORgt+QpNt7NekJ2AiCrQE088UWQNFwInIiJXx7cxbka4UaMJtr8gEvsDfq9A8ch79ZSqzINT56iM0m18eaZ82C7ITkBEFejLL7+UHYGIiKjM+E7GzSjaVhCWk4D1uOwoxWO/CpE6GkLfB4rfTCjV5GpJHNFEZWVQcw0Oyoc9EcKeDkXlKzsJERERESZsfrbQ/Yt6vFdJSciVcDFwN6N4DYEqaBWU4G2AOkJ2nOIz/QaR2A8ie43sJJWipmcYfDU+smOQGzOos2VHIFdlq95X9SSqyuLi4jBz5kzH/bvvvhtt2rRx3O666y5cvXpVYkIiIqKicUSTm1LUNQGf5yGMk2RHKT6RCZHxLuAxAIqiyE5Toe4J7oIuQXcj0ZyI5RdX4FBqjOxI5GYMKle/uiTJItLfAQI+haJ4yI7itoQQVf7fIXJPH374IVJTUx33jxw5gieffBKBgYEAgHXr1mHhwoV45513JCUkouqAo5SorDiiyZ159APUtWWnKBnbZcB2TnaKSqEoCoL1wfi/2oNlRyE3ZFClyo5Arsq8ByJ1AoQwy07iloTtOkTyo7AnPw6RvRLCniE7EpHDmjVrMHjwYKdtzz77LP7zn//gP//5D1599VWsW7dOTjgiIqJiYqPJjSmKAihuuE5HzhbZCSpVHa8IRBkiZccgN2NQEmVHIFdm2gaROgVCcC2vkhIpYwHLodyGnXEaxI3OsKdOgTDthBA22fGomrtw4QLuvPNOx/1evXrB29vbcb9x48Y4f57TZ4mIyLWx0eT23G/ovzBtghB22TEq1X01+8qOQG7GT0mQHYFcnWk9RPrbslO4FWHPAKwnbtuYDeT8DJHyb4gbXWFPnwdhOZO7S+RAZK+FPfmp3O32LAh7OoRpa+79nN+LPqc7XS2WpLNarTAajY77K1euRGhoqON+SkoKVCr++U5ERK6NazS5O8UNv4WWGIik+wHf5wFdRyDzc0AVCnjeD0XRyU5XIZr6NsEdXnVxIeui7CjkBnw0XtAoFtkxyB1k/wjhO6XKvnaWhrCeBxRPQPHIXc8KaiiaOwD1HYBIBVDIBx32BCDzM4jMzyA0jQHbNUCk5+4z/wGR9R0gMhzHEOqNEDk/A/ZUQNsair4joG3l+H4I6zmI5KeBwKUQ2SsBkQ3FdzogUqCoAivsa0Duq3Hjxti1axdat26d7/4//vgDjRo1quRUREREJeOGXQq6leL/Ye4n2jk/y45SMtZTECmjAMXn7z/aAWS8DwQuhaKpLzdbBVAUBffV7IcPz30sOwq5AYPGS3YEchciHTDtBDy6y04ilbBeAlRBgGkLRNrLgLoWYE8H7HG5+0tzUOupfE6U5nzfdiH3BgDmnRCZiwHoIbSNAFvS3+cXEIm9/jlE9g9QfKcAXsNKk4qquEceeQSvvPIKunTpghYtWjjtO3LkCF599VVMmzZNUjoiIqLiYaPJzSnqECj+70CYH4ZIey3/P4xdmbhlEVb7dYjkJ4EaK6Cow+RlqiDtAtsg9Eoorpuuy45CLs6g0cqOQG5EmH6DUo0bTcKeCZH8GGBPAvD3SEDraYmJTIDlWMG7RSaEaTsUNpooH5MmTcLatWvRtm1b9OrVC40bN4aiKPjzzz+xceNGREdHY9KkSbJjEhERFYqNpipC0d0F1FiVO7opa4nsOKVnvwaR/G+gxnIoqgDZacqVWlFjUqMJmH1yLtKt6bLjkAszaLj+BpVAziYIP3O1nT4nMj8E7PGyY5SM6XcI8/7cf7uJbqHVarFx40YsWLAAK1aswNatWwEADRs2xOuvv47nnnsOWi0/jCCikpuw+dkiaxb1eK8SklB1wEZTFaIoGsD3BQjzfsB6XHac0rOdg0gZCQQshaLyLrrejYR71sQLjZ/DW3/OQ5YtW3YcclEGdakm+lB1JdJyr6TmvxCKyk92mkolrH8BmUtkxygVkf4W4DsdUPkD6vpQFDaYKZdOp8O0adM4RY6IitTqjVlF1sS8VHQNUXnjXzVVjKJoofjPy11kW9sagF52pNKxHIVIHQ8hzLKTlLu63nUxudEk6FTVc/QBFc1PVfV+7qmCmf+ASPpXbuOlmhBCQKS9Dsd0OXdjOQaRPBQi8T5A5EDYM2UnIheQkpKCRYsWIS0tLc8+o9FY4L78zJkzB3fddRd8fX0REhKCwYMH49Qp5yUWhBCYNWsWwsPD4enpiW7duuH4cecPK00mEyZMmICgoCB4e3tj0KBBuHLlSp7cw4cPh8FggMFgwPDhw5GamupUc+nSJQwcOBDe3t4ICgrCxIkTYTbz3zsioqqIjaYqSNE0gCrwK6hqfAclaB3g0U92pNIx74QwvgAhrLKTlLuGvg3wbMPx0LjjVQOpwhnUWbIjkDuynYdIegjCtE12ksph+g0w75SdonzYLkMYp8pOQS5g8eLF2L59O/z88o5ONBgM+OOPP7Bo0aJiHWvbtm145plnsGfPHmzcuBFWqxW9e/dGZuY/Tc23334bCxYswOLFi7F//36EhYWhV69eSE//Z4r/pEmTsGrVKqxYsQI7duxARkYGBgwYAJvN5qgZOnQoYmJisH79eqxfvx4xMTEYPny4Y7/NZkP//v2RmZmJHTt2YMWKFfjxxx/x/PPPl+bLRERELo6NpipO0dSGyv89KIHLAE0T2XFKLmcdRPJjELarpT6EyP4Zwp5cjqHKR6ShOcbeORoq/hrSbQwqruFFpSQyIFJGQWR+DiGq7hRMYc+CSJstO0Y5USCShwKCDWYCfvzxR4wZM6bA/aNHj8b//ve/Yh1r/fr1GDFiBJo3b46WLVviyy+/xKVLl3Dw4EEAuaOZ3n33XcycORMPPPAAIiMjsXTpUmRlZWH58uUAckdRffHFF5g/fz569uyJ1q1bY9myZTh27Bg2bdoEADh58iTWr1+Pzz//HNHR0YiOjsZnn32GtWvXOkZQbdiwASdOnMCyZcvQunVr9OzZE/Pnz8dnn31W7BFaRETkPvgOt5pQdO2h1FgFxe81QPGXHadkLIcgEgdB5Kwr1cOF5SjEjV4QGZ9BCFM5hyubdoFt8HT9f8uOQS7GoEqRHYHcmoBIfzt3+rH5UJVsOLnlAuAFEoBIB6rZ+lqUv3PnzqFhw4YF7m/YsCHOnTtXqmMbjUYAQGBgIADg/PnziI+PR+/evR01er0eXbt2xa5duwAABw8ehMVicaoJDw9HZGSko2b37t0wGAzo0KGDo6Zjx44wGAxONZGRkQgPD3fU9OnTByaTydH4up3JZEJaWprTjYiI3AMbTdWIoqiheD0CJXgj4DUCbrUWvEiHSH0WduNLEKJki2grmqa5j8+YB3GjD0T2TxDCXkFBS65zUCc8XpeXuaZ/GJAgOwJVBaaNEMmPQCTeB5H5BYQtUXaiciGEALK+kR2j/JljYE9/D8J8AEK46bpTVGZqtRrXrl0rcP+1a9egUpX8z3chBCZPnoy7774bkZGRAID4+NxmbWhoqFNtaGioY198fDx0Oh0CAgIKrQkJCclzzpCQEKea288TEBAAnU7nqLndnDlzHGs+GQwGRERElPRpExGRJGw0VUOKygCV3wwoQT8Dmkay45RM9vcQiQ9AWP4s9kOE7ZYFK+3Xctd9SnoQwnyoAgKWzr0h3WHQ8tNsAtSKCt5KkuwYVJXYzkGkz4W4cQ/sKeMgzAdkJyob+3VAVMGFs+1xQOYHuQuEJ7SHPWUsRNY3ENaLVXJUGuWvdevWWL16dYH7V61ahdatW5f4uOPHj8fRo0fx7bff5tmnKIrTfSFEnm23u70mv/rS1Nxq+vTpMBqNjtvly5cLzURERK6DjaZqTNE0gOK/CFC8ZEcpGdu53AVvM5cV+ce3EDYg+8e8O6zHIVInusxUuqvZ12C0cEg4AX4aH6gK//ueqJSsgGkTROqzECJHdpjSs16UnaDiiUzAtBki7VWIxF4Q6W/KTkSVZPz48Zg/fz4WL17stNi2zWbDokWLsHDhQjzzzDMlOuaECRPw888/4/fff0ft2rUd28PCwgAgz4iihIQEx+ijsLAwmM1mpKSkFFpz/fr1POe9ceOGU83t50lJSYHFYskz0ukmvV4PPz8/pxsREbkHNpqqOUVTD4phDqBpAMCd3t2aIdJfg0gdB2EvZD0bkZa79kV+7AlA1ncVE6+EYtOOF11E1YJB4yE7AlV19htAVvEWE3ZJtvOyE1S+rGUQllNF15Hbe/DBBzF16lRMnDgRgYGBaN26Ndq0aYPAwEBMmjQJkydPxkMPPVSsYwkhMH78eKxcuRJbtmxBvXr1nPbXq1cPYWFh2Lhxo2Ob2WzGtm3b0KlTJwBA27ZtodVqnWri4uIQGxvrqImOjobRaMS+ffscNXv37oXRaHSqiY2NRVxcnKNmw4YN0Ov1aNu2bQm/SkRE5OrcaJEeqiiKRz8oHv0g7BmAJRawHIWwHAUsR3KnKLgy02aIxPsB/3eg6Nrn2a2oAgDfKRBpr+b7cJH1FRTvxys6ZZFijWw0VWf1vEIRoc99Oa6lLdkaZESlITI/BTx6QlGHyY5SIsKeCZG9WnYMCey5o5oClhY5pYnc35tvvonBgwfjm2++wZkzZyCEwD333IOhQ4eiffu8f+sU5JlnnsHy5cvx008/wdfX1zGiyGAwwNPTE4qiYNKkSZg9ezYaNmyIhg0bYvbs2fDy8sLQoUMdtU899RSef/551KhRA4GBgZgyZQqioqLQs2dPAEDTpk3Rt29fjBw5Ep988gkAYNSoURgwYAAaN24MAOjduzeaNWuG4cOHY968eUhOTsaUKVMwcuRIjlQiIqqC2GgiB0XlA+g7AvqOjrFNwhaf23jK+ACwnpSar0D2eIjkxyG8x0LxeQaKctuPteejQPZawJLPVU1U+Q/Xrmw3TDdkRyCJGnuq8bD3CtkxqDqxx0Mk9gN8JgBew6EoWtmJiiTs6RApIwGL66yvV6nMe4CsbyC8hrHZVIVlZWXhhRdewOrVq2GxWNCjRw8sWrQIQUFBJT7WRx99BADo1q2b0/Yvv/wSI0aMAABMnToV2dnZGDduHFJSUtChQwds2LABvr6+jvqFCxdCo9FgyJAhyM7ORo8ePbBkyRKo1WpHzTfffIOJEyc6rk43aNAgLF682LFfrVbjl19+wbhx49C5c2d4enpi6NCheOedd0r8vIiIyPWx0USFUtRhgDoM0HWCSJ0EmLfLjlQAe+4iqra/AMO7ty0+qQIMb0IkDgJgdn6YNrJyYxagfeBd+PnaWsd9nUoHs91cyCOoKrlh4ZtGkkBkQqS/BWSvAvxmQdG59vQVkfZS9W0y/U2kvwaYNuV+vzR3yI5DFeA///kPlixZgmHDhsHT0xPLly/H2LFj8cMPP5T4WMVZRF5RFMyaNQuzZs0qsMbDwwOLFi3CokWLCqwJDAzEsmXLCj1XnTp1sHbt2kJriIioamCjiYpFUfkAAR9DpL0OZOe9YonLyFkHaJoAPmOdNiua+oDPBIiM+c711lMQmV8C6tqAOgJQ1859rpXsvpp9kWhKRI4tB/+uNwI6lRa7kvZg4/XNuJZd8GWOqWpIsLCpSBJZT0EkPwqhbQ3o2kHRtgV0baCo/GUncxAiB8j5XXYM12DeBZHYH8J7NBSf0VAUvexEVI5WrlyJL774Ao888ggAYNiwYejcuTNsNpvTCCIiqrpavTGryJqYl4quIZKJjSYqNkXRAH6zAE0ERPrbsuMUSGS8C2iaQPHo7rzDexQUfXfAvBMi4yNApOb+wW7e5fx4JQDQ1IZimJfboKoEnmpPjL5zJFLNqfDT5g5XvzekG9oHtMMzh5+tlAwkzw1TGoQAOBuGpLIcBiyHIfAZAEBoGgLatrkjnXTtAFU4ABMURcKC9abdANz4SnnlzgJkLobIWZM7uknfWXYgKieXL19Gly5dHPfbt28PjUaDa9euISIiQmIyIiKi4mOjiUpEURTA+2lAXRsi9QUAJtmR8iEgjM8D+n1O6zUpigJoG+XedO0hkh/P/4p0IgWwpACi8p+bv84fAJBiTkGALgDJlkKuqEdVRo7dhAxRA75KkuwoRP+wngGsZyCy/14/TBUGxfsJwPupys+iDgYUv9wridI/bBchUv4N4TEAiu90KOpg2YmojGw2G3Q6ndM2jUYDq9UqKRERlQeOUqLqho0mKhXFoy8QGAqRMia3MeNqhCXvouC3ULTNgYAvIFL+DYjMAooqdzpCpjUT+5MPYHfSXpxKP43/3vUpUsyplZqB5EkQEfAFG03kwuzxENYzQNb/oHgV7/Lq5UbTEIr30xAZCyr3vO4iZy2E5RgQtIELhbs5IQRGjBgBvf6fv0FycnIwZswYeHt7O7atXLlSRjwiugWbR0QFY6OJSk3RtQZq/ACRPBSwJ8iOcxs7hPkQFF2bAisUXSsg4BOI5KeQ78isSpgeYrZbcCT1CHYn7cWR1KOwin8+sbTYLUgxJ1d4BnINN2whuJPLb5Cry14Jkb0S0DaDom1WoacS9kzA9DuEaSNg2l7whwKUy3Yx9+qqunayk1AZPPHEE3m2PfbYYxKSEBERlR4bTVQmiqYO4DMx92pALsUCkTwCCFgMRX9PgVWKrj0Q8GHuyCxYbttZ8Y2mxWc+wBHjsXz3mexmNPNrhlB9CK6bXK2RR+Xths236CIiFyGSBkOo6+UuGq5tDejaAOr6uVf5LI/jCxtE6njAvLNcjlddiKwVuetqcVST2/ryyy9lRyAiIiozNpqo7DwfALK+AawnZSe5TQ5EyljA8DYUz/4FVin6LoD/+xCpEwDcsgaCqNgrgWVaMxGbdqLA/amWVNTxisBLzWZgwel3cT7zQoXmIbluWLSAp+wURCVgOw9kn4fI/jH3vuIHoW0FxfdFKNqGZTq0yHifTabSyPkZQuUH+M6EonCIJBFRaRQ1JY7T4YiKVj4fPVK1pigaKDVWQQn8HtAVPHpIDguEcTJE9s+FVikePaAY5uHWXwlhnAYhKm7xzUMph2ETtgL3707aAwDw0/qibUDBUwCparhhscuOQFQ2Ig0wb899zS1Do17kbAEyPyrHYNVM1jKI1Gcg7FmykxAREVE1xRFNVC4URQXoWgG+UyCStsuOcxsBYd4DxXNQoVW5o55MEMZpuRvMuyAyFkLxfaFCUu1LPlDo/p2Ju/Bgrf+DRqWBCpwGUdXdsPBNIVUR1lMQGe9C8Z1a4ocK60UIY8W85lYrpi0QycOAwKVQVH6y0xARScdRSkSVi40mKleKtgmEphlgLXhKmBzFGy2ieD4AqGpCZLwHWA4BmZ9BeP4fFE2Dck9U1FQ4oyUNR42xaBPQqtzWPSHXlWxOg1VooVEsRRcTubrMz2E3H4Xi9Qjg0RuKooOwJUJRBxX4ECGyc9dlEumVGLQKsx4HLMcAfWfZSYiIiq33w68VWbPhu1eKVXuzjogqHxtNVO4Ur0cg0lzshb2QKWq3U/TRgK4jYN4NkfUtoL6jQiIZtAakWwt/Q/XHjT9yG00c0VTlCQgkijoIU87JjkJUPiz7IIz7gPRACE1jwLwXMMzPd808IQSE8RXAekpC0CrMdll2AiKiEjWPiKhqYKOJyp/nw1BENkT6XBR3JFHFK1kORVEAfSco+k4VlAfw1xpwJftKoTUxqUeRajbyCkLVxA1bTYSp2GiiKsaeDJh3AwCE8UUIqADTZii6u3Kb+uo6QPa3QM5PkoNWPcJ2iR9TEBERUaVjo4nKnaIogPe/AcXThUY2OY9oEsIK2BOhqMMk5QH8tEWvm2GHHWnWNDT0aYB7grvgVNppXDddr4R0JMMNWwCglZ2CqAJpGgDGZwEAIufvizSowgB7ksRQVZj1kuwEREREVA2x0UQVx2MQkPk5oK6bu06ESJWXxbwPwm6EojJAmGMgjFMAewrgvzh3qlwlO5V+GgdSDhZZV8crAnW8IgAAd/rUh8lmwqKzH+KYMbaiI5IEN2xesiMQVSB17pXpbmePr/wo1YWNjSYiIiKqfFxhmCqMovKCKngTVIFfQAn+DfB8SF4Ye+LfU/kAiMzcP75FOkTK07mX0q5EFzIvYuHp92G2F33577uDnBdx1av1mNRwAjoGdqioeCTRDQsnuVAVpm0N2AqfLkzlzHoW9vR3IewpspMQERFRNcJGE1UKRRUAlWE2lICl8kJk/w/25OEQGQtu2WiBMO+qtAhZ1iy8e3oRsm3ZRdaqFTWia+RtKGlUGoy+82n0COleERFJogRL0c1HIrekBLrg1UirAyuQ+SHEjZ4QdqPsMERERFRNsNFElUrRRwOqcHkBzHtzp/HdSmRV2um9NF54pflM3FezLzzVnoXWtjREFbiOk0pRYXjdYbg/fGBFxCRJbpjSIITsFEQVQFO3Ul9r6TYiHcheIzsFERERVRNco4kqneL1EETG+7Jj/OPvNz9CmAHzXgjzfij6e6HoWlXI6QJ1AXg44l8YFD4A2xK247frm5BsTs5Td3dw53we/Q9FUfBA7cGo530H9iUfwDHjMaRbMyokM1WOHLsJGaIGfBUujExViLohYDksO0W1J7K/B7yG8SqmRFQuej/8WpE1G75zlYsCEVFlY6OJKp3iMx5QvCDS35IdJZflFOypzwKm7bnrNwEQmV8AoQegKIWPOioLT7Un+tbsg56hPbAv+QDWxa/HpazLjv3ZtpxiHad1QCu0DmgFu7Djr8zz+OyvLxCfwyvTuasbIgK+YKOJqhJb0SVU8ax/AtZjgLaF7CRERERUxbHRRFIo3k8CqhAI44sALHLD2M7l3pxYAPNhQN+pwk+vUWnQKagjomt0wIm0k/g1bj00Kg3qetUp9jG23/gD6+J+w5P1RsAm+KbOXSlQoMAuOwZR+dG2BSxFX2GTKofI+h6KgY0mIiIiqlhsNJE0iucAQBUMkToud/0IF5M7ha7iG003KYqC5oZmaG5oVuLHRnhFIM2ajrl/vgOrsFZAOqoMj4UYUE+9XXYMonLiC1jPyg5Bt8r5BcJ3OhSVt+wkREREVIWx0URSKfoOgP9iiJQnZEfJy7xPdoJiq+d9B2Y0fRFv/zkfqZZU2XGoFO6rURP3enwvOwZR+dE2BiwHZKegW4lMIOdXwOtfspMQUSUpyVpKXHeJiMoLrzpH8mnqA14jAH1vQBMJVOC6SCViOQIhTLJTFFstz3DMbDoNwfog2VGoFNrqT8mOQFR+1HUByyHZKSgfIpsNbSIiIqpYHNFE0inqUCh+Mxz37enzgMzPJCa6yQxYjgC69rKDFFuIRzBmNJ2GeacW4Fr2NdlxqARizA1RX3NEdgyi8qF4AFxvzDVZjkBkLgW8HucV6IgqQVff/kXWbEv/pVi1N+tKWktEVNnYaCKXo+jaQ7hEowmAeb9bNZoAIFAXgBlNpuKdUwtxIeui7DhUTDGZdjzgJTsFUTnQtgIsMbJTUCFE+puA+QBgmA1F5Ss7DpHbKUnziIioOuLUOXI92raAKlh2CgCAcKN1mm7lq/XFi02moIFPA9lRqJguZ99Aoj1CdgyiMvIAbFdkh6DiMP0GkTQYwnpJdhKqQNu3b8fAgQMRHh4ORVGwevVqp/1CCMyaNQvh4eHw9PREt27dcPz4cacak8mECRMmICgoCN7e3hg0aBCuXHH+PU9JScHw4cNhMBhgMBgwfPhwpKamOtVcunQJAwcOhLe3N4KCgjBx4kSYzeaKeNql0tW3f5E3IiIqHjaayOUoKh8oNf4HaJrIjgKYD0MI1/kjqCS8NF4YWf9JqBW17ChUTDGW1rIjEJWNNgqwJ8pOQcVluwIoetkpqAJlZmaiZcuWWLx4cb773377bSxYsACLFy/G/v37ERYWhl69eiE9/Z+rAU+aNAmrVq3CihUrsGPHDmRkZGDAgAGw2WyOmqFDhyImJgbr16/H+vXrERMTg+HDhzv222w29O/fH5mZmdixYwdWrFiBH3/8Ec8//3zFPXkiIpKGU+fIJSnqmkDgtxDGyYDpd4lJcgBLLKBrIzFD6YV5hOLekG7YeH2z7ChUDDGZnujJ93zkrlQ1Acth2SmoJBQvwHoaUIfKTkIVpF+/fujXr1+++4QQePfddzFz5kw88MADAIClS5ciNDQUy5cvx+jRo2E0GvHFF1/g66+/Rs+ePQEAy5YtQ0REBDZt2oQ+ffrg5MmTWL9+Pfbs2YMOHToAAD777DNER0fj1KlTaNy4MTZs2IATJ07g8uXLCA8PBwDMnz8fI0aMwJtvvgk/P79K+GoQEVFl4YgmclmKyhuKrrPsGICbTp+7aVD4QHiqXeRKflSoPzOvI0twvRRyU6oaAKyyU1BJiEyIlKdgTxkLYU+WnYYq2fnz5xEfH4/evXs7tun1enTt2hW7du0CABw8eBAWi8WpJjw8HJGRkY6a3bt3w2AwOJpMANCxY0cYDAanmsjISEeTCQD69OkDk8mEgwcP5pvPZDIhLS3N6UZERO6BjSZyacK8W3YEiJzfIKzuu+aIn9YX/Wvm/2kmuRabsCHW2qHoQiJXo4kErLGyU1BpqesCSoDsFFTJ4uPjAQChoc4j2kJDQx374uPjodPpEBAQUGhNSEhInuOHhIQ41dx+noCAAOh0OkfN7ebMmeNY88lgMCAigusYEhG5CzaayGUJYQXMe2XHAKzHIRJ7wp76LITZPS8/3y+sDyY3moR7gu6Gt9pbdhwqREx2kOwIRCWkATgaxs3ZoSiK7BAkye3feyFEkT8Pt9fkV1+amltNnz4dRqPRcbt8+XKhmYiIyHVwjSZyXZZYQGTITvE3O5CzDiJnHQS0gKIFoAOU3Jvi9woUfTfZIQukUWnQ0j8KLf2j8IR9OE6m/4n9yQdxKOUQ0q2u8jUmADiangybrwpqxS47ClHxaFsDlv2yU1BZmLYCmCE7BVWysLAwALmjjWrWrOnYnpCQ4Bh9FBYWBrPZjJSUFKdRTQkJCejUqZOj5vr163mOf+PGDafj7N3r/OFhSkoKLBZLnpFON+n1euj1XLiQiMgdcUQTuSyR86vsCAWwACILEKmAPeHvS3m7zyfBGpUGUYZIPFnvCbzXegGmNn4e3UO6wU/DhThdQaYtG2ds7WTHICoepQZgOSY7BZWV7YLbjtil0qtXrx7CwsKwceNGxzaz2Yxt27Y5mkht27aFVqt1qomLi0NsbKyjJjo6GkajEfv2/bOm5d69e2E0Gp1qYmNjERcX56jZsGED9Ho92rZtW6HPk4iIKh9HNFVjwnwEUDyhaBvJjpKHsPwJZH0tO0bxKe7ZpFErajQ3NENzQzM09m2Ej899KjsSAYgx3YEmGvdehJ6qCU0EYImRnYLKgTA+B9T4EYqKazVVJRkZGTh79qzj/vnz5xETE4PAwEDUqVMHkyZNwuzZs9GwYUM0bNgQs2fPhpeXF4YOHQoAMBgMeOqpp/D888+jRo0aCAwMxJQpUxAVFeW4Cl3Tpk3Rt29fjBw5Ep988gkAYNSoURgwYAAaN24MAOjduzeaNWuG4cOHY968eUhOTsaUKVMwcuTICr3iXFff/kXWbEv/pcLOT0RUXbHRVE0JexpE6qTckTmBX0HRNpYdyUEIO0TaKwBssqMUn8r9rxT2x40dsiPQ3w5n5OBhL4BLppBLUzdmk6kqsV2BSH0eCPgMiqKWnYbKyYEDB9C9e3fH/cmTJwMAnnjiCSxZsgRTp05FdnY2xo0bh5SUFHTo0AEbNmyAr+8/f9csXLgQGo0GQ4YMQXZ2Nnr06IElS5ZArf7n5+Sbb77BxIkTHVenGzRoEBYvXuzYr1ar8csvv2DcuHHo3LkzPD09MXToULzzzjslfk79wh+CRtEWWsPmERGRXGw0VVemPwD7VQCASH4cCF7vOp9iZn/vfm9e3HRE063uCb4bx9NOyI5RJehUWpjtFvhpfNDCx4BMO5BhsyHJnIVkS9GXZ04wpSDO3gjh6tOVkJaoNBQAObJDUHkz7wBsVwFNHdlJqJx069YNQogC9yuKglmzZmHWrFkF1nh4eGDRokVYtGhRgTWBgYFYtmxZoVnq1KmDtWvXFpmZiIjcHxtN1ZW+KwA9ABMgUgDzPsCjj+xUELZEiPSSf7oln1V2gDLrWKMDLmZdwq9x62VHcWu1PYIwNWg7dpq64G79dvio/rkalxDAGVs77MhqgP1picixm/I9Rpg+EB7KucqKTFRy2jaA5aDsFFQRrKcg1BG8Ch0RERGVGhcDr6YUlQ/gca/jvjDvLaS6EoksuOOPpUh+CsKWIDtGmf2r9oOI9GsuO4bb0ql0GFsjFr6qJPT1XO3UZAJyp8I10hzAk34rsLDWbjwd5o0m3jWdahp4h2Fm8B8IVF2rzOhEJeAHWDnarqoSqc9AJD/KxcGJiIio1NzvHT2VH8X7n/9vdo2FhxVNHSgBHwAofO69y7Gdg0h+DMIWLztJmagUFcY2GIVgfbDsKG5pWIge4eozxar1UDLRWbceL9b4Hm/XuoT7g0JwT0AtvBDwc54GFZFL0TYERLrsFFSRLIcg0t+SnYKIiIjcFBtN1ZTIXgtk/++fDdbTELYkeYFuoejugmJ4Q3aMkrNdgEgeLjtFmflofPBsw/HQq/Syo7iVjoZa6KL9tVSPDVZfxGCvH/Fv3xXQqfKfTkfkEtT1Acsh2SmoMlhiYDf+B8JyUnYSIiIicjNsNFVDwnoOIu0l2TEK5zEQbvnjabsIIcyyU5RZhFdtjKz/pOwYbqWWzsyrxFHVp6gBFLywMFUlNiD7W4ik+2FPehgiexWEsMsORURERG7ADd/JU1kIexZE6sS/10K6hbo2FHUNOaHyY08E4KZ/0IoM2QnKxV2B7TCwZn/ZMdzGmiQjkuy1ZMcgqjja1oC1eFNDqYqxHIYwvghkLZGdhIiIiNwAG03ViBACIv1t5Ptt17as9DyFsl2XnaD07FWj0QQAD9QejBaGKNkx3ILZbsb36V1kxyCqIF6A9aLsECSZSF8AYWGzkYiIiArHRlM1o/i9AlXQGiiB3wOaf64uprhao8nuxotqV5ERTUDu4uBj7hyFUH2o7ChuYZ/xKk5YO8qOQVT+tM0BwUXqyQxhfKFKTBEnIiKiisNGUzWiKAoUJfdbruhaQanxPyh+rwGKAdC2khvubzZhw7Xsa+49oqkKNZoAwFvjhcmNn0WwPkh2FLfwTXIYrEIjOwZR+VHVAiyHZacgV2E9AZHxkewURERE5MLYaKrGFEUNxesRKMG/AdpmsuMgw5KB+afexVFjLITluOw4pSbS50OYdkKIqrNgbphHKF5uNgP1vO+QHcXlXctJwmbTANkxiMqPygDAKjsFuZLMjyHMR2SnICIiIhfFj90JiipQdgRczrqC984sxg3TDdTxisCM6wLA4ALrC7+6V0E7BZQC9xX8qKLkf8w1mNCwLkI9a5fyqK7HoDVgepOp+PDcJ4hJLd4bDC+1F7JsWUUXVjGrEzPQITwM/io3ngJKBACaKMB6THYKcjk2iJQREPruULxHQdE2kR2IiIiIXAgbTSTd/uQD+Oyv/8JkNwEAfk/Yhhx7juRUZaNW1KihD5Mdo9zp1Xo823A8ll1cjs0JvwMA7vCqi1YBLXE+4zyOGP95Q9rItyH6hfXFe2cWyYorTY7dhO8zumGU3wrZUYjKQAvYb8gOQa5KZAI5ayGEFUrA+7LTEBERkQtho4mkSjWn4oOzH0Pgn2lm7t5kAoBanuHQqKrmr5dKUWF43WFo5d8SEV61EaALAACYbCbM+XMezmeeBwDcF9YXrQNaoaUhyqkBVV3sTr2Kbl7t0EhzQHYUotLRtgIs+2WnIFdn2gJhT4ei8pWdhIiIiFwE12giqQ6lxjg1maqKCM8I2REqlKIoaOEf5WgyAbmjnSY3mohgfRAMWj+EeYQh2ZyC+2r2w3ut5uPZhhPQIbA9dCqdxOSVa1lyHdgEX2bJDSkhgOWo7BTkFsxAzgbZIYiIiMiFVM0hF1RmQggohS+EVCaHUmLQJqAVjqZWzZEuEV5VZ22mkvDT+uH5Rs/h9ROz8WvcOjxV/98I/LsZ1UbXCm0CWsFkM+FQagz2JO2Fr8YH0TU64mzGOZxKP43jaSckP4PydTnnBraa+6OHfo3sKEQlo6kNWBJkpyA3IXJ+huL1oOwYRERE5CLYaKJ8/XRtDdIsaXikzhAoUGCxW2C2W2ARFnio9PDVlm6IfLYtG19d+Aa7knbjgzbvYfSdT+OPGzvwW/wmJJoTy/lZyFPbq5bsCNLU9AzDc40mwiryv0qVXq1HdI0OiK7RwdHQvMO7LgJ0AVWu0QQAKxNNuKtmDfipkmRHISoBtewA5E7MeyBs16GoQ2UnISIiIhfARhPlK82Shs0JvzsWfL5dXa+6aOkfhRaGKNzpUx8qpejpQWfSz+KTvz7DDVNuQyk+Ox4NfBugd1gvNPZthFeOv1auz0GmJee/xmN1H0XrgFayo0jR0LdBser2Ju/DD5dXVqkm4+2ybNn4MbMX/u3LhcHJjYjqd7VIKgsB5PwCeD8pOwgRERG5ADaaKF/9a/bD1hvbYRO2fPdfzLqIi1kX8fO1tfBWeyHS0BwtDFGI8o+EQWtwqrUJG36+uhY/XVvjtB7TpewraPB3Q6KmZzhUUMEOe8U9qUqUaE7E4rMf4b1W8+Gj9ZEdx2VZ7JYq3WS6aXvKVbT37ITmml2yoxAVj/UsAC0Ai+wkJJO2FSDsgLXo9bpExscQtmtQPPpA0d1V8dmIiIjIZbHRRPmqoa+BzkGdsP3GH0XWZtqysDd5P/Ym516dKMKzNvRqD9iEDTZhRaY1E0nm5DyPW3HpewTrgxBliIROpcXgWoOw8upqx361okb7wHboXKMT1sT9glPpp8vt+VUGq7Bid9Je9ArrITuKywrSB8mOUGnmX9NgQNC/MMhzFTRK/tMKiVyHCdA0BawnZQchGZQagDocsMTk3tfeBVgOAcj/wycAgEgFsr6CsJyE8BoKlWf/SghKREREroiNJirQgJr34a+Mv2AVVsTnXC/24y5nXylWncluwsLT7+P+8IHoFBSN+2sNRG2vWvju0g+IrtER3UO6wl/nDwBo6tcEKy5/j43XN5fmqUiz7cZ2dAqKhrfGS3YUl9TUrwmebzQJyy99h7icONlxKpSAwJrEeMR63o9RNWIQpjonOxJR4RSOxqyWtG0B65+A9ZaLdVj2A+oGgN0IiBsFPRDQRubWGo9AqMOh6FpXSmQiIiJyLWw0UYFCPULwZlTuukk/XV2DlVdXw1PtiWxbdrmdwyZsWHl1NVZeXY0GPg0QXaMDnqw3Apezr2Dl1dW4lHUZWpUWw+o8ikxrZrmdt7Jczr6CcYcmoJFvQ0xr8gLUChfYvVW2LRsLT79fZaZMFsf57AS8eq0e3g2/Br2q/H6XiMqdPe9IVKritHflNoryYzsLKH6ApjlgPe68T6kBqPwBy+G/N5ghUscCgT9A0URUZGIiIiJyQWw0UbEMCh+AAJ0/7gpsh0VnPqyQq4OdzTiLsxln8933HzdfKPx0+hmsj9+A/jX7yY7iMoQQOJt+DoG6wGqxTtOtcuwmHLd1QBvVVtlRiApmOwcovoBIl52EKoUKsJ4pvESk5TaZtHcBlgMABKCuDwhj7s/LrezJsKSMg8V/ObxLeaVaIiIick9FXyqMCICiKLgnuAs81Z5o7tcUOpVOdiS3s+rKTyWagljV/ZV5Hu+cXljtmkw3xWSHyY5AVDRNfdkJqLJomueus1Qclv2AplHuNDvbFcCelKfkhq0u3roehWdjpuCdUwux8fpmx1VniYiIqGrjiCYqsf7h96F7SDcsufCVYwFwKppFWPDi0RnQqXTwVHvgnqAuuK9mX3hV0/Wb7vSpjya+jfFn+inZUaSIyUiF3VeBShFFFxNJo5UdgCqNUrJya8Gv3XvMvfDVDSDblvvhyjFjLI4ZY7Hs4nLU8gxHK/+WeKj2A1Ap/LyTiIioKuK/8FQqXhov/LveEwiuRlcNKy9muxlGSxrWxP2CqUenY2P8Zljt1fMqZAPC75MdQZp0ayY+SnsYaXb+DpELsxXv4g7k7gyAtexT4rOFDz5PewSfxOcg25aTb83V7Gv4JW4d4nPiy3w+IiIick1sNFGpeao9Mab+SKj4Y1Rq6dYMLLu0HNOPvYx9yfshRPUa3RLp1xz1vO+QHUOaA8armBnfFnstPVHNvvXkLuzxgIrTPKs8bSMAZfvA47ytBV5NuBc7U68Wq/6vjPNlOh8RERG5LnYIqEwa+DbA+IZj0cyvCZSSDrsnhwRTAj44+zE2Xd8iO0qlUhQF3UO6yY4hVYY1Cx/HmfCB8RFk2v1lxyHKS11LdgKqaPaEMj18m+k+vHktENdNKcV+zF+ZF8p0TnJfH374IerVqwcPDw+0bdsWf/zxh+xIRERUzthoojJrG9AGLzZ5AQtavY0hEQ+hlme47EhuKzbteNFFVUy4R03ZEVzCwbSrSBb83SFXZJMdgCqSuj5gu1imQyRavWETJfs5OZx6GLsS91S7kbzV3XfffYdJkyZh5syZOHz4MLp06YJ+/frh0qVLsqMREVE5YqOJyk2gLhD9a/bDm5Gv4eGIf3GEUymcSj9d4j/W3V2oR4jsCC4jQOGaJeSCLH+hxAtFk/tQBZb5EM31JW9UJZtTsC5+PRSFP1vVyYIFC/DUU0/h6aefRtOmTfHuu+8iIiICH330kexoRERUjnjVOSp3iqLgvpp9cYd3XXx49hOkW9NlR3Ib2bZsnM+8gAY+d8qOUml8Nb7wUHkgx57/wrHVhUbRwFtJlh2DKB9pf496+Ut2ECp3GsB6usxHaaA+jOdqdoS/Khn+ynXE2+/A4oQgpFszC31cG//WZT43uQ+z2YyDBw9i2rRpTtt79+6NXbt25ak3mUwwmUyO+0ajEQBgFUWvJ5aWlvZ3raVK1d6sK0mt1VL031dVtfbWr5ctx1RIZelqi6pztVpzZvnV3vr1Km5teZ6/tLXpGcV//SjP2lu/XsWtlZUVAJS/a8sy6lgRHLNMFSjZnIz/xL6ONGta0cUEAHiw9v9hUPgA2TEq1Suxr+JiVvUeNh+k88e8sDWyYxDlT3sXYNkvOwWVKwXQtgQsMRVy9AT7HfjPtQbIsRf8BuC15q+grnfdCjk/uZ5r166hVq1a2LlzJzp16uTYPnv2bCxduhSnTp1yqp81axZeffXVyo5JRER/u3z5MmrXrl2qx3JEE1WoQF0gGvk2xIGUg7KjuI2TaSerXaMpxCMEVmFFiD4Eh1NjZMeRItmcBqMIhkG5ITsKUV4iQ3YCKjUF0LYDbFcBmABhAkQOAGuFNZkAIER1AfW82uNkRly++2voAlHHq06FnZ9c1+3TJYUQ+U6hnD59OiZPnuy4b7fbkZycjBo1ajjVp6WlISIiApcvX4afn1+h5y5ubUUck7WucX53q5V9/qpcK/v8rlwrhEB6ejrCw0u/fiwbTVTh6nnfwUZTCZxJPwuz3QydSic7SqUZXf9paFVa2IUdb5yYg3OZ1W+Kjh127DV1Qm+Pn2RHIcrLehaADoBZdhIqCVUtQPGUNhqtrl7ByQJ6lK39W3F9pmomKCgIarUa8fHO6xEmJCQgNDQ0T71er4der3fa5u/vX+Dx/fz8inxDVdLaijgma13j/O5WK/v8VblW9vldtdZgMBTrcQXhYuBU4ep53yE7gluxCCt+uPyj7BiVSqvSAgBUigqP3/FYtV1Ifk+GVnYEogJYAE0D2SGoJLR3AfYbgO2stAh1tCkF7mtuaF6JScgV6HQ6tG3bFhs3bnTavnHjRqepdERE5P44ookq3B1cf6HENlzfhGB9MHqH9ZQdpdIIIXA4NQarr/4sO4o01bO9Rm5D8ZadgIpDFQ6ovF1iTa266gsA8o5UAYD/nv8SWdYh6BzUiSObqpHJkydj+PDhaNeuHaKjo/Hpp5/i0qVLGDNmjOxoRERUjthoogrnrfFGqD4E100JsqO4leWXViBIXwNtAqrHVXkURUGbgNZo5NMQe5P34de435BoTpQdq1LV1vMlmVyYneuHuTztXYDlKGC/JjsJACBMdQY6VQTM9rxTLtOtGfjs/H+xK2kPpjR+DiqFg+yrg4cffhhJSUl47bXXEBcXh8jISPz666+oW7f0H0rq9Xr85z//yTPNriy1FXFM1rrG+d2tVvb5q3Kt7PO7Y21J8KpzVCl23NiJXUl7cDzthOwobqWRT0NMafwc9Ory/cV3B4mmRLx+Yg5SLamyo1SaR0MCuUYTuTbFAAij7BSUhzegqQ1YTxVdWsneTPwXzmbFF1ozudEktPSPqqREREREVNH48RFViruDO+OFxpPRyKeh7ChupYV/VLVsMgFAkD4ILzSeDG+1l+wolaa2hqP+yMVp6slOQPlSu2STCQDqehT9p+bWhK0VH4SIiIgqDRtNVGkURcHQuo+glX9LaBVOESqO1Vd/xqIzH+BA8iFY7BbZcSpdba9amNzo2WpzBb5aanmL9hIVj1p2AMpXmsuuoVVHm15kTZI5uRKSEBERUWXh1DmSItuWjVjjcRxMOQSr3Yp+NfsiPuc6TqWfwv7kg8iyZcmO6HK81F5oH3gXOgV1REOfBtVqPYs/005hS8JWnE4/gxRLwVcxcmdaRYuPam+FWrHLjkJUMCUEEBx555LUdwC2C7JT5HHcGo13rhX+4VIr/5Z4rtHESkpEREREFY2NJnI5RosR3176HruT9siO4rKCdDXQsUYHdAqKRi3PcNlxKo0QAonmRJxOP4NT6WdwJv0MruXEyY5VbkaE+qKr/lfZMYgKpwp3mcWm6RbaFrkLgbuY7ab78OX1wkc1dQ/uihH1Hq+kRERERFTR2Ggil3XceALvnVkMk90kO4pLa+jTADObTqu2l4dOs6TjbMZZXMy6BG+1NwxaA/y0vvj43KdItbjXosX+Wl+8Ffo79Kps2VGICqZtC1gOyk5Bt9PeBVj2y06Rx4+Z/8LapMIXA3+g1mDcX2tgJSUiqhrS09Mxffp0bN68GYqioGfPnnjzzTfh6+tbqTmuXr2KHTt2QFEUdO7cGbVq1arU81PJZGdn4+jRo1AUBVFRUfD09My37vLlywgNDYVOp8POnTtx+PBhPPHEE2X6+bLZbGjVqhWOHTtWosdcvHgROTk5jm3NmjUrdYabrFYrzOZ/rojq5ZX/mrA//fQT/vzzT7z44ou4evUqkpOTERVVtotXWK1WvPfee9i0aZPjd3fixInQaCp+aZmsrMJnDRX0dSiN6jP3htxOc0Mz/PsOfsJZmDCPULQPbAc7qu90Kz+tL9oEtMb/1bofvcN6okONu9DUrwn61ewrO1qJpVrSscnUr1i12SYfnIlrA35UQJVOVL/14txDPi8G2jaApknlR7nFdWvR63oF6PwrPghVKWvWrEFaWhoA4J133sFDDz2E2NjYMh93//79jjdi33//PaZMmYJr18o2gjMxMRETJkzAPffcg/bt2ztuBbFarZg/fz769euH++67DwsWLIDVas1TN27cOFgsFnz77bdYvnw5rFYrxo0bl+8xbTYb3nvvPYwfPx4AcO7cOWzZsqVMzwvIfRPesmVLrFixAsuXL0fr1q2xZs2aMh83PT0d48ePR9OmTdGsWTNMnDgR6elFr/eWnx49egAAgoODERIS4rjdvF9VXL9+HVu2bMGvv/7quN1u165duPPOOzFmzBiMGjUKDRo0wO7du/M93v333w+73Y6rV6/ikUcewc6dO/Hkk08WmsFms+Gvv/7CiRMnHLdbqdVq1K5dG9nZxftAdd26dahTpw6aNWuGLl26ICoqCv3798+39pNPPoHRmPsB8zPPPIN27dph+/bteer27duHqKgoeHh4wNfX13HLz6xZs/Dxxx/jiy++AACoVCqMGTOmyNxWqxVZWVmO2+0mT56MLVu2YPTo0Rg1ahR+//13TJ48Od9jleR399ChQ+jbty8aNWqE+vXrO2638vHxga+vL3x8fBy3m/fLu0nNFZnJpUUHdcSpjDP4nVekySNYH4Q3I1+DRsVf4/x0D+6KX66tQ5o1TXaUEvklOR3NwlqgnjrvFJhskw82HbkfO47UxMHjmTBbbKgZ0hWTHz2BDo1+k5CWqiXrX8j9nKr6NrhdksjIHdUEAJbDgKYBYDmUe18VBqgjcq9MJyr3NTHBXHRj0ldTuSMwyP3NnDkTR48exZEjR7Bs2TKMHTsWY8eOxR9//JGnNjExEa+++iqOHDniNCpi3759eWqffvppHDp0CGfOnMHMmTPx0EMP4d///jd++y3vv7Hr169H3759i9z25JNPonPnzvjtt98wf/58fPLJJ2jdunWBz23y5Mk4d+4cRo8eDQD44osvcOHCBbz//vtOdTef/00ffvghWrZsme8xJ0yYAIvFgh07dgAAatSogUceeQT79xc8CvLAgQOO0VL33nsv2rVrl6fm1VdfxZ49e9CgQQMAuW+C//Wvf2HgwLwjFEvyfRg3bhy8vLzw7bffAgA+/fRTjBs3Dl9//XW+WQ8dOoSYmBin495sui1btszxfEqquKN/ilt74cIFzJ07F+fOnXNqHhbUOFizZg26du0KPz8/vPPOO9izZw9mzZqFyMhIp7olS5bg1VdfRVJSEho2bIgjR46gY8eOuO+++5zqJk+ejB9++AGdO3cGkNt4eu6557BnT/7LlXh4eOCXX37B6NGj8dJLLxX48wXkNoWefvppJCUlwdvbG6mpqahTpw7Onz/vVNeoUSN06dIFQ4YMgY+Pj2N7fk3SmTNnYteuXRg8eDAOHz6MZcuWFTga6oMPPsDo0aOxc+dOxMbG4s0338SUKVPy/HxNnDgRn3/+OcaMGYPt27fj/fffL/D7unr1ahw8eNDxs1+zZs1CG5779u3DU089hZMnT+LWSWM2m82pbuvWrYiJiYFKlTvmZ8CAAWjTpk2+xyzJ7+4TTzyB8ePHIzo6Gmp1/h/y2O2V97cbRzSRyxta5xHU9arjuO+h8oCHykNiItfQv+Z9bDIVQq/Wo1/NPrJjlFi2LQevX/XHf9MegdH+zydtJosHZv53LOYt9cbumDSYLbn/aMUlZOLLX8o2hJeoZDIAdf2iy6hyWf/MnTpn2Z/bWLIl/bPPHp+7XXNnpUYSAkgwF93Y+vSvz7Hm2i8w2ThVnorn5hSTDRs2YNSoURg9ejQyMzPzrX3yySdRu3ZtxMfH4+WXX0ZISAj69Mn/7wO1Wg21Wo1169Zh7NixmDNnDhIS8r8AwowZM4q17dKlS3jxxRfh4eGBgQMHYuXKldi1a1eBz23r1q1Ys2YNBg8ejMGDB2PVqlXYunVrnjqbzeb0pjczM7PAN5G7du3CZ599Bg+P3L+f/f39naYN3e6zzz7DAw88gLi4OFy7dg0PPvggPv/883wz3GwyAcCdd95ZYIaSfB+OHj2KTz75BK1atUKrVq3w4Ycf4ujR/Negmzt3Lp5++mlMnToVmzdvxrRp07Bx40bH/po1azr+W7duXdStWxc2mw3Hjh1D7dq1C/walGT0T3FrhwwZAn9/f4wfPx7PP/+841aQmTNnws/Pz9FQ7dWrF8aOHZunbsGCBTh06BDuvPNOHDx4EFu2bEGTJnlHs+bk5DiaTADQqVMnp+bcrUwmE0wmEzZu3Iju3bsXmPHWrLt27ULTpk2RlJSEpUuXYsiQIXnq0tLSEBUVhZMnT2L//v3Yv39/gU1ARVFQt25dR1PuscceK/B7cPM1YcuWLXj88cfRp0+ffEcCWiwWdOjQAVarFb6+vpg5cyZ+/vnnfI/p4eFRYMMmPzebWFFRUUhNTcVrr72GefPm5akTQjj9ngghUNBqRiX53VWr1Rg9ejRatGiB5s2bO26FKWr0VVnwXSq5PJ1KiwkNx+F85gXU9aqDYH0wrMKKmNQj+D1hK06k/Vkh59UoGlhF3hcoV7EraTe6BHVms6kA13MS0CGwPX6JW4cMa4bsOCUiIPBH6lXsT2uBgUG+6K7dgNe+GosDsfmvOXXibBp2nuyP1vW3w0tfuqHlRCWiCgBsRZeRJPYrBeyo3H8vMkQNZNvyfxNzqyxbNv53ZSU8VB7oFdajEpKRu7PZbNizZw9+/PFHfPnllwBy30Dm59KlS/j555/xzTffYODAgejTpw/69ct/mrrJZEJ8fDzWrl2Lt956y3GuW509exanT59GWlqa0/Qko9GY7xs1nU4HANDr9UhOToa/vz+uXCnod/SfN6E3RzsU9Cb08ccfR8eOHTFs2DAoioIVK1bgiSeeyPeYN9+k3mSz2Qod2bBo0SIcPHgQwcHBAHKbCD169MDTTz/tVBcSEoIvvvgCTz75JBRFwdKlSxEUFJTvMUvyfbjZRLs5laewJtrXX3+NAwcOoGPHjvjxxx9x6tQpvPLKK3nqOnfujC1btsBsNqNLly644447sHbtWnz88cf5Hrcko3+KW5uTk4M5c+bke7785NdQ/eSTT/LUabVaBAQEOBor99xzD6ZNm5anzsvLC5s2bULPnj0B5DY1C1qT59FHH0VYWBgaNWqETp06IS4urtD1e/JrCt1zzz156m7+vhaHVqsFANSuXRtr1qxB3bp1C/zdUalUWLFiBb777jusXbsWAPJtyNz8mtaoUQMxMTGoXbs2Ll68mO8x69at61h/zG63Y/bs2YWuz5RfE6tbt255psX16dMHffr0wVNPPQVFUbBkyZICfxdK8rvbuXNnHD58uNARkzcVd/RVWfAdKrmFYH0wgvXBjvs6RYf2gXehjX9rzPlzHs5mnC33c464Yzia+DXB7JNzkWxOLvfjl9Xp9DP46uI3+Pcdj1fbhcALU0MXiHmnFiDCszZOpldMM7Ki5dhN+CHBhMPmx7HzUOGjAqYvrgXgUQQYPFArRIfwEDvCg7LQtM5FRDdZVzmBqfqws6FJRUsQdYouukWqJbViglCV88Ybb2DMmDHo0aMHmjZtilOnTqFhw4b51pak0fPcc8+hSZMm6NGjB9q0aYNz587B39/fqWbnzp1YsmQJrl+/7jRawc/PD/Pnz89zzMaNGyM5ORmPPfYYOnbsCIPBUOgbweK+CZ06dSqioqKwefNmCCEwd+7cPNP2bmrRogW++eYbCCFw4cIFzJkzJ98mwK1uNplu/v/8/tb8+OOPMWzYMMf6Ma1atXJMVbtdSb4P+TXRHn88/3VbPTw84OHhAbvdDiEEGjdujAsXLuSpu/nm/6uvvsITTzyB2bNno0WLFgU+/5KM/ilubWRkJK5cuVLoSKpbFbehqtfrIYRAo0aNsGjRItStWxeJiYl56t5//308+OCD0Ov1UBQFJpMJP/74Y77nfumllzB+/Hj4+flBURT4+vrif//7X4FZi9sU+uqrr/J9fH7f32effRYpKSl444038MgjjyA1NRXvvvtuvo//4IMPMGfOHIwcORJ33HEHTp8+ne9IrEceeQRJSUmYMWMG7rnnHlitVrz66qv5HvP999/HE088gdjYWHh5eaFLly4F/nwDxW9ivf322/jkk0+wcuVKCCHwf//3fxg1alS+xyzJ7+6uXbvw+eefo3Hjxk4Nqvymp5ZkCmFp8apz5PaSzSl4JfZVpFvL943Psw3Ho01Aa0w7+hLicuLK9djlaXjdYegZeq/sGC7pQPIhLDr7gewYZVY3owW2fFC6BZh9vHVY89aHUKu4ng6VJ83ft6JHq5AL0bQErEeKrisnMZau+CBeVezRwQoUDK3zCHqF9uAHKFRuhg8fjvfeew9ff/01PvjgAxgMBtx5551YsWJFkY+12+2wWq2OJsmtvvjiCzz11FMlyrJjxw6kpqaiX79+ha6h8umnn2LTpk0QQqBXr14YNWqUY4TT7eLj46EoCkJDQws8b0ZGBp5//nmsXr0aADBo0CC8++678Pb2zrf+gQceQNOmTfHMM89AURR8+umnOHLkCFauXFng8YUQhS4mXNLvw/r1652+BgU10e655x5s3rwZTz31FMLCwlC7dm189tlnedbyadasGU6cOIEnn3wSQ4cORc+ePdGqVSvExMTke9xOnTrhtddecxr9M2PGjHynPRa3tm/fvti3bx/uvvtup0bA999/n2+GNWvW4OWXX0aPHj0wf/58nDp1CtOnT8/zfdiyZQvatm2LxMREjBkzBqmpqZgzZ44jz60sFgtOnToFIQSaNGniaBDl5/r16zh+/LhT0+z2dZ9u+vbbb9G3b1/89ddfjqbQe++9h6FDhzrV/etf/3L8/5ycHOzYsQMdO3bEunXl86Go1Wot9tXbLBYLcnJyilwEOysrC3a73WlNqfwsXLgQjz/+OA4ePIiHHnoIVqsVr732GqZMmVLs/LfL73d34cKF+WbZtm1bvsfo2rVrnm1t27bFwYMHERUV5fhd6datW77TdEuLjSaqEo4bT2DeqQUQ+V11p5SmN5mKJn6NMf3oS7jmwo0mFVSY0vg5NDfkXupzfdxviPKPQi3PcMnJ5BNCYPafc3E6/YzsKGVSJ7k1fv+s9G/oP595EI3CeTl6Kmea5oD1uOwUVBLqhoCtcl8P7UJBsj0C10VtbM2ogwNpV4t8TI+Q7hhW91GoleKvjUHVz8qVK/MsAP32228X+pidO3ciJSWl0EZPYQtLA8D58+dRr169PFfUuqksl1632Wzo27ev0xpDBTl69CiGDh3quCperVq1sHz58jJfeh0AEhISMHHiRGzatAkA0KtXL7z33nt5rtL26aef4qGHHkJgYCAAICkpCStXrsTIkSMLPX5R34f//ve/ea5wlt82AIiNjUW9evWQlZWFGTNmICUlBS+99BJatWrlVDd+/Hhs2bIFVqsVx48fR0ZGBnr16lXg+kAHDhzId/RP27ZtS127dOnSfM9V0JTH8rZmzRp06dLFMUovJSUFO3fuxIABA/LUFrTA+M1FqW9ls9mwevVqPPjggyXOdP78ebz88sv5jhT68MMP82wzGAxo3759nhGMJ06cwNChQ5GUlITLly/j4MGD+P777zF37lynuh49euDll19Gt27dHNtGjRqFTz/9NM+52rdvn2c0UH7b8lNYE+vatWuOq83dzPTJJ5841hMrq+vXr0NRlEKvqnjzeXTr1g3vvvsuateujbvuuivP4u1lwUYTVRk/XV2DlVdXl8uxIjxrY0bTF3Eo5TA+P/9luTawKoK32gv/af4y/LS+GHdwIhRFQb+wPhgUPgB6tV52PKnOZ1zArBOvy45RJjUvtcWOb0u/QN/4R60Ycvd/yzEREXKvcGYp+IpF5ILUdwC2C9JOLwSwx9IbX98QRa7dFGWIxIQG46r9v2GUv0mTJuHcuXM4ePAgHn30Ufzwww/o1auX4zLkt9q/fz+aNGnieMOXlpaG06dP53sVtblz5+K7777DpUuX0LVrV2zcuBE9evTAqlWrHDUDBgzA2rVrUa9evTyPVxQFf/31F4CCp5sJIaAoSoGLjPfs2RMbNmwocATTTe3bt8cLL7zgGCHyv//9D3Pnzs33alRt27bFU089haFDh+aZClgW+Y0IKmyU0NWrVx1r3nTu3Bm1atXKt65NmzY4dOhQkdtKQgiBI0eOoH79+vDz80NiYiIuX75c6DTGkoz+KUltcaWnp2PGjBnYtGkTFEVBz5498eabb+ZpXmRlZWH58uX466+/nBbAvr3xevv3RgiBNm3a4PDhw3nO3aJFC2zbtg333nsvDh8+jO3bt+Orr77Kd1F4IHd9oJ07d5bqed511135/twOHDgQ27dvR48euWv3bdmyBXfffTeOHj2KWbNmOTUeu3fvjtdffx0TJkzA4cOHIYRAVFQUYmNjnY5Zq1Yt+Pj44D//+Y9jtFVBP1u3b7fZbIiKiiqwybx9+/Z8t98+1W3gwIGIjo52NLA//vhj7Ny5E2vWrMn38Xv37s1zpcL8phqePHkSQ4YMcUxZjIiIwPfff5/vwvAVMfrqdlyjiaqMgeH9cTX7GvYmF95l9lB54KGIB7AxfhOum/L+I1/LMxxTm0zB3uR9WHIh/8uouppMWxa+vvgNpjR+Di38oxCTegRr437F3uR9GF73MbT0r75XJavncwc61YjGrqT8r1Lh6rSKFuf3l21hvpjTgRhydzkFqiI2Xh+Ee4PXckphWdjzf5NELkwVLLXRpChAtG4DftM9iIvZhTeajhljsT1xB3qFcnFwymvz5s04cuQIWrdujfnz52Pq1Kl5Fqq+afTo0U5vYr28vDB69GgcPJh3pG9xFpZeu3YthBDYuXMnwsMLHj1e0EiZonTs2BH3338/hg8f7jQ95vYpS3a73Wka0kMPPZRn9MZN8+fPx5IlS/Dyyy+jV69e+Pe//43evXsXOEW1uCNJ8huvUNBCxT/99BOeeuopdOnSBUIIjB8/Hl988QUGDhzoqDlw4AD27t2LxMREpwxGozHPws5Tp07N9zw33d5kURQFVqsVH330ERRFwb333ptvs/Gmm6N/IiMjARQ++udm4+Fmc/DMmTMwGAx5Gmk5OTn48MMP84yYK2jq3Lhx4+Dl5YVvv/0WQO4IsnHjxuHrr53fn/zf//0fNBoN2rZtC72++M35m4tc56e4C4zf1K5dO+zevRvR0dGFnvPWBfRtNhv27t1b6FTp2NhYREREAAAuX76MKVOmYN++fejZs6dToyk9PR133/3PH7uKouTb7AsNDcWvv/6K/v3749KlS5g2bVqen+N58+bh7bffhtFodBoVlJWVhWHDhhWY9dYrCObk5ODUqVOIjIzM08S6fPmyU1Np2rRpeUbg3TR27Fj89ttvaNWqlWP0n6Io+Taaxo0bh+nTpzsaaCtWrMDYsWMdI6dustvt6NSpE2rUqIHevXsjKSmpWFMIS4qNJqoyVIoKY+8chYa+DfDtpe9gE3nfnOtUOkxu/Cx8ND6Iy45HWtJuZNuynWru8LoDG65vxJprv1RW9HIRoAsAANwd1AkxqblrcNwwJWLB6XdxV0BbDKv7qKOmunmo9gPYn3wAFlG6dY5kCVIH4/pPtXH1bNnWwdl3NBOxlzojsk7pPmmqarbcuA9jt9VE69DnMbfdL6jvnf8nU1QE20VACQBEiuwkVFz2eNkJEG+vj4vZxWtSbozfjB4h3aFSCh/ZQdWPh4cHVCoV/p+98w5r6nzf+OeEsKeigooT98RVQVFcuHfVqnXVrXVVq7aO1kG16lc7HK11b6vVOquts+6FgooDxb1A9oas3x/8khKSQEAkIOdzXb1KTt685wkEzLnzPPctCAIymQwXFxdevtQ/lqlUKrXGs6RSqd7Yc/W+xhhLQ5rwY6hzB9ISq3KCuivkl19+0RwTBEFHaKpTpw5nz56lWbNmQJr/U+PGjfXu2aJFC1q0aEF8fDy7du3Cz8+PESNG8OzZM73rjxw5oreT5Ouvv9bqJClZsiR79uzRjEzt2bMHV1dXvXvOnTuXS5cuUalSJQBCQkLo3bu3ltD08uVLrl27RkJCgpY46ODgwMaNG7X2M+QvZYg1a9Ywf/58evbsCcDHH3/M7NmzDQqUs2fP1vr5Ojk5MXv2bL1CU8eOHXn+/DmOjo5AmjDm4uKChYUFO3fuxNPTE4ARI0Zgb2/PmTNnmDJlChs3bszUlP3mzZsEBv7nq7dq1Srq1q2rs+7FixcEBWU9yu7g4MDly5c1r5NLly4ZFBeMNRhXc+bMGVauXEmVKlW0BNKMY2bpDfSlUinu7u78/vvvevd88uSJRmSCtA6d4OBgXF1ddXyYpFIpMplMI1q9ePHCYFegq6sr//77L7179+bJkyc6YtvIkSPp3bs3Y8aM0UoldHBwoEgRw9dSGbuyrly5ondcUqlU8ubNG83vSlhYmF7RFuD48ePcuXNHJ31OH1FRUVqeWH379tUrPkskEsaPH6/52Zibm+dKB15GRKFJ5INCEAR8XVpTydadlSG/8Dblvz+IUkHKhMqfU9W+CgCDyn/KJ2V6cSnyCqfC/uVxQtpMaiV7dzYVkE6m9JSzSUv3qefkgZ3Ujnh5vOa+q1H+3IoJopdbT1q7FL437c6WRelQsh0HXh0ydSlGU05enYsrBZLi391sOVWm4OtV9fllajhuzvdzobqCR4rCCgtJMkkKO+ZcrQokciM0li5HW/BFPS8+K79B7G7KCdLyIBOFpgKBWRVQBJu6Cq6k1AOME5pCU0K5FRNUqLtyRfRjb29PYmIi3t7eDB48GFdXV4MXShYWFoSEhODu7g7Aw4cPDa61sbFBJpPh4eHB9OnTcXNzIzFRd3RdEATc3d2JiIjA2dk501pDQkKYNGkSgYGBWl0shkbnMnYfGOL69ets2rRJI9w8fPgQDw8PPvroI0B/0lRiYiJRUVFER0drRBFDGNNJ8sMPP9C9e3emT58OpH2v9+/fr3c/hUKhqRXA3d1d5wK/W7dudOvWjSNHjhiMe1fz7bffZnp/RpYvX46/v78mTW/mzJm0bt3aoNCUkcy6f7p27UqrVq3o3r07kNa9dfHiRdq3b8+ECRM0P4uAgABu3bpFnTp1GD9+PEOGDKFXr14Gz6lQKIiLi9OIQQkJCXprqF27Nq9fv87S42fRokV0796dmjVrolKpuHfvntZYaHr8/PyIjY1l8eLFGoNxfZ1uagylwWXE2Nc3pHUfLViwgM8++wxBENiwYQNFixZFoVDodEGNGzeOHj16EB4ezpw5c9i8eTMLFizQ2VMtOtvZ2XHo0CFGjhypM17n6OiInZ0dcrk8x4IxpI23Tpw4Uef41KlTqVevHl26dEEQBP766y+9tUKamGuMyARpz+3OnTsan7j79+8bFNuqV6/Oo0ePqFixopHPJvuIQpPIB0kFu/LMrfkt6x9vJCT+ES5WJWjv2pbajrW01lmaWeJTvBk+xZvxNOEp/749h4SCKcKUtUl7MyCVSPFybsyx0BNa9ycrk9n6bDvnws8zpPwgKtiVN0GVpqNTyQ78+/YsMbIYg2sEBNq5+mIumHPwtWk62swFc4o+qsvJXfFZL84GMXEpTFvVkVWTo3CyLVwjTzKllE7Hx9KstAJLiZJX8f9dNKQoFHx/Tco/z6ewuNFBytvcM2GlecOTxGosDeqMo6WCopapFLFIpKhlPEUtYiliEUlR87cUNQ/FSpqU9WYqMRks/+MIUrd8Y9x+NS57gu6x0OOi0CSiw44dOzAzM2PJkiUsW7aMqKgodu/erXftt99+i7e3N506dQLSunX0eTlBWsdIamoqS5cuZcaMGTx69EhnTEmNra0t9erVo3PnzlodHBlHtoYPH87o0aN59OgRhw8fZvny5ZQvX97gc1MoFKxYsYKHDx+yfPlyQkJCePr0Ka1aaScM//TTTwb3yMiff/7J+vXruXz5Mr169WL9+vU0atTI4HpjO0mqV6/OnTt3uH8/7UOsqlWrGjRZL1GiBOvWrWPo0KEIgsCmTZsoVqyY3rUdOnTI0pRdTUxMDDNnztT4GPn6+jJ//ny9QppaZFJ/ndnIVna6f9Tx8Gq6devGwoUL+f7777XqV8fHS6VSEhMTsbe3N9iJB2k+PJ6ennz66acIgsDOnTv1GofPnj2bxo0b4+HhkWmanZeXF3fu3OHixTQ7iSZNmhj07FK/3hwdHY0yp1cnmxkyon779i22trbY2NgAcOHCBXbt2kWlSpUYO3asXkFk8+bNTJgwgaVLlwJpPkybNm1CJpOxefNmrbUDBgygYsWK7N+/n8TERDZt2qTp9ktP+q4jMzMz1q1bp1e0NDMzQ6VSoVAoDL6mM5Leu0k9FhgXp5uKPnDgQOrVq8fp06dRqVRMnDhRJ0RAPWLYpEkT+vTpQ9++fbV+tvrS/7777jt8fHyoV68egiAQEBBg8O9XWFgYHh4eeHt7a/39MjTGmRNEM3ARkQxcjbzGioe/ZL0wn9GwSAM+rzQaiSDhacJTvgmaZ3CtgMCwCkNoVrxwGfe8TQln9/M/uByp38DYTmrHl1W+oLhlMY6FneBi+GVCU0LzrL5i0uKE7Xfj8e33Fxlfq7IDP4xdiaWFESLCB8KLxEq0OJS1z4uVVMqX9RMZVG4Dkg9UPwlPLUmfk/14FpuQ5VobcylFrCwoaiWlehE5vqXu08T5BJZmKf8tEpxBFfEeKxZ5Z8w9QBZg6ioAeKmowqyXhiPYDbGwth+lrHMnjUfkw+LNmzcIgoCLS+avq+DgYE2CWrt27TTdTe/C3Llz9R7PeNGqNhRWx4irVCpatWplsLNj7NixyGQyzp07x927d4mOjsbX11evWbKx+Pr6MnToUHr27GmUh0+bNm1o1aqVVifJ8ePH+eeff2jYsKHGPPrq1avUrFkTGxsbdu3axZUrV5g8ebJe76qQkBA+/fRTAgICEAQBDw8Ptm7dqvdnYYwpu5ru3btTunRpRo4cCcC6det49uyZJg5eTc+ePalevTqff/45giDw22+/ERgYyN69e/V+Dy5evEjPnj2pWbMmkGa0/Oeff2o6xtJTp04dfv31V5o0aaJ57OjRowkMDNQy4G7fvj07duxg6dKlnD17FmdnZ+Li4jIVco4cOcKJEydQqVT4+vrSvn17nTUNGzbE09OT+vXra4kiGUWp58+fa0b6zp8/z40bNxg8eLBeAS0mJoYZM2Zw4sSJLAU89fcnMyPqZs2asX79eipXrsyDBw+oX78+AwYM4O7duzRq1EhrpC4nGJtUKJfL+emnn7SEyfHjx+uM4gHMmjWLwMDALP3S1KQPCJBKpVSqVAk/Pz+9SYXp2b9/P3PmzNEyZW/ZsqXB9YIgcPLkSb33vX37lsuXL6NSqfDy8jIo5uZFAqIoNImI6OF10hsuRVzmUuRl3iSHUtSiCJGp+X88xNelNZ+W7YcgCPz95hg7nv1uMDGvU8kO9CljuF33Q+Zh3EO2P/ud0JQwmjh70ahoA2JlsTxPekF4SgSdS3bExaoEu5/v4e/QY3r9vnKbcvJqXFwtISn+/f9J9mnkwJxBywrNqNjlyBZ8eryq0esblXTg+wb7KWdj+jGj3CRBbs+nZ0dx+63up2vGYmtuTosyVrQt/Rif4sewk8aCWRlQPM/FSkWyjeAEZq4g2GsnAUprgfy2wYflNX8m9uJAePbF+9YlWjGovGEDVpHCx82bN+nfvz8vX75EEARKly7N9u3bqV373brfOnbsyJYtWzTjcOHh4QwZMoRDh3I+et+4cWMuX75MkyZN2LFjBy4uLtSoUUOTTpcRtTBRr149zYVn3bp1tbx6IO3C/rvvvtNJGjMmej0rXr16xYQJEzh16hSCIGgi0IsVK8aDBw803+e6dety/fp1Hj16RMeOHenVqxfXr1/n77//Nrh3fHw8KpUqU+PhWrVqaUzZAwICNKbs+rx81AJeVsfCwsKYMGGCVoLbTz/9lGkEfFRUlFHdP2fPnqV///7Y2NggCAIJCQls376devXqsWfPHs3Fu7o7RqVSsX37dqKiogwKPdmhTp063Lx5M8t19evX58KFC0RERODp6Ym3tzdyuVxvN6CxAp6ali1bMmLECC0j6tWrV2sE1Zo1a2p8pPz8/AgODmbz5s0kJSXRqFEjnfE1NcZ2thmbVDhhwgRCQkIYMWKE5nlVqFBBqyMt/XPKSGYiT1ZcvnyZoUOH8uzZM/r166cx7n758iV+fn56Db6zS0BAAHfu3KF///5ER0eTlJSU6UilXC7XK7LlBuLonIiIHkpau9LDrRvdS3clIjWCP1/u51z4BVOXlSXHQk9Q1KIoHUu2p52rL84Wzqx+tIZUZarOWplSvxFmYaCSfSVm15iBQqVAKvnvz2BDtD9xaFS0IZcjrxCRGvneajEXzHHWjMrlje7/79VYfin6OeO6Ls+T85maV0nZ66C4+jqWzkd9mVK/KbUcQ4iR2RMrsyNObk2f0r8bN1KWz5AppYy7Mprbb2PfaZ8EmYzDj2QcflQMC8mnNCltR99KL2lTfHsuVSqSbcwqgioO5P8/9imtC/L7gASUedeRaQxOZkl8UtwZe7MkHIRELIUk/k2sxMXoVwY/FAE4F36ej916YCu1ycNqRfIzw4cP59tvv9Wkrv3xxx8MHTpUb9dPdjySXr16peW5VKxYMV69emWwjr179+pcBGccnfPx8SEyMpJx48bRsGFDLC0tM/XlyejHolAo9Pry9OnTh0GDBjF06NAsR3vCw8OZN2+eTq2GRKlSpUrxxx9/6L0vvZhnZmaGmZkZR44cYcyYMUyePJl69epprTcUBa8m48gQZM+UvWzZsoSHh2s6N8LDw7U6S9RIJBJ27typdSwzc2uAIkWKGOxeSU+zZs0ICQnh/v37qFQqqlWrhoWFBaDdIbJw4UJmzZqFIAia9DI/Pz9mzZqltV/v3r0zHevLON7UtGlTbt26ZZTQamVlxeHDhxk1ahSzZs3Say4Oab836UWln3/+OdP9szKiTt9Jd/HiRT755BMgbZzQkGeaoc629EJTdpIKAU6fPk1AQIBmVK9z587Ur19f7/mz4yelRm30nV78LVs2zUd30qRJjBs3jpYtW7J7924aN25M9+7dOXnypGasMiO//fYbvXr1omjRogBERESwd+9ejVCWnl9//ZVffvmF+Ph4+vfvT0REBCNGjNArjKnFqIiICJ4/f46/vz+7du0ymFyZE0ShSUQkEwRBoJhlMdys3bCQWOgVbPIbvz/fTRGLIng5N6Zh0foUsZjKD8E/EyfX7mJQqAqv0ARpP1upkPmfwIp2FZhX81t+fbSGWzG53xXgbFaM8ENlOX8zAcjbWa1df6fQuIYvjSplPXdf0Hmd5JTtxyTJ5fhdsQCqax1/VnMks2oa74uRH1CpYEbgRM6+eDeRKSOpSiWnn8dy+rk90xqOYESFNWTyvljkfWBeH2S3gHSJmvJAMCsLkqL5ZmROTUtLXe+7Kg7X6GhbhR0x9QiK139Bn6JM4Wz4Odq7tn3fJYoUEJRKpUZkAujVq5fBC6TseCQplUqtT/hTU1NJSUnRu3bSpEmEhITg7+9Pv3792L17N76+vjrr1MJT//79adasGTExMdSqVUtnnZo6deqwbds2VCoVT548YeHChXqTyczNzZk6darBfdIzdOhQmjZtytGjR1m6dCmrV6/WEYRAO3peHxlFl5SUFN68ecOhQ4f4/vvvgTRhLD1qbyx9CIKgt7PLGFP2adOmAWmmznXr1tWkwR0+fFiTlpeetm3b6nS36DvWunVrTpw4oePhpFKpEATBoIm7VCrF2dkZuVzOmzdpCZ9qgUHN3r17dUQlfcf0JdtlxqVLl1i/fj1Vq1bVEiozCokpKSmkpKRw7NgxJk2alOmexgp4arIyoraysuLmzZu4urpy9uxZrTS3pCT9H+Bt2bJF09m2Z88eTWdberKTVAhpP0elUqmpTaVSGUx8g7QkxfRjdj169DC4duPGjUyYMAFzc3PN/ulfM0lJSYwZMwZI89VatWoVv/zyS6ZC8apVqzRdZQDOzs6sXLlSr9C0evVqLl26pBnhdHd3N/h6/fzzz1mxYgXjx48H0rq/Bg8eLApNIiJ5TYeS7WhYtD6bnmx9L4JDbrPm0ToczR2o4VAdd7uKzK7xNTNvfYtM9d/FiKyQC03GYmdux+QqEzn46jB/vtyf6afu2aGcvBqXVpmRGGe67piQV2VpVCnrdQWdV4k2gG5qUE7YGJRM65Kt8Sp6IuvF+YRl9z/nzwe5ay6fkcXXJIQlTWBGjZ8/WH+r/IUUzOuCzF//3Ypnaf8VEEqbBdPPUWBWvOERluOhJ2nr0qbQpaaK6KdOnTqcPXtWY/Z77tw5jWlzRmJiYvjkk0/w8/Ojdu3arF69mlatWjFjxgydte3bt6dv376ai/Aff/zRoFBy4sQJAgMDqVevHkuXLmXatGl6E8wOHjxIs2bNcHJyokyZMpq0K0NiwrJly5gyZQqvX7+mcePGdO3aVadLSl3r0aNH9Xr2ZOTZs2ccOHCAbdu20aVLF9q1a6c31S0znxxBEHSEpi+++IJq1arRunVr6tevT0hIiM542ePHj7OsLyPGmLLb2toCaR1R6buiMl6Ay+VyUlNTUSqVJCUlaUSFmJgYvYmCW7duBdI6ZYwlK4Hh2LFj/PPPP7x69UojkKlr0EdGn5ysxpuMTXzr168frq6uVKlShSZNmvD69WuNOXdGDAl46vozviazMqL+/vvvadWqFfHx8YwZM0ZjNn/06FGNj1NGjOlsy05SIaR5tLVr145hw4YhCAIbN240+Lh58+axb98+zUjbd999R1BQkI4wqGb+/PlcuXLF4PPJaHhesmTJLLsR9YlghtIPLSwsdDqjDL1u4uLi8Pb+z6tXEASDnWU5RRSaRESMpLhlcaZUmcSVyKtse7aDGFnudgfkJgqVgp8frGRG9emUsXbjyJt/tEQmAJlSZuDRIhmRCBK6le6Cu11Ffg35jTh5zi/azQVznB/X5eTv8YBpPZJevn03T4CCgEoFV9/k7oXpuLM1GF27Ap+W3YmN9P0KOO/K5qeD+eVm3ojKG4NSeJv0JYvrLdc2DBfJXYSiIHE2LDIVUEpJ7lPEvBJRBv5tfZvylkcJj6lk9+4mziIFn+vXr7Np0yYqVUr7tOThw4d4eHhojJrTd3KoL57s7e15+vQpLi4uPH36VO++3333HQsWLGDy5MlAWmz99OnT9a61srJCIpEgCAIymQwXFxe9CWKzZ8/WmEEDODk5MXv2bL1Ck0KhYP78+axevZrVq1dn+j1o3bo13bp1w8zMDEtLy0w7btRjXJaWlkRGRuLk5KQxbU5PdkeFhg8friWuVahQQWO6rg+FQsHTp0+1xvf0jc6pO75sbW1Zs2aN3r30JYXp47vvvmPu3LkIgqARpyCt42XKlCk669V+Nvb29ppxJTUhISF6z5GVwGBhYYGdnZ1ODSVLluTrr782WLux403qxLesmDVrFuPGjcPBwQFBELC3tzc4IpmVgJeR9u3bc+fOHYNG1M2bNyc0NJS4uDgtMbJZs2Zagkd6jOlsU9OhQwcuX75MSEiI1thaRt+jxYsXs3r1avbu3YtKpaJHjx5aHUPp+eOPP7h06ZJGjBsxYgReXl4GhabixYsbfA1AWpdXejP5jLf1jbKWLFmSPXv28PHHHwNpHVaurq4Gzx8cHKzpxNuyZYtWemR6pFIpMplMs/bFixd6k//eBdEMXEQkByTIE9j9fA+n3v5r6lIyxUwwo5xNWR4l6H6aJCBQr4gH7V3bUsWucqaz4CL/EZESycqHvxCSoN/EMzPUo3KPbuYPj5+GtRxZNubdUj7yO9ejvenzT833sndRK0uG10ri07I7sZUaZ7CdorAiWWmDo/n78/1Sc/RNd8afcckj56//8CrlwCrPNdhLo/P4zIUAsyqgDAfV+3/9mIL1sX05G2046ntKlUnUcXo3s2eRD4N//838/Vf6C+9p06bx1VdfcfToUSZOnKjxSDK2C8QQrVq14tChQ0ybNo3IyEhcXV05f/48ly9f1lqXPnVMjT5zbzUtW7Y0SvCpVKkS33//vU7SWLly5XTWDhw4kJ9++oktW7awcuVKHB0dcXd31/EsSk9oaChBQUFaopA+vyJjzZqPHDnC8OHDiYiIwNbWlujoaMqWLau340mddpeR9evX6xx7+fIln3/+uUaICQgI4PTp0zqjYWPGjOGXX4xPla5YsSLbtm3Dy8sLSPNF+vLLL3n2TLdb1NPTk0uXLmW5Z2BgoEFPJH20bNmS+fPnM378eG7cuIFKpaJ27doa4+zp06ezaNEig55Oai+nx48fU6FCBYN+WfrEvvzA7du3qVChAomJicyYMYOoqChmzZqFh4eHztqxY8dy9OhRPDw8NL8PgiDo+FllB2ON5tXi14oVK7CxsaF///5aI4xqoSo7f7fU3Lt3j27dumlGUi0sLNi/fz+VK1fWWfvw4UP69+9PUFAQxYsXx8bGhoMHD+pNdty6dSs7d+7k5s2bDB06lM2bN7NgwQL69u2baY3ZQRSaRETegeC4B2x4splXSYaNIgsCFWwr8EmZXlR3MKzCi/xHVGoUkwOmocxGR1I5RTUurTYjMS7/JL25Frdh15wfTV3Ge2VG4Bfsup87Y3OGKGplydCaSQwo93taCpse3qaUYtvTbmy/b0EpO3OWNPqbyna39K7NDa5GNWfwyVqkKt5/YqI+qjvbs857JyUsdT8xF8kh5g3/33Ppwx17vpjalt/eGBbirSRWfF5ptCg2ieSY58+fZ+qRZKxoAWlCjJOTE0qlkmXLlhEVFcWECRN0fHmaN2/OkiVLNKN9ly5d4ssvv+TcuXN6a1i2bBkymYzPPvtMK1I944iTOs0uu5w7d47o6Gg6dOhgcGxn48aNzJ07l4iICCpXrkxgYCCenp46NRsya/7zzz919qxfvz5//vkn3bt358aNG2zdupVbt27p9YRZuXKl5uvk5GT27NlDvXr1tI6r6dy5M3379mXJkiUEBgYil8upV6+ejhgAaT/fc+fOIQgC3t7elCpVyuD36eLFiwwcOJARI0bw7NkzLl68yK5duzRddOlZvHhxpgJDeowxkFfTsGFDrl27ppVAmP7rgwcP0qVLlyyj6jt37syhQ4f0eixl9MnavXs3vXv31jLWTo8+ERHSRuAmTZrEo0ePUCgUmg67jJ5dOcGYZLTKlStz69YtHTP9jOgT5RwdHfHy8mLIkCFaXT3Dhg1DJpMxevRoBEHQdNdlFDzVnY3pZRX17dz4HigUCu7fvw9A1apVMx23UyqVGlP6qlWrsm/fPk03VEYuXLjA/v37UalUdOnSRTOKnFuIQpOIyDsiV8o58uZv9r88UKB9j8ZX+pyGRfWnLojosvzBKq5FZT26IhWkFH9Sl3M7897wOysEAY79sAkL8w9zzClRbkeTg0OIl+XNmGiR/xecBqYTnIJiG7IxxIdDIYnI0s3USwSBT6paM7HaTopZvNYclymlPEyow62YatiaJdOp5N5s1xEcX4e+J3yITTFteIGbvQ0bmh+lgu1dk9ZR8JGCeR2QXc96aQEmVFmBH97WJjQlKtN1EiSMr/w59Yt45E1hIvmS8PBw5s6dq5Mkp2/05MKFCxpzXDXqi+mMZEe0uHfvXqZjMmouXrxIz549qVkzrbv27t27/Pnnn1ojM+lJf6Gb2cXq999/j5OTE3369MlS3MguderU4d9//6VVq1bcuHGDM2fOsHnzZtauXau1rlatWhqz5oCAAI1Z8++//66zZ4MGDfD399fqCGnevDlnzpzJsp7ExER69eql16w8KzFGzf79+xk2bJhmTOvChQusW7eOLl26GDzvtWvX8PLyokSJEgQFBen4T6kx9mdmyEB+3bp1evf19PTk7NmzNG7cmOvXr/PixQu6deuGv//7G53+9ttvmTt3Lp999pnOfYIg6O0qA6hSpQrLly/Hy8tLSwhJPyqYXYKCgvj000+NSkYz9rX0+eefc/36dfr16wfA77//ToMGDQgODqZKlSr8/PPPmrUJCQnMmzePEydOoFKp8PX1Zfbs2e/0nHLC/v37uXfvHtOnT+fVq1dEREQYlTAIaabu+rrw8gLRo0lE5B2RSqR0KdWJj4o2ZOOTLdyJLXgXVQ5SBzyc6pi6jAJFqxItshSanM2KEXGoDOduJpLfRCZI8y96HV2JcsWDTF3Ke+Hv0E55JjIBRCWnsNRfwrrbQ+hbVcGNtzZcfh0L6Po4KVUqdtxL5EDIx3xaDRLlUm5HmHMnIkHThSQRHCja+j/j8RSFZZbeR6+TyzL0TGtiU95vF5cxvIhL5JMTvvzm44SH40VTl1MwEYqDxOGDF5meKWryv9AyxMkzF5kAlCgJT8k8klzkw0edovb3339nmqIGaR4to0aNYurUqchkMiZOnMjly5f1Ck1v3rxhwIABLF26FEjzMTHUSdG+fXsqV67MuHHj6Nq1q0ELAi8vL+7cucPFi2l/B5s0aWJQsFAqlVy4cAFPT8+svgUaM/OxY8caFDcyJqepySpBzdzcnCJFimi8bpo3b85XX32ls84Ys+b0ewK4ublx8OBBypUrp9cnSh/W1tYG95VKpVqdJFFRUXrNkufOnculS5c0HUkhISH07t3boNC0Z88eJk+ezObNm/H398fHx4ddu3ZRtWpVnbWGzJkzYqyBvJpx48bRo0cPwsPDmTNnjma8SU16Y3F9qDulDPkaqUkvTs6dOxeADRs2ZPl80uPg4EC7du2y9ZisGDdunNHJaE2aNKFPnz707dtXS3jNOO558+ZNTp8+jaWlJQAjR46kS5cuHD58WGckz9bWNkcpbGoDejXvIv7OmTNH4z01ffp0BEFg9OjRnD9/3qjHZ+wpatSoUaZ2KfrE+pwiCk0iIrmEi5UL06pO4deQNVyKzH4rsynxLtYEqUT8c5AdSlsbbreG/x+VW2VGYlxyputMzYvw8h+s0PTHo7JA3pv2R6ek8OtNjDp3gkzGb7cgLZ5ee2RIqVIx8VxNWpWty5U3EJmcytImj2ldQjciHiBWVoRh5/rwJt44v6i8IDI5hYEn6rO8mRMtih8xdTkFC7NqoHwDCv3msx8S9kIkMmVJo9fbSvP202SR/IexKWqQduE0ZMgQTp06RVhYGB999BEXLlzQu9ZY0QLg0aNH/Pnnn/z0009MmjSJMWPGMGzYMJydnbXWqbun0l/wLlmyhKlTp+rsKZFImDBhglEXe8aIG9lJTkuP2lxc3aVSrlw5wsN1Bd7smDVPnDiRqKgo/Pz86Nu3L9HR0QZ9stILKAqFgmvXrhn0EerduzejR48mLi6OjRs3smrVKoYNG6azTqFQaI29ubu7Z/o9nD9/PsePH6dy5cr069ePQ4cO0a5dO4OCF2QtMBhrIK9mwIABVKxYkf3795OYmMimTZu0xpuM7axRG5HrG2TKKE7q6xpLjz6fLoBOnTplmqaoJjk5mVWrVumMD+rzUspOMpp6jHT58uVa6zPWGxYWpjHHhzQB9MWLF1hYWGjEp82bN2f6HDIajKu5cuUKw4YN4+7du1rf63cZndu3bx/+/v40bNgQSDMHj4sz/n1eRlHpf//7HwCHDh0iODiYoUOHAmnjstnxDzMG8cpSRCQXEQSByvaVuBJ5NVv+PaYmOP4hCfIE8c17NkhU6H8jlTYq58HJnaZPlTOGl+Eupi4h17kV05iNId7/301UsIlMTuGP4P+6mEaddmNivdF8XulXJOneO6QorBh9aTjBkfnvOSfJ5Yw6XY4FXn352M2w8axIOswb/X8Xk2k8tvKaIpLXdC/WmJ1hxo3xrn20nv0vD+Bi5YKLVQlcrFxwtXShin1lLM0s33O1IvkBY1PUAIoWLcqgQYMYPnw4dnZ2TJgwQXNBmRFjRQtIE4U+/vhjPv74Y65evcrHH3/MnDlz+PTTT5k7d67G/2fRokWcOnWKH3/8kYSEBAYOHAigV2gCqF69Oo8ePaJixYpGfS8yEzf0GYOradq0qcGuCD8/P2JjY1m8eDGjR48mOjpar2fPqlWrSE1NZenSpcyYMYNHjx5pRdqnRz2q1KBBAx48eJDpc0ovoEilUsaMGWPQZ2bKlCns2LGD6Oho/vrrLyZMmMCAAQN01pUoUYJ169YxdOhQBEFg06ZNWqloGbl06ZJWZ0znzp0NXogbKzDY29uTmJiIt7c3gwcPxtXV1aBwolAo8PDw4NatWzqjn2qMTd4ztuMK0kRQQ+gTbtSsWrWKiIgI7OzssLKyMtg1N2LECOzt7Tlz5gxTpkxh48aNNG/eXO+e2UlGMzYx0cfHh06dOjFw4EAEQWDr1q14e3sTHx+v+btw8OBBvc/92rVrPH361KDQNGHCBNauXcvo0aM5c+YMP//8M9bW1nrXGpvAaGVllaknE2DQT0ulUpGQkKB1TG04PmfOHE6ePKn53nbu3Jk2bdpkep7sIno0iYi8B4LjHrDq4WqiZFmPAeQXyli78WXVL3CycDJ1KQWCh3EPmX93IRIk1CvigX/Udc2oXMjN/N3FlJ4erW34ouePpi4jR4SmlGHviw44mSfhaBFPisKCnSFl8X+T/8SW3Ma3vD1L6v+GnTQWhVLCJP/JHHmcfzqZDLG5dQhNnA1HX4vw/6bfOetCKMjIVVLmvu3Ci+Scj8XVdazN2EqjCU0O5WXSa4paFKGag+6Yi0jBJzspahMmTOD8+fPs2rWLu3fvMm7cOPz8/PSKEQA7duxg3759qFQqunbtanAdpI1frVq1il27dtG5c2dGjBjB8ePH2bp1Kzdv3gQgNTWVyZMnc/78eWJjYxk1alSmI08dOnTg/PnzeHt7a5mBZ+z4eNfuiTJlyvD8+XOj1uYWxsTPvy9CQkL49NNPCQgIQBAEPDw82LZtm0FBLzvG8J6envz00086AsPkyZO11oWGhlKkSBEUCkWmBvJqOnTowN69ew2KFWri4uKYMWMGx48fRxAEfH198fPzw97eXu/63BztUvP06VO9xzOKnWqPrjp16nDz5k3i4uLo1asXf//9t85js5OMplAoWLFiBQ8fPmT58uWEhITw9OlTWrVqpbVOJpPx66+/cvr0aVQqFS1btmT06NEGBT+A+/fv8/XXX3Pjxg3mz59v8G+CPh+yFi1acPr0aa112Ulg/OSTTxg/fjwTJkzg2rVrLFiwgLt377Jt2zbNGn1+WunRNwZZuXJlbt68qXltJSYmUrdu3SxF4OwgCk0iIu+JOFkcqx+t5VbMbVOXYjTFLYuzsPZ8zCWG/9iKpHEn9i4Xwy7TqkgbKji78dPljRz+NZLE2PzfxZSeRrUdWTra8KdX+Rm50gzvw+MITyo4wl5u4mprTaUi5sgUFJjuLZ8yDqzzKpivtzzDrOr/j8sV3HCJnBKtdCUFa+yFcE4m+7Ln7dt32s9MMGNUxRE0dm6USxWK5EeySlEbOXIky5cv13QrPHv2jH79+unt5jl69Cjt27fP8hikeTQFBwczduxYhg8fruW7VKtWLU0EPcDSpUv5+eefUSqVbNmyhRYtWhh8PlkliKkxVtwwhD6TYGM9f9S8ePGCUaNGcerUKQRBoFWrVqxatYoyZcroPHbMmDH8/fffmcbPZ5Z4JggCzs7OdOrUSavj6bPPPtPrOZPetDoyMpInT55QuXJlzQiZIRFGTXaM4Y0VGJKTk7G0tNTUq1QqSU1NNZiUNnHiRM6fP0+fPn20RMeMyW8DBw7ExsaGMWPGAPDbb78RFxen012WHXHSkLG2oe4jgKSkJG7evIkgCNSuXVuvQPbRRx9x5coV6tevz7lz57CxsdH5fUmPscloY8eORSaTce7cOe7evUt0dDS+vr5cvXrVYL1Z8ebNG7755hsOHTrEtGnTGDt2rNbYXUbUSZAtWrTgxx9/xM3NjUaNGukISNlJYAwNDWXw4MGcPHkSiURCs2bN2LZtGyVKlMjx8wKYNWsWhw4d4pNPPgHQiOXz589/p33TI47OiYi8J+zN7ZlcZSKRqZHIVQrkShlylYIrkVc5/Dp/epW8TXlLoiIRR4mjqUvJ91S3r8adc0kM3vA7fTo3oGLp+iTG/mPqsrLNi9CCezErlSjoUlHFhg/TYipL3iQk8SbBcBR8fuTf57GE1KmJu20h/aEZg+I+mDcA2ftLFcqvOEneaL7ubL0XebFe7A8PzfF+CpWCX0JWk6RIokUJwxdHIgWb9B4u+vjtt9+0bpctW9bgRfSMGTN0RCV9xwCGDx9Oz5499Y7ypL9o7tatG3K5nBs3bvDkyRP69+/PgAEDmDVrlt4a1IJSVpHuMpmMxo0bI5fLsbe3Z+bMmbRo0cJooUkfagHn4cOHnDlzhp49ewLw559/0rZtW531AwcOpGPHjmzfvh2VSsXatWsZNGiQ3jGm48ePc+fOnUzj52/fvk3v3r0NigNhYWGsXLmSf//9V3NM7V0DaULOnj17tIzh//jjDwYPHoydnR2pqakcOHDAqBj37BjDq4UzZ2dnAgICcHNz09vh06pVK44cOYKjY9r77Li4ODp16sS5c+f07hsbG0vt2rW5e/e/oCF9otrNmzcJDAzU3F61apXeMb/sjHZNmTJF83VycjL379+nVq1aXL+uP5ziwoUL9OrVCxcXF1QqFW/fvuWPP/7Ay8tLa13RokWJioqiY8eOdOjQAWdnZ0qW1O/Rt379eoYOHao1Oqg+pu/8AQEBmp+9k5OTVtdW+ueSlUdUXFwcCxcuZO3atYwcOZJ79+7h4OCgt8b09O3bl4iICGbMmEHz5s2Ry+XMmzdPZ50gCJQrV07T2TdgwACDAp6LiwtHjx4lMTERpVKpJTi+C35+fjRu3FjT2eXn50enTp1yZW81otAkIvIekQgSillqz38LwMP4EO7HBVPJrhJlbNw4HfYvKvJHc2GyIhlHc1FoyoyExBRevInm8MnbKJUqTl64z55fR1KyhCPL1pzg2atIU5doNKHhicjkFphLdf8xLgh0K3OJDUH6k4ZE8ie7nrbm6xqi0JQpMv//92nK+SexHwLdrP/AxbUtsUobUpRm/BmuPyErM1So2PBkE0mKJDqUzN1EJJG8p3Xr1pw4cUInTS2rFLW9e/fqXFim7855+PAhwcHBxMbGapkhx8TEGDS37tWrFwqFgkePHmXqs9K4cWNNQlzRokW5cuVKpkljd+7coX///llGuqtFj8zEjcxS56Kjo3WOqz1/OnTowPXr1zXG5rNnz9Z4S6UnOjpay2vqyy+/1BrpSU/JkiUzFZnAuMQzX19frduff/651u0xY8bQq1cvzW0/Pz/Onz+Ph4cHx48fZ86cOZw4cSLTOiB7xvD9+vUzSmBITEzUiEwAjo6OOh466TE2+U2hUBAXF6fp0oqPj9dba3bEyYxi35UrVwx22wFMnjyZ3bt307RpUyBN+Pniiy+4dOmS1rrDhw9jZmbG/Pnz2bZtG9HR0QbHJ1esWKEjKuk7Bui8thQKhd7vgTEeURUrVsTBwYEFCxZQqlQpHSHQkE/VF198AUDbtm2JiIggOTlZb+dcdhMY//jjD62xSLUA/K507NiR2rVrU758+VzZLyOi0CQikseUsy3HjOrTiU6N1vghNXH25Mfgn0kwYDCdlyQpCucYUnZYv+sCDWqX5cHjtDe0DeuU0/y/WFHbAiU0KZUq3kRXokyxO6YuJUfUtL+Cu1MzQqLjTV2KiJGUssn/XlL5Atk1kNYAecH83cwNBAG8LP7rFL1m3ZPnSTkbp9v5fBeJikR6lO7Gi6SXPIh7gLudO+VtDZsli+Q/tm7dCmQvTW3SpEmEhITg7+9Pv3792L17t45Ycf78eTZu3EhoaKiWGbKDg4OmoyUjxvqsqEWm9HvqS9hS8/nnnxsV6W5M90ROU+eeP3+ulZ5XtGhRvR067u7uPHz4UJPm9vDhQ2rWrKl3T2Pj59Vcv35dRxwcO3Ysx44dy7R2a2trrWQ4tR8TQJs2bQyasGdEnzG8PoFDqVTSpEkTnJ2dsxQYlEolCQkJms6xuLg4ZDKZwRrkcjk//fSTlsgwfvx4nc6qQYMG4enpyaeffoogCOzcuVNn1BKM77zSx0cffcTEiRMN3p+cnKwRmSDt553+Z5exBkEQDHodXbt2jcuXLxMeHq41RhkTE6O3SwmgTp06bNu2DZVKxZMnT1i4cKHeLqGAgACNR9T48eMZMmSIljAJULNmTQRB0CuaZmaIbuy4YXYTGE+dOqX5Xi1atIgrV67w/fff611vLGfPnqVfv35IJBKePXvG1atX+fnnnw2a+ecEUWgSETER6U23q9hXpoZjDa5Gmt4A9nnic/GNdyY8ehbOifP3USj++5Tkr5O3iY1LYsqINty698qE1eWMF+HlCqzQJAjQrWI8y/R3covkQ7yLZx3bLQKgAvkzkJQGpeH468KEh60Zz99hWvTAq0McffMPqcr/LlQaF21ET7ceuFq5IFfKkQgSJIL+VCMR06MescksTS0jJ06cIDAwkHr16rF06VKmTZum01E0ePBgBg8ezLp16wymzGVk5syZXLhwQcdnJSPZiXMH4yPdjeme0Pd9CgoKMigGqalevTrDhw/XfC82bNhAtWrVNPf37t0bQRCIjY2lbt26mnrPnz+vSbXKiLHx85B2Mf3777/z7NkzfHx8OHbsGK1bt9bxJgJtXymFQsG1a9e0uspUKhVJSUma7qSMtw0ZYadPszty5AgTJ07k008/1VknkUgYP348V66k/dtmbm5u0Fj6008/pW3bthovpV9++UWvIKRm8uTJhISEMGrUKADWrVvH48eP+fnnn4G00brIyEimTZtG7dq1OXHiBCqVilGjRukVcYztvIK0zjo1CoWCy5cvExdn+IMiGxsbjh8/rkkuO336tNb3duDAgWzZsoVGjRrp7bJTf/8gzYj92rVrJCQkaHVWOTg4sHHjRr3nX7ZsGVOmTOH169c0btyYrl276vU8Uo8KSqVSEhMTsbe35+VL7X9jM3prGYux44bZSWDcv38/AQEBmrpHjhyJh4dHpkJTaGgogiBk6uM0bdo0/v33X43I1qhRI4NjkTlFFJpERPIJFW0r5Auhae/LfXxUtJEYEa0HlUrFj+tO4ObqxD9n7mrdd+5qCDeCniOTF7w48lM3quNoG0Ul1xtYmBsXL56f6FrqOMuu524kq8j7oaSdDRVtxLE544kHHEGwA5XYtVfX8iEHeTd/ivQiE8DlyKtcjfTH07kxD+NDqGTnzvCKn2EmZB4nLWJarl+/zowZM3j06JFWgtmjR4901lpZWSGRSBAEAZlMhouLi86FpZphw4YRGhpKUFCQliikTwwx1mclO3HuYHyk+2+//UavXr0oWrQo5ubmxMbGsmbNGkaMGGFwb0i74M/qgnLdunXMmzePcePGoVKpaN26Nf/73/8093fu3FnzdXrxpX///gb3NDZ+HmDLli1cu3YNT09P9uzZw/379/nmm2901t2+fZsjR47g4eFBpUqVkEqljBkzho8//liz5ubNm9jZ2WmNwalvC4KgY4Sd0RBdnQgXGBhIYGCgjiE6pAlzjx49Mphgp2b69Om4urpy4MABIG3ML7NUw9OnTxMQEKD5+Xfu3Jn69etr1err60v58uXp0KEDHTp0ANK+f1999ZWmG0gtGrVr147Q0FDc3Nw0Zvi2trakpKRozPLVpPfrkUqlVKpUKdPRuZ9//pmPP/5YY3aekpLCnj17NPer0/rSv44M0a1bNzp37sy2bduMTiW0s7Nj9erVrF69OtN12fGIyi7ZGTc0NoGxVKlSWj8bCwsLSpUqpXfPu3fv0qdPH80YXpkyZdi1a5eWSKxGLpfj7u6udSwzo/OcIApNIiL5hIq2FUxdAgCRqVH89fooPdy6mbqUfMfJC/e5fvs5JUs4Ehuv2w6ckFgwfY6Onovn6Lk6SKUeVCxjR7XyCqqWDaOq230qugQgNcvfhuFuNiE0KtmTqwUkea0w06yUgJ4PMkUyQ/kSpDVBfhcoWKmWuU0FyQ3spe2Jkxv2NMkJSpRciLgIQFhKGMnKZMa6jxITWPMxgwcPZty4cXh5eelNmkuPvb09iYmJNG3alMGDB+Pq6mqw42TTpk3MmTOHiIgIKleuTGBgIJ6ennqFJmN9VowZ1UnPuHHj6NGjB+Hh4cyZM0cT6Z6RVatWMXLkSM1tZ2dnVq5cmaXQZEzguIODQ6aCQGZdOBl5/PgxFSpU0OqQSU9GTytIEwetrKxQKpWoVCqqVq2qNQ4Hac9/5syZVKlShQMHDrBhwwa93jWGfJUM8b///Y9GjRrRvn17vQKfPsLCwvDw8MDb21vLrFlf15q6e84YVCoVSqVSU4dKpdL6+Z05c4Zff/1V53EDBw7U6ubRZ/KsFjJlMhnx8fEsXbpUazQw4whoVjRs2JCHDx9y//59/vzzTzw8PGjQoIHmfvXXhjreMmJmZsbq1auzFJrOnz9P06ZNtbzV0pPxdze9R9T27duJiooyWszKLobGDQ0lMOqrw8PDg44dO2peM1u2bNF6vumf39ixY/n66681gu/OnTsZM2aMXpHXysqK+Ph4zesgKCgoSw+17CIKTSIi+YTytuUQEPKFKfjh10doXtwbZ0vnrBcXEhKTUlm5KS3l5HVYjImreT/I5UqCH8cS/BjAFqiPhXkj3MvaUq28nKplQ6la5i7lit1Capa/OrfqOKdw9bWpqxDJiqauxnlBiGRAHgTS2qCKA8UTU1djMiQC1LVz4lx07gpNGbkedYMJN77A2cKZ+bXmoEIljtPlM8zMzDTjRFmxc+dOoqKi+Oqrr9i8eTPR0dHs3r1b79qlS5dy/fp1WrVqhb+/P2fOnGHz5s161+rzWfnpp5901hkzqpOeAQMGULFiRfbv309iYiKbNm3Sm5KmTzAyRlTJrJtq9+7d9O7dW8sXJz0ZR9eMGQscN24chw8f1hI7BEHQdBTp60KzsbFBJpPh4eHB9OnTcXNz0zFlX7VqFbdu3cLNzY1bt24xZsyYXDFJPn78OBs2bGD79u306dOHoUOH6nR+ZKRv37707ds3y70/++wzvWNj69ev17u+Xbt2tGvXjmHDhiEIAhs3btRKQMxMZE1/nqxEo9evX9OqVSsdDyqFQsHTp08zNbv39fVlyZIleHh48PbtW5o3b07jxo3Zvn07d+7cYfr06Vrrnzx5wqJFi3S6eU6ePKlTV8OGDbl48aJOcl16Nm7cSNOmTbW81dRkHM1UKBS0b9+eY8eOIQiC3lHId8HYcUNjEhjVBAQEANrpmefPn+f8+fM6zy8qKkqrq7Bv3756xwchzeC/Xbt2vHr1iiFDhnD06FGNB15uIQpNIiL5BCszK0pbl+ZFkuHUgbxCppLxx4u9jHLP/FOxwsTmPZcIiyh8JsapMgV3Q2K5GwJgD3yElWUTKpe3oVr5FMZ0+sXkHU/RqcXYFWx6gVYkcwSgSVH9RpkiRiD/f+8Xs2qAAhSZ+zp8qNS1eov+IPDcJVGRRGLSC9Y/2cTd2LvMqTkbO2nuxEqLvDtNmzblxo0bWjH2+li7di3z5s3jxYsXCIKAm5sbM2fO1IxDZcTc3JwiRYpoLoCbN2/OV199pbVGbfhbunRpjSfT2rVrAf3R8zkZ1WnSpIlWpLs+SpYsyZ49ezRjYnv27MHV1VXv2rNnz9K0aVMkEolGDLt+/brWGBakjaL17t1bZwTI0HMzZizw0KFDwH9iR0hICAcOHKBSpUp06dJFb72rVq0iNTWVpUuXakYkM5oUm5ub4+bmBkDt2rUzTW/LDq1ataJVq1bExsayY8cOPv30U6ytrfn+++9p3Lix3scY26HUsGFDzdfJycns2bMn09fw4sWL+e2339i7dy8APXv21Opik8vlxMbG4uDgoPW4mJiYTE3GM1KyZEmtfcF4s/uXL19qzNa3b9+Oj48Pf/75J1FRUfj4+OgITX369KF169aMGzcuy27EM2fOsHLlSqpUqaLVKZbez2nNmjWAcaOZZmZmqFQqFApFlufOCcaOGxqTwKgmOyOnZmZm3LlzRyMG3r9/32BXXtu2balcuTJHjx5FpVIxa9Ysjal/biEKTSIi+YgOrm1JUiSz68UfOj4SeU1Wn94qVcpC8wnvs1eR7Dxoev+s/EJyipxb92O5dR88KnWgWY2DJqtFqYKfgz8lLlVMS8zv1CruQBGLnCWGiaRDcQ+EIiA4gKrwjYvWNL9CNdsOlLYUKG2eQDFJNIdiSxKc8Oa9nO/M27PYS+059/Y8LUr4YGWWu6MFItlDbSQsk8lYu3YtVatW1bpgS38BunHjRpYtW8bq1as1HREXLlzgyy+/xNzcnM8++0xnf0tLS1QqFVWqVGH58uWUK1eO8PBwrTXpDX/VCILAq1eveP36tY7nT3bi3AFatmypV9TJ2PHxww8/0L17d82FvIWFBfv37ze4Z9u2bdm9e7cm8Wz48OE6Xk2NGzfmr7/+onfv3gbrS48xY4Ft27bVdLy8evWKRo0a0bhxY3777Te9HS8AtWrVAtL8g9RCQkZSUlK4e/euprMr4219I3nZwcHBga5duxIZGcnPP//MvXv3DApN+tLoQLdT6fPPP9e6PWbMGL1jlBl9oipUSLPXCAkJYfr06RqfqH79+jFw4EA2btxIkSJFgLSulmHDhhnVYZUetbm8GmPN7tP//l24cEHTYVOkSBGddDxIE9gWLlxoVE2GktjSY2gkU03G14Gnpyfdu3dn4MCBWuKVvvHY7Br5GztumN0ExocPH+r40elb+9133+Hj40O9evUQBIGAgAAdgbZ79+7s27cPgKNHj2qM6d8HotAkIpKP8C6eFgta1rYMy+7/SLLSdMbMtRx0E0mUKiUP40O4EnmV54kv+Lr6ND2P/LBIMwA/iVxeuL1RDHHofFWTCE1KFRwN7cnyWxV5EFX4Os0KIiWsTV3BB4QqCswbgqzwCeDWQhzTnbXf5FcpYs0KSVdux/2X+ikg0LxIKQQgXgnxciXxChnxihTi5UnIVcZ3YsbJ49jxfBcHXh2iRYkW2JpZEyOLJVae9renf9m+HA89QaoyFRVpHir/n2+FhcSCUtYlKW1dmpJWrmLQxjsya9YsIiMjdUyXQ0JCcHbWHvdftmwZR48e1epe6tixIzVq1KBr1656hSY/Pz9iY2NZvHgxo0ePJjo6WmeMLGO3T2RkJH5+fmzdupW5c+fq7GlMnHt6vvzyS83XycnJbN++XW+nQfXq1blz5w73798HoGrVqga7NGrXro23tzc+Pj4cPnwYFxcXvaN36ceP/P39adiwoWadvoQ4Y8YCs9vxAhAdHc3q1at1xqvSCzeJiYk69ahvGxrJMwaFQsGBAwc0CW9q8/TMutDSexEZ06mkxtraWsd7Coz3iZo5cyZDhw6lTJkyVK5cGYAHDx7w8ccfM3v27CzPnxnGmt1LJBJevHhBkSJF+Pfff7XS0DKOO0KaiPjixQtNN1pmZPRzioiIYMuWLVrH9flPpX8OGV8HahP0X375RWudPuEmu0b+kDa++ubNG63XbcYOyuwkME6ZMoWtW7dq/X4bWtu+fXvu3LnD5cuXUalUeHl5UaxYMa01T5/+Z2GwZs0aUWgSESlsVLWvwpdVJ7M0+EeSFO+Q5fwO1HTU/STox+DlBMbcBKBR0YY693+InL3ykCsBT0xdRr7l8s043saWpbjDszw758m3HVkSUOP/BSZRZCoopIhabS4jfkPVWEqSmOD0J6uFnvjHvsReasvoEtHUkO7Uu16lglSVDWdlrdkWGm30eRIUiRx+rWs4ezsmiDh51n+LBASKWxbXCE9lrEvj6dxYb/eKiH6OHDmCr6+vzgXos2fP+Pvvv+nW7b8gE4VCoXdErnz58jpdR2patWoFgKOjI8eOHcu0luTkZH744Qd+/PFH+vXrx507d7Qu6gzFuKtJ332VnowXzt26ddN7UXnq1ClNR1L9+vUz7eARBIEZM2ZQtmxZmjdvzr59+/TWln5Mp169enp9cyCtk2bHjh1GjQVmt+MFoFevXhQvXjxTs3d9Ak1mrF69mr59++Lo6Mjnn3/O5cuXWbZsmY5wULp0acqWLcvQoUM190VFRREVFQXo75TKqlPphx9+4IsvvmDq1Kma77tCoeDatWt69zPWJ8rMzIxNmzbxzTffaL0WsvKUMgZjze5nzJhBgwYNMDc3p2XLllSpUgVI+1mXL19eZ31kZCR16tTB29tb67VhqEsI4J9//mHdunWa3391gh1k37Q8O6No2TXy37hxIxMmTMDc3FwjEAqCQFhYWI5r2L9/P48fP8bGxibLtStWrGDAgAFaqZAZyct/b0ShSUQkn1LZvhKflOnFxidbsl6cy5SzKYuDufa8t0ql4kH8QywkFng6NyZJnqgxcvyQuXpTNC/ODKVSxdFr7RnY6resF+cSK4Nq8iCq8I0MFXRS8pd//AdA4RhdNhZzIZUxjrs4aNGDZlaXcJYYNlsWBLAUEmlpcZiTll15nRLxTuc2RmQCUKEiLCWMsJQwAqIDNcV4OesfxxHRxdiULYDU1FSSk5N1vFCSkpJISdHfMT58+HAWLVqk6Y4KDw9n5syZWpHpSqWStWvXMn/+fHx8fLh06ZJmtCk9xsS4G4NSqdS6mI6NjaVTp048efKEBg0apHVe//gj5cqV46+//tLx64H/jMMHDBhAqVKl6Nixo95uk/Rk9v7u3r17gHFjgdnteIE0c+rjx49nWl92WblyJaNGjeL8+fPcvn2b7777ji+//FJH8LOysuLt27csWrSIxYsXa3V+GdsplbFT6e+//2b//v1UqFBBI75IpVLGjBmj8dhKT3Z9otzd3XNFXEqPPrN7faNsPXv2pGnTprx+/Zq6detqjpcvX17LwFpNv3796NevX5bnf/r0KevXr2fjxo2UKFGCJ0+e8PTpU82IoD6MMS8HCA0NJSgoSGudPjE3u0b+8+fP58qVK1SrVi3L52dsDeXKlcPCwiLL/QCuXbvGt99+S+vWrRk6dCjt2rXT+T2OiYnhyJEjqFQqYmNjddL6DI3v5QRRaBIRycd4F2vKvpcHiZZF5+l59XUzhadGkKhIpGGRBgyrMIRYWSwxshicLJzytLa8pohj1p8gFHYOn7Pl0xZgZArwOxOfKnZyFERSTOsZ/+Ehuw/SGiDP3J+iMGEmKOlusydb692trXhtuil1dj3/g+r21XCycMxybbw8nrDkt9ib22EntcNKYvXBf9iTEWNTtiDtAnjgwIGsWbMGJycnIK0zZeTIkQbTyfz9/bVG8IoVK6YzKlerVi1SUlJYuHAh9evXJykpScsnRn1h++uvv7Jjx45sPT+A3r17a3W9BAYG0rZtW83906ZN03QbqbtOUlNTmTJlCl9++aXei/tx48Zpvm7VqhUHDx5k2bJl2a5Njbo+Y8YCs9vxAmnCSUxMDI6OWf9eGIu6e+rkyZMMGjSIdu3a8fXXX+usy26nFJBlp9LRo0dZs2YN8+bNY+7cuQY9nTKSHZ+o3EYtBjVo0IAHDzIPn3BxccHFxUXrWKlSpXTWKRQKtm7dmmW3YNu2bQkICKB///4cPHiQOnXqUKFChUxFJmPNyzdu3MjcuXOJiIigcuXKBAYG4unpqVdgya6Rf/HixY0SmbJTw9KlS+nSpQu+vr5aonnGBEj1vgkJCfz+++8sWLCAESNGMGjQIL777jvNmrJly2o8vsqUKaM1LmtoJC+niEKTiEg+xlxiToeS7djx7Pc8PW+KQteI/GlC2mhUgyJpCSUZO54+VIqKQlOWvApN4OydrvjUOpAn54uXia0xBZEUhZgMmLvEgfwumDcCmW5ClIhxyE38soxMjWRSwBQW1J5PKWvDFzAypYwrkdfYlK7LWSpI+azCYLyLZZ5O9iGRnZQtPz8/Bg8ejJubG5UrV0YQBIKDg+nSpYvWhVd6Mo7UqVQqne6nxMREBEFg9uzZCIJgsONF7Z2UXdKPvUilUqZOnYqnp6fm2PHjxwkODtby7rGwsOCHH36gatWqevccNmyY1u1atWrpGFWDtrFycnKylrk2/Cei3bp1ixIlShh8DulHhbLb8QJgb29Pw4YN6dChg9bFtfoCOSdIJBJ27tzJ77//rknCS03NneAdOzs7jdBkqFNpxIgRtGjRgo8++ohp06Zp/fwyjlblxCfqfXD8+HEdE2p9AoexqFPflEplpt5TwcHBlCpViqpVq2rEyKxEdWPNy5ctW8b169dp1aoV/v7+nDlzhs2bN+vd01gjf3VnXs+ePVmxYgX9+/fXet1mHHvLTg0LFy7k9evXBAQEaAm7hrC1tWXo0KF06tSJb7/9lu+//17r7112xvbeFVFoEhHJ57Qs7sPBV4eJl8fn2Tn9o/wZUK6fVqrcs8RnmAlm1HWqk2d15AfEjibjWLChDK5TGlK11Ps3J45PFVtjCiKi0PQ+UKWJTIXUGDw3kOWDl6UKFb+ErKZf2U+o4VBd5/41j9ZzJfKqThqtXCUnRWHCdiwTkJ2ULXNzc7Zv305ISIjGv6ZevXqZRng3btyYiRMnMm3aNFQqFUuWLNEk1qnJSceLMdy8eZOgoCAGDx4MwMiRI4mOjgbSOmYaNWoEoOX/kh6pVGpwxKZChQp6L04zjoFl9IdK392QXkSrUqWKzshNZhjb8aKmSpUqms6n3GLFihV8//33jBgxgvLlyxMcHEzLli3fed+rV68SFBREUFAQgiBQq1Yt2rRpo+k2U+Pv78/gwYPp27cvU6dOzbQ7Lyc+UblN//79CQoKom7dukYJHMbi6elJt27dMk19e/LkCcePH2fdunXMnDmTDh06aI2Y6cNY83Jzc3OKFCmiWde8eXO++uorvXsaa+SvFhrVouyECRM0twVB0BGws1PD9evXCQ4ONup7L5fLOXDgABs2bODKlSv07t1bYzxuCkShSUQkn2NpZklblzbsfbkvz84ZLYvhYXwIVewra449TXxGDYfq2EoLl/BSxMnW1CUUCJKSZUxf2ZRfvoyiZJGQ93YehVJCQoZPrUUKBikKceRRJP8h15O8ZQqeJT5n0b3/4eFUl75l+lDS2lVzX0B0oI7IpEapKly/VzlJ2cqOf83SpUuZNGmSJh68a9eu/PDDDzmq1VDXj/riM2MXy5w5c7Q6j86cOcPXX39NQkIC33//PXv2pI2F2tvbc/PmTerU0f7gLzAwEFtb/e9Z1B08kNaptGXLFr1jSMYaK1taWlKuXDmj1uaEb7/9Ntf39PT01MS6Q5qYlT71KydcvHiRjh078vnnn9O/f39UKhVXr16lffv2HDlyRDPmNmvWLLZt28avv/5Ku3btstw3N3yi3pXr168TFBSUqSCWE4xNfWvTpg1t2rQhKiqKrVu3cufOHcqUKUO/fv30drYZa15uaWmJSqXS/PzLlStHeHi41pqBAweyZcsWg4b+GX29lMrs/R02pgY11apVIyEhQUuUM0Tp0qWpV68eQ4YM4Y8//sDS0rQpp6LQJCJSAGjj0pojb/7O0wS6K5FXqWxXSfMH9lniM7qW6pJn588vqJT54yKkIBAZncS0Vd1Y+cVmHGz0/4P5riQqcs+vQSRvEYWm94k4TppTTD06l5GA6EBuxdymVYkW+Lq0RipISZQbNm1WFrL0wfeZsgVpnjj6RspyQna7fp4+farVUWRtba3pbkrv9fTNN9/QqVMnZs2ahaenJ4IgcOHCBfz8/LQu3tNTs2ZNrdsNGjSgdevW2Xk6WqjyQKDdu3cvAQEBWp0sORmd++mnnzRdavp4l3G8xYsXs2nTJrp27ao51qNHDxo3bszChQs1wtaTJ0+4ceOGxissK95X11x2qFSpEklJSUYJHNkhu6NbRYoUYfz48YwfP55r164Z/P001rzcz8+P2NhYFi9ezOjRo4mOjmbVqlVaa9Spdrll6J+TGtTY29vToEED2rVrl+UY6bVr1yhTpsx7qTkniEKTiEgBwFZqQ+sSLTmkJ1b5fXEs9ARRqVGMr/w5KpUKO6kd9Yt45Nn58wvHzt01dQkFiqev4pmxdghLx6zA0jzzNuecECd3yvU9RfKGVANx4iK5gCp3fEYKI7J82BGkUCk4FnqCY6EnjFpbGHkfKVtqrl+/riNw5MSXJrtdPxn9gtQdTIBmZArSPJykUinfffcdkydPBtKEozVr1tChQwejzhUVFZXtWPj03LhxI8ePNYZJkyYREhKCv78//fr1Y/fu3fj6+uZoL/XFuaFur3fhzp07WiKTmm7dujF16lTN7a1bt+b6ud83ixcvplmzZjRr1izXfLLU7Nmzh+PHjyMIAr6+vvTo0cOoxzVs2JCGDRvqvc9Y8/JWrVoB4OjoaNCUvEGDBgD4+PgYVVfr1q05ceIExYsX1+qAMtS9WKxYMRwdHbVquHnzpt69q1atatB7LSOOjo588cUXPH78mH379nHnzh0CAwONSvl7H4hCk4hIAaGda1v+CT1usH3+fWAhSZv1FwSB6VW/xM48dz/VyO8oFEpOXQjO9X0tzM1I/YANrW/ej+W77Z8zZ+DSXE+ii5YXzd0NRfKMVPmH+5o3OarC5dOTm+SX0bmcUthG5943ixYt4vfff+fZs2f4+Phw7NgxWrdunSOhKbtdPxmNzitWrAikGZ2nN2MGaN++Pe3btzd67/QjQAqFgsePH/Pll19mq7685MSJEwQGBlKvXj2WLl3KtGnTGD58eI72GjVqFPB+xvGsra0N3pfRALqgMWHCBNzc3HBycsrV8bl58+axb98+jan2d999R1BQELNmzXqnfb/99lsmTJigSY0MDw9n5cqVmp97jRo1WL58ud5Ovvr162s6JNPz5MkTFi1aREhIiNbv4MmTJ7XWqYXEa9eM80ocMmSIzvn0HVM/L2MZPXo0NWrU0IhXFSpUoH///nqFptevXzNixAhOnjyJIAi0bt2a1atX56rhvCg0iYgUEBzM7annVJfLkXmXLhQS/4jwlHCKWRYrdCITgJmZhOlj2vLtskNYW5kTG//uHTpNGlTkgv/7n603NaevxPGH+2f08d6Qa3s+iK/N+As+QEKu7SmSd6QqlShVIClcaex5g0r8ncgp+bGjKTsU1o6m98WWLVu4du0anp6e7Nmzh/v37/PNN9/kaK/sdv307duXIUOGsGHDBhwd08bEY2Ji9BqdZ5f0I0BSqZQKFSpkasZtaqysrJBIJAiCgEwmw8XFhZcvX77TnvPmzdN7PKc/X0jrQsuYzJf+voLMy5cvuXs397v6//jjDy5duqQR4kaMGIGXl9c7C0379+9n7ty5mtvFihVj3759GqEmPDycAQMGMHnyZK1uMzAsCvfp04fWrVszbty4TMU2tTiTVQdjeHg4YWFhOomOMTExJCQY/nfc2DHSe/fusX37dk03pLW1tcHnNnLkSJo0aaIRyX799VdGjhzJwYMHM30O2UEUmkREChDmEvOsF+UioSlhzL+zgClVv6CsTf6Z+c1LmjeuTKXyxZk/pQsnLwazbud5UnKYelahjDNlSuqab36o7DvlRK8m5EpX07GwLnx5vhwJMvGCuqDiamuNUmWGRBAvjHMdZSRIioHy/XijfcjIs2nimt8obB5N7xsrKyusrKxQKpWoVCqqVq2aZ345M2fOZMiQIbi5uVGpUppH5oMHD+jWrds7XYQrFArWrl3Lli1bcrHa94u9vT2JiYl4e3szePBgXF1ddVLcsktcXJzm6+TkZP766y88PT3fac/ExEQdE2s1uZHQZko8PDx4/fp1rna4QJqok77by9bWNsvuP7lcjlSauWyhbw9ZuvAYNzc39u3bR48ePbh27RobNmzQ1GHoZ5WcnMzChQszPW96rl+/zowZM3j06JFWB5TavH3btm38+OOPvHr1Sut14+joaNBDLDtjpBlTJ5OSkgx+b58/f64lKn311Vd4eHgY9TyNRRSaREQKECoVlLYuxcukV3l2zmhZDAvuLsKv1hyKWRbLs/PmJ5o2cse1hCP9uzXCp3FlJs//g5dvorO1h7nUjJnjOzB9wZ/vp8h8yIs3Cdx43JoG7ln7jBhCqYIVD8bwc4ASENPmCioWEgkrvC8jlYgi0/shBYTSQFza1yJGIy/gHUEScnk+uZBjY2ODTCbDw8OD6dOn4+bmRmKiYTP23EQqlbJ161YePnyo6YaqV68elSpVeqd9zczM3rkbKK/ZsWMHZmZmLFmyhGXLlhEVFcXu3bvfac8lS5Zo3Z4zZw4jRox4pz3zg2n3+yIyMpJatWrRtGlTLY+mXbt2vdO+H330EYMGDWL06NEIgsCaNWto1KiR3rVBQUF8+umnRERE8Pz5c/z9/dm1axeLFi3SWVulShWWLVvGF198gUql4ocffqBatWpaa8qWLcu5c+cYNWoUjRs3Zt++fbi7uxsUY2rVqsWLFy9wc3Mz6rkNHjyYcePG4eXlpbcDauLEiUycOJH58+cbTMnMSHbGSFu2bMmCBQtISUnh9OnTLFu2jO7du+tdq1QqefPmDa6uaQmnYWFhuW7yLwpNIiIFCBUqWhT3YduzHVkvzkWSFEn88+Y4/cu9W+t2QaVL6/8ihEu5OJKcIqNYUTuiYhJRGJGkVdrVielj2vI2Ip6I6MLVkXPwgkeOhaZ4uQNTr4/k2JO4rBeL5Gu+aRyHh+NFU5fxYaN4BOYeIAswdSUFClkBF5o+Kqr/Ak0kZ6xatYrU1FSWLl2q6Uz47bff8rSGSpUqGS0uhYWFcf/+fZo1a4ZcLkepVOp0NUBaVPyYMWP47LPPtFLEatSokWt15yYuLi6ar2fOnPlezuHs7ExISMh72ftDoH///vTv3z/X9/3555+ZP38+EyZMQKVS4evra1B0GTduHCtWrGD8+PFAmpfS4MGD9QpNP/30EwMGDGDGjBkIgoC3tzebN2/WWWdtbc3mzZv5+eefadKkCevXrzfY0RQZGUmdOnXw9vY2SmwzMzPTeIJlxuzZszVCT/rOp7Jly+qszc4Y6fz581myZAn29vZMmzaNrl278tVXX+ldO3XqVOrVq0eXLl0QBIG//vorW91bxiAKTSIiBQqVyVpx/317hm6lu2IrLdjmhjnBXCrh+u1nPH4ewYPHYUREJWBvZ8Uqv37cefCanQeuEhquK4aYSQT6dm3E0D5ePHoezrfLDpmgetNy5loC0T1ccLILzdbjniRWY8z5TjyIEkWmgk6fqrb0LbPa1GUUDmQBYN4IZHnn5VfQKcgdTR5OdSlp7WrqMj4IbGxsWLlyJZ999hmQNs6zZs0awLBRsKnZu3evJnXuyZMnBAUF8fXXX/PXX7oJxerncvToUc0xQRA0Iz35jZYtW+p9v5vRhDk7pI+PVygUXL58mWLFCmenvjEMHjw4V/cbP348y5cv588//+T777836jFxcXF4e3trbguCYHCEslSpUpw8eVLjdZQxZTBjt86ECROoV68en3zyCTExMXr37NevX7YS25o2bcqNGzeoV69epus2bdrE+PHjMTc3R/L//hL60ukge2OkUqmUr7/+mq+//jrLWgcOHEj9+vU5deoUKpWKiRMn5rrwLApNIiIFCBWmS5hJVqZw+u2/dCppXHTuh4S9nRVVK7pQsoQjtaqWoo13Nd68jeXXrWdY9HUP3FydmLpgr9ZjqlQowfSx7aha0YWzVx4y54dDOfZ2KsjI5UqO+Hemn886zTGlCpIUDiQq7ElQ2JMgtyNRYUui3IZ4uTXhKQ78FGhPbEq8CSsXyQ3qFHfg21rLTV1G4UJ2FaR1QR5o6koKBHJlwRWa2rnmLO5dRJeiRYuycOFCrl27xk8//aTlB5Pb4yS5xYIFC/D396dNmzYA1K1bl6dPn+pd+/jx47ws7Z1Jn4iXnJzM9u3b33mE8OrV/wR4qVRKrVq1WLFixTvt+SGTnJzMqlWrdEyoczo6d/bsWQCWLVvGgAEDjHqMVCpFJpNpRMcXL15ohJmMHDx4EB8fHxwcHPjf//7HpUuXmDNnDrVq1QLSEtky0qxZM65evYqfn5/OfQqFgq1bt2oS3DJDneook8lYu3YtVatW1eqAunLlitb6efPmceXKFZ3RvvTExsYSGRnJjh07kEqlLFmyhKVLl3Ljxg3++OMPvY/JjuG9n58fs2bNombNmjrHcgtRaBIRKVCoTJow88+b47Rz8UUqKVx/OgRBwNbGElsbS0qWcNQcb1C7LL8fvMbgXl7UqFySuw9fU8LZnp4d6vFJl4ZIzSTs/yeQ//12jHz6PjVPOHO3NGuTJ5MoU5Igk5EoM0ZwK9hpLSJQ1NqKFZ67sTR797RGkWwiDyTtLZ4NSKxBmb2OwsJEQe1oKmtThur2hi9SRLJHiRIlOHXqFP3798fHx4e9e/dqxrfyq6mzRCLRRLmr0Tc2B2kX4c2aNcPJyQmAqKgozp8/T+fOnd93mTmiU6dOWre7detm0HTbWDZs0E3B/fLLL7US+UT+Y8SIEdjb23PmzBmmTJnCxo0bad68eY73K1OmDLVr1+bx48d89NFHOvdnFGMgbXSuR48ehIeHM2fOHDZv3syCBQv07j9z5kxu3rxJYGAgW7duZcyYMYwZM0YjcBkaaStdujS//PKLznEzMzNUKhVKpdKguKVm1qxZREZGUrFiRa3jISEhOr+jAMWLF89UZAKYNm0avr6+fPzxx1rn2bJlCwsXLtTq0FOTHcP7vXv36ohK+o69C4XralFEpICjUoGNmelG16Jl0Sy+vxTvYk1pWKQ+NoVwjC49JUs40rdrQ168jmLp7I+xMJcSHhnPwlVHufvgNb7NqvPHX9dRqcDCQkqpEo68Co0mVVYwL2xyispaytOYwuVNVdiRCAI/Nb1NKesnpi6lECMHYkFSRhSaDKBSgVxVMDtN27n45lsBpKDi6OjIoUOH+Oabb2jQoAG7d+/Gy8sr33Y02dvbExoaqnkdnDp1iiJF9Cfbzp49m4CAAM1tJycnZs+enW+Fpowolcr30pW1a9cuUWgyQEBAALdu3aJOnTqMHz+eIUOG0KtXrxzvt3fvXq5fv86AAQN0jNkNMWDAACpWrMj+/ftJTExk06ZNNGvWTO9adRfiP//8w8iRIxk1ahSrV7/b2L6npyfdunVj4MCBWt5mGUXPI0eO4Ovri4+Pj9bxZ8+e8ffff9OtWzet4z179mTFihX0799fq/MpfRrfmTNn+PXXX3VqGjhwoF6PKjDO8P7YsWP8888/vHr1SivpztD44LsgCk0iIgWIBkXrUc5G1yguL7kfF8z9uGA2P9lCXae6eDk3pq5THcwl7xY7W1CxtrKgbOmiALx8E834b34nLCLtE4WAOy9ITErrzJHJ5Cyd/THFitgRFhHHi9dRrN52lnshH/4FoNwq6zUiHxafVLXGq2jO0wZFcgMrMHMFxas03ybFE1C+NXVR+Qo5+rs/8juO5g40dtbtCBB5dwRBYP78+TRs2JBu3boxd+7cfCvoLVq0iI4dO/L48WNatGjBgwcPtOLKM0MQBJRK01gxGEPv3r0133eFQkFgYCBt27bN9fPkVxExP2BtbQ2kCTiJiYnY29u/U3qhubk5jRs35sCBA1SvXt3oxzVp0oQmTZpkuU6hUHDp0iX27Nmj6V6Tyd4trfj8+fMAWh1PgiDoCE3ZFYXUBt0TJkxAEARUqjQPXoXivw+i9aXWpa/BGPQZ3ltYWGBnZ5c2rZHOx6pkyZJGeTtlB1FoEhEpQDQq0pCwlPxxoSBTybkW5c+1KH8mVP6cBkXqm7okk2Nna0kpV0eN0BQXn4y1tQUKpQqFQsnF64/p3rYuJUs4UrKEI9v3Fw7D3nhzeVpzhUihwdHi3d7cieQC0hogvw5mFQEVmJUWhaYMmJHKlFIKHqaWIjhZQkhiBKnK/D+227pEq0L74c77IqPg0K1bN6pVq0bPnj0JDg42UVWZ07BhQ06ePMmFCxdQqVQ0adJEMxqXEQcHBy5fvkzjxo0BuHTpEvb29nlYbfZI32kllUqZOnWqwRGgdyG/ioimpF+/fuzYsYOiRYsSFRVFx44d6dChA87OzpQsWTLH++7evZvevXtz6tQpTp06pXP/2LFjNV+rPY8MoW/Mzs/Pj9GjR9O6dWuqV6/O/fv3qVy5co7rBfTWqY/sikLGiLxyuZzY2FgcHBy0jsfExBgU0IwxvPfx8cHHx4fu3btTt27dLOt4F0ShSUSkACEIApJ8+I+iQOazy4UFR3trfpjdm2VrT5CSKmP2hI4IgsD2fVc4c+UhHVvW1FofE1c4vGsiVEmmLkFEpPChigbzOiC7DYr8mSxlaiQC1JJeoNb/21kpikiY8ro9MfL8m3ZpLpjTqkQLU5fxwaHPRLdq1apcvnyZlStXmqAiwyQmJmq+Njc31xrXSUxM1Bq/UbNo0SK6d+9OzZo1UalU3Lt3jz///DNP6s0ON2/eJCgoSJN4NnLkSKKjo4G0OPZGjRple8/03VHpUalUREZGvlO9HyL37t0D4PDhw5iZmTF//ny2bdtGdHQ0gwYNyvG+t2/fpnfv3lqm7Goy/nzU44yHDh0iODiYoUOHArBx40aD4kiXLl3o0qWL5nbVqlXZu3evzrrY2Fi++eYbHj9+zP79+7lz5w6BgYEG0+X27NnD8ePHEQQBX19fevToobMmJ6JQVvTr14+BAweyceNGzUhsVFQUw4YNo2/fvnofo8/wfvly7UAWteB3/vx5TcdWetILfu+KoBJ7BkVEChThKeFMCZxu6jK0+KLKBDyc3q8qXpBQqVQkJcuwsU4by5DJFMQnJlPEUTtqte+4dbwKjUap/LD/DEf4SEmhcPlSFXbKO9qyq+VWilroRvWK5DFCMZBWBPldUOVfASW/MOftxzxNyr+v2xbFffisQs4v9kQKPhKJJNNuj/TjN+mJiori4sWLAJl2P5mSnj17MmzYMI0ZeLVq1fj6669JSEjgxIkT7NmzJ9t7btq0KdP71aKWSBr169fn+vXrpi4DgJYtW3Ly5EmtMco2bdoY7DTau3evTkre4sWLtdb079+fGjVqsHPnTm7fvk1SUhJeXl5aHmZq5s2bx759+zQC29atW+nevbuOYfa8efPw9/fXKwrVqVOHOXPmANC6dWtOnDhB8eLFtX6H1aNzYWH//dujUCgYOnQoe/bs0XRmPXjwgI8//pj169dn2kWVGd9++y1z587ls88+07lPEATWr1+fo331IQpNIiIFjIiUSCYHTjV1GVqMrzSWhkUbmLqMAkdsfDIrN53m8Mnbpi7lveHkaMMdD7GjqTDiUcKBzd6/YCONN3UpIgASVxDMQfHc1JXkW1KU1viFt+dFcripS9GLuSDlu9rzcbEqYepSRPIBfn5+WFpaMnLkSFQqFWvXrkUqlTJp0iSDj5HL5aSm/jceqq/7yZQ0aNAAf39/ze169epx48YNIC2KXp0gJvL+MDc3N2gqD2iJIdnhr7/+yvR+famClStX5ubNmxq/qMTEROrWrcuDBw901k6aNImQkBD8/f3p168fu3fvxtfXl3Xr1mmtUwtp6V9bdevWJTAwUGfPOnXqcOnSJc3vSUJCAl5eXty8eVNrnbGi0OvXrylZsiRPnz7V+z0oV66czrGQkBCN8Fe/fn3c3d111pw5c0bvfmoypgUqFAr27dunlWj3PhBH50REChj5cHKOfS8P4OFUF6lE/JOSHVJT5TjaW+NRw42SJRyJiUvigv+HNeLiVNQGEIWmwkhAWCwTr43ht8ZL8uXfrUKH8g1gC9KaIA8ydTX5jteKSqyKqJ1vRSaALqU6iyKTiIYjR45ojb58+eWXeHt76xWarly5wrBhw7h7966WH5Wh7idTkV4EA7Q6mKKiovK6nEJJlSpVshSFckJmSXP6DLYBPvnkE7y8vPjkk0+AtJRAQ2NjJ06cIDAwkHr16rF06VKmTZvG8OHDddZZWGiHQCQlJRk0hVepVFpirK2trd61ZmZmbNq0iW+++SZTUUjtcaVPUDKEu7u7XnEpPVOmTNE5JggCr1694vXr1zq/52ZmZixbtkwUmkRERLQRyH9XbM+TXnDw1WF6uHXLerGIhqJOtoz6tBmJyanY2VgCsOPANX7deuaDGaezdiiYqU4iucObBJUoMuUrEkB+B8wbguyaqYvJN1xObcPGMEhW5l+RydXKhY4l25u6DJF8RGRkJA8fPqRSpUoAPHz4kPBw/a/hCRMmsHbtWkaPHs2ZM2f4+eefNV0i+YmMXjcVK1YE0rxu5HIxVSQvsLS0zJYQYizGGmunx8/PD09PT06dOoVKpcLPz08zVpkRKysrzVipTCbDxcVFb0pey5YtWbBgASkpKZw+fZply5bRvXt3vXt+9NFHDBo0iNGjRyMIAmvWrMnUJ8wYUQigQoUKesdfHz3K2YfNGX2vIiMj8fPzY+vWrcydO1fvYxo2bMjFixfx8vLK0TmNQRSaREQKGPnVePvg68PUL1KPcrZlTV1KgUEiEQCBuPhk/vn3DgF3XvDsZSR2NpbExn8YRuGCTf58vYrkDR+7R5i6BBEdVGkik3kDULwGFIASVApADqpYE9eXd8hUFuxM6MnJyJxHducVg8sPFJPmRLT47rvv8PT0pEGDNOuCGzdu8Ntvv+ldK5PJaNy4MXK5HHt7e2bOnEmLFi2YPHlyXpacJX379mXIkCFs2LABR0dHIE1kyswAWSR3yQtXndDQUIKCgrS8lPR1NEFaAmH6FEJD2Nvbk5iYiLe3N4MHD8bV1RVzc92/mfPnz2fJkiXY29szbdo0unbtyldffaV3z59//pn58+czYcIEVCoVvr6+zJ4928hnaZhDhw5pvk5OTmbLli2ZjisaS3JyMj/88AM//vgj/fr1486dOzqpc2rOnDnDypUrqVKlCnZ2dprj+hL9coro0SQiUsCIkcUw4Ub+emOgxt22It/UnGnqMgo0UTEJnLsawpnLD7h28xkyef5qa88u7i1Kc1b1ytRliOQx1lIp8z3f0r3ULlOXIpJdzNxB4gCyW8CH20EQpizPqogG+dr4W42Xsyej3UeYugyRfMjbt2+5dOkSKpUKLy8vihcvrnfdRx99xJUrV2jRogU//vgjbm5uNGrUiMePH+dxxZkjl8sZMmQI+/fvp1KlSgiCwIMHD+jWrRsbN25EKhV7JAo6GzduZO7cuURERFC5cmUCAwPx9PTk3Llz77RvaGgoTk5OKJVKli1bRlRUFBMmTKBs2ex/AD5+/HiWL1/O1q1bGTBgwDvVZSxqo/CcoFQqWbt2LfPnz8fHx4f58+dToUKFTB/z77//6j2ePsXyXRF/W0VECghypRypRIpSpTR1KQYJSXhEjCwGR3NHU5dSYCniaEuXNnXo0qYOCYkpXLrxmDOXH3DB/xFJyTmLSBURyUssJBJ2+16gmv0NU5cikhMUIWlNThJXEOxA8dDUFeU6/rKWrAuTkqTI/yKTjZk1/cr2MXUZIvmU4sWLa0W6G6Jfv35EREQwY8YMmjdvjlwuZ968eXlQYfaQSqVs3bqVhw8faoya69WrpxkPfBeOHj3KpEmTePToEQqFQpP0ld98qj50li1bxvXr12nVqhX+/v6cOXOGzZs3v/O+Li4umq9nztT/offVq1f53//+R1BQmk9hrVq1mDJlis44nNp0ftmyZXkiNEVFRb2T6FurVi1SUlJYuHAh9evXJykpiTt37mjur1Gjhs5jQkJCGDp0qNax9evX56rQJHY0iYgUEN6mvKW4ZXH2vtjH/lcHTV2OQca6j6Kx80emLuODIzEpldEztvPoWTjTx7TlzoPXHDx+y9RlZUn1Jm6cMM//YykiucugGlZ8U+snU5chklOk1UD+BPgwRnjVyFXm/JHYk78jCk6X5aByA2jt0tLUZYgUYJRKJVevXqVx48ZA2hhdcnIy9vb2Jq4sb6lSpQrLly/Hy8tLKxre1tbWhFUVPtTJgrVr1+bWrbT3sU2aNOHChQvvtG/Lli31+h6dPHkSgIsXL9KxY0fGjh1Lo0aNUKlUXLlyhdWrV3PkyBHN7wdAly5dePLkCY8fP9Yr0rzreFmjRo00tSoUCh4/fsyXX37JjBkzcrRf+fLlNfsJgqA1/igIgl7vJ3X6XlbH3gWxo0lEpACgVCmJSIlEgoS/Xh81dTmZcif2nig0vQdsrC3w+7IrE+fsokOLmnRuXZtDJ26R3z8qEJJVINqKFDo230mmgv1gBpbbZOpSCjlSMCsNkqJpX5MC/L9BvyoB5I/RKybJ74F5I5Bd1b2vgBKhdOOXSE9CEguOyFTBtgItS+Tep8sihROJRML48eM1F8fm5uZ6vWs+dBwcHGjXrp2pyyj0WFpaolKpNMJfuXLlDJrYQ1ry4PHjxxEEgTZt2tCzZ0+967788kvN18nJyWzfvl2rE27x4sVs2rSJrl27ao716NEDT09PFi5cyL59+zTH9+7dy/Xr1xkwYECmaXk55X//+5/ma6lUSoUKFShVqlSO93vy5InRa69du8bly5cJDw9n1apVmuMxMTE6qY/viig0iYgUAB4nPMHe3J7fn/+BTJW/x6fuxt41dQkfLGVLF2V4v6YE3n3JjdvPMJeakSrL3y3fqfEyKFwfmor8P35XrCln247mxf42dSmFDDMwrw/KMFC8BMXTtP/0Li0HygRQ/f+bfMEZpBVB8QJk10FwAlV0XhX+3giUNWNNmA0JilBTl2I0AgJDyg9EIoiBCiLvTvXq1Xn06JEmxa0w0qlTJw4dOmSUsbTI+8PPz4/Y2FgWL17M6NGjiY6O1hI80jNv3jz27dvHoEGDAFiwYAF37txh1qxZOmszptF169ZNy2D8zp07WiJT+nVTp07VOmZubk7jxo05cOAA1atXz/ZzzAofHx/evn2LtbW1lhF3XvDy5UuuXbtGQkKCVlqdg4MDGzduzNVziaNzIiIFgIOvDvNR0YZMu5mzlsq85utq06jmUNXUZXyQPHkRgY21BVcCnmAuNUMqlSA1kxAU/Jrt+/Nf94GriwPXq8WZugwRE2FnYc6uNmeoYnfT1KVooVJBYoId0RHFsLWLxck50tQl5Q5mZQAzUDwx/jESZzArD6oUkN8B8q8PYHZRqCT8mfgxhyPemLqUbOPr0poB5fqbugyRfIxcLmfPnj2EhIQgl/9n3P/NN9/orO3QoQPnz5/H29tb68J2167CE9hQvHhxIiIisLOzw8rKSuPRFBaW/73aCit16tTh0qVL2NjYAJCQkICXlxc3b2b9niI1NZWaNWvy4MEDADw8PAgICNC7NuN9u3fvpnfv3gYFsLFjx2bviaRj1apV+Pn5ERqa9sFHzZo1WbZsGW3atCE6OhonJ6cc750djhw5QocOHd7rOcSOJhGRAsCb5DeYCWZZL8wnrHu8Eb9ac7A0szR1KR8cZUsVRSIR6Ny6ttbx5o0rExWTyJHTQZiZSVAo8sfFYmhYLBVqOvJYUXgi00X+Iz5VRt8TPsxsUJOepXegxz4hV0lKtCEqojhRb4sQFW5P1FsbosItiH5rRmSYkui3ciJDk4gOjSclKa1FXBCcqOHpiVcHAc/WdylTQdfLoMAgWIH8QfYeo4xI+68AolJh8DUVpSzJ6qhm3E94nbdF5QJO5o587NbD1GWI5HP69u3Lmzdv+Oijj7Q8hwyt7du3bx5Vlj+5du2aqUso1Hz//ffY2toyfvx4reOLFi1CEASmTZum8xiVSqURmSDNT8tQj0zv3r21fI8CAwO1RiVTU1O5e/eu3sdnHBm7ffs2vXv31ur4UaPPB8pY1qxZw4oVK1i3bh1eXl4AXLhwgSlTprBkyRK+/vpr/P39c7x/dnj27BkxMTE4Ojoybtw4Ll26xLJly2jevHmunUPsaBIRyefEy+NZ/3gTg8sPYMKNyaYux2jauvjyabnC/abmfZKYlMqNoOeUdnWivJszAKkyOVcCntKwTlmOnb3L2p3niYhKMHGlUK1WSU46F7yOApHcpXkZB/w8/qCUde7HaUdFFGOIZ0WSE1LeeS+3KsXx6mCDl+9zqtUNwMysgLxNMqv0QSbEGSJR5cgPkW3p73SfCmban24Hyb1YHeZInNz0f/9yQueSHeld5mNTlyGSz6latSr37t3L1oWvXC5HKhX7DETynrp163Lp0iWsra21jicmJtKkSRO93UZDhw5FLpczevRoBEFgzZo1QFo6WkY2bfrPE1IqleLu7o6np6fmWHrD7IwYMszObWrXrs3hw4cpW7as1vEnT55QpUoVJk+ezPfff//e64C0brGbN29y/vx5ZsyYwYwZM5g9e/Y7G52nRxSaRETyOZcjrvIk8QldS3VmtP84U5djNAICHVzb0b10V63Opj9f7MfB3J5mxb2xkFiYsMKCjUql4vCJ22zee4kV8/tSwlnXCCkpOZXPZ/9O8CPT+5LYtS5CsDza1GWImBg7c3OmN4imb5mtudrddP91Xb5obIZCnrueZY7F7GjcvhhebSOo38QfK5ukXN0/V5HWBXmgqavIE+QqKT9GfUxQ/CuszazoWcwKEFCoJEQrLPg74g0qCu7b29k1ZlDJzt3UZYjkc3x9fTl8+DAWFlm/l7pz5w79+/cnIiKC58+f4+/vz65du1i0aFEeVJo/CAkJYdKkSQQGBpKc/F8Igjg6lzfUrVuXwED9/0YZui8hIYH58+dz/PhxVCoVvr6+zJ49+70nBf7111+Z3p/e+yk71KxZk6CgIL33ValSheDg4BztmxPUCXPz58+nVKlSDBs2TEydExEpbNyKuUVV+yokKQpWzLQKFX+9OcrVqGsMLjeQ2k61ALgQcYmwlDD2vTxIW9c2tCrRElupTRa7iWREEAQ6t6lNrWqlWP/7Bb4Y1gpLS3PuPXxDWEQczRtXxtrKgm8ndmTo1C2kpMqz3vQ9UuqVJcElTFqCSD4gXiZj9iVbLCR9+dhtZ67smaKwYtpdX9wHxhK84XKu7KkmJjyef7bG889WMLesSf2WpfBsn0TjloE4F89HFyeCM8hvmbqK906s0pnjya14nWpGUPxLAJIUyWwLLVj/PmaGo7kDFW0rmLoMkQJAlSpVaNWqFT179sTKykpzXJ9/zOeff86KFSs0Y0v169dn8ODBhUpoGj58OKNHj+bRo0ccPnyY5cuXU758eVOXVWiIj4/X+GKlR6lUEhen6+WpUCgYPXo0W7ZsMWr/Pn366BxzdHTEy8uLIUOGIJEYH6yQWdKcIAg5FppSU1NJTk7W+n0FSEpKQqnMW8sLiUTCzp07+f333zl06JCmvlw9R67uJiIikquoVCpuxdympHVJrkX6U9yyGOZCwdKH36aE87/gH9j4eDMAXs6NAYiVx/LHi72sDvnNlOUVeMq7OfPF8NbsP3YTlUqFXKlk659X2PdPIPdC3mBrY8nYgbk3b51Tgu++oYa0qKnLEMknPIl3zrW9vgsaTVB4HMdrCbhWLZlr+2ZEliLj8tGn/DQpjP51SzJzSBdSU/JJV6YqAswbmLqK946NEMNfEWFci31p6lLeGx5OdcWkORGjSExMpHLlyty6dYurV69y9epVgz5EcXFxeHt7a24LgoC5uXlelZoviImJ4ZNPPkEikVC7dm1Wr17NsWPHTF1WocHHxwc/Pz+d4wsXLsTHx0fnuJmZGS9fGv+3vnjx4jx//hxvb2+8vb15+fIl1tbW7Nq1i0mTJmWr1lOnThn87+TJk9naKz09e/Zk4MCBREdHa45FRUUxaNAgPv44b8elV6xYwc6dOxkxYgTly5cnODiYli1b5uo5CtYVq4hIIeN50guiZTGUtCrJ9qc7aePSmhtRAdyLu2/q0rLNqbf/4lXMk04lO3A2/DyRqWkpT3di75KkSMLazDqLHUQMYWkhpU610mzZe5lPOjegQe2y/G912punzq1rc/ZK/vBtKfbMDEqZugqR/MDzhNz5fT/4uhfb76WNs8nMIHpAZSTfvkGpfP9jU9f+eca6xR0YM3v/ez+XUciugrkHyIIAmamreS88U9REocofQQfvi3pOHqYuQaSAsGHDBqPXSqVSZDKZppvkxYsX2erw+BBQC2v29vY8ffoUFxcXnj59auKqCg+LFi3Cx8eHw4cPa4ywL126RHR0NP/++6/ex7Rp04YxY8bw2WefaaUl1qhRQ2ftzZs3OX36NJaWaXYdI0eOpEuXLhw+fBgPD48c1x0aGkpQUJDWuGVOO5r8/PwYPHgwbm5uVK5cGUEQCA4OpkuXLnpFuPeJp6cn+/bt09yuUqUKy5cvz9VziEKTiEg+5lbMbRzNHUlUJPAi6SVTin1BrCy2QApNkObP9FX1qfQt04dVIb8CIFPJuR0TRKOiDU1cXcGmWiVX/jp1mzaf/oS11X9dFt6NKjHq02ZMnLOLR8/CTVghPHwQRt2yxQmUm7YOEdPzIu7dDZpCEmoy85IL8N9YaJB9Kh36NyR4q25SzPtg3y9PqPVRM5q1O5sn58sSWQCYVQblW1BFm7qaXOdsUnXgw+1mspBYUNNR9wJKRMQQ169fJyAgQOsiOP3o3P79++ncuTPjxo2jR48ehIeHM2fOHDZv3syCBQtMUbLJ8PHxITIyknHjxtGwYUMsLS3p3bu3qcsqNBQvXpzr16+zfft2TbLaiBEj6Nevn45BuBq1+ffRo0c1xwwZd4eFhWn5lZmbm/PixQssLCw04lN22bhxI3PnziUiIoLKlSsTGBiIp6dnjoUmc3Nztm/fTkhIiMYLqV69elSqVClH++WEn376iYkTJ+pN+QNYvHhxrp1LFJpERPIxt6JvU9LKlcsRV2ni7IlUMONiRO56kOQld+PucS/2Ph8VbcjtGG/OhV9AiRL/qBui0JQLjOjvzelLwURGJ2qOJSSmUMTRJk86PIzB9pEKymSSSS5SKHgW924+AElyG8Zf7ECiTNfX4VQ9KfUulCDsUd54KC2bKMP9WFlKlXmWJ+fLEsUDkNYAeSzw4XT/pChtuBwbYeoy3iu1HGqIIRkiRrNo0SJ+//13nj17ho+PD8eOHaN169ZaQtO3337L6NGjGTRoEDNnzmTfvn0kJiayadMmmjVrZsLq8x71BXT//v1p1qwZMTEx1KpVy8RVFS6srKwYOnQoQ4cONWr948fGp9T6+PjQqVMnBg4ciCAIbNmyBW9vb+Lj43WEpr179+oItPoElmXLlnH9+nVatWqFv78/Z86cYfPmzUbXZAh3d3fc3U0T+KD2h3rfhuogCk0iIvmWZ4nPuR8XTIsSzYlIjaCtaxv2vzqkGTkrqPz95h+qOVRlWMXP6OHWnX/fnuFK5DXkSjlSifgn6V2wt7Vi3OAWzPvpv7SM+MQU5HIFz19HmbCy/3jyOJyGFVy4pshHRsoieU5kUjI3Yzyp43gpR4+fe3s0wZG6IhNAspmKxEHVYE7evMYSY5OYN6wa/SdXoEHT69ja668rT5DWACQgv226Gt4TV2XNSVIkmLqM90q9Ih6mLkGkALFlyxauXbuGp6cne/bs4f79+3zzzTdaawICArh27RobNmygc+fO1KhRg2HDhtGgwYfv6WaIR48eceDAAdzd3UWhqQCgUCh4+vSpliikb3Ru5cqV/Prrr/zxxx8AtG/fnpIlS2JnZ8elS/+915g0aRIhISH4+/vTr18/du/eja+vr95zm5ubU6RIEeTytM7p5s2b89VXX+Xm08tzRo0aBaSJ0O+bwjWcKyJSQFCqlKx/vAklSkpalWRw+YG4WLlwKuy01joncyeT1PcuhCQ8QqVK664palGEHqW7Mb/m+/9jV1jwbVad+rXKaG4nJKbw/HUUCkX+6WwweyADVf7osBIxHX2O1WPVw1HIlWbZetyeF335IzhzwSHQKZUqfeq/S3nZ4vHtUL4bGk3vmpWZ3r8zezd05OXT8nl2/jTMQH73gxSZAAKTnExdwntFQMDDqa6pyxApQFhZWWFlZYVSqUSlUlG1alWePHmis65hw4asXLmSV69eMWbMGLZt20bp0qUZOXJk3hdtAnx9fQkICADg1atXNGzYkL///pupU6cWqtS9gsiRI0coW7YsNWrUoFmzZtSuXZtOnTrpXWtubs748eP57rvvcHd357vvvmPhwoU6606cOMH+/fspXrw4S5cu5erVq4SF6f9gytLSEpVKpfEvOnDgAOHhBd/+4erVq3zyySfUqlWLWrVq0bdvAezJAgABAABJREFUX65ezX3LAVFoEhHJh/zz5hiPE9LaRR3NHQAwE8zwKZ7W5mwlSWsBreFQHTMhexdppiZGFkuULFrrmFQiFbuZcglBEJgyog1Sadqf9/jEFJ68yF/jJs+fR9LE7P2lg4kUDORKJcuuwydnJrPl6WCC4z0wZsLznxdlsl4EnGlsibNb3iYdKuQKAk4/Z/XMlwz1cuTezTz8tFxwBj5cAbeyVXLWiwow7nbuOPz/v/ciIsZgY2ODTCbDw8OD6dOn8/PPP5OYmGhwvaWlJX369GHMmDG4u7uzc+fOPKzWdLx8+VJjBr19+3Z8fHw4cuQIFy9eZNu2baYtTiRTZs6cyYULF6hevToRERFs2rSJPn366KxLTExk48aNNGvWjFatWrFmzRpOnDih8YJKj5WVFRKJBEEQkMlkuLi4GEy38/PzIzY2lsWLF3PgwAHmz5/PqlWrcv155iUXL16kbdu2VKpUCT8/P+bPn0+FChVo164dly/nrj2LeGUnIpLPSJAn8nfof3Grx8NO8lHRRgiCQMeS7TkRdorytuW5F3efGFkMzYs30+l0yu88SXhKUYsipi7jg6WcmzMLp3fH0lxKlYouJCSlYGEhJTVVnvWD84g3F8Kp6l2E+/L8MdInYjoCw2IJDLMCGlPEqjkNXS34qHgEHznfoprddcwk2t14rrbGJaolmKko2qoSEZuvvIeqs6Z4GSeq1NKfpAPw9GElwsOK0qBJWn1ymRkJcY44Fs3heLTECT7AkVTV/1u61TO/wQ7Kmrqc90Z9sZtJJJusWrWK1NRUli5dyowZM3j06BFbtmzRu/bWrVusX7+e7du34+7uzujRo+nbt28eV2wa1J40ABcuXNAYORcpUgSpVLwUNgXGJrkJgkC5cuU0o2sDBgygefPmWmtGjhzJnj17aNasGVOnTqVjx45UrlyZmjVr6j23vb09iYmJeHt7M3jwYFxdXTWJhBlp1aoVAI6Ojhw7dkzvmoLG4sWL2bRpE127dtUc69GjB56enixcuFArie5dEX+7RETyGbZSG5bVXUJYShgh8Y95lPCIoNg71HKsiYO5A21KtEKmkvEg/iGPEh4ztMJgzr49h1yVf0SErFB9QAa1+RWv+hU1BuB2tpb06liP7fvyJonLGJJTZFheTaJ0QzteKuJNXY5IPiEqOYVjT1I49sQCaIC9hRdjaicxvOJaJP/vH+9inWT0foIJTfCrNnBCX3q4SgUHtrZn7bfhgJKpq3x4dMeRv7emia5+297iXv1e9k8osQHFu9WcH1CqBB4qGnAjpSIB8SnIVArq2triYfWKkpbOvE7JXx2auYWH6M8kkk3U/kK2traadK6MrFq1ivXr1/PixQsGDBjAqVOn9PrbfMhIJBJevHhBkSJF+Pfff/n+++8192XWASbyfshOkptaAHJzc+PgwYOUK1eOFy9eaK3ZsWMHDRo0YNSoUbRv3x5BEBAyCZzZsWMHZmZmLFmyhGXLlhEVFcXu3bu11nz//ffY2toyfvx4reOLFi1CEASDiW0FgTt37miJTGq6devG1KlTc/VcotAkIpIPEQQBFysXXKxcaFLMk70v9lHDoToSQUI1h2oUsXDC0dyRGFkMVhIrWhRvzvGwk6Yu2yhKWrlSz8nD1GUUCgQB5vxwmGqVXLCxzn9JRjGxSdhfsaKZazEs7MwJKBJFhPLDHo8RyR5xqaks9jfj/JupLGm4gxKWL3C1jgacjNtAYTqh6dy+J2yv1ZlS5eNJSjAnMc6cpAQzbl9ScePUc82674ZGA9Ga2192d+TbTQ3x8LyWzTPq/0S2oBAsb8iZxMoExkcSL08EXmvuO5kaQ9q/cB+myGQvtaOUlThOLJI9OnbsyJYtW3B2dgYgPDycIUOGcOjQIc2aQ4cO8fXXX9O1a1eDXRsfOjNmzKBBgwaYm5vTsmVLqlSpAqR1N5UvX960xRVCspPkNnHiRKKiovDz86Nv375ER0fz448/aq15/fo1O3fuZN68eYwcOZJBgwYhkxnufHZxcdF8PXPmTL1rduzYoWUgrmb8+PE0adKkQAtN1tbWBu+zsbHJ1XOJQpOISAGgjI0bFyIu4V2sCdUdqmIhsaCszX8+Jb3K9ORZ4nOC4x+YsErj6FiyAxJBtIfLCwRBoJ1PdaYt+NPUpRgkLj6ZuIdp4lLFUk7Iq6iIUaWYuCqR/Mb5l7F0jvyYxZ7BuFpFYLTQJDdt9+Qmv+dZL8pAYlwyMz8xY+qqFrTodDr3i8pnKFQSDiR9zMHwUFS8yPoBHyDudu6ZfgIvIqKPV69eaUQmgGLFivHq1SutNX/99VfGhxU6evbsSdOmTXn9+jV16/43olq+fHl+++03E1ZWOMlOkpuvry9FihShQYMGPHiQdo2T0Yzbzs6O4cOHM3z4cIKCgli/fj2pqak0adKEAQMGMHbsWAB69+6d6d/ZXbt2ad3WJ8jY2NhoAo0KKqmpqdy9e1fv80hNTc3Vc4lCk4hIAaC4ZXGOh57Au1gTLCS6nSnWZtZMrjqRZfd/ytdiU1GLojRx9jR1GYUKr/oVqVG5JHcevM56sYl5+Sqa6tKi3K6oJF5lnA+PSOEhMimZ4afK4lveHogz7kEmFppyilymYOGIKCIXdKDnkCNGPip33yDmBZHKUqyOakpwwhtTl2JSKttVMnUJIgUQpVKJXC7X+AylpqaSkiJ+UKMPFxcXrU4WgFKlSpmomsJNxiS3cuXKGUxya9u2LdevX8/ymJqaNWuydOlSFi1axL59+1i/fr1GaOrcubPRNcbHx6NSqXSEKaVSSVycke8/8imJiYl6xxSBXP/AQxSaREQKAHtf7KOyfeZvRAuC2NSyhI+YLpfHCILA8L5NmTz/D1OXYhTPnkVSV1oM/7LRJKs+AMMZkVzn2JNsvMlTFEyhSc3qGa+IeNOVYdMO6PV70kKZkCc15RYBsuase2tNvLxwi0wAlezcTV2CSAGkffv29O3bl0mTJgHw448/Gox+FxHJL6RPchs9ejTR0dE6SW5yuZzU1FSUSiVJSUma7puYmBijfLWkUim9evWiV69emmODBw82ukYfHx/8/PyYPXu21vGFCxfi4+Nj9D75kSdPnuTZuQRVQe//EhEpBJwMO82zxOcMKvdplmNnSYok5gV9x6vk/NfBMrriCLyKiR1NeY1KpcLv5yP8feYOZmYSFAXg4tu9cgkul4wgVcj/tYrkX9r/Hc+DI7dNXcY70+qT8kxe9BfmFpl0+kmKgVL/p8L5hRhlCbbFtcJSgHPR+uOkCxsSJPzaYAWWZpamLkWkgCGTyViwYAGHDx8GoGvXrkyfPr3QejGJfDjMnTuXuXPnIgiC1oiXg4MDU6ZM0RGAjOGnn35i4sSJBv2VFi9erPn67du3+Pj44ODggJeXFwCXLl0iOjqaf//9lxIlSmT7/IURUWgSESkg7Hq+hycJTxjlPhxHc8dM1258soVTYafzprBs8GXVL6jtWMvUZRRaTl64z479V2njXY3rt59z6fojFCZM5cqKKtVdOFfiLXLyb40i+Zt2f8Xx8J8gU5eRK9RvXYbZv57CxlZf55IEUP3/f/mTUGUFlobV5m1qlKlLyVeUtynH3FrfmLoMERERkffK7t276d27t073EqR13zs7O9OpUydsbW01x8eMGcMvv/ySK+dfvXo1o0aNYu7cuXrv//bbb7VuJycns337dvz9/QFo0KAB/fr1y9RMW0QbUWgSESkgKFVKfnu0jkfxj1hUZ0Gmc7RHX//Njuf/mdpJkNDTrTt/v/mHOLnpouTn1JhNBbvyJju/CETFJLLpj4u0b1GTYkXt2HXIn+37rpq6LINUq12S00XeoBR9ckVyQNv90YScumfqMnKNCrVcKF/DmshQBVGhKUSFxtPQtwSTl1zFwvxV1huYiCeKWvwQWoZYE/77k1/xdWnNgHL9TV2GSAFl7969BAQEkJz8X2Jr+s4MEZH8wrfffsvcuXP57LPP9N4fFhZGfHw8//77r9bxgIAA7ty5Q//+/YmOjiYpKYmSJcWUzoKAaJYiIlJAkAgShlf4jP/d/4Hw1HCKWxY3uNbFyoWyNmWobl+N50kvcLFyoUupTphLzNnx7Pc8rFqb8NRwKlDeZOcXgSKONkwa1porAU8wM5MwZkBzwiPj+efMXVOXppd7t17TtEVpzqry70W0SP5FVUDNwA3x+HYojzNMAp7a9QRlsbZ88dUurKVZe1fkNXfkXix/Y0uyUhSZ9OEu+jOJ5JBJkyYREhKCv78//fr1Y/fu3fj6+pq6LBERvag7iTZs2GBwTcbX76+//sovv/xCfHw8/fv3JyIighEjRnDy5Mkc1zFv3jy9x7/5RuwszW1EoUlEpAAhlUgZX/lzwpLDcDR35MDLQ7xMfkWKIoVkRTLJymRSlamMqzSWiJRIWldqhYvVf3PEzYt58+eLfSQrTZNKEhz3kEZFG5rk3CLafORRnoTEFFJlCr4c6cu9h6E8exWps65sqaJYWZkTFh5LdGySCSqF5AcJ4K4CMf5bJJsoZR++oXxF78psdbfi+fWxrGi4DDNJ/hHXIpSl+fG1NTKVmIRliMqi0CSSQ06cOEFgYCD16tVj6dKlTJs2jeHDh5u6LBGRLLl+/bpOJ97YsWM5duyY1rrVq1dz6dIlmjRpAoC7uzthYWHvdO70qXHJycn89ddfeHqK/rHvA1FoEhEpYNhKbTTjZ51KdWDns92cjtJuM42TxbGi/o86xuE2UhuaFffmWOiJvCpXi4fxD01yXhH92Nqkmc/O+eEQNauUpFbVkqTKFDx88pYnLyIA8G1WjY871ufm3Zd89f2fJqnz5ctoPKqWIEDx1iTnFym4fGgdTRkp7+XO2R7FSDVTcexJHAttxzGr5s+mLkuDs+QlQ1xqse6NAguJOTZmVkTKYkxdVr7BydwRZwtnU5chUkCxsrJCIpEgCAIymQwXFxdevhRN9kXyN4sWLeL333/n2bNn+Pj4cOzYMVq3bs3YsWN11lpYWOh4Ikml7yZfLFmyROv2nDlzGDFixDvtKaKfrMJyRURE8jHWZtZ8VmEQ06pOoZhFMc3xVSGrCYy+qfcxbVxaI2CazpCnic9IUYifbOc3JnzWEqVKRfDjMHp1qs+K+Z/gUsyepg3dad20Gg52VnjWr4BzEdusN3tPOL4Su5k+CFQqmoRa0OFMCh0CVPg+kND8pQUNIi2ommBBiVQpZtkwqDdTqsisgUfxAXc0lW9ckQu9SpBs9t/3a2NQChuf6Pe/MBVNLP7mq9JxLCnlz7Di+TsVL6+pZFcpU79FEZHMsLe3JzExEW9vbwYPHszkyZPFxDmRfM+WLVu4cOECbm5u7Nmzh6tXr2JhYaF3bfHixQkODtb8ndyyZQtlypTJ1XqcnZ0JCQkxeH9oaCgnT57kr7/+0vwnYhyiGbiIyAdCsiKZXc/3cCLsv7nlTiU78LFbD8wEM621wXEPWPtoPaEp79Z+mhO+rjaNag5V8/y8Illz/dYzlq09gUcNNwb0bIxrcQet+1dvO8uWvZdNVB2Yt3LkqSLWZOcXeTcqJ5hT9tArnlw0/IZOjW0RW+yK2mFV1AbzIjZIHCxQ2VsgtzMn2Vog0VqCVYqKxN+uExcZj8RMgrmlOeZWUswtzTGzkCK1lBL5LILUZFkePLu8pWzD8lzpV5IEM923cAKwyuc1vi4H8r4wI1gW9Qm34kTPNYC+ZfrQoWQ7U5chUkAJDQ3FyckJpVLJsmXLiIqKYsKECZQtW9bUpYmIGKRhw4Zcu3aNOnXqEBgYiCAING7cmMuXdd9fPnz4kP79+xMUFETx4sWxsbHh4MGDuLvnfOQ4feqdQqHg8uXLvH79mhMndKc9Nm7cyNy5c4mIiKBy5coEBgbi6enJuXPncnz+woQoNImIfGDcjb3HuscbeZuSNmZUzb4qY9xH4WThqLUuRZHCnhd/8k/ocVR5GIndy60nXUp1yrPziWQPmUzBjgNXOXj8FiP7e9PGu5rmk6SXb6L55PO1JqutRoPSHLcTL1ALGo5yCU2uJvNw9w2U2ehWEtFPmXrluPZpKeKlhr+XVlIp21r5U9fpUh5WZhzPFDWZ89I5T//dya/Mrv41lewrmboMkQJOaGgogiBQokSJrBeLiJiY5s2bc+LECYYNG4arqytubm6sWbOGW7duaa1TKBTs27ePHj16cP/+fVQqFVWrVsXMzMzAzsaRPvVOKpXi7u7OqFGjKFKkiM7aOnXq8O+//9KqVStu3LjBmTNn2Lx5M2vXmu69cEFCFJpERD5AUhQp/PFiL8dCT6BCRRW7ysys8ZXetQ/iHrL28XreJIfmSW01HKozvdqXeXIukZzzKjSaH9aeQK5Q8vmgFpR3K0pyipweI38lyUQdIpYWUiKbSInJwlhYikBzRSnuWcTwSiEmXZkKiRJaPpESvvUG8ZEJpi7ng8ChmD3PptUhwiLrkcCi1lb80eYvylo/yIPKssea2L5ciC7cXjJSQcqvDVZgLhFHnURyxt27d+nTpw8vXrxAEATc3NzYtWsX1apVM3VpIiIGuX37NhUqVCAxMZEZM2YQFRXFrFmz8PDw0FnbtGlTzp8/n/dF/j8NGjTA39+f2rVra4SwJk2acOHCBZPVVJAQzcBFRD5ALM0s+bRcPxoVbcjaRxtwtXIxuLayfSXm15rDnhd/8vebY+/9U+Y7sXc5HfYvLUr4ZPuxcqWcl0kvsZPa42xZNMv1b1PCKWbhLHpg5IBSLk4sntGTM5cfMGvJfuxsLbG1sTSZyASQkiqngdyVk2aGL1DLmtlT8oGUe89fYGNtQRPPklxQvs7DKkUA6kVZYLfrIU/uih1ouYn18HpEWKQatTYyKZnhZ7uyq8UmnCzylzeSm3ly1os+cMrblhNFJpF3YuzYsXz99df0798fgJ07dzJmzBhOnTpl4spERAxTq1YtAGxtbVmzZk2maxs2bMj/sXff4XFUVwOHf7N9V733YsuWbMlyN2CwjammJ/QOCaQQkpBGICGhfIFQEyCQkAIECEkg9N4xuFCMu+Uuy1bvvay0db4/DAahtpJ2d3al8z6PHkuzM/ceFUuzZ88995NPPmHx4sV+jWHdunWUlZXhdrsPHbvssssGnGc2m1FVlfz8fB588EFycnJobg6tv6ehTCqahJjgHB4HTY5mMm0ZQ57j9ro50FPO3q69fNC0iiZHYH+JGhQDN8y8nrzIqT5f8++K//Jh4ypcqpscWw43Fv56xJv0Vmcb+7sPsDB+/nhDntTsvU4e/d9HPPf6JjwaL32Ki7WxZ04f7q8nRFWVZboMqj5pwOFw93to5rx0Polpwq72Py78L8NhYNbKNva9vUPrUCac6SfP4q0VkaO+blFaNI8f+SBmfegkd25qOouq3sm9i+SJKSdwcc4FWochwtjcuXPZsmVLv2Pz5s1j8+bN2gQkxDB6e3t5/PHHiYuL47zzzuO6667j7bffZsaMGdx///1kZAx8njJv3jxKSkrIz88nMvLLv3+fffbZmOP4wQ9+wNtvv83cuXMPLcNTFIVnnnlmwLkrV65kwYIFNDc3c9VVV9He3s4dd9zB8ccfP+b5JxNJNAkhDtnduYcXa15md9eegM8VZ4zj/2bdSIwxZuSTgeeqXuDVutcPfXxS6olcmH3+iNfdt/cBrpn+wwEN0cXo7Stv4g//eJfte7StUplRnIYap6fb4KZJ6aXL62ROUyy7tw9duZSSHE3vLAO7PW1BjHTysHoUji7xUv7UJlyOidd8W2vRSdGUXz+LNsMwW+wN4xvTIvnj/D/6OaqxqfLO5KbqxJFPnOCkEbgYrwULFvDkk09SWFgIwJ49e7jooovYuHGjxpEJMdAll1xCR0cHPT096HQ6cnNzOfvss1m5ciW7d+/m1VdfHXDNqlWrBh3r6KNHvyriC9OnT6ekpASLxTLmMYRvJNEkhOhHVVW2d+zg+ZoXOdBTHtC54k3xXJB1HofFLxxxedumts38qfTP/Y79Iv+nzI4tHva6R/c/Rl5kHsuTl407XgFer8rrK0t46MnVdHWHToWEL/R6HdMXp7NSVw2ynNKvjv5nDdXbqrQOY8JK+fUyPk7xbcncYBRg21lPYjXY/RfUGD3Tcx5vtshy1u9M+TZLk5ZoHYYIY2+99RaXXnop8+bNQ1EUtmzZwpNPPsmJJ56odWhCDFBYWMjOnTvp6+sjNTWV1tZWdDodcHA53fbt2we9zuPxUFVVRW5url/iWLZsGatXrx72nGeffZZzzz233w51X1AUhYSEBE499VQiIiL8EtNEJT2ahBD9KIpCcewsZsUUsal9My9Uv0R1b2CatrY6W3mo7G+sbCzg4pwLybZlDXnu1IgpA479rexhLs+9hMPiFw2ZqCqIyue56hdZnHA4Zr3Zb7FPVjqdwunHz+aohXlcdM0/6e4ZvjF3KPF4vOxeW82y/GR2ZnTR7A2vRFko01uk10ygTD91Nm+NI8kEoAKlPbOZHaPtLnReVeGTTmnQDxBpGP0ySCG+6qSTTmLnzp2sW7cOVVVZvHgxiYlSLShCk9l88B7cYrEwZcqUQ0kmAJPJNOg1a9as4cILL0Sn01FZWcn69et54IEHePLJJ0c9/xtvvAEcbOZ93nnnccEFF/SrajrllFMOvb99+3bOPfdc1q9fP+hYjY2N/OUvfxmy4kocJIkmIcSgFEVhQdx85sXOZV3rel6sfpkGR2B2ptvdtYebtv8f+VHTSbemk2FJJ92aRro1jVhjLIqiEGuKJd4UR6vzy6VPPZ4eHir7O2uaP+Ly3EtIMicNGLsgOp82VxvvNbzPqemnDHhcjE18bAQXnL6QR57WbjeQsdq3t5HEOgsxh8VS5m7XOpwJwZwapXUIE1JMcjSfLo8CRt5lbiS7u/I0TzTVqDNod3VpGkOokEST8IekpCROO+00rcMQYkQOh4Ndu3ahqmq/9wH6+gZ/4e+6665j1apVnHPOOQAsWrSITZs2jWn+e+65p9/HDz744KH3FUXpl2j6v//7PwAee+yxIcc74YQTxhTHZCKJJiHEsHSKjsUJh3NY/EI+av6Yl2peocXZ6vd5VFT2dO1lT9deAPSKnjRLKq3OVo5OWsbxKccy1ELfko7t3FByE9/MOIMVKSdg0H35qy3RlMiRCYt5re5Njk5eJjf3fnT5OUdgs5p46MlVuN1j6x2jlc6uPgrbEiiLatc6lLAX7dbh7RlfxY0YnPk7c2k3+udru6c9ETL9MtSYGaQh/yERBllyIcbnrbfe4qc//Sn79+/H4/GgqiqKouDxjD8xLYS/2e32fsmcr74/1KoEt9tNXl5ev2NDVT+NZKy7MW7atIktW7b0S4ZdffXVvPvuu2MabzKRRJMQwid6Rc+ypKUsTjiCVU1reKX2NTpcHQGbz6N6WJa0lJnRM3B6nfxu5+3Dzuf0Onmm6jnqe+u5cuq3Dx1XFIXv532HDa2bWNv0ESdJ81W/URSF805bwOyZGdxy72tU17drHdKoHNjViPkwPQ4/VItMRlPsRmZs7qHi9R3ss4fPEspwkX/GbN5M9l8Cb3f72G7O/cmkyHLVL8iLHmK8rrnmGh588EEWL158aPcsIUJVeXn5qK+xWCx0d3cfSkTt2LHDL028Gxoa2LFjR7/k0VcTX1+46667+N///kdlZSVHH3007777LscddxxXX331uGOYDHQjnyKEEF8y6owcn3Is98y+g/Ozzg3ozfKzVc+zp3Mvd+3+g89JrXWt6+nzDHwyszB+PsckL/dzhAJgRl4q//zDZZy4bKbWoYxKb6+LhbpkrcMIL6rKohYzJ77Yhu6GNex9dhMOSTL5XWxqDB8t8+/v1lAoOjShfTPyUBFhsGkdgghz0dHRrFixgujoaCIiIg69CTFR3HjjjaxYsYLa2lq+9a1vcdxxx3HrrbeOa8zHH3+cI444gm9+85vceOONnHHGGdx+++2Dnvvkk0/y8ccfk5mZyfPPP8/69evHXFE1GUmiSQgxJma9mVPSTuK2WbeQbk0PyBwu1cW/K/+L0+v7q/oOr4MNbYOv35Zm4IFjs5q48ZpT+M2PTsJiDp9iWfe+PiIVaWQ9EotH4dhyA0f9rZLWW1dRtmqP1iFNWDEpMXRcM4dOg38zQ3MTta8mMtGrdQghwaa3olekAkWMz6mnnsprr72mdRhCBMyJJ57Iv//9b26++WYOO+ww1q5dy/HHHz+uMe+99142bdpEXl4eGzduZOXKlcyYMWPQcy0WCxaLBa/Xi6qqFBQUjKkya7IKn2cDQoiQFGeK4zczrucPe+/nQM8BrcMB4KPmj1iSeKTWYUw6iqJw8jGzKJyexk33vkZZRZPWIY2oqqqVAncM9TPN1HhkN6zB5PQaib1nExWtPVqHMuElZidQe3UhVRb/97yaF1/l9zFHy6TYOSE+nXdba7UORVMRsmxOjENSUhKKoqCqKi0tLURGRmKxWA71aGpsbNQ6RCH8ZsqUKfzgBz/w23hGo5G4uDjc7oM9A5ctW8avfvWrQc+12Wy4XC7mzp3L9ddfT2ZmJna7VOb6ShJNQohxizRGcv2MX/CnvX9mV9durcNhV+ce3m/4gKVJSyjrLmNz2xa2dmzjkpyLKI6ZpXV4E15OZgL/uPNi/vLEh7zw1hatwxlRXV0HhTmZ1Jgl0TSY9C6FRkkyBVzK9FT2f2ca9WZXQMafGzu2nXr8SVHgosj/UWhexj+bbHS5J+fPlfRnEuOxYcMGrUMQIiimTJkyaKPw/fv3j3lMs9mMqqrk5+fz4IMPkpOTQ3Nz86DnPvTQQzidTv74xz9yww03sH//fp588skxzz3ZKKo61D5OQggxOk6vi4f2/Y3N7Vu0DgU42MDco37Z6HlxwhFclfddDSOafFatK+WOv7xFd09o9/GZOS+D96Mnd5XFUI7fp+fAnz/SOowJLbM4i5LLsmg1BqaRUlqkjTWn3BeQsceq3ZvKI+1Hs6N78v2/K46ZxbUFP9M6DBHmKisrSU5OPtQcua+vj6amJrKysjSOTAj/2LFjx6H3+/r6ePLJJ4mLi+Pmm28e85grV65kwYIFNDc3c9VVV9He3s4dd9wx7iV5YiDp0SSE8BuTzsiPpv2AIxOO0DoUgH5JJoBZ0YUaRTJ5HX34dB7/w2UUFwSmj5e/eByy89xQjO3+X8YlvpSzaAqbLg9ckglgXnLo9QOK1dXz87j/kWZO0DqUoIs0SMNmMX7nnHNOv49VVR1wTIhwVlRUdOhtwYIF3H///axevXpcYx577LHExMSQl5fHu+++y/r16wckmXp7e/nrX//K008/jdfr5dprr6W4uJhzzz2Xmpqacc0/mUiiSQjhVwadge9OvZLjko/VOpQBZsUUaR3CpJSaHMODt17AZWcfwSAV0CHB1efWOoSQpbZIA+dAmXp0Ph9fkEqXnxt/f127Q8HjDb1bPp0Cy2O0jiL4ZOmc8Aen09lvq3er1YrDEdrVw0KMR1tbGwcOjK8fbFdXFz/60Y+YOXMmhYWF/OQnP6Grq6vfOd/97nd54403+Mc//sGJJ55Ie3s7d999N7m5uVx11VXjmn8ykR5NQgi/0yk6Ls25iAiDjVdqQ2NHlBRzMrGmWK3DmLQMeh3fu2gJ82dlceuf3qClPbR6s/TaA9MXZyJwNHSNfJIYteknFfHeiVG4dYHvYPBxTSe37fgxN836U8gle480reI5ZR4udfL8H4yQiibhB180/k5OTgagoaEB6YgiJpJFixYd6tHk8Xg4cOAA11577bjGvPrqq7HZbDz11FMA/OMf/+Dqq6/u13tp06ZN7Ny5k76+PlJTU3nnnXfQ6XScfPLJzJolvV59JYkmIURAKIrC2ZlnEqG38VTVM1qHQ4OjkWernueczLMGbSwogmPh7Bwev/cybn3gTT7bUq51OIfYQ7yHlJa66ju1DmHCyb9wIW8t0qMGscjoyV19ZEVeyRVTHg3epCPY55nPHmcuCSYP9Y5WrcMJGqloEv5wzTXXsGTJEi677DIA/vWvf/Hb3/5W46iE8J8//OEPh943GAxMmTKF9PTxtWLYtm0bW7duPfTxQw89xJw5c/qdYzabAbBYLEyZMgWd7ss/1iaTaVzzTyaSaBJCBNRJaSuwGWz888ATqGj7SttrdW/Q6+njkpwL0Smht4xksoiLieAPvzmb+x99P2R2pevudoCqEnLlHlrzqnTUt2sdxYQRnRiF8fvzeDNJm75Xd6w3kGH7BitSXtZk/q9q86bzQEMyXe4mrUMJuki9VDSJ8fv2t7/NlClTeOONNwB49NFHWbp0qcZRCeE/Rx99NE1NTVitViIj/ZOg93g8dHV1ERUVBUBPTw9eb//l6w6Hg127dqGqar/34WBTcuEbSTQJIQJuWdJSrHorfy37x4AG3cH2fuNK+jx9XDn1W+iV0GuQO1nodArfu2gp763dTWe39n+0vapKtN5Mp1caX/ejU4iIi6SrRZbPjdfUJdPZckYyTSbtfsZU4OdrM/jP8YuZG/OJZnF4VB1/azuKLne9ZjFoSSqahL8sX76c5cuXax2GEH730EMPcdttt9HQ0AAcbAx+7733cvzxx9Pe3k5sbOyYxr3ssss44ogjuPjii1EUhaeffprLL7+83zl2u51TTjnl0MdffV9WRfhOUWUxrxAiSErat/PAvr/gDIEn8wvi5nN13vcx6CTfrqX/vvQZDz05vh1E/MVwbDSVHkmofN3yJ+qo2lyhdRhhy2DUk/Pdw3lnmudg9+sQEG+18Nzxb5BtLdVk/ud7zuW1lsmZZAK4pfBGpkTmah2GCFPXX389d911F+eee+6gT3qfeUb7dgVCjMfDDz/Mfffdxx//+EcWL14MwMcff8yvf/1r7rnnHn7961+zcePGMY//1ltv8d5776GqKieccAInnXSSv0IXXyHPsIQQQVMcO4vrCn7BvXvvx+7RdierjW2baHQ0kW5N0zSOye7sk+fxzOubaG7t1joUohRZdz8YS3o0bNY6ivCUnJdM+7dn8E6kEwiNJBNAa28f31lzBs8sf4JYU3NQ597mWjopk0yZ1gwWJxxBYfRMMm0ZWocjwtiSJUsAOO200zSORIjAeOCBB3jrrbfIzs4+dOyUU06hsLCQ/Px8fv7zn496zM7OTlpbW8nNzeWkk046lFw6cOAAnZ2dREdH+y1+cZBUNAkhgq7SXsU9u++l061tk+EbZl5PQVS+pjEIePmdrdzz93e1DoMZSzJZqa/ROoyQc9JWldLH1mkdRtjJP3Muq5ZYsetD9zbr+Jxo/nb4PX4br1eN4jPnUuxeMz1eAz1ePT1e6PF46fF46PY4aHd1a76EWku/n/U7UizJGHVGrUMRQoiQVFRUxI4dOwZ9LD8/n7179456zKuuuooTTjiBs88+u9/xJ598kk8++YSHHnpoTLGKoUlFkxAi6LJtWdxS9FteqHmZj5o/1qxJeJdLlkmFglOPncVTL6+nWuOm0+XrG0g50kaD165pHKFm2wwjKYlRdDbL/xdf2GJsxFy1kDfTnKDxBggjyY70726Lb9hP+rxaSX5WhtLr6aXJ0SzVtGLMrrvuumEfv/vuu4MUiRCB4XQ66evrw2Kx9Dve29s7oHG3r1avXs3f/va3AccvvfRS7rrrrjGNKYYn2y4JITSRYE7gu1Ov4I7i2zg8/jBNYuhyy5OhUGAw6PnOhUu0DoM+h4uiZimd/rpasxvvj+ahN0jz/JEkZCXQcsN81qZp34fOF2dmr/XbWC3eDN5ubfHbeBNVScd2bHqb1mGIMPaHP/yBVatWYbVaiYiIGPAmRLg766yzuPTSS2lvbz90rK2tjcsuu2xARZKv9Pqh72GkwXdgSKJJCKGpNGsqV0/7PrfOuoX5sXODOveBnnJcXldQ5xSDO/bIAqZPSdY6DHaX1DFXn6R1GCElxq0jrcaFySpLfUZiuLSIWrNb6zB8UpgYxcyoTX4b76XupbhU+X06ki3tW4k2Rmkdhghj7733Hvn5+fz3v//F6XRyySWXcPPNNx96EyLc3XbbbRiNRjIzM5k3bx7z588nKysLg8HAbbfdNqYx3W43nZ0DW3Z0dHTgcsnfrkCQHk1CiJBS1r2fF2tepqRje1DmizJEsSxpCcuTjibZIgkGLZVXt3Dtbc9T36Rt767UlGhKZnTjCvFlT4GW7jAwZ0sfla+U0Nfj3yVWE9HUJdN59+x4CJNXRn+zyMm3pzzml7GqPIXcXJOo2TLocBJjjOGBefdqHYaYADo7O3nqqad47LHHsFqt3HnnnRx++OFahyWE35SVlbFp08EXRObNm8e0adPGPNbvfvc7Nm7cyOOPP05cXBxwsErqyiuvZPbs2dxyyy3+CFl8hSSahBAhaU/XXp6vfpE9XaNv+DdWs6KLOCZ5OfPi5qBXZJmQFprburnu9y+w90CjpnHMXJLJ+5O8MfhxTzVSvm6/1mGEhalHF7Dr5CSqLeFRzQTw6snr/VbRdG/b+ZR01fplrIkux5bN72ZJ1Ynwj7q6Oh5//HEeeOAB7rzzTi6//HKtQxIiJHk8Hq644gqef/55pk+fDkBpaSlnn302//znP4ddWifGRhJNQoiQpaoqOzp38kzV81TYK4I2b6wxlhWpJ3BK2klBm1N8yd7r5Ld/eIXPtpRrFoPZZKDvKAt13h7NYtBSdq8B0w0fIbcIQzMY9Uw9ZRalh8ewzxYePZm+6r6lLZye9ty4x9nhXswfamVvGV/NjinmFwU/1ToMEcY8Hg+vvPIKjz76KAcOHODSSy/l8ssvJy1NGswLMZKvVknNnz+fvLw8jSOauCTRJIQIee3Odn6x9XrcanCrBa4t+BnFMbOCOqc4yO32cM/f3+X1lcFZQjmYGcVprIyv12x+rRT0mIh8cCvt9R1ahxKy8s+ex6bDbTSYPFqHMmZXzjLz68IHxjWGV4X/az6Lyt4mP0U18S1LXMKVU7+tdRgijKWmppKdnc0VV1zBsmXLBjxeWFioQVRCCNGfJJqEEGHh4f3/ZG3zR0GdM8WczG3Fv8OkkybIWlBVlcee/YR//u9jzWKIPi6e3e42zeYPtgWtZhz3raO3q0/rUEJW3vcX887M8L91Oiwtmv8uvWdcYzi9Zn5WdzR2T6+fopr4Tk87lXOyztI6DBHGcnNzD+2SpShKv8pTRVHYv1+WPAshtCe1zkKIsLAi9YSgJ5oaHI28Ufcm38w4I6jzioMUReGK844kJTGKu//6Dh5v8J/cJ1Xq2Z2mhk2D5/FYVmOk/r61eNzhW6UTSIqikH3NUbwzJXz6MA1nR3MvHq8Ovc475jFMOgfLYuN4q0USTb6KMcVoHYIIc+Xl5VqHIIQQI9JpHYAQQvgi25ZFUXTwy8Ffq32dJkdz0OcVXzr12GLuvuEsrJbgV5aVlTaRZ4wL+rxBpaqs2KVQc88aSTINQW/Qk/rLJaycIEkmgB6XiwP2onGPc4x1HQoTPxHrL7FGSTQJIYSY+CTRJIQIGyelnhj0OV2qm15ZFqK5w+dN4S+3XkBCXETQ507zWIM+ZzAluAzs+/snWocRskxWE7G/Ooq16S6tQ/G7ko7xJ++TdeXMjU73QzSTQ4wkmoQQQkwCkmgSQoSN4phZLIxbEPR5k8yJQZ9TDJQ/NYW/334RyYlRQZ3X0jux/1TGeCb25zcetmgrpl8dwWeJ4bernC9aHJGjvsarwov2c1jZdxqN3lwAjosM3q6g4S7WGKt1CEIIIUTASY8mIUTYUBSF7+d9h47dHZR27wvKnDHGaKz6iV3REk5Sk2O4+JuHcd8j7wdtTmebEybwrtFRTh3dWgcRArJ+vpSGeIVYO0R0eTB2uNifb2FP5MRMMgEUxZaP+poXe8/lteYvdmPMIsU8myKbFbOuGYd34n6t/CXGGK11CEIIIUTAycuYQoiwYtKZ+On0H5NmSQ3KfMnm5KDMI3x38vIiIiPMQZuvpXFip2GsjvDfQc0feq0KuyKdfJLs5L08D2/O103oJBPArKiNozrfpZr4pLP/UuIGRxsr22olyeQDq96KWR+8311CCCGEViTRJIQIO5HGSC7PvTQoc0miKfTYrCa+ccKcoM3X1m4nRpm4Tw4tkmgiJS+F7fETrwfTcKbERhJlbB/VNUbFyeUJo7tGfEmqmYQQQkwWkmgSQoSlaZF5mHSmgM+TYpFEUyg6+5R56PXB+xNWTHzQ5go2Y9/Yt7efCEwWI01XFNCjn1wJt+KEsV3nJPi7P04URkW+dkKEi29961soisKdd97Z7/hLL72EogzcabOgoACTyURNTc2Ax5YvXz7oWACnnHIKiqJwyy23DDj/629XXXXV+D8xIYJEEk1CiLBk1BmZEVUQ8HmSJdEUkpITojj2yMB//7+w/8Naju9Ox6ROvD+b+h631iFoKu0HR1AaMfmWfdX0DPxZdnv12N2RuL36Ia+rdMnmCGMlO5gKEV4sFgt33XUXbW1tw563du1a+vr6OPfcc3n88ccHPScrK4vHHnus37Ha2lpWrlxJWtrARpDf/e53qaur6/d29913j/lzESLYpBm4ECJsFUXPZFtHScDG16Ej15YTsPHF+Jx/2gLeXbMraPPt3FjDkTNTWJvchJuJU/2i9EyuJWNfNf3UYt7KdgIDX52e6DbWd1LXl02apRKAur5sfvzp+Wxp7ARApyiY9HpMeh1mvR6TXsGk13HknEYtww5rdo9d6xCEEKNw/PHHs2/fPu64445hkzyPPvooF110EUcffTQ//OEPueGGGwZUPZ122mk888wzfPTRRxx11FEAPP7445x44olUVlYOGNNms5GaGpx+pEIEwsR7aVYIMWkUxRQFdPzT008lzSp/5EPVjGmpzJmZGdQ59+5qYGlzCrqJkmdSVTzNk/fJr+r0MIFyhqN27sqzuWvXj3mp9jy+8e6Zh5JMAF5Vpc/tptPhpMneS02XndquHuqcA5eFCN/YPb141cm9VFWIcKLX67n99tt58MEHqa6uHvScrq4unn32WS655BJOOOEEenp6+PDDDwecZzKZuPjii/tVNT3++ONcccUVgQpfCE1JokkIEbYyrRkBa66aa8vhjPTTAjK28J/f/PgkHrnrEn5yxbHodMGpStmzo45jOtJQ1PDOUES5dZz0Tg9lH+zWOhTN7Ht3JycFrigy5NV323m4xMm1a+No7e0b8fz5OVZc6uStgPMHWT4nRHg588wzmTt3LjfffPOgjz/99NNMnz6doqIi9Ho9F1xwAY8++uig51555ZU888wz9PT0sHr1ajo6Ojj11FMHPfehhx4iMjKy39sTTzzht89LiECTpXNCiLClKAqF0YV80vKpX8ddnHA452edi0EnvyJDXXpKLOkpB6ubMtNiuemPr9LbF/gnwru21rK8KBV9rAG8Cqgq3VYPn3rrAz63P+T0Gkl5aCelVS1ah6K50sfWseT6ZaxNm3x9mkYrK9lNndZBhDm7x06EIULrMIQQo3DXXXdx7LHH8otf/GLAY48++iiXXHLJoY8vueQSli1bRnt7O7Gxsf3OnT17NtOnT+e5557jgw8+4NJLL8VoHHyTgIsvvpjf/OY3/Y4lJ0vfUBE+pKJJCBHWiqJn+m2sKRFTuHHmr7kq73vEmeL8Nq4IjsXzp/LX319EcmJUUObbs6OenR9Vs/OTKnZ+Wo2x2hOUef2hcFMPLZJkOqTlgU9JcQ7dAFsctK9Wj71uIbq2RbKD2hjZ3ZN3qaoQ4WrZsmWsWLGCG264od/xnTt3sm7dOq677joMBgMGg4EjjjiC3t5ennrqqUHHuuKKK/jLX/7Cc889N+yyuZiYGKZNm9bvLTo6MFX8QgSCJJqEEGGtKKZw3GPEGmP53tQruanwBqZFTfNDVEIr03KT+MedFzMjLyXoczfVd0IYLKezeBSq3w5eE/VwEJseS4Nhcu++54tNlb1srLCzak8PruY56BVJzo2WXZbOCRGW7rzzTl599VU+/vjjQ8ceffRRli1bxtatW9myZcuht+uuu27I5XMXXXQRJSUlzJo1i8LC8d/DChGqZF2IECKsxZviSbOkUdc3tgUdp6SexDcyTseit/g5MqGVxLhI/nzrBfzuT2+wel1pUOZMiosgS4XcD/pomhvDplgHapB6Ro3WvBYjjZ3yZPerrKflg04STaOxptTO8YZ5eGM2ok7mjuqj1OPu0ToEIcQYFBcXc/HFF/Pggw8C4HK5ePLJJ/nd737HrFmz+p37ne98h7vvvputW7cyZ86cfo/FxcVRV1c35JK5L9jtdurr+y/HN5vNxMVJxb0ID5JoEkKEvaLomWNKNBXHzOK8rHMGbEErwp/FbOR3vzid625/gc+2lAd0rqyUGJr//i67vqhmegUWpMWSUJSO1+XG6/Dgcbjx9LmIzE+ibFEMeyO16wdk6wqfJX7BEJ0YxUfZkmQai/d22Tll9gK6bBu0DiVs2D2ydE6IcHXrrbfyzDPPAPDKK6/Q0tLCmWeeOeC86dOnU1xczKOPPsoDDzww4PGv924azMMPP8zDDz/c79iKFSt46623xha8EEGmqGoY1PkLIcQwNrVt4U+lD47qGqNi5PfFvyPFIo0VJ7Ieu4Orf/MUZZXNAZtjflwEu/65clTXTFkync7laXwW74AgVz6dtFWl9LF1QZ0zlOWfMZs3j7VpHUZYu3AJVLt3ah1GWLgw6zxOSluhdRhCCCFEQEmPJiFE2JsdM4tMa6bP50+JmMItRTdKkmkSiLCZueuGs0iIDdwuTx3bK0d9zYG1pbTctpqj/lbBsRUGTJ7gJZuUTtld7avK391NslMKvMdOpVsJj90WQ4H0aBJCCDEZSKJJCBH2DDoD35n6bXQj/EozKAbOyzybGwt/TaYtI0jRCa2lJkVz1w1nYjEHJplgOjx/zB1q6vfWU3HfWoru2M6KbSoJQdj5zNvRF/A5womz18mC9bKcaayOmhZBu6tV6zDChiydE0IIMRlIokkIMSFMicjl1LSTB33MpDOxJPFIbp11M6emnyI7JU1CM/JSufmnpxGIdly7qlvIP/PwcY3R2dzFvn+uI/nm9UQEuLrJ2SpPdL9u3wtbyOkdvjGrGGhBjpXo1D1ahxE2IvQReKVjhRBCiElAEk1CiAnj7Mwz+fG0H5JuTQcOLpH7Vu6l/GnuH/nu1CsPHReT09LDpvHjbx3j93FnZ8ZTtbLEL2M5e50UtgU24WFvkV2vvs7r8TJzdZvWYYSVU2bbiE7fSre7S+tQwsbc2DlMjcjVOgwhhBAi4KQpgRBiwlAUhYXx85kfN5cmRxMplhStQxIh5txT51Nd18YLb23BZjVh7x17v6KYKAvZbT2UPvimHyOExGoHJAauqqmrSRIDgyl9czszjlzK7iiX1qGENJ0C5y02UOPdwJjXjE5S8+PmkR81TeswhBBCiICTiiYhxISjU3SSZBKDUhSFa644lpt+eirfXDFnzOPodAoRH+1m36v+39bdsaPR72N+weZRcNgdARs/3GW906B1CCEvOcpAt270DfAnO6NipDimiGhjtNahCCGEEAEniSYhhBCTikGv48SlMzl5eRFpyTFjGmNGejxtZYFJStRsqcQSoD5NCS4pZB7O/jV7WbEdkD46Q6rvdLNr9xQyDYUYFelr5auimELMerPWYQghhBBBIYkmIYQQk9KUrET+cefFFBeMvneXsq8uABEdNPXkWbgUb0DGjnUMn8BKyk0gOjEyIHOHi32PfMrJa53oAvMtmBDKmh08tRY2bJpBbN8CUkyyi+dwYo2xnJy6QuswhBBCiKBRVFVethNCCDF5OZxu7vrr27yzepfP18xLj2PvP97D63L7NZb8bx/Om7MhINvjAUc2mGi4Y/WQjy+8ppiaC8uJbokhan8M6h4dXTt6qNlST0/75NqtbtrxM/ng5FicerlN8kVhmoXZU9y0KfuweybXz8pwjk1ezvlZ52LRW7QORQghhAgaSTQJIYSY9FRV5YnnPuWRpz/y+Zrc1Fhc722jtXT81U06nULWNUexMte/iauvO+6AgfI/rR3y8dnnzqT5FzUDjquqSubKXNb/xj+764WL3CPy+OycFLoMUt7kK7Ne4egZNuISmql1HhjyvEz9LHp19bS4moMYXfDNjJrBr2b+UuswhBBCiKCSpXNCCCEmPUVR+Na5i7nlZ6dhMup9uqa8vp32RdPIOmrGuOdPvH7p0EkmVSXd4Z/eSsbu4RNZPTW9gx5XFIX6JTVYIydXVUb5p2XMe6KSRJdvPxMCHB6Vd3b08L/VVqpK55KqziXaMLAXmttt5MMNaaSbphw6FqGPRCFwOy5qIcmcqHUIQgghRNBJokkIIYT43PFLZnDbL8/w+fyeXicRs3PGPe/2hMETQHPaTRzz7was16/lpHe6ye4dX8JJ6XQO+7jqHbrI2WN2k3/alCEfn6hqSqqZ/tdSMvyU7JtMylucPLvOyRtr01FaF5JpzEf/+a2nXuehvdfD82utZOqKiTJEU1Y6nXRdscZR+9dxKcfS7mzXOgwhhBAiqCTRJIQQQnzF4vlTKZye5vP5doP//5Tmd5s44cU2um9ZTeXGcgBK39iO5cZPOGnL2Fe8ezscwz6ecN7QjcAT96fQurNjzHOHs8b9jaTeV0JO7xh3WVNVMhyGg5Vpk7BjgYrC6r12nlpjYOeOWSS65+P8fAdEtxee+tjDJ5tyKG108NpGLzGGWG0D9pO8iKmkW9PZ3L5F61CEEEKIoJKX54QQQoivUBSFS886nF/f9ZJP59e321HBLwt+MvsMFK/tpPT1dewfJCHhcXsoe3I9MbOOoGMMfYNcbUM3aU7KSaDmsKoBx62dViIfS2DrUztHPd9E0l7fwYwPWqk4Jcrnawq7TGSvbaF5Ww1tde0ALEyPI3F2Oo4ZcXyQ7QLdxFoqNpLGLjcvbhhYwddm9wDQ7fDS1TQd4tYHOzS/U1FZ2fgBEXqb1qEIIYQQQSUVTUIIIcTXHLUwj9zMBJ/O7ejuIzZ7fH1Y4l16TvnERcSNn7D3tW0Mt0+H1+Nlbt3Yegb1tvQM+Vh3Sw8ZH+QMmNt0b3S/JNOcCwqZ+2gBC/46k4W/nFjLnEay750d5HebfDq3sNOE/g8bKH17x6EkE0BbbRulb+2g8v61nLyqD530GR9g1Z4eMo35Wocxbvt7DvBU5f9IlD5NQgghJhlJNAkhhBBfo9MpfPfCo4iNtg55jqLA9Ix45kVZ6WsbOoHjC9v/fcqe/23E7fL4dL5la8uY5ulq6hzysd7uPtbfWELk9YlEN0V/Gdtp/ZeLqWc4aSyqo25eDbVnV7Do+smVbJqyeuSv/cEk03rsHUNXkAHsfXkrJ77b7a/QJpQPt1qx6CZG83lJNAkhhJhsJNEkhBBCDOLoI/J59Z9XY7V8mWjRKQrTM+KZH2khaV0p1X9+k93/+hBH1+C7tfnK2eca1fmVH+3D4hndkiuzB3q7+kY8r3T1AcovaCJxfzIAdfOqScyKByAhM46mKQ39zm9fPvL29LGp0SOeEy5Gqmo6lGTq9O1nouydnRh9yy9OKnWdLiz2Iq3D8AvdBNtJTwghhBiJJJqEEEKIISiKQl5WIsWZCcyzmkj8dA/Vf36TXU+uoqumVbO4nL1OFjWMrs1iotv38/t6HHhMB/voJJemojMevF3IOSkDRen/pDlmb/ywY0XGRRD3HzOLbijGYJoYrSEj7t/Mitc6WLEdDms2keg6uJRxtEkmOLgUMtsxxibjE9yrW+ykmrK0DgOdV4/ZGYG1L5YIeyJ4R5c42tG5K0CRCSGEEKFpYtzxCSGEEAFS1N3LKw+9rXUYA9T/YS0nnz6bksVRVFsGNldOdRjI6NGxMd4JQKxTx8j1TAeZrSbaUltJ2ZHG5iv3HDruXeoccK66ffgn3TO/n0dNRDk1Z1QwY042rTf1ULunYdhrAm3B92eh5MOOm/fR2+3rV+VLnc1ddL73ZfIgBshNj6O3sxf7KMczmo14Jt9GdD5S2L43ianTOul0B3jHQ68CusG/EZGrjmTzZ19W7s07fCady9YOef7Xbe/YzrKkJX4JUwghhAgHkmgSQgghhnH6D1aEZKLJ61XZ+/JWbK/rOfnMOZQssJFi15O8307XxhrqdtXijo+A384CnUJcl0qdj2OnF6fiMLSjfuWJdExyFI3T6gec27J5+ASAZ8qXywJbc5rR/8PAvMeL2PzYDh+j8a+Fvyym9uwKAJLyEqjcWuOXcdtq20Z9jdlmxnrt4WyMGJjAEwftqu9jV306xRl5zMhQUS2NNDjH9j1LMCZhJRYVFdqsOPdFY2/S0VTroKGxm8SECDLyLNgye7En19ARWYeiKpTt6t9Ha/O6ZuZ4ltCz/CNU/cjd3Ld37MSretEpspBACCHE5CCJJiGEEGIYuUVZFC+dScma0Fz+4nF72PvsJszPQjsH377Q3dpDQa+ZPTYHhncrfR4ztiiKBtrx2L6slJqyIotGfXW/8/QOPdVba4cdy/0+MOcr8ZrdNHy/igWLZlJ6czWdTV0+xzVei24opuaMikMfR2VHwNagTT9A7E8O5+N4STKNTKGkpo+SGoAY0qITWTDFQGR0B43uClzq0D3O9IqeNMM09ldH8dKBHvi8X5IBL8udEezaXMUXGy02NnXT2PRFUimW2Og0UjNtdHYNbAC/dUMzxZ6j6D3uE1T9wIrCr+rx9FDeU8HUyCmj/9SFEEKIMCSJJiGEEGIEp33/hJBNNI0ku8ZNbJyZqs0VQ55jshhJzI0nJjsKa6YF1/EHewy5rF8+gVaOHli5EV+eRJVr+Eqe0jcPkPgjKx5T/47XdfNrSPlXJD2n2/G4A98Ne9FNxdSc0v9rYJtjZl5CEYYUHVv/tHvUTdnHyyl3YWNS1+nita0uwITVWMBhUy2kJ/bRqVQdWmIXa4zH1JfLmt1uPuxyA3b4SlNuNyrvmaopPiYRZWsfzS0Dd/9r7+ylfefQ/bZKNjdj213E9KJoIqb10J66F4d58F0Et3fukESTEEKISUNucYQQQogRLDn7CGJ++hgdzcGrvvGbnS2YW3r6HUqfkULGecm4pjnoSe6mO7oLdL100MtXF8K5rA7gYEPvxhkDF96ZdplHnL63q4/kbVOpW1g94LGoyhg8bl8X9I1NzrxMki+OpWbJwERbzWlfHstfmEnzDT3UlzYGNJ6virSrkBC06SakXpeXVXvssAfg4BK7KKuOV/f1gA9dyUo8LUQWGzm8PZ1dW4avzhuMvdfJ1g3NsAF0umym5sWRXOClN+cAnZFfLjUt6djOGemnjXp8IYQQIhzJYnEhhBBiBCazkRXfPlbrMMZEaXdQU1KNTq9j1hkFzH0sH/UxOzWnVNCYX09PbDeKbvCG3k7LwWVdeSuyUQ0DGx/3bBn5iXxsajRtBQOXHgHoevXMOD6P5KmJ6IaIYbQURSFvcQ6LbpxNwWsZuP7aSc2SkZcNtma1kHlFsl9i8JW5a/glV2K0Di6x+3hf/+qlkXSrLt6PqSPnmDQibCMnT4fi9arsK23l49faMe6c1u+xsu799Hp8341QCCGECGdS0SSEEEL44LBT5vHMPS9rHcaoxaRFsfDoYjpWtNAaf7B6SPHxSbjH6MFgMmBYNvAxVVWp3jByNdLUW9Opjxq8UqT2iCo44uDNSLo7hpimWNp+1TumXenMVhOzf1tA68ImemPaqGH0zbm7ijpYcNUsmte1U7W1Bq83sNvB6TucgDGgcwjffeKtJ+VwG/nVMZSNs7LNkGzv97FH9bCjfTcLE+aNa1whhBAiHEhFkxBCCOEDlyP8qk8MRj3tP2+g9sIKeuIH7x0zkvjMWBqKByaUYhvi6Gwefsz535tFfbFvy5G8Bi+GLtOYkkwABadOpea4Cnpj7COfPISu5A7qvlWJ66+dZL+XyIKHCrFEjL3CZSSetpErwkRwNXjtrElrpGBpJkaDfszjlH2gx9YbD0BsRzZRK5dRtdFfUQohhBChTRJNQgghhA96u8MvKTDjlGn0RY0v7uzT0/AaBzYCj9wTM+x1WbPTabx0YF+moaiqSvffxr4Dm+GkMV86KKfNQU9WJ309Dv8O/NU5mntGPkkEn6Lwga6GaYeljXmIhsZump+ZhuWNpWz8WwRb1jehV8aeuBJCCCHCiSSahBBCCB/0hWGiyXT6+PsedR3XPuhx1/ahd4ozW01E/Z9x0ATVUNK2Z1D2cfkoozsoPj2W+pmjb+Q8kqjNcX4f86t6GjsDOr4YuxjFTPW2pnGNUVffxY6S5kMfGw1y2y2EEGJykL94QgghhA/CraIpMTueusKacY/Tldwx6PGmjUP3QJr9mwLa03zvkaSqKi0PjW1pH8CUb2ZBAIpFej4O7Pe8o6EDAtwHSozNou4Eurr9XM2m+KfhvRBCCBHqJNEkhBBC+CDcEk1Tzskccjc5fzBHDd7EuvDUfKqPKx/VWIpHwT2OHli9x3WN+drh2IotFByXR3RSVEDGd7s8xHtkOVWomaaPZfdG/1fIrV5X6vcxhRBCiFAkiSYhhBDCB3094ZNoUhSFjuNaAjqH5TodqdOTD74fYabo9HwW3T2LnmtbUEZbuWGAhN9Ejv46IGdeJu0ZraO+zhe1Z1fQ9fsmIl6B6W+mM/fSQr/PkeiUDYBDiqqSWmHAq/q/0mzt+n3U1Lf7fVwhhBAi1EiiSQghhPBBOFU0pU5Pojs2MFU+X2jPaMX0iId5j8wg6U0bbb+pp2ZZJS6ra0zjuW0uDKbRJ10Sr4we03yjoSgKPXHdNF5VTeEp0/02rt6gx4MsnQslR+rT2F82vt5MQ4mJsvLs65sCMrYQQggRSiTRJIQQQvggnJqB1+1tJO7ONHTuwP6Zd5tdNMyqxWMaujG4LxS3Qvfv3Lgco0tSLbqpmLqFvu9sN2566Lq+hSmLsvwyXPo1R1IWMbbEnPA/i6Kna2vgGrRbLUb2lTfSFUbVkUIIIcRYSKJJCCGE8EFvmD053PHqHiJuTkDvCP2lWWnPZVO5eXSNyxdcXUzNKRUBimhoHrMb5XYnBcfkUXBsHrYY65jGmf6dxXyYLUmmULLEkUpLa0/Axq9r7OSI+VN4e9XOgM0hhBBChAJJNAkhhBA+GEv/IK3teb8M46+iMNlNWodykAdi6+KIaIvA0GdEVVUSy5LZ9OCOUQ0z+7yZ1F5aHpgYfZCemkr3Hc103d5E6nPRzLusEN0oGq/nnzWPt4q8AYxQjNYMQxx7PvN/A/Cv21hSSXSUFbdHvv9CCCEmLkVVA9DtUAghhJhg6ssbuWreL+npsGsdyqhlzcnA+Ac3fVG9msyvuBXSP8qm6pEG6ksbDx3X6XXodApul+9L72Ycn0fXLc2oBm1uX7JtWdT21uFW+++SF1+VgOMBKF1zYNjr85YX8N4ZcXjlpT7NHevJoHZrMwaDnp4eBw7n2Hc+HI0n7r2cjq5e5s/KDsp8QgghRLDJbY4QQgjhg9TcZH7xyA+0DmNMqrbW0PsjiGiNDPrcKTvScF5sYP31Jf2STABej3dUSaa0/GTsN7ZrlmRKs6TR0NcwIMkE0JrVQvfdzSx4sJCk3IRBr8+cncXa0+MlyRQiPjM0krgggb4+V9CSTACvr9xOSmI0B6qagzanEEIIEUxyqyOEEEL4aOnZR3D6VSdqHcaY1O1poO2qPqIbYoM2p8lupPzGBpoqWvwyXkJhHG6zNn2NkkyJdLg6cHidQ56jKAp1i6qx/MvLoutnY4kwH3osMTuBHZdkY9dLIXmo6FZddOgd2HuH/p4Gwt79DWSkxlJd105vX3DnFkIIIYJBEk1CCCHEKFx17+VMnZ2jdRhj0lzZSv3324mrjg/KfPH/TaOttt1v4xmi9H4by1eR+kgKIvPp8zqwe3xbNukxeag5s5zM5+OZc8FMohKiaPhBIc3j3J1P+F9KpyXocx6oakFVVWYVpPPQk6uDPr8QQggRaJJoEkIIIUbBZDHxm6d/hsVmHvnkENRe30nFd5tILEsO2ByqqpL+aRZb/jm6Jt8j0UcHN9FUEJWP3WNnT/deutxdo77eHttD809rybjxSLKjkjksNp2syGgKYhJYEpnJEZ1JzC6PYnpMcBJ/YqCV1hpmzkun8PDMoM3Z0dVLa7uduBgbZRVNrF2/L2hzCyGEEMEgiSYhhBBilLJnZPCjP1+pdRhj1t3Ww97vVZGyM83vY0c2RxN7SwobfroDr9e/y8R6SntR3MHZ/S/OGMverlK8jG93sKzmuWxe1c6+96upfrkGz+sddL3SzP7Xq6jc3EhzRSeON9s4PDbdT5GL0fAq8H50He9ZaphR7P//D0P5oj/TkoV53PnQ27S09QRtbiGEECLQJNEkhBBCjMGJly/nuEuWah3GmPX1ONj+g/0k7vdfZVP6ukwqzmtk19uBqdDY/c4+Im9KxNBnDMj4X5VkSUJlfImyLGUqHzw68k5/bpeXypdrWKrPwKiTWzOt7EsKXrLnQNXBvmXLF+fjcLq5/S9vIhtBCyGEmCjkbkYIIYQYA0VR+O5dl6LTBafCJhBcDhfOCP81I+7M60RvDOzytj0ry1B+ZsXaaT10LN4UT0FUPsnmJL/MMTViCge6y8c9jrc2FvDt50MBylZWU3ggkiXeNJZZMjgqKoNFcWkUxSaRHRVDlCk8l2uGgzidmeyK4H19v6hoSk+J5d4bz2Hbrhru+MtbuN3Sx0sIIUT4U1R5+UQIIYQYs1+ffBsb3t6qdRhjklGYhvpP/1ZxZLyRw/rflfh1zMGk5CWR/0gGngQP5faKQ8fzIqbS6eqkyTn6reONipEpETns7fZPRVayPpVPbo/F12STL8w2A4knJLO+vc5vY05mxYYEUEG3rY+m5u7gzTsjg7/+/sJDH5fsruHntz5H8YwMbrv2DGxWU9BiEUIIIfxNKpqEEEKELKfDxWt/f5efL7+JX598G5ve26Z1SAMcf8nRWocwZmnHJ/p/0Aj/DzmYhrIm6vsa+iWZAMp69tPsbGFaZB6JJt8/v1RLCjHGGL8lmQAaPfXkL7T5bTwAh91N9cu1LLNk+DF9Nfkk660k6CyYd7lpWdkc1CQTwIHK5n5L5YpnZPDHG8+hZHcNP7rxaZrbghuPEEII4U+SaBJCCBHS/nLNo5Ss3sWGt7dy/Ym3sun9wFfLjMaR31yEJSI8lzQ5jgxATxr/rcQbVvqMFHriBo9fRWVfdxktzhbiTfFk27KYHjmNGVEFTIucRqY1kxhjzKHz8yPzaXI00zyGKqiRZB3l/y+IAux7u5oj7MlEmqTyZSym7rNg/qCX2tp2Tebvtjuobejod2z258mmqro2rvr1fymvbtEkNiGEEGK8JNEkhBAiZJnMRqbMzul37K8/ewxPCPUxsUZYWHrOEVqHMWqJ2fE05zT5f2BncOpsUo8cuR+Tikqrs5VKexWl3fvY3bWHfd37qO6tpsPVgV7REWmIZG/3XjxqYH6mVHfgbrUq1jcwZY+ZrMjoUV9r0utZqktniTuVJd40lqppLCWdhbHB23nNFzpFoTglniiz/xJq2fooKitb/TbeWD3x/KcDjs2ekcEffns2HV29/OA3T7F1Z7UGkQkhhBDjI4kmIYQQIa1gYV6/j8u3V7HqmY81imZwK751DIoSXguZsk9MD0zMjuC0flQ9KjrX+G5jPKqXbnfgliil6NNY/YgrYOMDtFR2YlhlZ05syqiuW+RIouyDGvZ/VMf+NbWUra6lbFUNtS/XckRn0piSV/6WZLNx7KJaYqesZU66/+LJc2n/uQG8+cF2Sg80Djg+Z2Ymf/jt2bjdHn72u2dZ+fEeDaITQghtOdxuKtrbqe3qpMneQ0dfH3aXC7fXG/RYVE8zavfDeDtuQXXtDPr84UiagQshhAhpb/1zJX/8zl/7Hbtvza3MOmqGRhENbv+2Ch751b9Z/9YWrUMZUfLURGIfNNOd0OXXcRW3QuRNiexZWebXcYeSlJNAzjVp1CyuQAmx3f+MipGel4qo2u0IzoQKTD0li7XdI1fALLVmUPbW8OfpDApTjstgt9JGU6/dX1GOyqnzFTpNOwCIdhbz+ib/VJ0ZUDjamc6edTV4vdreBi8ozub+m88dNOm7dVc11972PH0OFz+6fDnnn75QgwiFECK42vt6+fe2rby8ZxfdTifdTgc9ri9ftFGAgsQkFqSlsyAtg4Xp6WRERY/7xTPV0whKBIruYLNJVfWA82NU+zPgeB9wf3mycR6K7UKwnIGiSO3OYCTRJIQQIqS1NXbw92uf4IP/rsXrVYlOiOKZ+ofR6/VahzaoTe9t4x/XPUnZlnKtQxlU+owUbPfrsMf6tz+TzqUj6vdJ7Hqr1K/j+iJ7bgbxP46ksSh0dmJLq1jA2qeDn6DJnJ2Ia6qRLW31DHaDd0RMOhWv1PjcSFynV8g9LJW2ZA872ke/1DLabEYBOhy+JdyOzE0kOsKF3tRNp/nLfmw6r5HPNs2k1+0e5urRmWGIw7bDQ319x8gnB9A9N5zF4gVTB31s685qrv398/T2ufjjb8/m8HlTghydEEKMX7Pdzsa6GjbW1rCprhavCgk2KwlWGwk2G/FWGwlWG31uFx9WHKCxu4fqrg6a7b79HZ2bksa8tDRyYmKZl5bOzMQkDDrfE0Cqcytq25Wg+3wTEWMBOLeB2gG2C1GMxaj2/4BzXb/rlOhbUWzn+zzPZCKJJiGEEGGhem8t/73jBXSKjmv/ebXW4QzL6/Xy/n/W8MpDb9PX00djRTP2rl6twwLAEmFm9i/zqTqxfExVQKqqDnjVUO/QY/u/+KBVMg2m6PR82n5Tr9n8XxWnj2fD7cmg4b5w8RlRxMyPYUtv46FXgmfHptDyagPqGKt4knJiiJgTxTZ7E92ukZucH56dSGTqFsyeFN7dbMY1wnKHrOgocmd+Bsrg8TlqlvFZlX8btpvQcWRzEnt3aPezk5sZz+P3fguDfvAnRX/650qefX0Tf7v9ImYVpAc5OiGEGBunx8P9n37M22WlHGhvC+hcRp2Ok6blc3HxHKbGxWN3OUmNjOJAextb6usoTk4hPyFx0OST6mlCbT4VJeqXKLZzUT314FgFai9Yz0HRRQLg7bwT7P/sf7EShZL4Joo+OaCfXziSRJMQQoiw4vF4KFm9i0d+9W8iYmxExEYQEW3jmAuXMP+4Yq3DG9THL6/n5jPv1jqMfvIW52C6XqUjtX1U1+ncOpIeyaD90kYcEQ4MfUbMN0ZTuuZAYAL10aI7i6lZXqFpDF9QUGh4uIiuVu2b1psjDKQUxNPdYKe1tptBy5xGyWTVk3VEKtWRvRzoHPzJQ4LNSlHxNlTlYJIrunc+r2/tG3bcU2ZH0GVbP+TjvowxFsvVDPau1rbp9s+/exxnrpg76NKP71z3JLvLGnjxH98nKSFKg+iEEGJ0muw9/OiNV1lfWxP0uQsSEilOSSHSaMJiMLK3pZnPaqtRVZU5qWn8dL6NBWmpKKYFh65R3ftQDNOGHdfb+m1wfjTwAfMKdHEP+vvTCHuSaBJCCBFWert7+d6ca6n/WhPdWUtmcN/qWzWKaniqqnL9ibey+f2SkU8OIpPFyJxfzKTmlHIYxUpE27XxtJS1kffLTFqf6Wb/p9oneKa9leb35YDjEb9jIetfC514AkEFsmYlok4zsaWjoV/F0orCGOzRn/Q739K+hHd3D77bW1pkBNOLNqMqQy+NM6oRrPosF4+fb12P1KVR/kGtX8ccC71OwWoxcfm5R3DhGYvweLx8sukAN9z9EkaDnnf+fQ36IaqehBAiVJQ0NnDVay9R1x24zTbG4/Yjuzgv83mU+H+DYcrBqqRh+juprj2o3Q+A490hz1Fi/4xiOTEQ4YYtg9YBCCGEEKPR1drN8vOPYtN72yjduB9VVTn+0mVcff+3tQ5tSIqisPDEOSGXaHL2uVj/+23kvp2F7dd62jN82/I9dkEU+9aWs+Hn2va2+ULOvEzssZ1ah9FP9LTQWCoZSApQvb0ZtsOUeAsphyWyV2mn2+XEGbVtwPm9MWs5PHsZ6yqbyYmNJivORHRULx5zHXbdLtQhlsx9waX0MCs1nq11LX79PBzDJLeCyeNV6bY7aGrp5qlX1vPiW1uobTj4f+yk5UWSZBJChKwuh4P1tTV8XFXJf0q24vCExu/VwRxMKTlQW8/9/EAEqi4F9KkH33SpKPpU0MWj9r0OfW+OOKba+TswHQ6KlYMvw5jCbjdif5NEkxBCiLCSnJ3ElbdfxJW3X0RHcyf1BxopWDR8ubPWutt7eOael7UOY0jlG6owXGhg3k9mUvuNSlTD8E/4PcWuYR8PtqRlcdQSWommDlsdkKJ1GEHT3dpH91vV6BU4+aJEGpSB1VyKAua0Tzg2zYTr88dHu+9hRqKTrX7u+W5XtF/i+FUej5enXl5Pa/uXTXDPO3W+hhEJIcSXup1OKjvaKW9vZ0dTA59UVVHSWO/3atOgUXvAs//g2xeHRjuGtxG1cdGhD5Xk9aDE+Ce+MCWJJiGEEGErJjGamMRorcMY0VO3v0BH82ifUgeX2+lm/T0lZL2TQfSNRtoyh65u6kkLnc8lNjWaviWhV57f5mklPS+b2jLfdlubMFTorumFzCEeVly4GHui0mktBVLHfP3XxVksJLQZic9K4ECVfyulxsrt8XLC0pn879WNABy5YCo5mQkaRyWEmCxUVaWlt5fKjvZDCaUv3q/oaKelN7wrdhV/NCscibcTdJJoEkIIIUSANFQ08eIDb2gdhs+qttawaFPxsImmmPXxQPAbfH7V1MU5xJ8XRf2ialoNoZEg+Lqph+mp1W4jPs201XkwBWhsh66VgsSZ7Gke/w5Gc+JS6F3dzv7WeuKirdgsRux92lfrbSyp5JafnXoo0XTBGQs1jkgIMdF4vF7qe7qpaP8ygVRxKKHU4dPOouEqKIkmNXRekNOKJJqEEEKIAHI53bicodurYDCevOFvMBtfDuw2xV83+7yZ6C06+uodmJNNuM/oozW7mVqCG8domRK0T1poobHKOVRBk1/kJqvsaR7fGLNjU2h8qZ4vOmi0dfYSaTOPOzZ/qK5r40BVC3k5Seh1CvOKsrQOSQgRhhxuNzVdnf2SSBUdHVR0tFHd0YnTG1rLhoNFGaEfoF94JdEkiSYhhBAigDKmpRIVF0FXW/jsQNaePXQCJ646nh2bywM2t9lqYvaN+fR+6qJmfT1512VSu7gqYPMFSqYyhY8eDa8Eo7847F7S9JnUeaoDMr4SUQ7E9juWGxVLVXeHzz1CojwGvpqr0usVuu2hs8zx8Wc/4YwTZpMUHznpG8oKIYb2Rb+kii+WtrUfTCZVdrRT29UZjNqdsBOU36hS0SSJJiGEECKQFEWh4LBpbHh7q9ahjEinU1hwexE1UZVDnmN5LzKgMcw8Zxo1x1bCsWBRVWqV8EsyZehy+PRPNhy9Xq1D0cyeJxPIuLSDLo//b7Z79LWsWKRCUyE9pSqNu9vobm1j4TcyWNde69MY+r7+H8dG2WhpD51kcE19OwpwzOICrUMRQoQYh9vNm/tK+U/JFjbW+fY7TwSZGloblGhB9kkVQgghAmzGYdO1DmFEBqOe+ffNpGb50EkmvVPPvhcqgINJqcJTphMZF+HXOFzf+LLJaLhVcigo5Lpmsv7BCBz2yZtkAmiqcmLbG7gkiV1fR3JsA/s/rqO79WDWyL65y+dXqj1dA6vNjEb9oOfaLMaxhjkuL769lTD7LyCECKCazk7u/mgNSx77Bz9/5w1JMoUyb+htUhJsUtEkhBBCBJhOH7qv6yRPTSRxZjzmM3XUzhp+qZOi6sg9PgtDnJ6uU1ppT2hg+o5Mtn6vFK9n/ImV6Uun0JYZmo29h6OgkO0poPQ1C+/vdjCGjZHDktmqfF611T8bojfAsm9bqEnYHNAvhWpy8dXXTFsqO1kyLYOGSAd7O/r/HOkUhfSIKBKNNiLdepp29H+8pb2Hwulp7Cyt63c80mYGBYry09ixt/9jgVbX2MGbH+7g9ONnB3VeIUTo8KoqayrK+XfJFlYe2D9J/roEVlB6NElFkySahBBCiEAr3xEay78iYm3kn5GLYboeZ24f7ZmtuKxO2qn36Xq32UXTNf2TUQ1FdRQ/nofH5MEe301caSKej6FiZS1tte2jii92eSQ9hFeiKcdbwP43bKzc0QeETo+fQFJ0Ksf+yEhdxF506EggBUNnNN3VJno7VSIW11LpqQtokilTycWrdwH9G3iXrTy4G2JhWgQJM2Lx9nnpqbfTUt2Jx9VBIx00DjHmztI65hZmsmXnlz/j03KT2LKzmj6NdqN7/NlPOOnooiGrrYQQE4/D7WZjXS1rKst5a18pFR3tWoc0oQRj1znVuRk8TSj6pIDPFaoUVfWxa6IQQgghxuSKwp9StbtG6zBIn5EKj9uDMpeqqiRWJmH+LILmVe1UbKxmpFuOORcW0vSTwDSQ9rdUfQb1r6dQtrV35JMnmCmzLOhO3RzQOSw6C27VjVv9combQTGQ2VdA6VsmKnf3kZxlpLHK/wmgOTMzAAVVVTlQ1YJX9eJwuJmanYjBoGNnqW+JWX+59vsn8M0T5wR1TiFE8O1ubuK+Tz9ibWUFve7JuZlEMNy7pJUz0p8NwkxGsJyMEvN7FCU0djUNJqloEkIIIQLI2eekpjS4S26G0tXUTVSQ2jMqikJLTjPkNMO5MLUzmfjNydjXOjmwqhJ758AETdOm8Klm0h1Io2xr6DSPDqaMWToC/ROdUF3E9nddzDtLoSO2iuiWHDa/5GZPgxs42JMpEEkmgK27+ieFoyIsREaa2XvgYC1U8YwMSoKYOP7Xc59yyjFFmIxy2y7ERNTR18f96z7m39u2+LxzphiPYH2NXeDeMymTTCCJJiGEECKgKnfX+KV/kT90tXQT7Y5BNQT/RrY3upeaoyvgaIi/3kz+nmz064zUfNBIfenBJ/C1exqY0pOEIyK0l6AZFSMHNkzeV5tNGYFLsOX2zMbRbGTdK3047F7efwgghS+SS1ro6uk/d8nuGopnpFOyOziNeBtbunjt/RLOOmleUOYTQgSHx+vl2Z3b+cPHa2ntm3zVsVoJ5iYLivXM4E0WYiTRJIQQQgTQpne3aR1CP9buCOyx2u6G4jV4aSyqgyLQXQEz67OJ3BhDx5oebOXGg4+FsJjdc9hdOvmqmXR6OOZqI+WGAP5MG92sfVqbfkijsau0HrPZgMMRnITjv55fx6nHFmM2ya27EBPBprpablm1ku2NDVqHMukEo0fTQXqwnBGkuUKP/LUSQgghAqCxqpmHfvoYH734mdah9GPttGieaPq6jtR2Ok5th1MhtCIbKNdezPsvTb4kE8Cyb1kotwW2N1O9ZT+KLhfVG8SXnMcgf2pyUHs1Nbd28+p72zjnlPlBm1MI4X+NPd3c/dEaXti9U+tQJq2g/XWxnISiTwzWbCFHEk1CCCGEn21bvZPfnHo7fT3jWwIWkxJN/g9ycGU5Me4xsfm+nbhdnnGNaWg3Qfa4hpi00nXZfPjXybtkTkkM/HbNKc5cdoRwkklRICcjgYqa1qDP/eTz6zj9uGLMZmPQ5xZCjJ9XVbnspefZ29KsdSiTltVgYH7c+oDPo8Q+BObjAj5PKAtOR1AhhBBikmhraOf3F94/riSTLdrKol8WE/OMkZqTKmgsqqPmrAqK/zodS8T4mkrqe+VP/1hE6aPZ+UQsnkmbZ1Jp1TcGfJb2koiAzzEec2ZmUl7dQo/dGfS5W9p7eDnEluIKIXz31r5SSTJp7Oo5TtIslYGdxFCAYjkeJZjNoEKQ3G0KIYQQfuLxeLjz0gdorWsb0/Umi5EFPygm9fkoas6uwG3u36umYVYt+f/IIjJ+bE/GE7PjaZgX2v2PQpEeHY4PptNSG/q9g0bDbNORNsXk07nJWWa6PV0Bjcems7H1A3tA5xiv3WXa9lP594vr6HNMrJ9DISYDr6rywGefaB3GpJYTE8EVuf8K/ETmYwM/RxiQpXNCCCGEnzx1+4tseq9kxPMiYm0UXpkHej7f/kQFPbQvaaEuvmLYa5vzGsl+JBHzq7m42tw4WpxUbqjB0TtyhUXuT9OpNQX4lbwJKKVmHms+Ce0EyGgoOpVjr9FTZ92H0+vkONcMPG1WHJ06etuhq8VLe6ObtgYX3s9XambPMjK29Knvku1TKRnn0tBAMpv0mid5WtvtvPj2Fi48Y5GmcQghRue9/ftosduJNJrodgW/IlLAb+fvxqwP/K62iiSaAFBUVQ3+HsdCCCHEBLPlg+1cf8Lv8HqH/7Oq0ynM+VsBDbP9tzV6+idZbPjZjmHPyZmfifPPHSi6yV3KPVo57hms/CMEsX1owC25IIK6nA0jnqegEKGPwEoEHty0eloCFlOmMoV1D9jos3sDNsd4JcZF0NymfSP42Ggrz/71u1gtvlWjCSG094PXXyHOYuHpHSO/GCX8b3lWNI8svifwE+mSUJLWoCiycEy+AkIIIcQ4tda3cftF94+YZAJY8KtZfk0yAdQurmL+d2cNe078DyMkyTRKyfpUPvqrnomUZIqM1dM5dZdP56qodHu6afI0BDTJlMU0Pr7PGlJJJr1eIT7W1u9YhG18/dH8pb2zlxfe2qJ1GEIIH3U6HDg9Htxq6PyOm0xMOh2/nfNqcCYzHyNJps/JV0EIIYQYB4/Hwx2XPEBbQ8eI5xafPYPq08sDEkfD5VVMXzZlyMfbcwK98GliseqsVPwvFUcIJT/84bCLdfR4tK/K+UKON5819xpxOUKrwL5oejqt7XbiYmzMyEtlbmEmcTG2kS8Mkv++tB67D8tlhRDaW3lgPzcsWcwnVcMvjReBccUsHbm23UGYSUGxfiMI84QH6dEkhBBCjIHX62X9m5v53z0vU7J65AqR7HkZtF/TELBdSFSDiv32Vha9VMzmP+3E/ZVeN4qi4LD2BWTeiSpqTxHby0InIeMPWflmqiNDZ9eyRH0yH/5Bf6gPVKgonpHBtt01ALR12GnrGHt/rhl5KThdHuy9Trp6+vy2W11HVy9vfriDs0+e55fxhBCBkxYZyVTTyzg9IfbLbhJIibDyg2mPBmUuJep6FJP0z/uCVDQJIYQQY7DpvRLe/OdKKnZUD3hM97UlajHJUVhuA485sDeZqkGl5pwKZvw3m6zZ6YeOR8TaDjYeFz6x6qx89srESjIBTDuzGw+hU6EV2ZkSUkmmvOwkimeks6vUPzszGvQ6dpc1sL+ymfqmTnrsTpISIv0yNkDJ58kwIUToUlWVOXG7ULvvxeMNnd+/k8X186qJMAR2x1QArOeD7duBnyeMSEWTEEIIMQYLT5zDwhPn4PV6qdxVQ+nG/cSlxpKZn0Z8aiw/XfJbSjcdwGDUk/uHNJoS6oMWW2tWC8pDCgufL2bzgzuxxVkBWWbjq15vL7OPiWDzuxMn2TTnOBuVbNQ6jH7a95kBt9ZhAJCVFkdZZZNfx4yOstLa3v9nyGjwX8Z3p58SYkKIAHLvwtT9S0DFLXtwBdWitGhOT/t74CcyLUaJvilgFevhSiqahBBCiHHQ6XTkFmVxwmVHs/DEOaTmJmOymLjuiR9jNBuZd0shTfnBSzJ9QTWo1J5fQeF/c0hfnBz0+cOdblEZFtvEuE3SG8ByeJXWYQxQURI6yc+4GBt52YlMn+K//ytREQObh5tN/nuNt7ahY1zL+oQQgad2/BLUXgA8PmwYIvxDpyjcOHclAc/96KegxD6AohgDPFH4mRh3UEIIIUSIyS3K4qdvfYea47Rt/tmS3UzDj0IvyRDq2j1tHPWtiVH4XbTURrOnUeswBph1Yuh8fbftrqGsshmr2T9PFrLT4wZ9gmMy+ncN6+59wU9iCyF8o6oOcO879LFbls4FzYUFFgqjAlzFq8SixP0DRRcT2HnClCSahBBCiAA5ftlyZkQVaB2GlHOPUWVUCVNnW7UOY9y2fWAnYddCzLqBFTZacqc1AqHzCn9eTuKhJuC+mpabRKSt/9d19owMKmvbKK9uHXC+wY9L5wCefHEdfQ6XX8cUQviJu5yv/o7zyNK5oJgWF8lPZ/wnwLMYUeL+gmLICfA84UsSTUIIIUSA6BQdJ6Yer3UYYoy8eEk/LbSSIWP12Ss9dL04kyR9itahkKbPIn77Qj66MxIIjSSo0ainu8cxqmvmFGayr7yJnl4HcwszDx33DvNkcndZPYXTUynIS0HnhwTwtl013HD3yzhdodHrSgjxFe6yQ++qqlQ0BZrVYOC6BR5eOfZB4kz+7bn3dUrMrbLD3Agk0SSEEEIEUI974jSUnozqPNUsuTBC6zD8omq3gy33J5KsTwv63AoKOWo+plULWHt7JOtf70H1hkaSCaBwehoNzb7tTKQoUDwjg607D+44qargcn+5fZ5jmAojj0dlZ2k9e8oaiI62MKcwk9Sk6HHF/tmWcm6+9zXc7hDawk8IAZ79h971qrL1ayCtyI3m7ZPf4Ht5j2DSB7L/nwUl+nco1rMCOMfEEDqL44UQQogJRlVVKu3SHynceZyhkxAZrz67F1tnEkQEZ8cyk2Ii3V7A7jf0rNznAEKveXVuZjwlu3xbMqfTKcyclkrJ15bYfXU3uZ5e357ktHf00t5xMFmVPzWZvfvH3kdrzWf7+P2f3+K3Pz4ZvV5eRxYiFKjuLxNNblWedgdCdnQENy/YxdFJbwZ+MmMxSsw9KIapgz6sqmq/VgWqtwN6XwDbBShK+C/DHy35iRdCCCECoKx7P/+tfJp93WUjnyxCVnbrPD54fmJVpfXWmyAvsHNE6aOIa5jOxpdc7GpxA6G5tEuvV3C5PMMud/uC0aAnLyeJHXsHJum+en1nd9+o47CYxt+E/N01u7CYjVx31QnSl02IUPCVRJNecfOnpc0YdW6MOhdGnRuD4qK8J4PffjIxqmaDyaTXc1WxyvfzHsKsH/3v3NHRQ8RVKJFXD7m7nNr3Jmrn7aiGAhTLieBtQe15FCX6hkmZZAJJNAkhhBB+4VW9dLm7aHa08G7D+3zS8qnWIYlxynUW8v7DvYRKHyF/aSj1BizRFKuPw1Kax7pXenA7egMziR8VF2Sw5fMlcMMxmw1kp8ezu2zwXd76+g4ul8tKi6Oqrm3Ucej0/vkZe/W9bVjMBq759jGSbBJCa54vk9IGnYdT054fcMqm1u8HM6IJYVlWNDfPeZkc297AT6bPOVjFZJo75CmqqxS1/WeAF5wNqM7VBx8wHQmWMwMfY4iSRJMQQggxCh7Vw6ctn1Ftr6bV2Uars5VWZxttrjY8qvRImSgylSl8+KDKREsyAZTv7CXvZH1Afl5juzN5/9nwqQCz+7DMLcJmIjkhitIDgy9ty86Ip6qujbmFmaPete4QP/abf/b1TdisJr574RL/DSqEGD3DdHB9NuwpTq+OKJOBLmf/30VxFjOJViOlbd2BjDCspEXa+O2C/ZyY/HeCkkfXpaEkPIeiixn2NLX7HuDrjd4/7+U0iRP+kmgSQgghfFTSsZ2nK5+huneMTyZFWIjUR7H+zzY87om5Q5DHBYm6ZBo8AejT5A6v/kD2PheKcrCh92BioixERVo5UNUy6ONWi5HYKCsul8enyiidAoX56Rj0OrbtrsHrVcnNjB90Od54PPHcp1jMRi4963C/jiuEGAXT7BETTT/N/ys/nGZgc/tRrG4s5sMaC7tburj9iAPk2Co48+0lODyT+0Usg07HlUV6fjj9YWyGYCXeFJSYu0dOMjk+BceHA6+O/DGKITtAsYUHSTQJIYQQI2joa+A/FU+xtaNE61BEECQ6MtnaOTGTTF+w9sWB0f+JJtUVXomm6ro2Zs/I6FeJNCs/Da+qYjDoaWzuonqYpXAzp6exqaTS5/lSkmLYvqcWgLzsRBxON53dff12rfOXv/9nDTaLkbNPme/3sYUQI1OMc3wqVjTq3BwWv4rD4ldx7QxocaSQYG4A4DeL5nLTp5Ozxw/A4enR3DL3LaZHBvn+K+I7KObhE/Wq6kXtunvgA4aZEPHtAAUWPiTRJIQQQoxgQ9smSTJNIr0VNmKNDuJNeiJVKHO46fFMrMSTq8kK6f4f1+sKv2UCFTWtWC1GevtcxERZOFDdQo995CV1+VOSR5VkArD3Og69X1bZPOpYR+u+R1disRg59djigM8lhPga46wxXfZFkgngwqx/sab+Wt4t7/JXVGEh0Wrh1wtqOSMtSMvkvsowEyXyJyOf1/c6uLd/7aAOJeb3KIqkWeQrIIQQQowgyhCldQgiCOKq4zG8YGPnSx/hsDv5ot4n/ZJlNDnddLomzvKFmhIVY4YRl+ry67ieMEw0dXT1UpSfRl1jJxkpMZR8XnE0HL1eGdPuckZj8G+97/rrO1jMRo47akbQ5xZiUvPD71dFgdvnPkFJ08XU94T+BgvjpVMULp1p5qcFTxBlbNcgAjNK7B9RFNOIZ6pf2VXwENvlKGNMME40kmgSQgghRnBkwhF82LiKsp5BbipEyLN22LC229B5dSguBcWjoPPowKWg8ygofTo63+xlx/tlg15v2V1DUqedzqJx9ltQVYL/0uzgyrb0ktU7i+yzG6n3+K/nmNcZGp/faO3YW4eiQGu7b43MZxVksNWHnkxfZzQEf2mh16vyuz+9gdlkYMmiaUGfX4hJy0998OJMTfxx8RYuea/An/sGhJx5KdHcMu8DiqI3aBaDEnUdisG335OKsbD/98O4yLdKqElCUdWh2h8KIYQQ4gtNjmZu2v5/2D12rUMRPtK5dKS9nMXWP+/G2Tf2V5YVRUFRwH3m4Ti8vt02TY8wE9PRg7uzl762HrqaO1EUhdrDpg/Ym0ZL806w0Tl/o9/GS9y1kHWvhM+uc6ORm5lATLQVr9fL3v2NOJzuUY+RlR5HVe3QPZ8CyWjQc/cNZ7FoTo4m8wsx2ai9L6B2/Mpv492352r+snXiVNZ+IdZs5pfzWzg38z/otHytwrQUJe4Rn3eKUz21qE3LD35gPh4l9l4UxRK4+MJMeHVsFEIIITSSZE7kyinf0joM4aOU7Wm4rzCx/g8l40oyAaiqiterkmkduZQeQK+AY81Odry6kT2rdlKxrYLW2jZaalqZafNtjGCJSvXv641ux8jnhCujQc/WndWU7K4dU5IJwKDX7tbb5fbw67teZOuu0VdiCSHGwFPv1+F+PP3vzEuJ9uuYWjuvwMY7Jz/N+VkaJ5mUOJSYO3xOMgGgSwMlFqznoMQ+IEmmr5FEkxBCCOGjhfELOC75WK3DEMOwtUcSf2cam7+zh/rSRr+OHePjzmBzTEaaKgZv9GyoaPJnSOO2+sleojctJEo/tj5kCgpJplQy9LOI7FlEe3QMBvPEvL3s7Ru5QfhITD72aNLrdcyclsqcwkxmz8jwW4Kqz+HmuttfYPc+/z4BFkIMpPpp6dwXDDoP9y16gUiT0a/jaqEwMYpnTtzO7XPuI97k37/VY6HE3IaiTx7dNYpysPF3tDT/HowsnRNCCCFGwel1cevO31Npr9I6FPE5xa0QX52AZVME2/9aSm/X6Js0+6JwxVw22szDnmPSKSSs3UV7Q8egj+t0CubzjqTVMbaKmECJTTIw79t9VCqlo7puZ8lsWnr6fy7TouMxbeijvW5iLaHLzoinsqZ1XGNkpMTQ3NYzbEVUVIQZnU5HR9eXjX8TYiPISItlV2k9Lh8TnsOJjrTw51vPZ2p20rjHEkIMztv6HXCu9vu4r9edzU/WJPp93GCINBn5+bxuLsp6EoMuRJYBWs9FF/N7raOYcCTRJIQQQozS6qa1PHrgMa3DmLQsXVbidyag7tTRtrWLmq11OHrHX20ykqj4SJJOno9Hgci2bnobOrAkREG0FYfJSIeqkuJwseP5T4cdp+jsI9jgY6+n4FI58UIbZdmbfDrbprfx9ke5gz4WY7YwszGSyi2hVcE1HhE2EymJ0URGmFGAXfvqcY5hJ8JZBelsH2ZnuzmFmUM2Go+LtZGdHs/O0jpc49wFMT7Wxp9vvYDs9PhxjSOEGJy3+TRw7w3I2L/e8nOe3RteyfxvTIvkV0VPkWQeeWfP4DGiJH+EoovVOpAJRxJNQgghxCjV9dbzq5LfaB3GpKGqKokHkjGvt9G8pp2KjdWE8+1Lzuwcduelah3GAAoqOVsrmHZXOgeyBt+B76uSjKm8sGboJIVOUTjKnM6+t6sJz73ohlc8I52S3WN7wlQ8Ix29TofL7WFfRROOr1S4+VI5FRtjJSc9gZ37xpdwSk6I4i+3XUBacsyYxxBCDM7bMB/U7oCMbfdE8Y33v8eB9sCM70/T4iK5ef5mFies1DqUgczHoov7m9ZRTEiymFAIIYQYpVRLChH6CHo84fVqYrjRuXWkfZxJ/ZOtlJSMnPgIF8aI4ZffaaUowkLZ/gaaLmpk0QeFVBmGXx5qUmzDPu5VVdb01bDwG+kYqz3orTp0Zj2qqrL/w1rUkKzq8l1X99iXaH41QTVzeiq7Sg/2TMpIjfVpeV57Ry/tHdXERluJS7VxoKplTHE0tnRx7W3P8/Bdl2Dzsdm9EGJkqrc7YEkmAJu+i/uOWM257yzE5Q2lvUy/ZDUY+PEcB9/KfRCTPvBVx2OhWE7VOoQJa2J2axRCCCECSFEUpkVO1TqMCcvcbSHjhVx6zlVZf912qkpCqcx+/EzRwydoNKGquLdVAOB1qey6pILYYZYSKCjU1vu25GpDex2fRDayVl/PancNazy1JJyegjkivF/vLK9uJSs9btzj7CqtZ25hJkX56ZjNo/uatHf2Eh1lHdf8FTWt3PnQ22FdJShEyPFzI/DBzIpezy8XhGYCZ0VuNG+f/Abfy3skZJNMYAGzbPASKJJoEkIIIcZgWtQ0rUOYkDLeyaH2jHbW372NtrrBG2qHO8Uy/I5BkUY9cy1G8iPMxJsMEIQEwPRICxWfJ5oAOsu7sd/iQa/oBz0/wTWf1XvtY55vW3sDHBOFOTJ8d0+KirDQ3jH2r8FXbdlZzY69tewfYrfCoeRmxrNjmH5Pvlr58R6efd233lxCCB+o7UGZ5lu5j7IsKzooc/kiOzqCR4+p5C+H3UO69YDW4QzPWICii9A6iglLEk1CCCHEGEyLzNM6hAknviKRzbfuxGEP1Vc//aP07S0URgxcpmTVKyxUwPzWZvY8tZaqf6+m938fkbCyhIKyehZ09zHfbCDONHjyZ8xUFdPegcmK8jdqyOrMHnA8U1/EixvHn2Cp7+3G1Rdau++NRm5mPF09Ds3mj4qw0NXjwO3xz7KZv/xrFdt21/hlLCEmPeNc0CUHfBqdAncv+DeJVkvA5xqOSa/nmrk63jzhIY5OelPTWHzmLkNVQ3PZ4UQgzcCFEEKIMejz9PHjzT/D6Z3YSZFgUVUV/Xciqd4R+OUGoUCn11FwzCx00VbcFhMGl5vK90voah25p4eiKBSevoANej8knFSVhR4PO17dOOjDBZdOoeuHX/b/STPl8OJHEYxzwzMAZscm0/xyw6ivM1j05CxKoT3eQ6RqpGVtM92tY++XNBbTcpPYV67tjnr5U5LZe6DRr2Mmxkfyz3suJT5WXuUXYry8XQ9Az5+DMtfq5hVcsTI3KHN93bKsaG6e8zI5tsDssBdISuK7KIYcrcOYkCTRJIQQQozRh42reaz8Ca3DmDDMP47hwPrhG1CLg9Lz0ygrGlhtNFoLjXp2PPPxsOfMXTeNRrWROGMCazdm0Gr3TxXSUksGZW9X+3SuCmTNSkQ31UyJvYkel+vQYxFGI/P1yUHb3c6g15EQH0lDU2cQZhvc3MJMtuz07Ws3WvNnZXHvTedi0MvCByHGQ/U0oDYtB/yQmffBHTt/zKPbg/fiV1qkjd8u2M+JyS+jhOnWokrM/SjWU7QOY0KSvyBCCCHEGB2dtJSFcQu0DmPC6PtTOwWvZWCN1HYJQDho2N+IfpAb+ySzgYV6hWm7qpnX0cOMCPOQPZ5mW00jJpkAzB/ZsOqs7NqT7bckE0DPAd92bYxNi8BwagyfJbTwaUdtvyQTQI/LRbXJHpQkE8CsgnRNk0wz8lIClmQC2LS9ikeeWhuw8YWYNHSJoM8K2nS/KPg7RYlRAZ/HoNPx/WIjb5/4MCtSwjfJBKC6d2gdwoQliSYhhBBijBRF4dtTLiPeNP6dpwQoOoWuxC7SZ6cCEJcey6L/KyYqIVLjyEKPx+1hjslArFFPpFHPPLOBwopGup/+iB3PfUrN7hp2r9xOxb9Xk7WxjIV6HfFf2dEs32bmwLMjJ5kAtt6+B291EaWN/u1HFJllw5ey+phFcVR1D5/YSVeDs5NfWnIM2/3QfHuskhIiqaprC/g8/37xM9Z8ti/g8wgxofU8BJ7yoE1n0ju5//DXsRkDt6Pn4enRvHrSWn4588/YDCMv9Q5puiRwSaIpUGTpnBBCCDFOuzv3cOfue1B9etosRpL+1MF+CY1n1eI2uzA4jCTuSEb9VEfFezW01rZrG2CI0ekUvN6Rf/Z0OoVpRxagy0qk8vWN2Dt7fZ4jZVoKB747nTqzf5t3L4xNo+XdRhxDVEpFJlgpn+PC6Rl+6cni7iQqNvq3X9Fg8rITKasc3c5w/mI06EhNjqGqNvCJJoBIm5lH7r6EzDRJpAsxWqpzPWrrpUDwm00/X30B138c49cxE60Wfr2gljPSng3rCqZ+LKehGGZAxHdRJswnFTok0SSEEEL4wXNVL/Bq3etahzEhqKo65E2fqqqYey0kbkmm8sEGGg9o86R/MorPjKfympk0mPzbbyQrMpqI9S46GwfuZDf1tCzWdg2/TMyo05P2iYq7L7B9UIpnpFOyW7tqphl5KewuG33z9PHIy0ni73dchMVsDOq8QoQz1VOP2nIeeOu1mV+Fn226ltfKusY9lk5RuGSmmZ8VPEGUsX38wYUUC0rM7WA+FkUXnKrYyUSWzgkhhBB+8M2MM5gaMUXrMCaE4V5ZVBQFp81B7ZFVZJ+eFsSoJrekKUkYLp1Fg9G/FU0AVd2dJBweP+C4JcrI5r6REytWgwGP88uqgYTsaJKnxhCTbMNsM/ilzjAywsyBqpaRTwygtlFUoPlLWUUTjz/7SdDnFSJcqY61qC3f1CzJBKAocOvsR8iMGl/yZG5yNC+u2MBNs/40AZNMgPU0wAWKVetIJiRJNAkhhBB+YNAZuCrve1h0Zq1DmTTUguDs5DPZ5V+4kI0/yuOTFCeBWjOxtbcJs+3LviIqkL4sZUDj78F0Oh1kzkoEIGtuErvzetiS1cmumb0cWOShYbmO7hMs2E5PICFrbI1ye/ucxGjcpL6xuROjQR/0eVd+vAdZACHE8FTVg7frT6htV4K3VetwiDK2c9+R69CP4Xd2rNnM7xd388zR91AUvSEA0YUA4wIUwzTwtsiyuQCRRJMQQgjhJymWZC7LvUTrMCY81auS8UE2pTdXah3KpFAyx4IrwPmNbpeTzCNTMVn1TDsuA+NpsaztrvH5+upMB6nfTGN7Ygcub/+eKF5VpdPpYF9nK1Uz3aQXDqyeGonHo6I36NFp+IREVSE1KTro89Y2dLBfo75UQoQD1dOE2vZt6PkLhFCvxnkxH/OTeaOL57wCG++c/DTnZ/0H3UTLv+jSwHYlStR1KLF/BiUWrGdpHdWEJT2ahBBCCD9SVZW/73+YT1rWaR3KhJRQnkjXH1yUb6jSOpRJITY1ho3XzwhYJVO/ucwW3F4v3S5nQOcx6/UstCdy4NPRL22ZW5jJlp3D94wKpKL8dHbsDX6fqO9ccBTfOndx0OcVItSpzk2o7T8Gb5PWoQzK49Vx2ce/YF3t8Dt3FiZGccv8T5gf+1GQIgs+JfoOFNvZhz5WVSeKYtIwoolNKpqEEEIIP1IUhctyLiHRlKh1KBOS6xGdJJmCKGlOZlCSTADtjr6AJ5kAHB4PH5sbyF2UMuprt++pJT3Fv7s5jYZWBVWrP9unzcRChDi15/GQTTIB6HVe/rjwf8SaB1/WH2kyctPhDl5Yft+ETjKhSwHr6f0OSZIpsCTRJIQQQviZzWDjqrzvojDR6s61Z82SHljB5JmmXVIlkIx6Pa0Vvu/INNVmpiDChMfjwWTUZgmd0ainrEKbJ7R79zdQ3zR8RYQQk5K7VOsIRpRqqeSOxQcGHP/GtEjePfkFLst5HINuYvc8VCKukMRSkEmiSQghhAiA6VHTOC/rHK3DmHAcp/Wgm3CNI0JXTaph5JPC0KKIVDob7T6dm2g20P3mJir/vYa0T0tJrGxmYVYCyWYjGVYjuTYT0yLMZFqNAY15Rl4KvX0jN0cPlLXrpapJiK9SVSd4yrUOwycnJL/KJTMP7q42LS6SJ48r5Y/z/0iSOfhLcYNClwjGYjAdDvpcsJ6ndUSTjvRoEkIIIQJoR8dOHjnwT1qdbVqHMmEk3Z/J1qd3ah3GhGeymtj7+3l4Jlhiz2owkrVZR3dr36FjFr1Cn2fgLbFRUZiyt4aq7SMv1yz65mFsCFClU0JsBA6nm267IyDj+2JBcTZ/ukWerAnxBdW1B7Xl9JFPDBF9bivP117CuRlPYNIHfpmypiK+iy7qlwCofW+jWFZoHNDkIxVNQgghRAAVxRRy26zfcVTCkVqHMmH0XtqBwTQxK21CiaIoqBNw+ecCSzLdrX1Y9QpzrUZm1baif2Ed+XtrWWA2EGX4cou9Oag+JZkAUBTmWYwkm/1b2RRhMxEXY9M0yQSwZUcVnV29msYgREgJg2VzX2Ux9HLx1A8nfpIJwNPw5fvmZUOepnoaUb2tQQho8pGKJiGEECJINrRu4vHyJ+hyd2sdSthL+VsWmx/foXUYE57h98vYEzFxnpREY2DJNiPsb2T/J3txOQYuRTMY9eQtzofMRA68uA5n7+g+f0ukhewzFrLV7hxX9+4pWQlE2Mzs2d+AyxUa/VN+++OTOWl5kdZhCBESvF33Qc9ftQ5jdPTTwDMJlsEaClHi/42iixz2NNWxDrwNKNYzghTY5CEvBwohhBBBsjB+PtOj8niw9CFKuyfBjV4AGWZNvEqbUJTR5GVPhNZR+IGqcvIHvZS+WsKeEV5jdbs87Fm9a8xT9XX3sfe/a5l3bDF7EiKxu71jGsfe58JqMYZMkglgzWf7JNEkxBfCrKJpUnHvRG1aimo9FyXyJyi6g3/IVHcV6OIAFbytgBtU7XrfTWSydE4IIYQIohhjDCtST9A6jLDnTNZ2GdFkYa4Ireq7aLOJZJt19BcqCuuWRpKQFe//oIawe2UJUyubYYyLBxqaOtlZWv95ZVNo7Ja0bssBHINUgQkxKYVlomkSLWZSe8D+OKCiunbhbf0OavNxqI3zUZtPRu34DWrPY6BP1zrSCUkSTUIIIUSQFUYXoguRP8EppnRiHQuJNyZqHcqo2JN7tA5hUuja3ah1CIfoFYUHluzmsplj+963Gr20XFWENcri58gGF50YxYHsxHEtnwM4UNVCamK0n6Ianz6Hm/XbKrUOQwjNqWofeMLx/8IkSjQBKJGonbegtnwTnKu/PO5tBNdn4KkC0xFaRTehhcZdrhBCCDGJRBhs5EVO1TQGHTpS1Xm8tDaWVzfbeW1tMtG9C4k1xPk8RpIxlQj98P0PAqU7uovpy6Yw+/yZLPxZMYvunsXcRwuwRY+h2kUMqX53HRGe0FimeMOiPpYkvMt5WS+TGjG27/M+m5OYa44gKiHKz9EN1NncRZKfmtbbQqSiCWDNZ+FYxSGEn7n3E55Jm3CMeRzUbuh7haE+b8V2AUqAdgud7CTRJIQQQmhgXtxcTedPN07n2XUOvmgf41Hh9a123vokjTjHQqINMUNem2xKx9C+kBfWxFG5Px+b3hakqL+k6BR67m6h+Wc11J5fQc2yShqL6phxXl7QY5nIVFUlv8u/u6iNxXkFNi7LeRyAeFMjH578IH9a2jymsayxCTQvKyT7kmUUnjyPyLjANaGKqWrGolOYFWFmgVGPMsYneXpd6Nyyf7ShDI9nbH2nhJgw3Hu1jmCMJlmiaThKLFjP1DqKCSt0/moJIYQQk8iJKceTa8vRbP4emgY97vLAK5vtvPdpJgmuBUTqv6z8SDFlomtbyPOrY/hgtx1Q2FnXR82BGZokmwZjP71TXp30s4RmbZtRL0qL5pZZf+m3As2g83Bs0lujHitRZ6FsYz1eYE+Pg40WE63Li8i5ZBk5c3P9FvMX9q7ehfGV9ZT9ezU7n/mYOa3dGMfw8+kaY0PxQGjv7GX7nlqtwxBCU2pY9meCSZ1o0qWD7VuAGUxHoCS+gqKL1TioiUsSTUIIIYQGjDojV0+7Cqtem6Veba5WEiP0Qz7ucKu8tLGXVetzSHDNh5aFPLc6ilV7DiaYvmp7bR915TOx6rRftuY1eNAbh/68hO9SpqeSdt1S3pvq1mT+rOgIrlvo5e9HPIJJ7xzwuFk/+l5NBcThcPT/fDwo7O5xEDEjY8yxDsf9lV3j9qzayfSKRmyG0d2CV9W2Mqcwk5TEwC/588VqWT4nJjt3uO4cOzkTTUr07ShJ76NYTkCJuQsl7nEUfarWYU1o/lk4LoQQQohRS7Ekc8WUy/nLvr8Fd15TBo31aTT39PD1pNHX2Z1eXtrY9/lHQ5+7raYXna6QpKwd9Hn7hjwv0CyPReF21mg2/0SQNCUJ09kzWJPuRNW5GOlnxN8Wp0dzZcF2lia8jV43dCWPTjlY7bS+rtPnsbt0Q++Y1qLXoTfo8bgDW8F1YON+kpo7SZ47hZ4oK7t7+lBH+Bp3dvexdWc1AJlpcTgcLppatdsRcM1n+/jR5culelBMXmFb0TQJmU9CsZ1z8H3TIm1jmUSkokkIIYTQ0GHxi/hW7mXYglDZlGxKR9e2iOdWR7N678DKpPHaUtVLS/UszDqzX8f1VUJ5Etue263J3BNF7o+PYv2Pp7I604Wq0yaJcEZuDcuT3hw2yfSFvx3xKAXxvlf5NKu9Qz5Wbncy5fwj0QXh826qaGbHy+sx7m9AHWWBQXVdGzq9jujI4OyeN5jahg72V46tR5YQ4U719oCnWuswxmiSVTQpNpToGwYcVtWBVbLCvyTRJIQQQmjsmOSjuXP271mSeKTfxzbpTGQaZuJpPthbadWekauYxmNTpZ0YQ0LAxh+Kqqr0PqhtL6GJoC5Fj0ejBNMXPm1M8/ncGGMrjy19mjiLb8nNBncPumGqcErsTqZdsCQolTomi5H67CQYw1wNTZ3ExtiYMzPj4FthJnNmZjJzWvCWgjzy9Ef0OYauEBNiIlJVFez/0jqMcQidfm9BYTmj3xI51bEKb9PxqJ2/R3WVHvx+ioCQpXNCCCFECIgxxvDdqVeyLGkp+7rLiDXGYNVb+VPpn0c1ToZxGngtoLfT0ZbA6j12epwq4P8KpqF0e9qDMs9XpW/OYuNHO4M+70ST3KqyM1LbGD6udaPO8z3/kmyuZnaSmVVVjhHP9SgQF2ejpXXo/k5be53Mu+Aodj+11teQh1VwdCH61DhURUHVKagKeIAeFPbbR455KJU1rVQOskp0VkE6+8qbAp4EWvPZPq664b/8/pffICM1NqBzCREKVNWB2vEb6HtF61DGbpLlVRTDtEPvq65S1PafgtoDTgPYzpHlvwEkiSYhhBAihBRE5VMQlQ9AWff+Ec+PMcQSRTrN3v1E6+N4+VMLvS4vYAFG3yx5vGKsOuwee8DGV70qaTszULYY8Sx00ji9DkVVqL1flvGMlyXCTF289jfdTfY+ynqKmRZZ4vM102P6WFXl27nRsdZhE00Am/tczD//KHb97yOfYxiKOyuRLT1jTyiNlr3PidcbnKqFfeVNXHndk9z0k1M4ckFeUOYUQguqpwG1/Yfg2qZ1KOM0yTJNumgAVG8ravv3DyaZACXieyjGYi0jm/Ak0SSEEEKEKJ2i4/ysc0kwJbC/Zz9v1b8z4BylexpPbbFjNuQRadbT69Jmh7AvZMWZAjKurT2CuPcTKX+2lk3lX/ZhikmOInlmAqV7DwRk3slCb9Bj+9nhrI8Mjb4Vn7TMH1WiKT+mCYjx6VxLlG8/o5ucbhaeu5gdz37icxyD6fQG74ldVlos9Y2dOF3BW0ba3ePguttf5KiFeaQkRnH1ZUdjMRuDNr8QgaY6tx5MMnkbtQ7FDybX0jm147eg9qH2vvplXy3r+Si2s7QNbBKQRJMQQggRoqZE5DIlIheAwxMWkWZJ5Ynyf+P9/EYxxhDL2yUHq4ccbhWHW9skE0BKjA6/pSo8kLo9A8crHna9tQ+vp27AKR2NXXQ0dvlrxkkr7SdHsioxNJJMAJ82JHNpju/nT488AMz16VzF5nuL0g1uL4vOPoLtz3864rmFp8xHsRg58H4J9o6D/y9nHj+brX2B+bqmJEaRmhSNx6vS1+fC4/XS2m7H3qvN9/GjDWUALFk0jcPm5moSgxD+pva+dDBZ4b+/bCKonKidN/U7otgu1CiWyUUSTUIIIUSYWJ58NKmWVN6sf5uSju3oeqbhDOAytbGItqn4axFb8t8y2fSk9F0KtLzvL+adrNBq6vxpXR9eFXztS54XsQNfE02eURbbrPd4WfjNw9jx0mdDnlN01uFs8KqgQsQJcyjyekGvY4PL4/eVKsUF6XT1OCivbqGhOfSSrBtLKiXRJMKeqnpQu/8IPY9oHYqfTbKlc1+nxIBhhtZRTAqSaBJCCCHCyIzoAmZEF9Dp6uLV3aVUpe5mc/3ASh+tmM1Ov1Xm99XLK8iBln/+At6c4SVYjeJ9ZdQZ+Pmm68iP6SA/uoaCyN1kWPcNmXgyKE4ijUa6XSMnzPSjbZekKGxQVRaevoAdr24c8PDMC45ig8N9qHt5j8fLBgC3d0w7yo2kz+mmvLrF7+P6y8aSCq1DEGJcVG8navvPwbla61ACYHItnRvAtBBF8b2qVYydJJqEEEKIMBRtjOLi4vlcXDyf8vY2Xt6zi5d276Kiox04mDawGo04PR7cQWoMDIDB7pcVBqqq0tMQWtVaE820FUW8dbghIMmQ8dAB8TYrr5V9kUzJADKIMJ7EwlQrPylcw+yY/kvZnq8536ckE4C7awxLTBWFDXo9C09bgL22lYisRPoiLdR4vGxyBHfJqsUU2rfve/Y30NzaTWK8xtsXCjEGqmMdaucN4PFxdwERVhTT4VqHMGkoqqpO8vo5IYQQYmJQVZUupwOz3oBJr0dRFH757ls8v2tH0GI4e2kbja6hK6xUr4oyzHooVVVJ255B6997KN8gN/qBknPYVNaen4JTH3q3gZnR0VR3dg57zslTovh54esoipenyk9kc3McLfY+Kjo7Rhx//u4o6huGHz+UzS3MZMvOaq3DGFZmWhz33XQOacm+NWgXQmuqtxu16x7ofUrrUAJLlwDe0K2IDDQl4SUUY6HWYUwKof2SiBBCCCF8pigK0WZLv2O5sXFBjUHvSgEGTzSZuy04r9GR+sN46hYMfKKcvCONzof72PTp7kGuFv6SNiONDeel4tSH5hKK2s5OjDodrmEq8d480MU75UfjUVUOltA1oFMUFqVnsLelmQ7H4Ovj9Co0NXcHJvAg8YbBa8TVdW1c/vMnSIqPxGjUc8vPTiM3M0HrsIQYlOpYhdpxE3hDZxl6wITB74+Akf5MQSULFIUQQogJbEqQE00f71bRDXF7EflQPDU769n4w52k/D0LvVN/6LHE/clsuXIP+z+V/i6BFJceR9m38+g0hGaSCQ52EMmIjh7xPM/XnjB5VZX1tTV4VJVF6RnoB1kSmGGIwuMJ3c/dF253eMRv73VSUdPKvvIm3voweFWVQvhK9bbjbb8ete27kyPJBEzqZuDSnymo5CsthBBCTGAnT5vOc+deyCXFc4izWEa+YJyq212kG6cPOJ7+aRYlL3xZqbT5sR3wQyuxdQcTYZ7/yi1JoJltZtp/VEydObg9hcYi3mId87XdTifra2tIi4xiVnIKAEZFx6zkFAoi4v0VombCsevFO6t3hX2CT0wcqqcGb9e9qE0roO9FrcMJsvD7/eEv0p8puKRHkxBCCDFJOD0e1lSU89Kenby3fz8OTwASDqrKN2uMeHY24up24exy4eh20lLZhssxsFmz2Wai+AcFbLx3e1g+gQ4n0UnRbP5N6PemyIyORkGhyod+S76YEhtHfXc3vW4XBYY4ut5v9cu4WimYmsye/Y1ahzFq9998Lgtn52gdhpikVNULzrWo9mfB8R7g0TokbSjRoIZvj7rxkP5MwSU9moQQQohJwqTXc9zUPI6bmkenw8HbZaW8tHsXn1ZX+uU1Tp0XVnziouTZdT5f47A72fDHEj/MLkYSlTLycjStLUrPoKSxgT63/5KgB9rbDr3fo/q2M10o84ZpPvatVTsk0SSCTvW2Qu8LBxNMhmng3s+kTTIBk7aiSfozBZ3UqQshhBCTULTZzLmFs/jPWeey9tvf41dHLWNq3Nj7Odk8Cse/2s7eZzf5MUrhL0azkdqLpmodxpCiTGbmpKSyvrbGr0mmrzMr+pFPCnHeMM00rfq0FHuvU+swxCShunbhbb8OtXEZqnMDStTPwV0KnjKtQ9NYeP7+GDfpzxR08tUWQgghJrm0qCi+t2ARr194GWfPLBrdxV6VpQ9XMfeh/ZR9ILvFharM7xzGPltoPslXgAiTka0N9QGdJ0IxELcroFMERWSEWesQxqS3z8VLb2+RJbIi4FTnVtTWC6DvZZTYB1BsF6F23ACecq1DCwHh/v9vbAuypD9T8EmPJiGEEEIcoqoq/9q2mdtWfzhgV6/B5PYa0f96TRAiE75Iz0shJimGXZ/uBUBRFGYtnUFDhIr5yCwOpCpU9IRWf44ZCYnsbmkO6ByKqnJ0Uwp7dzUEdJ5Am1WQzvY9tVqHMSazCtLp6u7DbDLwrXMXs2TRNHS6gTsDCjEeqnsfastFoLZDxPdRdHGoXXdzcD9LgWIFtVfrKMbGfAJ4O8D12agvlf5MwSeJJiGEEEIM8Gl1FT9641Va+4a/IV1WY6TmHkk0hYopxdm01LbidnkwGA0kZSVQtqX80OOqApnfWkj1kQns7/FPs+3xOiw9k89qqwM6x/GODHZ+Gtg5Ai03M56ahg5crvDtL3PKMUXMKsjgX89/SoTNzGVnH86ShXmYzUatQxMTgOrtRu28GdChGHJQvS1g/4/WYYUYC9CndRBjYERJfBPV/m+wPz66S5UYlOR1snQuyKQZuBBCCCEGOCIzi5cvuISrXn+ZHU0Dd7jSe1Xmtlswrq7SIDoxmKmzc9i/rQKA6Qum0lTV0i/JBKCoUPPYBtJ75rD/SKsGUQ5U2dke0PENKDTvD42k2ljFx9ho7+wN6yQTwBsf7KC2oYO/3X4Rq9aV8qd/rmT3vnqmT02haHoaGamxWocowpDq2gtqB4ppEUrsH798wNsFujRU++PgDWzVZPgItxoTE+CEiMtRDNlgLBz9ZyD9mTQhFU1CCCGEGFKvy8WvV77DK3u+0n9JVTnx5XbKPtyjXWBigJTcJBrKm3w61xhtYd9t83F7A7+cxKjTcbg7hq3mHrpc/ftE5cTEUtHRHvAYCgxx9K3qwOUOz0TNnJkZbN1Vo3UYfpGcEEV6Sgy//P4JJCdG0dTSzd//s4a16/exYnkRl599hCScxIhUbxf0voTa+yK4twNDL49SVQf0voja8yh4KoIdaogxAmGy+6Y+DyX2ftS2K1AS30bRRaK6SlFbTh3VMErsn1AsJwcoSDEUSTQJIYQQYliqqvLo5o3c+dFqvKrK8WUGDjy4VuuwxNcoioLRbMDZ59uTCMPDJ7Gnpz2gMdkMRhas6aT2f1uJnJaI4drD2NjXeujxwzMyWVcT4CVtqgqKwnI1nb2rwzNZYzTqibSZaeuwax3KuGWkxvLQbReybvMBXn2/hLgYG0sW5tHQ3Mnzb26mq7uPE5cVcvk5R5CZNvadMEX4UL0d4N4PigXFOHOEc1tRe54A+78PVqrYLgV9OujTURTL8NeqHtSm48Abnn3O/MMABG5nT7/RT0FJeP5gcsnxIYp5OQCq6kZtmAc4fBvHdim66BsDFqYYmiSahBBCCOGTtZUV3Pf82/Te8CEuR5i8IjrJ5BRmUrHTt8RNxt0rWG0K3JKyeLOF/OdqaHq/tN/xzCsXsWNRJM19vUyNi2d/W+sQI/hHjj6a9P0GrJlWeirsVFUFdr5AmT0jg227wzNR9nU6nYLX2/8pSKTNzBHzp9DncLGztI7Wdjsmox69XofBoEevU772rw6DQXfwcf3Bf7PT4/jeRUtJjI/U6DMTQ1FVN3hqDiaUPPtR3fvBfQA8+8H7xf9JE0rsgyiWYwZe72k4WJHU+zKobWCcgxL/LxTF9yXAqrsStfl4P31G4UoPhHplpxmMRegSnh70UW/LueDaOvIwxoUo8U+gKNIDTguSaBJCCCGEz/Zvq+Bny27E3hmmu9ZMcLOOmsH2j3aPfCKQccl8Vi80BSSOdFskaX/dRfvmwRMj5sQIkm46hlXB6JuiqszeEUlzS3fg5wognQJJCVE0NHf5ddzUhChirEb2VIdOAi422orD6abXx+q8r7JZTXzngqM46+R5GPTSlyXYVG/n5wmkMlT3gc8TSwfAXYFvS7aMKLF/RLGcdHA8dxVqz8PgXIdiO//gMft/UOKfQdEnjC62nsdRu24f5Wc00SiERZ8mQz6YT0SJ/MGARJG35QJwbRr+el0CSsKrKPrEAAYphiOJJiGEEEKMyqb3S7jh5N/jCdN+NxPZrCUz2L7Wt0STKcHGnpvm4B3DraBRp2OaNYakFg/q5gYcdZ1ELMmlI9uKQ6+i//2n9JS3DTuGCmT88STW6NtHPf9oHd+Vzs5N4V8NVJSfRlVtG1ERFqwWI2azgc7uPqpqh/9aD8dmMaI+/RE5y4twFWZSNo6xQkleThK/+N7xzJ6RoXUoE47H46W+qZOKmhYqa9qorG3l9CM3UpD6qp+abutQYu5AsZ6J2v0wGLLBfByKYkBVe0H1ougiRj2qt/UycJcCOvC2Eza9iiYlE0rCswOWUqrOjaitF458uflYdHF/C1BswheSaBJCCCHEqN33vb/xxiPvax1GSDFZjFgjLVgiLLQ1duDsdY58kZ/lzsqifLvvOwHqHl5BaY9vy+dmRsSR3OzBs7Geprd34+4a/+enKpD051NY5wpsNc3h+lSqVtYFdA6tJMRG0NPrpG8cy1mn1bZSs64UFZh26nw6sxKpbAjvnfq+cOqxs/jlVSdKddM4uT1ebv3T6+yvbKa6rn1AY/2TlkRyw4X3jn0C/VSUyO+DpxG1++DOcUrM/SjWU8YT9iGqex9q5+/Atefg0jsR0pSoG1EiLh1w3Nv6HXCuHnkA28Xoom8OQGTCV/IbVwghhBCjtr+kUusQNFV0ZAEZ+WkkZsQTGRuBTq/D2ff/7d13XJXl+8Dxz3POYe8NiiIqIm6cuFIzUTM1G5YWZdnWSm05smzZ8lemlllf0yxXw1W5UHMvHDgRFcEJIrI3HJ7fH+ZJAgXkHA7g9X69eCXPcz/3fZ0Tlufyuq+7gLSkDC6fvUJg+0ZmiSshNrFC473Ty/dHQXdrG/KeW8OFCeuJ/+2wUZJMAIoKV8eso42tq1Hmu5ljRVfRaBSTrmEuV1OzCGzoVak5HJvVA65tqon56wCJ366nlQZ83B2MEKF5/bXpKMvXRpo7jBpNry8iPSOH/AI9seevlnp646a9OaRn3+Y2JZthKA6vgvW9oK0L1veDVR8o5QS526GqKmr6B5C/W5JMNYFVb7B9vMRlteBo+ZJMgKLxMXZUooIk0SSEEEKICnv9h5do3jXQ3GGYRdOOjTm2M5qLJ+NJuphMZmoWRfqiYmOO74rG3bdi/UOMITcrD8965V9XOXqlXOMC86xRTFQDrxboyX19E4F2zqZZAMhUC2jgX3t7dRyKukCDcvy8uTjZllrZk+tQ/LQuBTj1+x7SfthIG2sdHi4V36ZUncxdsoM/Nx7h2Ml4ss1QaViTXUxIZfQ7S/lt9UEG3N3ypuPy8/Ws3T/ottZQ7EaiWPdHUaxATYPcFSgWrVB0DW4z6mvUomzU3A2oaW9A/q5KzVU71ICP/hovFKepKErJvxhQM2eXfx5tHSMGJW6HztwBCCGEEKLm8Qvy5Yst7/PXnHD+N34h2Rl3TnPwwnL0ptIXFuHm40JKQupNe1lptBoatWmAta0VcC1JlJyQytVLldtG5lHPncTzV8s1Nml1NFZtW5Gnv/Vr0uww7XHgBem52Ly7k/pTOnEuu3iz6xCdK1aZepSsAnZ55pUZ681Y+VhBjDGirZ4KC/Wlnubm6mxLPR8XMrPziDmbRMumdTnyn9Pr4tOyS51T1atEL96B1kqH09CupGXmmix+U8rMzuOTb9YZvvd0d6CBrxv+vm40qOdGi8A6+NervYnI21FQoOfXv/Yz79dd5OQWYKHTENLW/5bPrNzizMPdoJQcwS2pSf1Q0YKiA11TsH0MNfsnsH28wr2YVP1lyNuEmrcJ8nYBklj8lwYoKnOU+WiuNYLXuJS4oxachLzw8k+l9TZiXOJ2SI8mIYQQQlRK4vkk3ntwGif31eJP8TcI7NCY6IjT5Rrr09ALazsrYm/Yaujfsj52TracPX6ejOSsEs9YWlvgWd8dBzcHdBZaCgv0XDl/FWcPR84cPluieuq/rGwtqRvgw5lDZ8sVo+/HoWyxSb/p/bvynbjw1jqTVTTdyDHIiwuvNudK7rXERzM7F/KeXWO47/tRH7bYlePUNVXFQ2vLlaJ/E6CBOhcyNlafk9VMoU0zXyKPX8DNxQ5fbxcysnI5c654c2YvD0cSk9K5/gnA1ckW91PxnC/jtMLAl/sTWY1OpjMme1srfpo+Ag+3mr9V0Bj2RsYxfe4mzt2Q9LaxtmDyK/cy8bOVt3zWzcUGrUZBUa4lnBQUMPz62j+fGniePm1+u8UsGtC4g0UQis2jKNa9yxW3WngaNTkMisqXaL/z6IBCcwdxc3aj0Di8WuotVc2D7F9Qs+ZAUdlbxBWPzShS1WRWkmgSQgghRKVdikng+Tavk5uVZ+5QTK55l0CO7Yyu0DNudVxwcLEnPTmD5PjU2167RddAju6Ipl7Tuji62aMoCso/vYfijp4nIzkTuJasqh/ky+mDsWXOqXOwJHVaNy7nFK9q0SoK3c9bcH5a+XpiGItbFz8uPxVIWmE+rfdnceF/Ef/GZGtB1vQeXMzOvOnzNmjpnOzB6eOXadKxDlst48mnCFSVoEgb0tJrb/WdhYWWul5OxJWREGoW4M3xUwk0quNCxvI9ZJTjpLmG/YM5Zm1prFCrnZBgfz6f9ECpW3buFPGJacycv5mte06Ven/ofe345c/9lV7n9SeyGdTp53KNVRw/AqvuqGlvgcYDRecH2vr/fmlcURQFVc2H3A2gcUJNearSMdZOlpi9wst6AIr1vaBYXotHsfr317qGKMqtN1ypai5kL/0n4XSzEw41KF5Hy5xLmJYkmoQQQghhFH99F870F74zdxgm17J7EEe2RZlt/eZdAynIKyxRQebq44ydkx3n/9kWpbPU4d+yPqf2nylzznrPh7D5hlOk7SwsaLs9g0uLI40ZulHUGdaGbZ2sS73np3XEPQri4/89Mc3TwwFNS1sO6BPpmejJyajLVRVqteVX1xUXVeXknHDUcmwFBdBY6FAf7lyrexxNGNX3ln2IqrPCQj15+YXk5hWSm1dAXn5Bse8d7K2p6+VMSlo2GVm5ZGblkZGZS2Z2HplZeVxJzmTN5mPk59+84qVeHRfOlyMpWZY3R2RyX4dFZQ/U+KB4hEPuOtScX6818/4vxe7fpJOuPopij5r5ZaVjrJ2sAXNuf7VA8diIYoRtbaqaA9mLUDOmAf/5b5jGG41n1f4FiShJEk1CCCGEMApVVXl74MfsXX3Q3KGYVKu7mnF463Fzh1EqnaWOwPaNDBVXWp2WgLYNOLH31tsaVcDm+/4cy0rB08aWBgtjubq17Gooc3H59l725f5bteOmsaZVoRvnIi6Tk1tQ6jN+fm6cPStbaq5rUVBAzJ8HKvRM45f7c6SWbp8DsLO1ZMGXI/BydzR3KCWcv5TCnxuPEHU6npS0bHLzCoslk/RlbKl9amhnBt3Tiu8WbWfN5mNVFHXpJjydTv92S8ox0hrF5WvU7F8gb13Zw0UZbIHS+7FVCZtH0Dh9YNQpi64OhYLI4hctu6JxnWfUdUTF1YDW80IIIYSoCRRFYdz3L+JYy/ucVOe/oyvML+TYzmiadwnEwdUefaEenVXZ250UwPLLA3T9OwP3SXuqdZIJoHD6PrwsbOmu+HBXvAc2m3OJ3nbhpkkmQJJM/1Ho71XhZ/IPxWFhoTVBNNVDVnY+n85eX21+j+v1RezcH8OiFXs5fOICjz/QkcSkDGLPXyU+MY3k1GyysvPLTDIB+Hq7sPdQHB1a+1VB5Lem1ZS3IXUuasoLUGTawwhEVdCi2D1r/GktQ/5zwQLFYbzx1xEVJhsXhRBCCGE0bj4uvDr7WT4Y+oW5QzEZtah6fAi9lWM7o7FxsK7QNr/045dJP14ztpVlnEik9Qlrjl6QD6C3S3Oy4u/dua1RBPRpxRk3B3LzqnFT4UrYGxnHnxuPMPCeVmaLIS0jh5izV8jKzieosTftWtTn8tUMok4lcPFy6m3N+cGM1fjXcyOtGpwQqtFU5OTIAig4YrJY7ixmrDGxHoCiq2/0aRXLENSsb//93v5lFItAo68jKk4STUIIIYQwqrse6kzvx7qzceE2c4diEvpy9rQxt5yMXLP2kjI1yxry76E0Qb6uKKfiyfb3Ii4htcrXb1HPjZgZq2/r2djww9TvFsTF+u5k1dJ+TTPnb6ZD6wZ4e1TtFrrsnHwysnJRVdiy+xRHT17i8pV0Uo3UwD72fPWo6it/RZMwLvM1ulfsXzDNxJZtAQugECxagd0zpllHVJhsnRNCCCGE0b3+w0t8vvFdHho3kHqBteuI4ZqSaKrtitKyzB3CbWmWnUvczDXEro1Ev/koGk3VfvizsbYgaUVE2QNv4fz2KLxOXsLetnaeQpedk8+ns9dVyRa6y0nprN18DFVVsbG2wMvdkfBtUfy+5iDRMZeNlmSqTjSK/DfUPMyUaLIKRdE1NsnUimINdk+DYodi96ycNFeNyL8JIYQQQhidzkJHm14taNOrBc9Pe4JLMQns+esAe1Yf4PDmYxTc4mSj6syvmS9JF2tvM+SaJDc+BZztzR1GhTT3dePMzH8riQoycymqoq2Y1lY6gtwdSdpwmKRzVyo9X/y+GAI6B3I4u3pUyRhbxKGzrAo/zODQ1kafOyUtm827ThK+PYrDURcZfn8H9PoiUjNyOHriEt8v3m70NasTrVYqmszDPIkmk1UzXZ9f64+qZoIuwKTriIqRU+eEEEIIUaVyMnM4sOGIIfGUHF/547JNTavT0qxLE45uP1EjejTdCey9ndHe156EqxnmDqVcdFoNPkfPkXTiouFawAOdOFwFP05tPRyJ+30XOVczjTpv0ON3cSArz6hzVic21hYs+HIEPp5OlZ4rKzuPrXtPs2F7FPsOnUV/w39HrCx15NXQ5Pvt+PTl83RuusbcYdx5FBdQq/j/t1Z90bjMNOkSatYC1JxfUNxWSEVTNSKJJiGEEEKYjaqqnD4Ya0g6Re89XW1OfLquXtO6FOmLuHgq3tyhiP9QgbodG+PUrhFxOfkkp5nx6O4yBPs4c+Kb4ke0Nx3Vj4OXTPvBr52HI8e/CzfJ3K4BPiS3b3TL0/5qunYt6/PlOw/f1hbHvPxCIg7FsXbLcXbuP0P+HZRMupVpr56lY5N1ZQ8UxqW4glpFFbmKA4rDa2DzCIpi+pMq1fwIFMsOJl9HlJ8kmoQQQghRbaQkprFj+V5WzFzN2eMXqnRtRVFo0KIedk62AGSmZnE57go5mblVGoe4Pf792nDcxsrcYZTKwc4K3er95CYX7yvl/VI/Ym+jos/LzR4bC12ZjcRb+rpxauZqk26Y8evdEusgX7KAU7V0W2noXUE8PqQjDet7lHpfry/i0uU0Ys8nEXfhKrHnrxJ7PolzF5PJL9DTtJEXJ2JqxomOVeGLsWdo33iDucO48yhuoFbBVletP4rrzyja0n+/mIKqFko1UzUjiSYhhBBCVDuqqnJgw2GWz1jNnr8OVMmaXg08uBxX+d41wjy0Vjr0D4RUy+oaBzsr9Iu3oeqL/7G78eAOHNNpy9WnycbagiBrSxK2HCPlzLWkhVMDD+r0aE66vTUx/ySsnOxtcLKzwkmnIfb7DRRW0fvRcEBb9A29sLyYjKLToHV3IkOjEJ+SSWZ27Tidrl3L+jzQrw0ajYbY80nEnr9K3IWrnL2YfMtqJVtrC1AgO6f6/Wyaw0uPFPLoXT+YO4w7j+IOapLp17F9Co3jBNOvI6o1STQJIYQQolo7H32RFTPXsP7HzeSasB9Mk3YNObn/jMnmF6YXOLw7ilZDYWoWsY421SrB0Swzh9jwwyWuBzzQiaOKcstkU1NfV9L/OmBIMJXG2smWvKw81Gp2KqIKuAX44NaiHjovZzJ1Wk7W0sqnW3F3sSMppWaelGgKD9xjw6iBs7HQVZ/fo7We4gGq6f8yRXH+GsW6j8nXEdWbJJqEEEIIUSNkpmaxZu4mVs5aw+Wzxv/DcsvuQRzZFmX0eYV5BD11NwdSq88H+zZ1XIn+uvQGyE0eCuFIERSV8sfytu4OHP9+g7kOJjeJquhNVd14uTtwOalmNK6vKi0CHHnv6V/wcDx323NsOPQg8Vfd0Bdp0OsVCvUaAJrWv0DbRltxsLmzfs5uSfEENbEKltmNonE1+TqiepNEkxBCCCFqFH2hnp0rI/h76Q7OHjvPxVMJ6I1QxdGie1OObjthhAhFdaC10mH3eA8uJxv3pLXb5epkS/b8v2+aMGoytDOHC4u48U/mDbydufzteqhtf1xXFBqM7kfUhTunsqmBrxtxF6qgP04N4+JkzZRnjhDc8O/bej7so3GcvVT673GNRiGokQPtm2VxT/BW/DyOVSbUmk/jDUUJpl1DF4jG/Q/TriFqBEk0CSGEEKJGK8gv4NLpBM4ev8DZYxc4G3Wes8cvcCH6EoUF5U9ANWnfkJP7ZOtcbRIwpBMlN6sZh0ZRsLLSYanTYmGhxUKrwUKrobBI5dKV9FKfaZKYxvkdN09mBj7alUP5hajqtQ/JDeISia+l2zm9g/2JbeBp7jCqTFBjb6JOm/hDfg2l1Sg8/3Ahj3Sfi1KB0j1VhdBxL5FXjtP8dDoNTw5SeaznXHTaO/T0P1MnmjReKK4/oegamG4NUWNIokkIIYQQtVJhQSHRETFs+WUnW3/bxdUytup4+3uSEGv6bQWi6qhAsxf7cllfxMWbJH8qqoG3Myk/bSEvM7fU6iSdtQW2j9/F5aslqyza+jgT9c2tj3UPHN6NyJwCgr2dOTG79h4B79rYm4st/cwdRpXyr+dG7HmparqZzm0ceXHwWhp4Hi3X+NQsTwa9eX+F1gho4Mj4xzcR4FM1h0xUKxofKIqv+HPahqAvI+GtqYPiugBFV//2YhO1jiSahBBCCFHrFRUVcWxHtCHplHI5rdh9RVHQ6jSGCqg6jbx4YsojZKVlk3juCpdiEtixIoIifZE5whdG4OjrineXQPByJl1fhK1Wi6W+CCUrl4LkTLIuJePctiEHbtFHx97WCqc9J0kuozLFo3k9sjo25mpqtuGaq5MtdRLTiFld9gfcgAc7Ebv6IIU5tbdRsr2XM1e6BJo7jCrVupkvh45fMPk6Oq2GVs52qIV6Ei11RkuyVgWNRqFfN1ue6rsML+eztxwbfakDz34UXOE1tFoNjw9QaBdwAivLHGwssrGyzMLGIhMry2ysdBloNLf7CqoxTV0ouljOwTqwGYRiOxJ0jSF3FWr6h6CmlRyq9UVxWYCi8zVquKJmk0STEEIIIe4oer2eo9tOsHnpDrYv20PqlXRcfZxJjk8FIHRET0Z99TS2DjbFnjtz+CzTX5hD1O5TZohaVJWgZ++5abKpRUEBMX+WrxLCpZEXRb1akHA1kzZ1XTn781Zyq1FzcnPT2ViS0a/iSYKarKq2z7VE5fTyvcC1qr763ZpiE9yQ2NQs0jNzTb6+MVhaaBncywJfz1QAFEX9t4JQAVCJveTGsg05Rl9bq9Xw94xvjT6v2ZU30aSth+K6EEXrXeyyqr+Cmv4e5K2/YWz9a9vltD5GDlbUdJJoEkIIIcQdS1+o59CW4xzecoxzJy7S/YEQej3a9abji4qK+Ou7DcydsJCstOybjhM1W9BzfThwJR1PV3vc7ayIT8vG39aKqApuZXOo64pLY2/ObTluokhrrqAnenAgo2YkPYzFxdGGlHTjJ0ZupFEUHDccIu8m69j7OOPWrB42dd1QHW04nZJJZnbtrZy7HRqNwuaZc8wdhvFpfKGoHBV1Fi3RuP1e6i1VVSFv7bWEU1EyitP/odgMNHKgojaQRJMQQgghRAVdjU/h23Hz2bx0p7lDESbS6um7Ob1qH9lJ6Vz/w3IF+hSLW/Bq7celwLrkV6BZf03n5mLH1RTTV7T5eTuTWIGEqPOz9xB/i+2iVaWdqz2Xt0dh26c1F5Mz8XCyRaNRUICYMvrrGZuiwJZZ31XpmlVCWw/058sep2uBxn3ZLYeoRcmo6R+i2AxCseppnPhEraIzdwBCCCGEEDWNm48LkxaPJSikCbPHzjd3OMIEDv+wiWZdAjmelC4JJiPSWVtQGBJIfmIpvV5qsdT0HFo2rcPVlCwuXTbda3fVKFTkSIM0M2+l02gUWlloOT53IwBuLevjHn2Jy0fOGca0frgzR4pUioqqpj6i9pZhlLfxVNlvgKJxRXH+AlUtqFxIotaqjW3OhBBCCCGqxJBX7qXrkI7mDkOYSG4N6WdTkzQe2ZsLd1iSCUCvL+LIiUtcupxGYCMv6tdxMc06CeWv/rG0tyY717yJgmYFhUQv2WH4/uRvu0m8IckEcPLXXdT3cqrq0O5g5T/0QlEsTBiHqMmkokkIIYQQ4jYpisJr/3uR0wdiuXz2irnDEUbk5O5A7H8+8IrKadg/mINVvA2qOoqOuYyXuwMaBYxdpJO493S5xzrUdcXcKb/s+PL9PDhqq7g+wv1vFOV6LeN//iWVKHkq6/v/Um/ya2N8f+Ot4vdU1FKqM0t5XrG8+ZxClJMkmoQQQgghKsHBxZ6Ji8cw7q530BfeOT1nart6TetydPsJc4dRa6hAoo8LVEGfoprgclIGrZrW5fCJ8h43XzYvV3vSzl8t93g7b2ejrV0ePu4O+Gg0ZEWdp6iwCEWjITmufAl6XRU3LNfo6lbpelVBtgCLqiSJJiGEEEKISmoW0oSnPxrG92/9bO5QhJFkm/h0sDuNAvjaWnFFEk0Gly6nEtTYG51Ow6nYRHLzCis1n5etFekVGG/l5lCedjyV4uFiRz0rC1L3nebS8j2k3uY8mTZSZSNETSKJJiGEEEIII3jotYFEbj5GxJqD5g5FVJJsmzON+D/3YdGhMQWF5e8BU17NfN1QgGMXyl/RY25JKVkk/ZN4a93Ml9hzSaRXoi+YNjmzQuM1FlrIN34VpqJAG28XMg/Fcn75HqKuX7/d+XRa7LPzaFPXlRwF4hLTycuvXFJOCGFa0gxcCCGEEMIINBoNb84fhauPaZr8iqrjG1gXtfYePWU2aXFXaO7lbNQ5vdzsaZFXQOzM1VgV1Nzkw6HjF8jMyiOggQetgupidxsVPMlHzlZofLaJ+mUF1nXlxDdrubAj2ijbtdRCPVE/bCJ61hrOzVxDCydbI8x6c4rsMROi0iTRJIQQQghhJM4eTrz722u413U1dyiiEjRV3Xj4DpK45gBaI7y/VpY62ro7kP3zVmJWH7h2sQYnmgCKVJVTcVc4HHWRRg08KvSso50Vlw9XLNGUcjK+QuPLw87GEv3+M0af90ZnftmJva3pttIpkmkSotLk/6JCCCGEEEbUrHMg/zv2JQNf7GvuUISodlJiLtPiNptQN/V1pa2nE8F2VrjvjyHq+w0U5hYAoLXSkW5de/r4RMdcxq4CyRRfF/sKVw9lXE41asLGx90B18hYLuyMNtqcpclNzcLf1cGkawghKkd6NAkhhBBCGJmdoy2vfP0Mj739IBZWOs4eu8Abvd+TU+mEAJLWRaJp5UdRUfm2J2oUhTaONhyfuabUZIoKNHwulMM1qD9TWfLyCwlq7Evk8QtljtVoFHSXkiu8hgK4O9qSaYQT3Zr6unL5p63kplZRs3cTFh1JPZMQlScVTUIIIYQQJuLm44KjqwMtuwfx3Odh5g5HiGoh+VQ8LeuUb3upnY0lTbNziZr/900TAAq1MzlwMSG1zDHuLnY0Tkzj1O+7b2sNB532tp67UVtvZ87OWlt1SSZTk61zQlSaJJqEEEIIIarAkFfupecjXcwdhhDVQnL4ITRlfKD3dnPA7VAcsWsjy5wvbt4m6rjXru1UV5IzadPM96b3m/u6UbRyL+e3Rd10TFm0SWl4udnf1rOWFlpa6zREzV4HVdw8X1r1C1G9ydY5IYQQQogqoCgK475/gdQr6URuOmrucMQtZCRnmDuEWi/pxEVatfUnxcmOswmpaLUa6rg74GKhRZeeQ/a5K1xad5C0cm7rys/MxXV/DBaNfSgoqD1bVCOPX6Cxnwenz14xXLPQaWhhbUnUzNWVruSKXrwDAGcHGxo+fhcHylFFBeDqZIvriQuc3H2qkhFUP1LQJETlKaqc3SqEEEIIUWVUVSXy76PMf2cpx03cNFfcvhbdmnJ0+wlzh3FHcKrvQeblFPR5lT81LiisBwcyc40QVfVR18uJi5fTDN+39Xa+VkVkZBa2llg+2o2klFtvgWvo40Lmyr1kXKx4Xyhjsfd2xrtjYyzqupGuUTh3JZ18IyUYLXRa/l461ihzCXGnkkSTEEIIIYQZqKrKvvWH+PGdJURHxJg7HPEfNg7WWNlYkpqYbu5QRAWoQKOX7+VYLWkMbqHTUqjXG3amWVpocd4eRcalFJOsF/BAJw7f4tNha19XYr4LN0pS0Jg0Fjoa9m/DEW3le05JokmIypMeTUIIIYQQZqAoCh36tmHm7o/5YNV4Ggf7mzskcYOcjFy8G3qZOwxRQQoQv2grHi525g7FKAoK9bQK+rdPUzNPJ5MlmQBOLttD4zouJa5rNAptHW2Inrmm2iWZAIoKColZfRCdtvIfb2XrnBCVJ4kmIYQQQggzUhSFkPva8c2+T3n399fxb1nf3CGJf5zYfQofSTbVODlXM3E5GY9GUzsyBoeOX6B1M18UBa6sizTpWgpQuD0KVydbwzV7WyuapmcT9ePman26n1qop6WnE+7OlUwySqZJiEqTrXNCCCGEENVIUVER237bzYL3fuFc1EVzh3PHaxzsz+mDseYOQ9yGoGd6c+BqprnDMJrOjbyInLaqStaycrDB//G7uKqqFP19lKvRl6pkXWNQAb+7gjjl4URRUcU/6lpa6ti0eIzR4xLiTiKJJiGEEEKIakiv1zNpwMfsX3/I3KHc0YJCAoiqhSdr3QlUoNmLfcnQariclk16DW4SbqHT4HkwluTTCVW6rgrVuorpVoJe6suB+NQKP2dlqWOjJJqEqBTZOieEEEIIUQ1ptVpGzxyJhaXO3KHc0bS6yjcXFuahAFGz13Fh1hpcD8eZO5xKaeHuWOVJJqi5SSaA7NusCJWdc0JUniSahBBCCCGqKd8AH4a+MdjcYdzRNBr543JtkHDoLJ6u9uYOo8JsrC0IdrThxLfrzR1KjaICeUF1zR2GEHcs+SsyIYQQQohqbNjEIWi0GjYu3MqlmMvmDueOU1RUZO4QhBEoQF1rCxLNHUgFBPm6kvbXAU6ckd/3FdX0kS5E3mTbnKWFFksLHVaWOiwttdf+afheh72tVdUGK0QtJD2ahBBCCCFqAFVVidp9kg0/bWXzLzvJSK49TY6rMwsrHU07BXB850n0hXpzhyMqwa9XCxLquZGelXdbTaKripODNQ2y84j+bXeN3rpmTp3DuvPYO0Oxt7P+J5F0LaFkYaGrNacRClGdSaJJCCGEEKKGKcgvIGJtJBt+3sruP/ZTkFdg7pBqvTqNvLCwtuTssfPmDkVUkgrYutlj7+mEtZsDls526Bys0dhag6UOvU5LAZBXVEROgZ7MnHwysnKpik9NrX3duLB4O9lJ6aZfrJZr0r4Rk38Zh3cDT3OHIsQdRxJNQgghhBA1WGZqFlt/282Gn7dwZGuUucOp9Vp0a8qZQ2fJzsgxdyiiKikKdh6O2Hk6XktOOdmis7dBsbVEtdRRpNGgVxQKUSksUsnXF5FfqCevQE9OXgG5eYW3nN7LzR63s1eIDT9cRS/ozuDgYkfvx++iSF+ERqvh2c/CsLSyMHdYQtR6kmgSQgghhKglLp+9wqZF29nw8xbO3eaJS6Jszh6OeDf04sSeU+YORdQQKmDjZIuVow2WjrZYOlijs7VCZ2uFvZsDx3/dSUF2vrnDrPXC3nmYJ6YMNXcYQtR6kmgSQgghhKhlVFXl9MFYNvy0lb+XbCflcpq5Q6qVmrRvSPyZROmXJSrFt4kPF07GmzuMO4JWp2X2/k/xb+ln7lCEqNUk0SSEEEIIUYvpC/Uc2HCYjQu3sWP5XnKz88wdUq3SoHk9Lp5OkD5Z4rZ5+Xlw+ewVc4dxx2jSvhEzdn6EVqc1dyhC1FqSaBJCCCGEuEPkZOawffleNi7cxsENh6v1yVs1SdOQAE7slm104va4+riQHJ9i7jDuKM99FsbDrw8ydxhC1FqSaBJCCCGEuAMlXUpm85IdbPh5KzGRceYOp8Zzq+PC1UuSLBAVZ+9iR2ZKlrnDuKNYWlvw+OSH6fPEXbjXdTN3OELUOpJoEkIIIYS4w8UePcfGn7eyadF2rly4au5wahzP+u4knksydxiiBgrs0Iirl1JIuphs7lDuSBqNwuhZzzDwhdCbjtHr9RQUyNZYcWewsLBAq638tlJJNAkhhBBCCACKioo4vOU4G3/eytbfd5OdnmPukGqElt2bcmTbCXOHIWqg5l2bcmyH/OyYk7OnEwtOz8TG3qbYdVVVSUhIIDU11TyBCWEmzs7OeHt7oyjKbc8hiSYhhBBCCFFCXk4e509cIj42kYTYRC6evMTW33aRIVt8SmjSvhEn98WYOwxRA7Xs1pQj2yXRZG5PfzScYROGFLsWHx9Pamoqnp6e2NraVupDtxA1gaqqZGdnk5iYiLOzMz4+Prc9lySahBBCCCFEueRm57Fp0XZWzlrDmcNnzR1OtaDRarC0tiA3S07zExXXsnsQR7ZFmTuMO569sx0/nfkae2c7VFWlIL+AmDMxeHp64uYmPZzEneXq1askJibSpEmT295GpzFyTEIIIYQQopaytrXi3md68+3Bz5n29xRa3hVk7pDMzq+ZrySZhKjhMlOzGNlsDAs/+p2LpxP46LEvAbC1tTVzZEJUves/95XpTSaJJiGEEEIIUSGKotC6R3PeW/4mbnVcGDZhCFY2luYOyyzsne3MHYKogdzruhLQrqFUM1UjyQmpzJ+8hGdbjCUh7goF+YWyXU7ckYzxc68zQhxCCCGEEOIO5OBiz7u/v0GTdg3x8vNg+gvfmTukKldYUGjuEEQNotVpad4lkBN7T8lJc9VUYYGejKsZpFxOJdU1HUdnFWtbKzTa26vRSLp4lf3hh8lOz8HW0YZ2fVrhXle244naTRJNQgghhBDitgV1CgCgXtO6Zo7EPCRZIMpLZ6HFvZ4bh7ceN3coohzUIpWUy6mkX84AwNLGEmdPJ5w9HMv1fPS+GBZ/vIzdf+xHX6g3XNfqtIQMbMewCQ8Q2L6RSWIXwtxk65wQQgghhKi0pp0CeHnWM7jXdTV3KFXG3smWK+evmjsMUUOoKiScSTR3GOI25efkk3j2ClcuXKWs87S2L9/D2O6T2bF8b7EkE4C+UM+O5Xuv3V+x15QhG6xbt46QkBAcHBzw8PDgwQcfJDY2ttiYvLw8Jk2ahJ+fH1ZWVjRq1Igffvih2Jjp06cTGBiIjY0N9erVY+zYseTm5pa65scff4yiKIwZM6bM+LZs2UK7du2wtramYcOGfPvttyXG/P777zRr1gwrKyuaNWvG8uXLy/8G/OO7776jZ8+eODo6oigKqampJcZ89NFHdOnSBVtbW5ydnUudZ+PGjXTp0gUHBwd8fHx46623KCwsXt165MgRevTogY2NDXXr1uX9998v8XOzcOFCWrduja2tLT4+Pjz11FNcvVr2/1Pmz59Pq1atsLa2xtvbm9GjR1d4bVOTRJMQQgghhKg0SysLBr3Ulx9PzWT0zJG41XExd0gm5dvEBwd3B3OHIWoQfaH+trdfieojJSGVhNhEioqKSr0fvS+GqcO/oiDv1o2UC/IK+GjYdKL3xZgiTIMzZ84wePBg7r77biIjI1m3bh1JSUk88MADxcYNHTqUjRs3MnfuXKKjo1m8eDFNmzY13F+4cCHjx4/n3XffJSoqirlz57J06VImTJhQYs2IiAi+++47WrVqVWZ8sbGx3HvvvXTv3p2DBw8yceJEXnnlFX7//XfDmF27dvHII48QFhbGoUOHCAsLY+jQoezZs6dC70V2djb9+vVj4sSJNx2Tn5/Pww8/zIsvvljq/cOHD3PvvffSr18/Dh48yJIlS1i1ahXjx483jElPT6dPnz7UqVOHiIgIZs6cybRp0/jiiy8MY7Zv384TTzzByJEjOXbsGL/++isRERE888wzt3wNX3zxBZMmTWL8+PEcO3aMjRs30rdv3wqtXRUUtapTW0IIIYQQotbLz81n9f82snnpDs4eu0Bmapa5Q6oUO0dbtJZaigr0NGzdgGM7o0tUKghRFht7a3IyS68AEdWHh58rz81+DC93b7SUfry7k7sDXg08S1yf8uDn7Fhe/kqlbg904t3fXr/tWMvy22+/MWzYMPLy8tBoriU6//jjDwYPHkxeXh4WFhasXbuWRx99lDNnzuDqWnpV6ujRo4mKimLjxo2Ga6+99hp79+5l27ZthmuZmZm0bduWb775hg8//JA2bdowffr0m8b31ltvsWrVKqKi/m2M/8ILL3Do0CF27doFwCOPPEJ6ejpr1qwxjOnXrx8uLi4sXry4wu/J5s2b6dWrFykpKTetWpo/fz5jxowpUfU0ceJEwsPDiYiIMFxbsWIFw4YNIzExEQcHB2bPns2ECRO4fPkyVlZWAHzyySfMnDmTCxcuoCgK06ZNY/bs2cTE/JtonDlzJp999hnnz58vNaaUlBTq1q3LH3/8Qe/evUsdU561y5Kbm0tsbCz+/v5YW1uXOb40klIXQgghhBBGZ2ltyf2j+zN924csuzqPxee/5eO1b/P8tCfo91QvmnZsjLWdlbnDLDefxl6kJ2WQmZbN4a3HJckkboultYW5QxBGkpaUQWZa8QR60sWr7Fq1r0Lz7Fq1j6SLptuC2759e7RaLfPmzUOv15OWlsZPP/1EaGgoFhbXfh5XrVpF+/bt+eyzz6hbty5NmjTh9ddfJycnxzBPt27d2L9/P3v3XkuinTlzhtWrVzNgwIBi640aNYoBAwZwzz33lCu+Xbt2ERoaWuxa37592bdvHwUFBbccs3Pnzoq9GUaQl5dXIvliY2NDbm4u+/fvB67F26NHD0OiB67Fe+nSJeLi4gDo0qULFy5cYPXq1aiqyuXLl/ntt99KvJ83Cg8Pp6ioiIsXLxIUFISvry9Dhw4tlpgqz9pVQZqBCyGEEEIIk1IUBfe6brjXdaN9aGvD9aKiIhLPJRF39Dxxx84Td+wcZ49d4OzxC2VuO6lqpw/E0qR9I06aeJuLqL0URUH2ktQul+OuYNPcGq3uWtXT/vDDFOlL31J3M/pCPQc2HCH0yZ4miBAaNGjA+vXrefjhh3n++efR6/V07tyZ1atXG8acOXOG7du3Y21tzfLly0lKSuKll14iOTnZ0Kfp0Ucf5cqVK3Tr1g1VVSksLOTFF18stmVsyZIlHDhwoFi1T1kSEhLw8vIqds3Ly4vCwkKSkpLw8fG56ZiEhITbeUsqpW/fvkyfPp3FixczdOhQEhIS+PDDDwGIj48Hrr2mBg0aFHvuevwJCQn4+/vTpUsXFi5cyCOPPEJubi6FhYUMGjSImTNn3nTtM2fOUFRUxNSpU/nqq69wcnLi7bffpk+fPhw+fBhLS8tyrV0VJNEkhBBCCCHMQqPR4N3AE+8GnoTc185wXa/XE38mkbij1xJPccfOEXfsPOdPXDJbJVFAu4ZciL5klrVF7dCiW1OObIsqe6CoMfQFegrzCw2Jpuz0nDKeKN3tPlceCQkJPPPMMzz55JMMGzaMjIwM3nnnHR566CHCw8NRFIWioiIURWHhwoU4OTkB13oBPfTQQ3z99dfY2NiwefNmPvroI7755hs6derE6dOnefXVV/Hx8WHy5MmcP3+eV199lfXr11d4u9V/t3Nd7+5z4/XSxpRnG5ixhYaG8vnnn/PCCy8QFhaGlZUVkydPZvv27Wi1/26zLOs1HT9+nFdeeYV33nmHvn37Eh8fzxtvvMELL7zA3LlzS127qKiIgoICZsyYYajwWrx4Md7e3vz999+GXk3leT9NTRJNQgghhBCiWtFqtfgG+OAb4EO3IZ0M1wsLCrl4Kp64o+c5c/gsfy/ZQfyZyyaPp+VdzTi6LarKT+0RtYejmwMxh+LMHYYwAZ3lvx+pbR1tbmuO232uPL7++mscHR357LPPDNd+/vln6tWrx549ewgJCcHHx4e6desakkwAQUFBqKrKhQsXCAgIYPLkyYSFhRmaVbds2ZKsrCyee+45Jk2axP79+0lMTKRdu+J/abB161ZmzZpFXl5esUTMdd7e3iUqkxITE9HpdLi5ud1yzH+rnKrKuHHjGDt2LPHx8bi4uBAXF8eECRMM1UI3ixf+rS76+OOP6dq1K2+88QYArVq1ws7Oju7du/Phhx/i4+NTYt3r15o1a2a45uHhgbu7O+fOnSv32lVBejQJIYQQQogaQWehw69ZPXoM7cJTHw5j/skZfPjnBDr0DzbJepbWFgSFBHBk63FJMolK8Q2sY9KqFWE+Zw6fNVRatuvTylDdVF5anZa297Q0RWjAtZPW/pvguf799ZPzunbtyqVLl8jMzDSMOXnyJBqNBl9fX8M815uJ3ziPqqqoqkrv3r05cuQIkZGRhq/27dvz2GOPERkZWWqSCaBz586Eh4cXu7Z+/Xrat29v6CF1szFdunSp6NthNIqiUKdOHWxsbFi8eDH16tWjbdu2wLV4t27dSn5+vmH8+vXrqVOnjmFb283eT+Cm/7/p2rUrANHR0YZrycnJJCUl4efnV+61q4IkmoQQQgghRI2k0WjodG9bpv41kfknZ/Dg2Puwd7YjsEMjXvi/J/lqx4d4+Lrd9vyNWjcgavcpI0Ys7kT+repzfGd02QNFjaSz0BmSS+513QgZ2K6MJ4rrPKg97nVv/79TZRkwYAARERG8//77nDp1igMHDvDUU0/h5+dHcPC1JP3w4cNxc3Pjqaee4vjx42zdupU33niDp59+Ghuba9VWAwcOZPbs2SxZsoTY2FjCw8OZPHkygwYNQqvV4uDgQIsWLYp92dnZ4ebmRosWLQzxTJgwgSeeeMLw/QsvvMDZs2cZN24cUVFR/PDDD8ydO5fXX//3JL7rW/I+/fRTTpw4waeffsqGDRsYM2ZMhd6LhIQEIiMjOX36NIAhMZacnGwYc+7cOSIjIzl37hx6vd6QNLsxCff5559z5MgRjh07xgcffMAnn3zCjBkzDImi4cOHY2VlxYgRIzh69CjLly9n6tSpjBs3zrB9beDAgSxbtozZs2dz5swZduzYwSuvvELHjh2pU6cOAMuXL6dp06aGdZs0acLgwYN59dVX2blzJ0ePHuXJJ5+kadOm9OrVq9xrVwVJNAkhhBBCiBqvbmMfXvi/J/ntylxm7fmEB8feR7POgXy28V1cfVxua86C/EIjRynuSFIMV6vp9XpSE9MM3w+b8AAWVuU7XdDS2oJHxw8xVWgA3H333SxatIgVK1YQHBxMv379sLKyYu3atYYkkr29PeHh4aSmphqqkAYOHMiMGTMM87z99tu89tprvP322zRr1oyRI0fSt29f5syZU6F44uPjDdu8APz9/Vm9ejWbN2+mTZs2fPDBB8yYMYMHH3zQMKZLly4sWbKEefPm0apVK+bPn8/SpUvp1OnfrdXz588vM5Hy7bffEhwczLPPPgvAXXfdRXBwMKtWrTKMeeeddwgODubdd98lMzOT4OBggoOD2bfv39ME16xZQ/fu3Wnfvj1//fUXK1eu5P777zfcd3JyIjw8nAsXLtC+fXteeuklxo0bx7hx4wxjRowYwRdffMGsWbNo0aIFDz/8MIGBgSxbtswwJi0trVj1EsCCBQvo1KkTAwYMoEePHlhYWLB27VpD9Vd51q4Kiip1wEIIIYQQohY7d+Iir/V8t9iHwfIIaNuQUwfOmCgqcadodVcQh7dKE/CaxMPPledmP4aXuzdayt4KZ+9id61Xk3oteXRkexQfPzbjlqdnWlhZMGnxGLre39GYod+xpkyZwubNm9m8ebO5Q6nxcnNziY2Nxd/fv8KN3a+TiiYhhBBCCFGr1W9al882vIOjm0OFnlM0VX+ikah9Lp9NMncIwsQyU7JIvZxGamIaieeS8G7gycdrJtHtgU4lejZpdVq6PdCJL7d9IEkmI1q3bl2xhufCvKSiSQghhBBC3BFOR8byZu/3yEjJKtf4wA6NiI6IMXFUwhwsLHV0faATm5fsqJL1GrSsR9yR81Wylqi8ilY0lcbO2RZ7JzvSrqZzfOdJcrPysHW0oe09LU3ak0mIyjJGRZOu7CFCCCGEEELUfI3b+PPxusm8ec97JU4As7azwrO++7UtMDod+bn5XDgZb6ZIhSnVaezN5KXjaBzsT93G3iz88HeTr2nnaGfyNUT1kpWaTVZqNgBt72mFZ313M0ckRNWRrXNCCCGEEOKOEdi+ER+vmYSN/b9/SxsUEgCKwrmoixzfeZLDW49zYu9pMlPLV/kkao5ew7oye/9nNA72B+DJ9x5h8Kh+JcbVaeRl1HVjImOxsrU06pyiZtBaaKnCw76EqBYk0SSEEEIIIe4ozToH8uGfE3BwtadF16ZE7T5FbmauucMSJmRpbcHY715gws+vYutgY7iuKAovffUUIfe1M4x7e8lY5kXP4L3lbxLQrqFR1s/NyjMkt8SdRV+gx85ZKtrEnUUSTUIIIYQQ4o7T6q5mfLntfZq0b4Szh6O5wxEmVK9pXWbt+Zh7n+ld6vHnVy+lcGLPKZw9nZj293v0GNoFjUZDl8Ed+GrHh3j4Gqefzn+3a4o7g72LXbEKSiHuBJJoEkIIIYQQdyS/oHq8+OUIFl+Yw3sr3qTbA53QWdxe419RPfk182XCz6/g08i7xL38vAJOHTjDxoXbcPZyYubuqQR1Cig25tdpf3DlwtUSz9YN8GHiojH87+gX1Gtat1yxnD12HgsraZF7J7G0tsCrgUepCU4hajM5dU4IIYQQQoh/pF/NIDriNOdPXOJc1AXORV/k/IlLpCammTs0UUmObg541ncnKKQJPR7uTF5OPg6u9jRsVZ/CAj12jraGsfpCPau/38C3r/1Ifm5BibladGvKl1s/ACDpUjKv9XyXS6cTbrl+4zYNOB0ZZ9TXJEzDGKfOAXjUc8fFy8mIkQlhenLqnBBCCCGEEEbk6OZAh37BdOgXXOx6enIGF6Ivce7EJc7/k4A6tiOajORMM0UqKir9agbpVzM4fTCW8B8341rHBfe6rrjXdaXr/R2566HOAESsPcic1xdw9viFm86VdDHZ8Gv3Oq58vvFdZrz0PYe3HCfnn35f3v6edBnUgWVf/QWApa2VCV+dqI6yM7Ip1GmIOHSWrJx87Gws6dDaDw83B3OHJoRJSUWTEEIIIYQQ5aSqKqcOnOHM4XNoNApzXl9A+tUMc4clbmDraMNHf06gsEBPQX4h+n/+WZhfSGHBP//ML6SwQG/4p0ar4aFx93Eu6gI7V+4jOyOHnMxccrNyDb9OTUwjITaR7PQcNFoNT304jPue74P9DY2eCwsKObkvhozkTNr3a4NWq2XWy3NZ/b+N6Cy0hiSUqN6MUdEUG5/CxkNn2XP4LHp9keG6Vquha/tGPPFAJ5o2LrmlUwhzM0ZFk/RoEkIIIYQQopwURaFJu0Y069yEYztOSOKgGrG2taJZl0Aen/wwLboF0aZXCzr0bUPIfe3o/kAnej3alT5hPeg/sjcDX+zLkFfu5eHXBzFswhAeeXMwWp0W/5Z+PPb2gzz76eO88vUzvDl/NFN+f4NP101mzsFprExdwLKr8/h67yf4+Hsye9x8Zo7+H7NenssnYTP48d1fiD+TSMd726LVXktQPPPp43S6r638rNxB9kdf4uOftrLzYGyxJBOAXl/E1j2neOntxWzdc8roa2/dupWBAwdSp04dFEVhxYoVJcYsW7aMvn374u7ujqIoREZGlhgTExPDkCFD8PDwwNHRkaFDh3L58uViY1JSUggLC8PJyQknJyfCwsJITU0tNiYiIoLevXvj7OyMi4sLoaGhpa73X7t27eLuu+/Gzs4OZ2dnevbsSU7Ovw31y7N2WeLj4xk+fDiBgYFoNBrGjBlTYsz8+fNRFKXEV27uv7+fGzRoUOqYUaNGGcaMGDGixP2QkBDD/bi4uFLnUBSFX3/9tVyv5+OPP0ZRlBKvQ1VVpkyZQp06dbCxsaFnz54cO3asQu9VRUmiSQghhBBCiAqq37QuY797gYVx3/DY2w/i4Gpv7pDuWJbWFrz4xQhWpP7IV9s/5OHXBpp0PQcXexoH+9NjaBfe+GEUwyc9iGd9d+KOnWfJJ8v5JGwGC6b8YhhvbWtF2OSH6DqkI7aONiaNTZhfbHwKc1ZGUPifBNN/5RfomfLln5woo7dXRWVlZdG6dWtmzZp1yzFdu3blk08+uen90NBQFEVh06ZN7Nixg/z8fAYOHEhR0b+va/jw4URGRrJ27VrWrl1LZGQkYWFhhvsZGRn07duX+vXrs2fPHrZv346joyN9+/aloKBk77Prdu3aRb9+/QgNDWXv3r1EREQwevRoNJp/0xdlrV0eeXl5eHh4MGnSJFq3bn3TcY6OjsTHxxf7urHSJyIioti98PBwAB5++OFi8/Tr16/YuNWrVxvu1atXr8Qa7733HnZ2dvTv37/M1xIREcF3331Hq1atStz77LPP+OKLL5g1axYRERF4e3vTp08fMjJMV40rW+eEEEIIIYSopJysXNbP38zvX/5J/JnLZT8gjCIoJIA354/Gt0kdc4eCXq/nQPhh/vounF1/7Kdpx8YE392SNne3oFnnJlhaW6Iv1HNi72n2rz/E/vBDnNhziqIi+ThW3VRm69ys33dz4GR8ucf36BTAR28OrmiI5aIoCsuXL+f+++8v9X5cXBz+/v4cPHiQNm3aGK6vX7+e/v37k5KSgqOjI3CtgsjV1ZXw8HDuueceoqKiaNasGbt376ZTp04A7N69m86dO3PixAkCAwPZt28fHTp04Ny5c9SrVw+AI0eO0KpVK06fPk2jRo1KjSskJIQ+ffrwwQcflHq/PGtXVM+ePWnTpg3Tp08vdn3+/PmMGTOmQtVSY8aM4c8//+TUqVOGEwdHjBhBampqqRVmNxMcHEzbtm2ZO3fuLcdlZmbStm1bvvnmGz788MNir0NVVerUqcOYMWN46623gGsJNi8vLz799FOef/75EvNJM3AhhBBCCCGqARs7awaP6sd9L/Rh54oIfpm2ihMm2BYjrrGw1PHk+4/y0Gv3GbaomZtWqzU0kk+6lMzauZtYM3cjCz/6HUtrC0Z+/BgPvDqA5l0Cad4lkCemDCUjJZNJA6YStVt+VsqiKAo9hnZGozX+ppz/1l7YudhgbWeFnZMtFlqLcs9zNS2byApWKG3fF8OVqxnVqkF4Xl4eiqJgZfVvA3tra2s0Gg3bt2/nnnvuYdeuXTg5ORkSPXAtQeTk5MTOnTsJDAwkMDAQd3d35s6dy8SJE9Hr9cydO5fmzZvj5+dX6tqJiYns2bOHxx57jC5duhATE0PTpk356KOP6NatG0C51jamzMxM/Pz80Ov1tGnThg8++IDg4OBSx+bn5/Pzzz8zbtw4Q5Lpus2bN+Pp6YmzszM9evTgo48+wtPTs9R59u/fT2RkJF9//XWZ8Y0aNYoBAwZwzz338OGHHxa7FxsbS0JCAqGhoYZrVlZW9OjRg507d5aaaDIGSTQJIYQQQghhJFqtlu4PhtDtgU481/o14o6eN3dItdJ7K94scTJgdeJex5XHJz/EsIlD2LfuEH99F86c134k8VwSz30eZtgC5OBiz6ivnmZ0pwlmjrj66/f03Yz7/oUqWet6RYdnPfcKVXQc3HS0whVqen0R+w6fpX+vFhUN02RCQkKws7PjrbfeYurUqaiqyltvvUVRURHx8deqtRISEkpNknh6epKQcC3Z5uDgwObNmxk8eLChOqlJkyasW7cOna70VMSZM2cAmDJlCtOmTaNNmzYsWLCA3r17c/ToUQICAsq1trE0bdqU+fPn07JlS9LT0/nqq6/o2rUrhw4dIiAgoMT4FStWkJqayogRI4pd79+/Pw8//DB+fn7ExsYyefJk7r77bvbv318soXfd3LlzCQoKokuXLreMb8mSJRw4cICIiIhS719/P7y8vIpd9/Ly4uzZs7ecuzKkR5MQQgghhBBGpigKjdo0MHcYtZKFlQXNOjcxdxjlotVq6XRvW95f8RY/x83GztGW7974ifzcfLIzckhJTKNRmwY0aFHP3KFWa/bOdjw9dZi5wyhTVk5+lT5nKh4eHvz666/88ccf2Nvb4+TkRFpaGm3bti1WQfjfih24Vh12/XpOTg5PP/00Xbt2Zffu3ezYsYPmzZtz7733FmvsfaPrPaCef/55nnrqKYKDg/nyyy8JDAzkhx9+KPfaxhISEsLjjz9O69at6d69O7/88gtNmjRh5syZpY6fO3cu/fv3p06d4tt5H3nkEQYMGECLFi0YOHAga9as4eTJk/z1118l5sjJyWHRokWMHDnylrGdP3+eV199lZ9//rnMhOh/3xdTvFc3koomIYQQQgghTOCtH1+m6+COfDNmHkkXk80dTq3QoltTxn3/AnZOduYOpcI8fN0Ie/dh9IV6MlIyURSFSQOmkpWWzSUjN4SubUZ88CjOHk7mDqNMdjaWVfqcKYWGhhITE0NSUhI6nQ5nZ2e8vb3x9/cHwNvbu8QpdABXrlwxVM8sWrSIuLg4du3aZajiW7RoES4uLqxcuZJHH320xPM+Pj4ANGvWrNj1oKAgzp07V+61TUWj0dChQwdOnSq53fXs2bNs2LCBZcuWlTmPj48Pfn5+pc7z22+/kZ2dzRNPPHHLOfbv309iYiLt2rUzXNPr9WzdupVZs2aRl5eHt7c3cK2y6fp7C9e2KJryvZJEkxBCCCGEECagKArdHwyhXWhrdq6MIDk+heSEVFIup177Z0IqyfEpZKRkmTvUaq1xsD+dB7an86D2NA72N+nfwlcFrU5rSJrM3DWV5TNW8+O7S8nNyjNzZNVTw9Z+3Pd8H3OHUS4dWvuh1WrQl3Hi3I20Wg3tW5Xer6g6cHd3B2DTpk0kJiYyaNAgADp37kxaWhp79+6lY8eOAOzZs4e0tDTDdq/s7Gw0Gk2x37PXv7/x9LobNWjQgDp16hAdHV3s+smTJw2nr5VnbVNRVZXIyEhatmxZ4t68efPw9PRkwIABZc5z9epVzp8/Xyz5c93cuXMZNGgQHh4et5yjd+/eHDlypNi1p556iqZNm/LWW2+h1Wrx9/fH29ub8PBwQ1+p/Px8tmzZwqefflpmnLdLEk1CCCGEEEKYkK2DDfc8ftdN7+fnFZD6T/LJkIC6/s/L/36fHJ9Cfu7NjwSvLSwsdbTu1ZzOAzsQMrAdnvXczR2SyWh1Wh4aN5AeQ7swe+w8tv2+x9whVTsvzxyJVlc9Gr6XxcPNga7tG7G1AgcBdGvfyKiNwDMzMzl9+rTh+9jYWCIjI3F1daV+/foAJCcnc+7cOS5dugRgSOp4e3sbKmDmzZtHUFAQHh4e7Nq1i1dffZWxY8caGm0HBQXRr18/nn32WebMmQPAc889x3333WcY06dPH9544w1GjRrFyy+/TFFREZ988gk6nY5evXoBcPHiRXr37s2CBQvo2LEjiqLwxhtv8O6779K6dWvatGnDjz/+yIkTJ/jtt9/KvXZ5RUZGGt63K1euEBkZiaWlpaGi6r333iMkJISAgADS09OZMWNGqU26i4qKmDdvHk8++WSJ/lOZmZlMmTKFBx98EB8fH+Li4pg4cSLu7u4MGTKk2NjTp0+zdetWVq9eXWq8vXv3ZsiQIYwePRoHBwdatCje28vOzg43NzfDdUVRGDNmDFOnTiUgIICAgACmTp2Kra0tw4cPr9B7VRGSaBJCCCGEEMKMLK0s8KzvgWf9W//ttaqq1/r6JKRy8XQCv3y+ksNbjldRlKbl4GpPyH3t6DywPe1CW2PrYGPukKqUh68b7/z6OntWH2DWy3NJiE00d0jVQu/Hu9OiW5C5w6iQJx7oxO4DZ8gv0Jc51tJSR9gDncocVxH79u0zJHEAxo0bB8CTTz7J/PnzAVi1ahVPPfWUYcz1LWzvvvsuU6ZMAa4lnyZMmEBycjINGjRg0qRJjB07tthaCxcu5JVXXjGcaDZo0CBmzZpluN+0aVP++OMP3nvvPTp37oxGoyE4OJi1a9caKnkKCgqIjo4mOzvb8NyYMWPIzc1l7NixJCcn07p1a8LDw2nUqFG514Zr1VEjRowwvKbS3Hh63P79+1m0aBF+fn7ExcUBkJqaynPPPUdCQgJOTk4EBwezdetWQyXVdRs2bODcuXM8/fTTJdbQarUcOXKEBQsWkJqaio+PD7169WLp0qU4OBRPMv7www/UrVu32ClxN7q+nbEi3nzzTXJycnjppZdISUmhU6dOrF+/vsTaxqSo/z3LUQghhBBCCFHtqarKgQ2Hmff2YqIjYswdToXVDfChy6D2dB7UgWadm9SYqhVTy83OY/HUZfzy+UoKy5GsqK1s7K2ZFz0DNx+XKl/7+qlz/v7+FTp17rqte04x5cs/b5lssrTQMmXsfdzVqeTJZaLycnJycHV1ZfXq1cUSb6Jslf35B0k0CSGEEEIIUaOpqsquVfuYN3kxcUfPmzucm9JoFJp1CTT0W6oXWNfcIVVrZ6MuMHPU/zi0+Zi5QzGL5z5/godfG2iWtY3xQfvE6QR+WraH7ftiivVs0mo1dGvfiLAHOtG0sbexQhb/sXbtWmbOnFnqqW7i1iTRJIQQQgghhACu9QjZvHQnC6b8wsVT8eYOx6BppwAGvhBKx3uDa8TJYdWJqqpsXLiNOa8vIDUxzdzhVJl6TesyJ/JzLCwtzLK+MT5oX3flagb7Dp8lKycfOxtL2rfyM2pPJiGMTRJNQgghhBBCiGL0hXrW/7iZn97/lSvnr5otjvpBdXn6o+F0Gdyhxp8UZ24ZKZn8MHERf323gTvh49sn696mXZ/WZlvfmIkmIWoaSTQJIYQQQgghSpWfV8Bfc8JZNHVZlVbDePi68cSUofR5oof0XTKyqD2n+Pyprzl/4qK5QzGZ7g924p1fXzdrDJJoEncySTQJIYQQQgghbiknK5eVM9ewcdE2zh67YLKKGAdXe4ZNeIBBL4ViZWNlkjUEZGfk8PlTX7N92R5zh2J0VjaWzD0+HS+/W5/AaGqSaBJ3Mkk0CSGEEEIIIcotMzWL47tOcmzHCY7tjObEnlPk5eRXaA6NVoNWq0Hzz5eltQX3PnsPQ98YjL2znYkiFzdSVZWln65g3tuLKSqqPR/nRrz/KI+9/aC5w5BEk7ijSaJJCCGEEEIIcdsKCwo5fTCWYzuiObbzBMd2RJOckGq4/9ikBxk2cYghqaTRaKTfUjWyb/0hpg6fTkZyprlDqTSfhl787+gXWFpbmjsUSTSJO5okmoQQQgghhBBGo6oqCbGJHN1xgrQr6Tw49j5JLFVzCXGJvPfgNE4fjDV3KJXywarxhNzXztxhAJJoEnc2Y/z864wckxBCCCGEEKKGUhQFn4Ze+DT0Mncoopy8G3gyffsHTH/hOzb8tNXc4dyWTgPaVpskk7ElZGaw/dxZMvPzsbe0pFt9P7ztHcwdlhAmJYkmIYQQQgghhKjBrGyseHP+aJp2DGD22PnoC/XmDqncLCx1vPjlCHOHYXSHLyfwzb49bIo9Q2FRkeG6TqPhbv+GvNS+E628vM0YoRCmozF3AEIIIYQQQgghKkdRFAaP6se0v6fg6u1s7nDK7aHXBlK3sY+5wzCqdTGnGPrbEtbHnC6WZAIoLCpifczpf+6fMvraW7duZeDAgdSpUwdFUVixYkWJMSNGjEBRlGJfISEhhvtxcXEl7l//+vXXXw3jGjRoUOL++PHjDffnz59/03kSExPLfC2qqtK/f/9SX0dKSgphYWE4OTnh5OREWFgYqampFXqvli1bRp8+ffDw8MDR0ZHOnTuzbt26YmOOHTvGgw8+aHit06dPLzHPlClTSrw+b+/iSURVVZkyZQp16tTBxsaGnj17cuzYsWJjYmJiGDJkiCGeoUOHcvny5Vu+ho8//pgOHTrg4OCAp6cn999/P9HR0RVe29gk0SSEEEIIIYQQtUSLrk35et+nNOsSaO5QyuTh68awiQ+YOwyjOnw5gVfX/kW+/tZVZfl6Pa+s/YvDlxOMun5WVhatW7dm1qxZtxzXr18/4uPjDV+rV6823KtXr16xe/Hx8bz33nvY2dnRv3//YvO8//77xca9/fbbhnuPPPJIiXn69u1Ljx498PT0LPO1TJ8+/aY94oYPH05kZCRr165l7dq1REZGEhYWVuacN9q6dSt9+vRh9erV7N+/n169ejFw4EAOHjxoGJOdnU3Dhg355JNPSiSPbtS8efNir/PIkSPF7n/22Wd88cUXzJo1i4iICLy9venTpw8ZGRnAtX9voaGhKIrCpk2b2LFjB/n5+QwcOJCi/yQrb7RlyxZGjRrF7t27CQ8Pp7CwkNDQULKyssq9tinI1jkhhBBCCCGEqEXc67gybdO7fDvuR1Z9s67sB8zk+f97Ehu72tVs+5t9e8pMMl2Xr9cze99eZg8YZLT1+/fvXyIZVBorK6ubJk60Wm2Je8uXL+eRRx7B3t6+2HUHB4ebzmNjY4ONjY3h+ytXrrBp0ybmzp1bZnyHDh3iiy++ICIiAh+f4hVvUVFRrF27lt27d9OpUycAvv/+ezp37kx0dDSBgeVLsv63Omnq1KmsXLmSP/74g+DgYAA6dOhAhw4dAIpVa/2XTqe76fugqirTp09n0qRJPPDAtcTqjz/+iJeXF4sWLeL5559nx44dxMXFcfDgQRwdHQGYN28erq6ubNq0iXvuuafUudeuXVvs+3nz5uHp6cn+/fu56667yrW2KUhFkxBCCCGEEELUMhaWFrw86xlGzXja3KGUqs3dLbjroZCyB9YgCZkZbDwTU6FnNsbGkJBpusqSm9m8eTOenp40adKEZ5999pZb2fbv309kZCQjR44sce/TTz/Fzc2NNm3a8NFHH5Gfn3/TeRYsWICtrS0PPfTQLWPLzs5m2LBhzJo1q9Tkza5du3BycjIkmQBCQkJwcnJi586dt5z7VoqKisjIyMDV1bXCz546dYo6derg7+/Po48+ypkzZwz3YmNjSUhIIDQ01HDNysqKHj16GOLNy8tDURSsrKwMY6ytrdFoNGzfvr3ccaSlpQEYXkN51jYFSTQJIYQQQgghRC11/+j+1a7ZtlanZfSMp2+6Laqm2n7uLHpVrdAzhUVF7Dh/zkQRla5///4sXLiQTZs28X//939ERERw9913k5eXV+r4uXPnEhQURJcuXYpdf/XVV1myZAl///03o0ePZvr06bz00ks3XfeHH35g+PDhxaqcSjN27Fi6dOnC4MGDS72fkJBQ6tY7T09PEhJufyvi//3f/5GVlcXQoUMr9FynTp1YsGAB69at4/vvvychIYEuXbpw9epVQ7wAXl7FT/P08vIy3AsJCcHOzo633nqL7OxssrKyeOONNygqKiI+Pr5ccaiqyrhx4+jWrRstWrQo99qmIFvnhBBCCCGEEKIWe+DVAegL9Hz35k/mDgWA+1/uj1+zeuYOw+gyb1HNc+vnSk/wmMojjzxi+HWLFi1o3749fn5+/PXXX4btVdfl5OSwaNEiJk+eXGKesWPHGn7dqlUrXFxceOihhwxVTjfatWsXx48fZ8GCBbeMbdWqVWzatKlYn6TSlJakVFX1tpOXixcvZsqUKaxcubJc/aNudONWxZYtW9K5c2caNWrEjz/+yLhx424a843xenh48Ouvv/Liiy8yY8YMNBoNw4YNo23btmi12nLFMXr0aA4fPlxqBdSt1jYFqWgSQgghhBBCiFru4dcH8fRHw80dBi5eToS9+7C5wzAJe0vL23zOquxBJuTj44Ofnx+nTpU8Be+3334jOzubJ554osx5rp9cd/r06RL3/ve//9GmTRvatWt3yzk2bdpETEwMzs7O6HQ6dLprtTEPPvggPXv2BMDb27vU09iuXLlSonKnPJYuXcrIkSP55ZdfbtoLqSLs7Oxo2bKl4f28vv3vvxVEiYmJxeINDQ0lJiaGxMREkpKS+Omnn7h48SL+/v5lrvnyyy+zatUq/v77b3x9fQ3Xy7u2sUmiSQghhBBCCCHuAMMmDOHJ9x4pe6AJPftZGHaOtmaNwVS61fdDp6nYR2ydRkPXevVNFFH5XL16lfPnz5doug3Xts0NGjQIDw+PMue5XoX033kyMzP55ZdfSu3x9F/jx4/n8OHDREZGGr4AvvzyS+bNmwdA586dSUtLY+/evYbn9uzZQ1paWontfWVZvHgxI0aMYNGiRQwYMKBCz95MXl4eUVFRhvfB398fb29vwsPDDWPy8/PZsmVLqfG6u7vj7OzMpk2bSExMZNCgmzeLV1WV0aNHs2zZMjZt2lQiKVXRtY1Fts4JIYQQQgghxB3i8ckPUVhQyMIPf6/ytZt1CeSex++q8nWrire9A3f7N2R9TMmKnpvp7d8Ib3sHo8WQmZlZrKIoNjaWyMhIXF1dqV+/PpmZmUyZMoUHH3wQHx8f4uLimDhxIu7u7gwZMqTYXKdPn2br1q2sXr26xDq7du1i9+7d9OrVCycnJyIiIhg7diyDBg2ifv3iibOlS5dSWFjIY489VmKeixcv0rt3bxYsWEDHjh3x9vYutQF4/fr1DUmUoKAg+vXrx7PPPsucOXMAeO6557jvvvvKfeIcXEsyPfHEE3z11VeEhIQYqn5sbGxwcnICriVljh8/bvj1xYsXiYyMxN7ensaNGwPw+uuvM3DgQOrXr09iYiIffvgh6enpPPnkk8C1bWtjxoxh6tSpBAQEEBAQwNSpU7G1tWX48H+rDOfNm0dQUBAeHh7s2rWLV199lbFjxxZ7Tb1792bIkCGMHj0agFGjRrFo0SJWrlyJg4OD4TU4OTlhY2NT7rWNTRJNQgghhBBCCHEHefK9R9AX6Fny6YoqW1NRFF6eObLWNQD/r5fad2JzXCz5en2ZY620Ol5s39Go6+/bt49evXoZvr/eI+jJJ59k/vz5aLVajhw5woIFC0hNTcXHx4devXqxdOlSHByKJ7x++OEH6tatW+zEMkPsVlYsXbqU9957j7y8PPz8/Hj22Wd58803S4ydO3cuDzzwAC4uLiXuFRQUEB0dTXZ2doVe58KFC3nllVcMsQ0aNIhZs2YVG9OgQQNGjBjBlClTSp1jzpw5FBYWMmrUKEaNGmW4fv29Arh06RLBwcGGe9OmTWPatGn06NGDzZs3A3DhwgWGDRtGUlISHh4ehISEsHv3bvz8/AzPvfnmm+Tk5PDSSy+RkpJCp06dWL9+fbH3PDo6mgkTJpCcnEyDBg2YNGlSsT5YADExMSQlJRm+nz17NoBhW+F18+bNY8SIEeVe29gUVa1gW3whhBBCCCGEEDWaqqp8/+ZP/Pp/f1TJev2evpvX/vdilaxVWbm5ucTGxuLv74+1tXWFn18fc4pX1v51y2STpVbLjH4DCG0UUJlQxU3k5OTg6urK6tWriyXeRNkq+/MP0qNJCCGEEEIIIe44iqLw7GdhvPv767jXdTX5eoc2HyMjJdPk61QHoY0C+OWhR+nbKKBEzyadRkPff+5Lksl0tmzZwt133y1JJjORiiYhhBBCCCGEuINlZ+Qwf/ISVs5ag1sdV65cuGqSdTr0D+bDP8ajqWDD7KpmjIqO6xIyM9hx/hyZ+XnYW1rRtV59o/ZkEsLYjPHzL4kmIYQQQgghhBCcOnAGK1srMlOz+PmD34hYc9Doazw++SGzn3xXFmMmmoSoaWTrnBBCCCGEEEIIowho25DC/EIWT11Gx37BBLRraPQ1fv7gN3b9sc/o8wohqg9JNAkhhBBCCCGEAKBhKz+atGvE16/+gK2DjUnW+CRsBhdOxZtkbiGE+UmiSQghhBBCCCGEwfBJDxAysB1nDp81yfzZ6Tm898Dn5GTmmGR+IYR5SaJJCCGEEEIIIYSBVqdl8i+v0axzE5OtkXg+iYTYRJPNL4QwH0k0CSGEEEIIIYQoxtLKgnd+e52O9wYbfW47J1s+XT8Z/5Z+Rp9bCGF+kmgSQgghhBBCCFGCpZUF7/72Oh36Gy/ZdD3J1LRjgNHmrM6S81PYdmU76xM2sO3KdpLzU8wdkhAmpzN3AEIIIYQQQgghqidLa0um/P46Ux74nIi1kZWer09YDwI7NK58YNVcbGYcf8T/RWTqIfSq3nBdq2hp49yagT4D8LdvYL4AhTAhqWgSQgghhBBCCHFTltaWTFn2Bu37tq70XGlX040QUfW2L/kAH0V9zP6UA8WSTAB6Vc/+lH/vG9vHH39Mhw4dcHBwwNPTk/vvv5/o6OhiY5YtW0bfvn1xd3dHURQiIyNLzNOzZ08URSn29eijjxYbk5KSQlhYGE5OTjg5OREWFkZqamqxMRs3bqRLly44ODjg4+PDW2+9RWFh4U3jT05O5uWXXyYwMBBbW1vq16/PK6+8QlpaWoXXLsuyZcvo06cPHh4eODo60rlzZ9atW1di3PTp0wkMDMTGxoZ69eoxduxYcnNzDfdnz55Nq1atcHR0NMyzZs0aw/2CggLeeustWrZsiZ2dHXXq1OGJJ57g0qVLpcalqir9+/dHURRWrFhR7tfz8ccfoygKY8aMKTHflClTqFOnDjY2NvTs2ZNjx46Ve97bIYkmIYQQQgghhBC3ZGltyXvL36RdaOWSTWlXaneiKTYzjm9j5lCg3jyZAlCgFjL79BxiM+OMuv6WLVsYNWoUu3fvJjw8nMLCQkJDQ8nKyjKMycrKomvXrnzyySe3nOvZZ58lPj7e8DVnzpxi94cPH05kZCRr165l7dq1REZGEhYWZrh/+PBh7r33Xvr168fBgwdZsmQJq1atYvz48Tdd89KlS1y6dIlp06Zx5MgR5s+fz9q1axk5cmSF1i6PrVu30qdPH1avXs3+/fvp1asXAwcO5ODBg4YxCxcuZPz48bz77rtERUUxd+5cli5dyoQJEwxjfH19+eSTT9i3bx/79u3j7rvvZvDgwYZkTnZ2NgcOHGDy5MkcOHCAZcuWcfLkSQYNGlRqXNOnT0dRlAq9loiICL777jtatWpV4t5nn33GF198waxZs4iIiMDb25s+ffqQkZFRoTUqQlFVVTXZ7EIIIYQQQgghao28nDzeGfwpBzYcua3nuwzuwHvL3zRyVMaVm5tLbGws/v7+WFtbV+jZGae+rlClUnuXtrwcMKqiIZbblStX8PT0ZMuWLdx1113F7sXFxeHv78/Bgwdp06ZNsXs9e/akTZs2TJ8+vdR5o6KiaNasGbt376ZTp04A7N69m86dO3PixAkCAwOZOHEi4eHhREREGJ5bsWIFw4YNIzExEQcHh3K9hl9//ZXHH3+crKwsdDpduda+Xc2bN+eRRx7hnXfeAWD06NFERUWxceNGw5jXXnuNvXv3sm3btpvO4+rqyueff14iQXZdREQEHTt25OzZs9SvX99w/dChQ9x3331ERETg4+PD8uXLuf/++28Zc2ZmJm3btuWbb77hww8/LPbvTVVV6tSpw5gxY3jrrbcAyMvLw8vLi08//ZTnn3++xHyV+fm/TiqahBBCCCGEEEKUi5WNFe+teIvg3i0r/KxHPTfGzCn5wba2SM5P4WBKZIWeOZh6yKQNwq9vOXN1da3wswsXLsTd3Z3mzZvz+uuvF6uA2bVrF05OToZED0BISAhOTk7s3LkTuJbQ+G+iwsbGhtzcXPbv31+h1+Do6IhOpyv32rejqKiIjIyMYu9Vt27d2L9/P3v37gXgzJkzrF69mgEDBpQ6h16vZ8mSJWRlZdG5c+dbviZFUXB2djZcy87OZtiwYcyaNQtvb+9yxz1q1CgGDBjAPffcU+JebGwsCQkJhIaGGq5ZWVnRo0ePSr1XZZFm4EIIIYQQQgghys3a1or3V77F5EGfELnpaLmfG/H+o7h4OpkwMvM6lnaMIooq9Ixe1XM87TjdPLoaPR5VVRk3bhzdunWjRYsWFXr2sccew9/fH29vb44ePcqECRM4dOgQ4eHhACQkJODp6VniOU9PTxISEgDo27cv06dPZ/HixQwdOpSEhAQ+/PBDAOLj48sVx9WrV/nggw+KVd6UZ+3b8X//939kZWUxdOhQw7VHH32UK1eu0K1bN1RVpbCwkBdffLHE9r8jR47QuXNncnNzsbe3Z/ny5TRr1qzUdXJzcxk/fjzDhw/H0dHRcH3s2LF06dKFwYMHlzvmJUuWcODAgWJVYze6/n54eXkVu+7l5cXZs2fLvU5FSUWTEEIIIYQQQogKsba14oNV42nTq3m5n7kcd8WEEZlfjj637EFGfK4so0eP5vDhwyxevLjCzz777LPcc889tGjRgkcffZTffvuNDRs2cODAv9sCS+sjpKqq4XpoaCiff/45L7zwAlZWVjRp0sRQCaTVasuMIT09nQEDBtCsWTPefffdYvfKWruiFi9ezJQpU1i6dGmxJNbmzZv56KOP+Oabbwz9lf78808++OCDYs8HBgYSGRnJ7t27efHFF3nyySc5fvx4iXUKCgp49NFHKSoq4ptvvjFcX7VqFZs2bbrpVsXSnD9/nldffZWff/65zC1u/31fKvNelYckmoQQQgghhBBCVJi1rRXvrxpP657lSzbFHIo1cUTmZaO9vX42t/vcrbz88susWrWKv//+G19f30rP17ZtWywsLDh16hQA3t7eXL58ucS4K1euFKueGTduHKmpqZw7d46kpCRDtY6/v/8t18vIyKBfv36G6iALCwvDvfKuXV5Lly5l5MiR/PLLLyW2n02ePJmwsDCeeeYZWrZsyZAhQ5g6dSoff/wxRUX/Vq9ZWlrSuHFj2rdvz8cff0zr1q356quvis1VUFDA0KFDiY2NJTw8vFg106ZNm4iJicHZ2RmdTmfYJvjggw/Ss2fPUuPev38/iYmJtGvXzvDMli1bmDFjBjqdDr1eb9iC999Kr8TExNt6r8pLEk1CCCGEEEIIIW6LjZ01H/wxnlY9St8mdKOYyDjTB2RGzZ2ao1XKrtS5kVbR0syp7PeuvFRVZfTo0SxbtoxNmzaVmdApr2PHjlFQUICPjw8AnTt3Ji0tzdC7CGDPnj2kpaXRpUuXYs8qikKdOnWwsbFh8eLF1KtXj7Zt2950rfT0dEJDQ7G0tGTVqlUlqnUqsnZZFi9ezIgRI1i0aFGpfZeys7PRaIqnTbRaLaqqcqtz1VRVJS8vz/D99STTqVOn2LBhA25ubsXGjx8/nsOHDxMZGWn4Avjyyy+ZN29eqWv07t2bI0eOFHumffv2PPbYY0RGRqLVag3bH69veQTIz89ny5YtFX6vKkJ6NAkhhBBCCCGEuG02dtZ8+OcEJg2YypGtUTcdlxB3hczULOyd7aowuqrjaulCG+fWFTp1Lti5Na6WLkaLYdSoUSxatIiVK1fi4OBgqGRxcnLCxsYGgOTkZM6dO8elS5cAiI6OBq5VCnl7exMTE8PChQu59957cXd35/jx47z22msEBwfTteu1XlJBQUH069ePZ599ljlz5gDw3HPPcd999xU79e3zzz+nX79+aDQali1bxieffMIvv/xi2Dp38eJFevfuzYIFC+jYsSMZGRmEhoaSnZ3Nzz//THp6Ounp6QB4eHig1WrLvXZZFi9ezBNPPMFXX31FSEiI4b2ysbHByelaL7GBAwfyxRdfEBwcTKdOnTh9+jSTJ09m0KBBhtcwceJE+vfvT7169cjIyGDJkiVs3ryZtWvXAlBYWMhDDz3EgQMH+PPPP9Hr9Ya1XF1dsbS0NLz3/1W/fv1iycLevXszZMgQRo8ejYODQ4neW3Z2dri5uRmuK4rCmDFjmDp1KgEBAQQEBDB16lRsbW0ZPnx4ud+ripKKJiGEEEIIIYQQlWJjZ81Hf06gZfegW447c9h0DYirg4E+A7BQylfPYaFYcJ9P6aeX3a7Zs2eTlpZGz5498fHxMXwtXbrUMGbVqlUEBwcbKngeffRRgoOD+fbbb4Fr28A2btxI3759CQwM5JVXXiE0NJQNGzYU6620cOFCWrZsSWhoKKGhobRq1YqffvqpWDxr1qyhe/futG/fnr/++ouVK1dy//33G+4XFBQQHR1NdnY2cG072J49ezhy5AiNGzcu9hrOnz9fobUbNGjAlClTbvpezZkzh8LCQkaNGlVsnVdffdUw5u233+a1117j7bffplmzZowcOZK+ffsaElwAly9fJiwsjMDAQHr37s2ePXtYu3Ytffr0AeDChQusWrWKCxcu0KZNm2JrVfTkt5iYGJKSkir0zJtvvsmYMWN46aWXaN++PRcvXmT9+vU4ODhUaJ6KUNRb1XsJIYQQQgghhBDllJOZw8R7p3J0+4lS73+59X1adLt1MsrccnNziY2Nxd/fv8wmy6XZn3KA2afnUKAW3nSMhaLjxcbP087l5lvIxO3LycnB1dWV1atX06tXL3OHU6NU9ucfpKJJCCGEEEIIIYSR2Njb8NFfE2nWpeQWJp+GXjTv2tQMUVWtdi5tmRQ0gfYubUv0bNIqWtr/c1+STKazZcsW7r77bkkymYlUNAkhhBBCCCGEMKqs9Gwm9v+I47tOGq49+d4jPD75ITNGVT7GqOi4Ljk/heNpx8nR52KjtaaZUzOj9mQSwtiM8fMvzcCFEEIIIYQQQhiVnaMtU9dMYkK/D4nafYqej3Zl0Ki+5g6ryrlautDNo6u5wxCiSkmiSQghhBBCCCGE0dk52vLxmkmc2Huadn1amzscIUQVkR5NQgghhBBCCCFMws7JTpJMQtxhJNEkhBBCCCGEEEIIIYxCEk1CCCGEEEIIIYQQwigk0SSEEEIIIYQQQgghjEKagQshhBBCCCGEECag6hMgbyeomaDYg1UXFK23ucMSwqQk0SSEEEIIIYQQQhiRWnAENb/yEiAAAA4VSURBVPNbyPsbKLzhjg7VqheK/QsoFi3NFZ4QJiVb54QQQgghhBBCCCNRc9ejXh0GeeEUTzJx7fu8cNSrw1Bzw42+9scff0yHDh1wcHDA09OT+++/n+jo6GJjMjMzGT16NL6+vtjY2BAUFMTs2bOLjXn++edp1KgRNjY2eHh4MHjwYE6cOGG4HxcXx8iRI/H398fGxoZGjRrx7rvvkp+fX2pcV69exdfXF0VRSE1NLddrUVWV/v37oygKK1asKHYvJSWFsLAwnJyccHJyIiwsrNzzXrd582YURSnxdePrvNGSJUtQFIX777+/2PXZs2fTqlUrHB0dcXR0pHPnzqxZs+am6z7//PMoisL06dOLXY+JiWHIkCF4eHjg6OjI0KFDuXz5cpmv45tvvsHf3x9ra2vatWvHtm3bit1XVZUpU6ZQp04dbGxs6NmzJ8eOHStz3sqQRJMQQgghhBBCCGEEasER1NRxQOkJl3/lo6aORS04YtT1t2zZwqhRo9i9ezfh4eEUFhYSGhpKVlaWYczYsWNZu3YtP//8M1FRUYwdO5aXX36ZlStXGsa0a9eOefPmERUVxbp161BVldDQUPR6PQAnTpygqKiIOXPmcOzYMb788ku+/fZbJk6cWGpcI0eOpFWrVhV6LdOnT0dRlFLvDR8+nMjISNauXcvatWuJjIwkLCysQvNfFx0dTXx8vOErICCgxJizZ8/y+uuv07179xL3fH19+eSTT9i3bx/79u3j7rvvZvDgwaUmc1asWMGePXuoU6dOsetZWVmEhoaiKAqbNm1ix44d5OfnM3DgQIqKim4a+9KlSxkzZgyTJk3i4MGDdO/enf79+3Pu3DnDmM8++4wvvviCWbNmERERgbe3N3369CEjI6Mib1PFqEIIIYQQQgghhFBVVVVzcnLU48ePqzk5ORV+Vp/8kqqPDyj/V/IoE7yCfyUmJqqAumXLFsO15s2bq++//36xcW3btlXffvvtm85z6NAhFVBPnz590zGfffaZ6u/vX+L6N998o/bo0UPduHGjCqgpKSllxh0ZGan6+vqq8fHxKqAuX77ccO/48eMqoO7evdtwbdeuXSqgnjhxosy5r/v777/LFU9hYaHatWtX9X//+5/65JNPqoMHDy5zbhcXF/V///tfsWsXLlxQ69atqx49elT18/NTv/zyS8O9devWqRqNRk1LSzNcS05OVgE1PDz8put07NhRfeGFF4pda9q0qTp+/HhVVVW1qKhI9fb2Vj/55BPD/dzcXNXJyUn99ttvS52zMj//10lFkxBCCCGEEEIIUUnXGn9vqthDeZuuPWciaWlpALi6uhqudevWjVWrVnHx4kVUVeXvv//m5MmT9O3bt9Q5srKymDdvHv7+/tSrV++Wa924DsDx48d5//33WbBgARpN+dIP2dnZDBs2jFmzZuHtXbJx+q5du3BycqJTp06GayEhITg5ObFz585yrXGj4OBgfHx86N27N3///XeJ+++//z4eHh6MHDmyzLn0ej1LliwhKyuLzp07G64XFRURFhbGG2+8QfPmzUs8l5eXh6IoWFlZGa5ZW1uj0WjYvn17qWvl5+ezf/9+QkNDi10PDQ01vA+xsbEkJCQUG2NlZUWPHj1u670qL0k0CSGEEEIIIYQQlZW3E9BX8KFCyDfNB35VVRk3bhzdunWjRYsWhuszZsygWbNm+Pr6YmlpSb9+/fjmm2/o1q1bsee/+eYb7O3tsbe3Z+3atYSHh2NpaVnqWjExMcycOZMXXnjBcC0vL49hw4bx+eefU79+/XLHPXbsWLp06cLgwYNLvZ+QkICnp2eJ656eniQklD9p5+Pjw3fffcfvv//OsmXLCAwMpHfv3mzdutUwZseOHcydO5fvv//+lnMdOXIEe3t7rKyseOGFF1i+fDnNmjUz3P/000/R6XS88sorpT4fEhKCnZ0db731FtnZ2WRlZfHGG29QVFREfHx8qc8kJSWh1+vx8vIqdt3Ly8vwPlz/563GmIKcOieEEEIIIYQQQlSWmnl7zxXd5nNlGD16NIcPHy5RETNjxgx2797NqlWr8PPzY+vWrbz00kv4+Phwzz33GMY99thj9OnTh/j4eKZNm8bQoUPZsWMH1tbWxea7dOkS/fr14+GHH+aZZ54xXJ8wYQJBQUE8/vjj5Y551apVbNq0iYMHD95yXGm9m1RVvWlPp9IEBgYSGBho+L5z586cP3+eadOmcdddd5GRkcHjjz/O999/j7u7e5lzRUZGkpqayu+//86TTz7Jli1baNasGfv37+err77iwIEDN43Pw8ODX3/9lRdffJEZM2ag0WgYNmwYbdu2RavV3nLt/85Z2vtQnjHGJIkmIYQQQgghhBCishT723tOc5vP3cLLL7/MqlWr2Lp1K76+vobrOTk5TJw4keXLlzNgwAAAWrVqRWRkJNOmTSuWaLp+oltAQAAhISG4uLiwfPlyhg0bZhhz6dIlevXqRefOnfnuu++KxbBp0yaOHDnCb7/9BlxLbgC4u7szadIk3nvvvRJxb9q0iZiYGJydnYtdf/DBB+nevTubN2/G29u71NPYrly5UqJyp6JCQkL4+eefgWtVWnFxcQwcONBw/3pjbp1OR3R0NI0aNQLA0tKSxo0bA9C+fXsiIiL46quvmDNnDtu2bSMxMbFYVZder+e1115j+vTpxMXFAde2vMXExJCUlIROp8PZ2Rlvb2/8/f1LjdXd3R2tVluiMikxMdHwPlzfepiQkICPj0+pY0xBEk1CCCGEEEIIIURlWXXh2kfswgo8pAPLLkYLQVVVXn75ZZYvX87mzZtLJCkKCgooKCgo0S9Jq9Xe8nSz63Pn5eUZvr948SK9evUynFD33zl///13cnJyDN9HRETw9NNPs23bNkOC5r/Gjx9frCoKoGXLlnz55ZeGhE/nzp1JS0tj7969dOzYEYA9e/aQlpZGly6Vey8PHjxoSMg0bdqUI0eKnwr49ttvk5GRwVdffXXLflU3vldhYWHFEngAffv2JSwsjKeeeqrEs9erpzZt2kRiYiKDBg0qdQ1LS0vatWtHeHg4Q4YMMVwPDw83bDv09/fH29ub8PBwgoODgWu9nbZs2cKnn356y/eiMiTRJIQQQgghhBBCVJKi9Ua16gV54eV/yOpuFG3Jhte3a9SoUSxatIiVK1fi4OBgqHZxcnLCxsYGR0dHevTowRtvvIGNjQ1+fn5s2bKFBQsW8MUXXwBw5swZli5dSmhoKB4eHly8eJFPP/0UGxsb7r33XuBaJVPPnj2pX78+06ZN48qVK4YYrlfR/DeZlJSUBEBQUJChYunixYv07t2bBQsW0LFjR7y9vUttAF6/fn1D0iwoKIh+/frx7LPPMmfOHACee+457rvvvmJb4coyffp0GjRoQPPmzcnPz+fnn3/m999/5/fffweuNeO+sbcVYIj7xusTJ06kf//+1KtXj4yMDJYsWcLmzZtZu3YtAG5ubri5uRWbx8LCAm9v72Lxzps3j6CgIDw8PNi1axevvvoqY8eOLTamd+/eDBkyhNGjRwMwbtw4wsLCaN++vaGq7Ny5c4ZeWYqiMGbMGKZOnUpAQAABAQFMnToVW1tbhg8fXu73qqIk0SSEEEIIIYQQQhiBYv8Cat4WIL8co61Q7J836vqzZ88GoGfPnsWuz5s3jxEjRgCwZMkSJkyYwGOPPUZycjJ+fn589NFHhuSEtbU127ZtY/r06aSkpODl5cVdd93Fzp07DU24169fz+nTpzl9+nSxrXnw7xa58igoKCA6Oprs7OwKvc6FCxfyyiuvGE5TGzRoELNmzSo2pkGDBowYMYIpU6aUOkd+fj6vv/46Fy9exMbGhubNm/PXX38ZkmnldfnyZcLCwoiPj8fJyYlWrVqxdu1a+vTpU6F5oqOjmTBhAsnJyTRo0IBJkyYxduzYYmOub6277pFHHuHq1au8//77xMfH06JFC1avXo2fn59hzJtvvklOTg4vvfQSKSkpdOrUifXr1+Pg4FCh+CpCUSvyUyCEEEIIIYQQQtRiubm5xMbG4u/vX6LxdXmoueGoqWO5dbLJEsX5SxTriiUjRPnk5OTg6urK6tWr6dWrl7nDqVEq+/MPoCl7iBBCCCGEEEIIIcpDse6D4rYYrEIpuYlIB1ahKG6LJclkQlu2bOHuu++WJJOZSEWTEEIIIYQQQgjxD2NUdFyn6hMgfycUZV47Xc6yi1F7MglhbMb4+ZceTUIIIYQQQgghhAkoWm+wecDcYQhRpWTrnBBCCCGEEEIIIYQwCkk0CSGEEEIIIYQQ/yFdZsSdyBg/95JoEkIIIYQQQggh/mFhYQFAdna2mSMRoupd/7m//vvgdkiPJiGEEEIIIYQQ4h9arRZnZ2cSExMBsLW1RVEUM0clhGmpqkp2djaJiYk4Ozuj1Wpvey45dU4IIYQQQgghhLiBqqokJCSQmppq7lCEqFLOzs54e3tXKrkqiSYhhBBCCCGEEKIUer2egoICc4chRJWwsLCoVCXTdZJoEkIIIYQQQgghhBBGIc3AhRBCCCGEEEIIIYRRSKJJCCGEEEIIIYQQQhiFJJqEEEIIIYQQQgghhFFIokkIIYQQQgghhBBCGIUkmoQQQgghhBBCCCGEUUiiSQghhBBCCCGEEEIYhSSahBBCCCGEEEIIIYRRSKJJCCGEEEIIIYQQQhiFJJqEEEIIIYQQQgghhFFIokkIIYQQQgghhBBCGIUkmoQQQgghhBBCCCGEUUiiSQghhBBCCCGEEEIYhSSahBBCCCGEEEIIIYRRSKJJCCGEEEIIIYQQQhjF/wPFQeOdhOKtPAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pengram(gdf, col, name, figsize=figsize)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "5f8b42f7-ea46-4743-ba9b-6b0defee9ff4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left');" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "7f674a6e-54c8-4855-9074-397bae208c51", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks');" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "4e84c8ee-b495-47ed-b49d-97ac9ff871d1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks');" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "90dbbadc-f9d6-4290-bc6b-3f6505a2b804", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks',k=3);" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "e3cc88f4-b1a2-44e3-85a2-69d5d7326760", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks',k=3, orientation='b',\n", - " query=['Chiapas', 'Campeche']);" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "6011ccf1-3c44-4892-a6bd-c930371b8750", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " )" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks',k=3,\n", - " query=['Chiapas', 'Campeche'])" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "df237c01-f54a-4b78-beef-40616f74eb9e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,\n", - " )" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJoAAALVCAYAAACIt4sFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hT5fsG8Dtd6U4XXXRQoBSwZZVVKntPERGwiKDIEAERkZ+IfsUFogIqOBBQkFUHe9UWkEKBQikUKJRd6G7p3mma5PcHEgnd8yTN/bmuXpKcN+fc6bJ58r7PK1IqlUoQERERERERERHVkZ7QAYiIiIiIiIiIqGlgoYmIiIiIiIiIiOoFC01ERERERERERFQvWGgiIiIiIiIiIqJ6wUITERERERERERHVCxaaiIiIiIiIiIioXrDQRERERERERERE9YKFJiIiIiIiIiIiqhcsNBERERERERERUb1goYmIiIiIiIioiTpx4gREIhGys7OFjkI6goUmIiIiIiIi0hrTpk2DSCSCSCSCoaEhWrZsiUWLFqGgoKDerrF582b069ev1o9/nE8kEsHCwgJdu3bF7t276y0fkSZjoYmIiIiIiIi0yrBhw5CcnIx79+7hs88+ww8//IBFixYJHUvNr7/+iuTkZERERKBjx4548cUXcfbs2Vqdq6SkpJ7TETUcFpqIiIiIiIhIq4jFYjg6OsLV1RUBAQGYPHky9u7dCwBQKpX48ssv0bJlS5iYmKBjx47466+/VI99vJTs2LFj6Nq1K0xNTdGrVy/cvHmzwuudOHEC3bt3h5mZGaysrODv748HDx5UmtHKygqOjo5o27YtfvrpJxgbG2P//v2Qy+WYPn06PDw8YGJiAi8vL3z77bdqj502bRrGjh2LFStWwNnZGW3atAEAbNu2DV27doWFhQUcHR0REBCAtLQ0tccePnwYbdq0gYmJCfr374/79++XyXbmzBn06dMHJiYmcHV1xfz58+t1RhjpNhaaiIiIiIiISKuZmJhAJpMBAD744AP8+uuv+PHHH3Ht2jW8/fbbePnllxEaGqr2mKVLl2LVqlW4cOECDAwM8Nprr5V77tLSUowdOxZ9+/bFlStXcPbsWcycORMikaja+QwNDWFgYACZTAaFQgEXFxf88ccfuH79Ov73v//h/fffxx9//KH2mGPHjiEmJgYhISE4ePAggEczmz799FNcvnwZe/fuRWxsLKZNm6Z6THx8PMaNG4cRI0YgKioKr7/+Ot577z218169ehVDhw7FuHHjcOXKFfz+++8ICwvD3Llzq/18iCojUiqVSqFDEBEREREREVXHtGnTkJ2drZrBdP78eYwYMQIDBw7EL7/8Ajs7Oxw/fhx+fn6qx7z++usoLCzEjh07cOLECfTv3x9Hjx7FwIEDATyaBTRy5EgUFRXB2NhY7XqZmZmwtbXFiRMn0Ldv32plFIlE2LNnD8aOHQupVIqvvvoKH374IQ4fPozhw4eXGf/mm28iNTVVNfNq2rRpCAoKQlxcHIyMjCq8TkREBLp37468vDyYm5vj/fffx969e3Ht2jVVIey9997DypUrkZWVBSsrK7zyyiswMTHB+vXrVecJCwtD3759UVBQUOb5E9WUgdABiIiIiIiIiGri4MGDMDc3R2lpKWQyGZ577jmsXbsW169fR3FxMQYPHqw2vqSkBJ07d1a7r0OHDqp/Ozk5AQDS0tLg5uamNs7GxgbTpk3D0KFDMXjwYAwaNAgTJkxQPaYiL730EvT19VFUVASJRIKvv/5aVWT66aefsHHjRjx48ABFRUUoKSlBp06d1B7v4+NTpsh06dIlLFu2DFFRUcjMzIRCoQAAxMXFoX379oiJiUHPnj3VZls9WXADgMjISNy5cwfbt29X3adUKqFQKBAbG4t27dpV+ryIqsJCExEREREREWmV/v3748cff4ShoSGcnZ1haGgIAIiNjQUAHDp0CM2bN1d7jFgsVrv9+DEAVIWZx4Wbp/3666+YP38+goKC8Pvvv+ODDz5ASEgIevbsWWHGNWvWYNCgQbC0tIS9vb3q/j/++ANvv/02Vq1aBT8/P1hYWOCrr77CuXPn1B5vZmamdrugoABDhgzBkCFDsG3bNjRr1gxxcXEYOnSoqll4dRYsKRQKzJo1C/Pnzy9z7OkiG1FtsNBEREREREREWsXMzAytW7cuc3/79u0hFosRFxdX7WVu1dW5c2d07twZS5YsgZ+fH3bs2FFpocnR0bHcjKdOnUKvXr0wZ84c1X13796t8vo3btxAeno6vvjiC7i6ugIALly4oDamffv2qiWFj4WHh6vd7tKlC65du1ZuNqL6wGbgRERERERE1CRYWFhg0aJFePvtt7FlyxbcvXsXly5dwvfff48tW7bU6pyxsbFYsmQJzp49iwcPHiA4OBi3bt2q9RKz1q1b48KFC/j7779x69YtfPjhh4iIiKjycW5ubjAyMsLatWtx79497N+/H59++qnamNmzZ+Pu3btYuHAhbt68iR07dmDz5s1qY/7v//4PZ8+exZtvvomoqCjcvn0b+/fvx7x582r1fIiexkITERERERERNRmffvop/ve//2HFihVo164dhg4digMHDsDDw6NW5zM1NcWNGzfwwgsvoE2bNpg5cybmzp2LWbNm1ep8s2fPxrhx4zBx4kT06NEDGRkZarObKtKsWTNs3rwZf/75J9q3b48vvvgCX3/9tdoYNzc37Nq1CwcOHEDHjh3x008/Yfny5WpjOnTogNDQUNy+fRu9e/dG586d8eGHH1bZc4qourjrHBERERERERER1QvOaCIiIiIiIiIionrBQhMREREREREREdULFpqIiIiIiIiIiKhesNBERERERERERET1goUmIiIiIiIiIiKqFyw0ERERERERERFRvTAQOgAREREREVFlFAoFkpKSYGFhAZFIJHQcIqImS6lUIi8vD87OztDTq93cJBaaiIiIiIhIoyUlJcHV1VXoGEREOiM+Ph4uLi61eiwLTUREREREpNEsLCwAPHrhY2lpKXAaIqKmKzc3F66urqrfu7XBQhMREREREWm0x8vlLC0tWWgiImoEdVmmzGbgRERERERERERUL1hoIiIiIiIiIiKiesFCExERERERERER1QsWmoiIiIiIiIiIqF6w0ERERERERERERPWChSYiIiIiIiIiIqoXLDQREREREREREVG9MBA6ABERERERERERNaz4q/2rHCNx31fn63BGExERERERERER1QsWmoiIiIiIiIiIqF6w0ERERERERERERPWChSYiIiIiIiIiIqoXLDQREREREREREVG9YKGJiIiIiIiIiIjqBQtNRERERERERERUL1hoIiIiIiIiIiKiesFCExERERERERER1QsWmoiIiIiIiIiIqF6w0ERERERERERERPWChSYiIiIioiZm2bJlEIlEah+Ojo6q40qlEsuWLYOzszNMTEzQr18/XLt2Te0cUqkU8+bNg52dHczMzDBmzBgkJCSojcnKysKUKVMgkUggkUgwZcoUZGdnq42Ji4vD6NGjYWZmBjs7O8yfPx8lJSUN9tyJiEhYLDQRERERETVBzzzzDJKTk1UfV69eVR378ssvsXr1aqxbtw4RERFwdHTE4MGDkZeXpxqzYMEC7NmzB4GBgQgLC0N+fj5GjRoFuVyuGhMQEICoqCgEBQUhKCgIUVFRmDJliuq4XC7HyJEjUVBQgLCwMAQGBmLXrl145513GueTQEREjc5A6ACkPaSlpcgqLkJWcTGyi4qQLS1GdnExJGIxRnh6CR2PiIiIiJ5gYGCgNovpMaVSiW+++QZLly7FuHHjAABbtmyBg4MDduzYgVmzZiEnJwebNm3C1q1bMWjQIADAtm3b4OrqiqNHj2Lo0KGIiYlBUFAQwsPD0aNHDwDAhg0b4Ofnh5s3b8LLywvBwcG4fv064uPj4ezsDABYtWoVpk2bhs8//xyWlpaN9NkgIqLGwkKTDipVKJBTXIwcaTGyiouQXfTvf4sfFY6e/Hd2cRGy/y0uFZeWljmXuZERdk8IEOBZEBEREVFlbt++DWdnZ4jFYvTo0QPLly9Hy5YtERsbi5SUFAwZMkQ1ViwWo2/fvjhz5gxmzZqFyMhIyGQytTHOzs7w9vbGmTNnMHToUJw9exYSiURVZAKAnj17QiKR4MyZM/Dy8sLZs2fh7e2tKjIBwNChQyGVShEZGYn+/fuXm10qlUIqlapu5+bm1uenhoiIGhALTVpMqVQiv6TkqeJQkep2TnHxo9lH/xaKcv69P/eJ/2nXhZ5IhHXDR6O1jW29nI+IiIiI6kePHj3w22+/oU2bNkhNTcVnn32GXr164dq1a0hJSQEAODg4qD3GwcEBDx48AACkpKTAyMgI1tbWZcY8fnxKSgrs7e3LXNve3l5tzNPXsba2hpGRkWpMeVasWIGPP/64hs+aiIg0AQtNGuLxsrSys4r+KxxlFxU/Wq5W9G/hSFqMUoVCsMwf9O6HPu4tBLs+EREREZVv+PDhqn/7+PjAz88PrVq1wpYtW9CzZ08AgEgkUnuMUqksc9/Tnh5T3vjajHnakiVLsHDhQtXt3NxcuLq6VpqNiIg0AwtNDaRQJkNmUSEyCguRUVSEzKJCZP7734yiImQ8cTuzqAiFMpnQkWukuYUlpnbsLHQMIiIiIqoGMzMz+Pj44Pbt2xg7diyAR7ONnJycVGPS0tJUs48cHR1RUlKCrKwstVlNaWlp6NWrl2pMampqmWs9fPhQ7Tznzp1TO56VlQWZTFZmptOTxGIxxGJx7Z4sEREJioWmalAqlSh4onCUWU6hKKNIvaBUXj+jpsTR3LzKd7yIiIiISDNIpVLExMSgd+/e8PDwgKOjI0JCQtC586M3DktKShAaGoqVK1cCAHx9fWFoaIiQkBBMmDABAJCcnIzo6Gh8+eWXAAA/Pz/k5OTg/Pnz6N69OwDg3LlzyMnJURWj/Pz88PnnnyM5OVlV1AoODoZYLIavr2+jfg6IiKhx6GyhSVpaiuT8vEdFosJC1Uyj/2Ydqc9AKnliG1cC7EzNhI5ARERERBVYtGgRRo8eDTc3N6SlpeGzzz5Dbm4upk6dCpFIhAULFmD58uXw9PSEp6cnli9fDlNTUwQEPNrkRSKRYPr06XjnnXdga2sLGxsbLFq0CD4+Pqpd6Nq1a4dhw4ZhxowZWL9+PQBg5syZGDVqFLy8Hu1IPGTIELRv3x5TpkzBV199hczMTCxatAgzZszgjnNERE2Uzhaa/rkfizmH9wsdQ2vZm7HQRERERKSpEhIS8NJLLyE9PR3NmjVDz549ER4eDnd3dwDA4sWLUVRUhDlz5iArKws9evRAcHAwLCwsVOdYs2YNDAwMMGHCBBQVFWHgwIHYvHkz9PX1VWO2b9+O+fPnq3anGzNmDNatW6c6rq+vj0OHDmHOnDnw9/eHiYkJAgIC8PXXXzfSZ4KIiBqbSKlUKoUOIYSgO7dZaKohDysrNDM1Q4FMhtY2tnjPvw8czM2FjkVERERETVxubi4kEglycnI4E4qIqJbir/avcozEfV+df9/q7IwmsYF+1YNIpYuTMy4mJyE2OxsAcO1hGvbdjIG3vQMGtGiJAR4t4W3vAD32bSIiIiIiIiLSWTpbaOrt1gLt7ZrhevpDoaNohdisrHLvj05LRXRaKr47fxbNTM3Qv4UHBni0hL+rO8yMjBo5JREREREREREJSWcLTQZ6evhswGC88McO6OTawRpwl1jhQU52leMeFhbgj+vR+ON6NIz09NHTxRUDPB7NdnKxlDR8UCIiIiIiIiISlM4WmgCgk6MTJnl3wM7oK0JH0WgOZmbVKjQ9qUQhx8m4+zgZdx/LQo+jja2daoldZ0cn6OvpNUxYIiIiIiIiIhKMTheaAODdXs8i+O5tZBQVCR1FI9kYmyAmPb3O57mVkY5bGen4KfI8rIyN0c/90RK7Pu4tYCk2roekRERERERERCQ0nS80WRmb4L1n++LdkCCho2ik5paWuJqWWq/nzC4uxt6bMdh7Mwb6IhG6Obuolth5WFlDxIbiRERERERERFpJ5wtNADCubXuUyOX48vQp5EiLhY6jMbo6OeNCclKDXkOuVCI8MR7hifFYHhYKd4mVqujUzdkFRvrcHZCIiIiIiIhIW4iUSiV7Yf8rvbAQK0+fxK6Ya0JHEZyZoSEAoEAmEyyDuZER+ri1wACPlujr7gFbU1PBshARERGRcHJzcyGRSJCTkwNLS0uh4xARaaX4q/2rHCNx31fn37csNJXjfGICXt23C0WlpUJHEZSjuTlS8vOFjgEAEAHo7OiE/h6tMMCjJdra2nGJHREREZGOYKGJiKjuGqvQxKVz5eje3AXdm7si9EGs0FEE5S6x0phCkxLAxZRkXExJxqqzYXAyt1AtsfNzcYWxgaHQEYmIiIiIiIh0HgtNFfB3ddP5QlNCbq7QESqUnJ+H7VcvY/vVyzA2MIC/qxsGeLRC/xYecDS3EDoeERERERERkU5ioakCvVzdhI4guMS8XHhYWSM2O0voKJUqLi3Fsdh7OBZ7DwDg3cwe/T1aYoBHK/jYO0CPS+yIiIiIiIiIGgULTRVoa9cMNsYmyCwuEjqKoLRx17foh2mIfpiGtefDYWdqiv4tHi2x83d1h7mRkdDxiIiIiIiIiJosFpoqoCcSoaeLKw7fuSV0FEHlSIuFjlAn6YWF+PN6NP68Hg0jPX30cHF51NupRSu4SiRCxyMiIiIiIiJqUlhoqoS/m7vOF5oyCpvOjK4ShRyn4h7gVNwDfBz6DzxtbB8tsWvREl2cnGGgpyd0RCIiIiIiIiKtxkJTJXq56HafJkuxGLlSqdAxGsztzAzczszAz5ERsDI2xkCPVhjcshV6u7WAiSF3sSMiIiIiIiKqKRaaKuEmkWCMV1tcSEpEUl6e0HEanbWxSZMuND0pu7gYu2KuYVfMNRgbGKC3mzsGt2yNAR4tYWNiKnQ8IiIiIiIiIq3AQlMlRCIRvhk6EgBw+PZNzD1yUOBEjcvcUDcbZxeXliLk3l2E3LsLPZEI3ZybY3DL1hjcsjX7OhERERERERFVgoWmahreug38Xd1wOj5O6CiNZoxXO+jr6+FKaorQUQSjUCpxLjEB5xIT8NmpE2hn1wyDW7bGkFat0c6uGUQikdARiYiIiIiIiDSGSKlUKoUOoS3icrLxbkgQIpIShY7SKHq5uuH9Z/viRvpDrA4/rZPLByvT3MISg1u1xpCWrdHVuTmbiRMRERE1kNzcXEgkEuTk5MDS0lLoOEREWin+av8qx0jc99X59y0LTTWkVCpxPPYevjxzCrczM4SO0yjE+gZYO3wUbmWk46cL55EvKxE6ksZhM3EiIiKihsNCExFR3bHQpOFKFQrsirmGb8LPILUgX+g4Dc7M0BB/jJ8EOzMzfHvuLAKjr0DBb51ysZk4ERERUf1ioYmIqO5YaNISWy5fxMeh/wgdo1E4mplj14QAOFlY4FZGOlaEnUTog1ihY2k0NhMnIiIiqjsWmoiI6o6FJi3xVtAhHLh1Q+gYjcbJ3ALPurnjJe8O6OTohFMP7mN5WChuZqQLHU0rsJk4NRSFUonk/Ed91B5/V4n+/dfjb7OKbuPp448fX8Xj/vv2ffr7+NH/Vp78v4sS/914fH/595X/mMf/NNDTg7WJCYiISLew0EREVHeNVWjirnN1dCklSegIjSo5Pw9/Xo9GcWkpvh02Er3dW+Cgqxt237iOK6kpyJVKkSuVIqOwANEP04SOq3Fi0h8iJv0hvjt/ls3EqV7lSaXo/esGoWM0Cu9m9hjh6YURnm3gJrESOg4RERERET2Br2xrKL2wEO8EH8GH/xzF6rOnkZCbK3QkQZx8cB9yhQIAoK+nhxfbe+PT/oPw7bCR+PW5cdj/0hRsGvM8XC25VKwiiXm52Bx1EQG7/0D3jT/i3ZAgBN+9jSKZTOhopIVk//486oLoh2n48swp9NuyCc8FbsP6yPP8uSEiqsKKFSsgEomwYMEC1X1KpRLLli2Ds7MzTExM0K9fP1y7dk3tcVKpFPPmzYOdnR3MzMwwZswYJCQkqI3JysrClClTIJFIIJFIMGXKFGRnZ6uNiYuLw+jRo2FmZgY7OzvMnz8fJSXcYIaIqClioamG7ExNMfEZH+yOuYZ1EeFCxxFMjrQYl1KSKx3Tv0VLBE2eije6dudsnSpkFxdjV8w1zD60H74bfsCsg3vx1/VoZBYVCh2NtIRchwpNT7qaloqVp09hdfhpoaMQEWmsiIgI/Pzzz+jQoYPa/V9++SVWr16NdevWISIiAo6Ojhg8eDDy8vJUYxYsWIA9e/YgMDAQYWFhyM/Px6hRoyCXy1VjAgICEBUVhaCgIAQFBSEqKgpTpkxRHZfL5Rg5ciQKCgoQFhaGwMBA7Nq1C++8807DP3kiImp07NFUS6fjH2D6/j0oeeJ/srpmTtceWNTr2WqNvZWRjg//OYqIpMQGTtW0sJk4VVdiXq7OLJ0rjwjA7+Mnoatzc6GjEBFplPz8fHTp0gU//PADPvvsM3Tq1AnffPMNlEolnJ2dsWDBAvzf//0fgEezlxwcHLBy5UrMmjULOTk5aNasGbZu3YqJEycCAJKSkuDq6orDhw9j6NChiImJQfv27REeHo4ePXoAAMLDw+Hn54cbN27Ay8sLR44cwahRoxAfHw9nZ2cAQGBgIKZNm4a0tLRq9QBhjyYiorprrB5NnGZSS/6u7pjTtYfQMQRVkx3n2tjaIfCFiVg5aCisjY1rfU13HevHolAqcS4xAZ+dOoG+WzZi5I7f8E34GVx/mAbWiOlJujqj6TElgMVH/0ZxKZfQERE96c0338TIkSMxaNAgtftjY2ORkpKCIUOGqO4Ti8Xo27cvzpw5AwCIjIyETCZTG+Ps7Axvb2/VmLNnz0IikaiKTADQs2dPSCQStTHe3t6qIhMADB06FFKpFJGRkeXmlkqlyM3NVfsgIiLtwEJTHej6crB+LTxqNF4kEuHF9t4ImfIqxrd/psbXM9TTw9zuPWv8uKbkcSPxUTu3os/mjfjk5D8IT4hHqY4XGQj8HgBwPzsLq85yCR0R0WOBgYG4ePEiVqxYUeZYSkoKAMDBwUHtfgcHB9WxlJQUGBkZwdrautIx9vb2Zc5vb2+vNubp61hbW8PIyEg15mkrVqxQ9XySSCRwdXWtzlMmIiINwF3n6qBQh5vPulpK8Ga32s3osjExxZeDhmF8O298cDwEd7Iyq/W4Dg6OGNbKE+4SK7haSnA5NRkbLl5AZLJu7fz32ONm4pujLsLK2BgDPVphcMtW6O3WAiaGhkLHo0bGQtMjv1yKxLDWnvB14hI6ItJt8fHxeOuttxAcHAzjSmaTi0QitdtKpbLMfU97ekx542sz5klLlizBwoULVbdzc3NZbCIi0hK6PSWnDgKjr2DjxQtCxxDMR30HwNigbsWM7s1dcDDgFSzyexZi/aprnmkFBQi5dwddnZvDwdwcQ1p54s8XX8JfL76Eoa08UfmfRE0bm4mTri+de0wJYHEIl9AREUVGRiItLQ2+vr4wMDCAgYEBQkND8d1338HAwEA1w+jpGUVpaWmqY46OjigpKUFWVlalY1JTU8tc/+HDh2pjnr5OVlYWZDJZmZlOj4nFYlhaWqp9EBGRdmChqZYsxWLIlbr5wm5Iy9YY4NGyXs5lpK+POd164O+Xp6Kve4tKx4r19ctdrtfFyRk/jhyDY6+8hpd9OsLYQLcn6hWXliLk3l0sPvo3um/8CS/t+h2/XIpEfE6O0NGoAclYaFKJzc7Cai6hIyIdN3DgQFy9ehVRUVGqj65du2Ly5MmIiopCy5Yt4ejoiJCQENVjSkpKEBoail69egEAfH19YWhoqDYmOTkZ0dHRqjF+fn7IycnB+fPnVWPOnTuHnJwctTHR0dFITv5vx+Lg4GCIxWL4+vo26OeBiIgaH3edq4MDt27g7b8PQ6Fjn8IvBg7BhGd86v28SqUSR+7cwh/XovGwsAAPCwuQUVgIM0MjTPT2wcwu3dDMzKzK82QWFWL71cvYEnUJmcVF9Z5Tm7Wza4bBLVtjSKvWaGfXrMqp8aQ9LiUn4YU/dwodQ2OIAPzx4iQuoSMirVNQUIAdO3bgzJkzSElJgUgkgoODA/z9/fHSSy/BrBp/C1WkX79+ql3nAGDlypVYsWIFfv31V3h6emL58uU4ceIEbt68CQsLCwDAG2+8gYMHD2Lz5s2wsbHBokWLkJGRgcjISOjr6wMAhg8fjqSkJKxfvx4AMHPmTLi7u+PAgQMAALlcjk6dOsHBwQFfffUVMjMzMW3aNIwdOxZr166tVnbuOkdEVHeNteucbk/9qKPRbdpCoVTi3ZAgneqPYmti2iDnFYlEGOHphRGeXqr7ShUKyBUKiGswS8nGxBTzuvtBIjbGstDjDRFVa8WkP1Q1FG9uYYnBrVpjsEcrdGvuovPN7bVdqY7OsKyIEsC7IX/ju2Ej4W1f/rIMIiJNc/36dQwePBiFhYXo27cv3NzcoFQqkZaWhnfffRfLli1DcHAw2rdvXy/XW7x4MYqKijBnzhxkZWWhR48eCA4OVhWZAGDNmjUwMDDAhAkTUFRUhIEDB2Lz5s2qIhMAbN++HfPnz1ftTjdmzBisW7dOdVxfXx+HDh3CnDlz4O/vDxMTEwQEBODrr7+ul+dBRKTLqlM8cvX5pxGS/IczmupBcl4eNl++iJ1XryBfViJ0nAa368WX0NnJueqBAjufmIBJu34XOoZWsDI2xoAWLTG4VWv0dmsBUzYT1zpn4+Mwec+fQsfQSN7N7DHhGR+M8WoHS7FY6DhERBXq378/HB0dsWXLFhgZGakdKykpwbRp05CcnIx//mncFwyagDOaiIjKV5NCE2c0aREnCwssebYv3uzWE6vOhmHrlSihIzUoaxMToSNUS1u7ZkJH0BrZxcXYfeM6dt+4DrG+Afq4u2NYqzYY4NESkkp2qiHNwRlNFYt+mIboE8ewIiwUIzy9MPEZH/g6OXPpKBFpnHPnzuHChQtlikwAYGRkhPfffx/du3cXIBkREVH1sdBUjyzFYvyvT3/czshAeGK80HEajE0DLZ2rb5ZiMVwtJYjPZRPsmpDKHzUTD7l3FwZ6eujl4oahrT0xuGVr2Jlqx9deF8kVnJxalaLSUuyKuYZdMdfQ2toGb/XohZFtvKp+IBFRI7G2tsbt27crXBp3584dWFtbN3IqIiKimmFTlnqmr6eHb4aNaLA+RkIz1NODRTnvsmkipVIJTxtboWNotVKFAifj7mPp8RD03PQTJv31OzZHXURSXq7Q0egpch3qE1cf7mRlYl7QQeyMviJ0FCIilRkzZmDq1Kn4+uuvcfnyZaSkpCA1NRWXL1/G119/jddeew2zZs0SOiYREVGlOKOpAdibmWP10OGYtncXmtocAxsTU61ZblJcWooJz3jDwdwcoQ9ikZSXJ3QkraZQKnE+KQHnkxLwycl/0NHBEX3cW8BI3wD49ztdqQSUUKr9F3j07/KOq9337w0lHhUJlVUe+/e///4b//5Xobr/ieuXecwTGZ7I9ORjUc5zUT+v+jHFU/dXRAklLMRi5EmlVX7Oa9JBL4s7LNbK0uMhkMnleKVjZ6GjEBFh2bJlMDExwerVq7F48WLV31xKpRKOjo547733sHjxYoFTEhERVY7NwBvQqrNh+D7inNAx6lVbu2Y4HPCK0DFqTKlU4m5WJk7cj8XJB/dxPjEBJQq50LFIB7W1tcONjHShY9BTlvbuh+mdfYWOQUSkEhsbi5SUFACAo6MjPDw8BE4kLDYDJyIqH5uB65i3evTC+cQERCQlCh2l3thoSSPwp4lEIrS2sUVrG1u83qUrCmUyhCfEI/RBLELvxyLu3z5OfdxaYIRnGywLPY7i0lKBU1NTZMwd/TTS56dOoEReije69hA6ChERAMDDw0Pni0tERKSdWGhqQAZ6evh22EiM2rEVmU1kWYu2FpqeZmpoiAEeLTHAoyUAIDY7CycfxOJqairszcyxc9wEvH5gLzKKCgVOSk1JM1MzXElJFjoGVeCrM2GQyRWY38NP6ChEpMMSEhLw448/4syZM0hJSYFIJIKDgwN69eqF2bNnw9XVVeiIRETUULp2Bf6dzVpdDpIcpAZ2baBAtcNCUwNzNLfAV0OGYfr+PUJHqRc2xk2j0PQ0DytreFip7+Kye0IA3jy8H6919kV+SQn+d+KYQOmoqWhpbY2HhQVCx6BKfHPuDEoVCrzds5fW9KMjoqYjLCwMw4cPh6urK4YMGYIhQ4ZAqVQiLS0Ne/fuxdq1a3HkyBH4+/sLHZWIiBpCSgqQWLMVUXoyzdusi4WmRtDP3QPNLSyR2AR26rJporvplcdVIsG2cS/iYUEBWtnYoqhUhhVhJ4WORVqsSPZoOaaDmTnsTExxLT1N4ERUnnUR4SiRl+L//Puw2EREjertt9/G66+/jjVr1lR4fMGCBYiIiGjkZERE1JiUeoDcrvICkkF6KaChO0+z0NQIRCIR+ri3aBLbaEuMxUJHaFSWYmNYio0BADO6dMNPF84jq7hY4FSkra6kpaCrc3NkFBbCTKx57zzQf36+eAH3c7LxTs9n4WlrK3QcItIR0dHR2LZtW4XHZ82ahZ9++qkRExERkRDkdkZIPtqr0jGuw2/XePZTY9ETOoCu6OfeNJo57rx6BVIdbZKdKy1mkYnq7EJSImKzs8ANPzVf8N07GLZ9Mxb8fQj3sjKFjkNEOsDJyQlnzpyp8PjZs2fh5OTUiImIiIhqjjOaGomfqxsM9fQg09CpbdV1KzMDa8+HY1GvZ4WO0uhis7OFjkBNSIlcLnQEqgYlgP03b+DgrZsY69UOc7v3RIun+rkREdWXRYsWYfbs2YiMjMTgwYPh4OAAkUiElJQUhISEYOPGjfjmm2+EjklERFQpFpoaiYmBAQz19bW+0AQA6yPPY0ir1ujg4Ch0lEYhVyigr6eH2KwsoaNQE1IgKxE6AtWAQqnE7hvXse9mDH4bOx5+rm5CRyKiJmjOnDmwtbXFmjVrsH79esj/fVNCX18fvr6++O233zBhwgSBUxIREVWOhaZGciszA4UymdAx6oVcqcQ/9+/pTKHpcmoKXCUSxGZz6QzVn+wiLsPURnKlEsvDQrFv0svQY6NwImoAEydOxMSJEyGTyZCeng4AsLOzg6GhocDJiIiIqoc9mhrJ5ZRkoSPUq7Z2zYSO0Gja2TXD0mMhuJvJQhPVn4yiQv4C1lLXHqZh340YoWMQURNnaGgIJycnODk5schERERaha9zGklUEys0nUuIR0GJbiz9MTE0hNhAH0F3bwsdhZoQJQBbUzOhY1AtfX7qBI7F3hU6BhE1QREREZg8eTI8PDxgYmICU1NTeHh4YPLkybhw4YLQ8YiIiKrEQlMjmdfDD6uHDMfoNm2FjlIvNl++hIFbf8GumGtQ6MDuWcNbe+nE86TGZWNiLHQEqqXM4iLMOLAXC/8+jOziIqHjEFETsXfvXvj7+yMzMxNvvfUWfvnlF2zcuBFvvfUWsrKy4O/vj3379gkdk4iIqFLs0dRImltYonnb9njOqx0USgUO3b4ldKQ6SysowLshQfjt8iV8MXAI2jWzFzpSg5Ertb+JO2keU0MjoSNQHe29GYOw+Af4pN8gDGvtKXQcItJyH3zwAT755BO89957ZY4tWLAAK1euxPvvv4/nnntOgHRERFRXnT5bVunxqEZJ0fA4o6mRiUQirBg4FK2sbYSOUm+upqXi8B3tL5xV5lTcfaEjUBNkqKcvdASqB+mFhZhzeD/eDQkSOgoRabk7d+5g3LhxFR4fO3Ys7t7lsl0iItJsLDQJwNzICLsmBGBqx85oKnsWFclKhY7QYJRKJU7HPRA6BhFpuF0x13ArI13oGESkxVq1aoW9e/dWeHzfvn1o2bJl4wUiIiKqBS6dE4ilWIyP+g7A823b44PjIYh+mCZ0pDopKpUJHaHB3M3KRHJ+vtAxqAkqkTfdAq2uWnIsGP/n3wfdnJtDJBJBqVRCJGoqbykQUUP75JNPMGnSJISGhmLIkCFwcHCASCRCSkoKQkJCEBwcjMDAQKFjEhERVYqFJoF1cHDEnomTse1qFFadOY18mXbu5FYoa7qFpovJSUJHoCaqoAn/3OiqSynJmLTrd/g6OcPcSAx/VzdM6dAJdzIz8Iy9g9DxiEjDvfDCCzh58iS+/fZbrF69GikpKQAAR0dH+Pn5ITQ0FH5+fgKnJCIiqhwLTRpAX08PUzt2gYulBDMO7BU6Tq005RlNHRwchY5ATVR2cbHQEaiBRP5boD75IBbfnjuDApkMr3bqgiXP9oWBHletE1HF/Pz8WEwiIiKtxr92NYi1sYnQEWqtqAnPzPCytYOrpUToGNQEZRQVNpk+bVQ+Jf6bufZr1EVM3bsLWUVFwoYiIiIiImpALDRpEDMj7d3qvKi06faaEYlEGNSyldAxqAlSKJWwMzEVOgY1orMJcXju922ISX8odBQi0lCXL1/GZ599hh9++AHp6eobDOTm5uK1114TKBkREVH1sNCkQcwNtbjQ1IRnNAHA6DZthY5ATZS1ifbOZKTaScjNxfg/duDQrZtQKpVCxyEiDRIcHIzu3bsjMDAQK1euRLt27fDPP/+ojhcVFWHLli3VOtePP/6IDh06wNLSEpaWlvDz88ORI0dUx5VKJZYtWwZnZ2eYmJigX79+uHbtmto5pFIp5s2bBzs7O5iZmWHMmDFISEhQG5OVlYUpU6ZAIpFAIpFgypQpyM7OVhsTFxeH0aNHw8zMDHZ2dpg/fz5KSrSzLykREVWNhSYNYmZkKHSEWmvKzcABoJOjE+Z26yl0DGqCTLV4JiPVXlFpKeYFHYTX99+gy8/f43ZGhtCRiEgDLFu2DIsWLUJ0dDTu37+PxYsXY8yYMQgKCqrxuVxcXPDFF1/gwoULuHDhAgYMGIDnnntOVUz68ssvsXr1aqxbtw4RERFwdHTE4MGDkZeXpzrHggULsGfPHgQGBiIsLAz5+fkYNWoU5HK5akxAQACioqIQFBSEoKAgREVFYcqUKarjcrkcI0eOREFBAcLCwhAYGIhdu3bhnXfeqcNnioiINBmbgWsQUy2e0ZRakI+CkhKtXv5Xlbd6+OFKagpOxt0XOgo1IYZ6+kJHIAGVKhTILi7Gwds38Latv9BxiEhg165dw9atWwE8Wrr/7rvvwsXFBePHj8fOnTvRvXv3ap9r9OjRarc///xz/PjjjwgPD0f79u3xzTffYOnSpRg3bhwAYMuWLXBwcMCOHTswa9Ys5OTkYNOmTdi6dSsGDRoEANi2bRtcXV1x9OhRDB06FDExMQgKCkJ4eDh69OgBANiwYQP8/Pxw8+ZNeHl5ITg4GNevX0d8fDycnZ0BAKtWrcK0adPw+eefw9LSss6fNyIiIXX6bFmlx6M+qPx4U8QZTRrESF8fRlr6orNQJsPemzFCx2hQ+np6WDN0BFz4BxHVozuZ6XBns3mdt/Z8ON4NCWrys0OJqHJisbjMsrOXXnoJmzZtwqRJk7Bnz55anVculyMwMBAFBQXw8/NDbGwsUlJSMGTIELVr9+3bF2fOnAEAREZGQiaTqY1xdnaGt7e3aszZs2chkUhURSYA6NmzJyQSidoYb29vVZEJAIYOHQqpVIrIyMhaPR8iItJsLDRpGG1ePrf18qUm32/E2sQEP4wYA7E+JwNS/cgqLkZOiRRuLDbpvF0x1zAmcCtiHqYJHYWIBNKpUye1nkyPTZw4ERs3bsT8+fNrdL6rV6/C3NwcYrEYs2fPxp49e9C+fXukpKQAABwcHNTGOzg4qI6lpKTAyMgI1tbWlY6xt7cvc117e3u1MU9fx9raGkZGRqox5ZFKpcjNzVX7ICIi7cBXyxrGzMgIWcXFQseolVuZGTibEI9erm5CR2lQ3vYO+LT/QCw++rfQUaiJyC4uRmsbW8Tl5ggdhQR2LysLsw7tw8lpM4SOQkQCeOONN3Dy5Mlyj7300ksAgJ9//rna5/Py8kJUVBSys7Oxa9cuTJ06FaGhoarjIpFIbbxSqSxz39OeHlPe+NqMedqKFSvw8ccfV5qFiKihVLUcDtDNJXHVxRlNGsZMi/s0AcBvly8JHaFRjG/vjQCfjkLHoCYkq6hI6AikIRJyc5FeWCh0DCISwPPPP481a9ZUePyll14qd8ZTRYyMjNC6dWt07doVK1asQMeOHfHtt9/C0dERAMrMKEpLS1PNPnJ0dERJSQmysrIqHZOamlrmug8fPlQb8/R1srKyIJPJysx0etKSJUuQk5Oj+oiPj6/28yYiImGx0KRhzP9tpm1soJ2TzY7G3kWijkxt/rB3P3RycBI6BjURD3KyYSjir2R65EpqxctJiKhp+/PPPzF58mRMmDChRrOXqkOpVEIqlcLDwwOOjo4ICQlRHSspKUFoaCh69eoFAPD19YWhoaHamOTkZERHR6vG+Pn5IScnB+fPn1eNOXfuHHJyctTGREdHIzk5WTUmODgYYrEYvr6+FWYVi8WwtLRU+yAiIu3AVzUaxtTwUY+mHs1d0NHBUeA0NadQKpFWkC90jEYhNjDA9yNGw9bEVOgo1ASUKhRwt7YSOgZpiMupyVUPIqIm5+eff8bEiRNx4cIF3Lx5E2+88QaWLFlSq3O9//77OHXqFO7fv4+rV69i6dKlOHHiBCZPngyRSIQFCxZg+fLl2LNnD6KjozFt2jSYmpoiICAAACCRSDB9+nS88847OHbsGC5duoSXX34ZPj4+ql3o2rVrh2HDhmHGjBkIDw9HeHg4ZsyYgVGjRsHLywsAMGTIELRv3x5TpkzBpUuXcOzYMSxatAgzZsxg8YiIqIlioUnDuEqsMMrTC34ubvh8wGCh49RKcx36o8HJwgJrh4+CXhX9DIiqw9rYROgIpCE4o4lIN61duxZLly7FzZs3cfnyZWzatAnr1q2r1blSU1MxZcoUeHl5YeDAgTh37hyCgoIwePCjvy8XL16MBQsWYM6cOejatSsSExMRHBwMCwsL1TnWrFmDsWPHYsKECfD394epqSkOHDgAff3/dknevn07fHx8MGTIEAwZMgQdOnTA1q1bVcf19fVx6NAhGBsbw9/fHxMmTMDYsWPx9ddf1/KzREREmk4712c1YW/18MPpuDgMbtkK4//cKXScGjPS14edqZnQMRpVTxdX9GjuirMJcUJHIS2naOK7NlL1XU5NqVZTXiJqWu7du4dXX31VdXvKlCmYOXMmUlJSVH2VqmvTpk2VHheJRFi2bBmWLVtW4RhjY2OsXbsWa9eurXCMjY0Ntm3bVum13NzccPDgwUrHEBE1NDb4bjyc0aRhmpmawdfJGUb6+vhh5Bj8OmYclvUdAC9bO6GjVYuzhaVOzu4Z1tpT6AjUBLABND2WXVyMd4KPIDI5UegoRNSIioqKYG5urrqtr68PsViMQv7/gYiItAhnNGkgV4kEAOBhZQ0PK2sAwACPlngucBuyiouFjFal5k9Mt9YlQ1u1xrITx8D5KFQX8bk5MNbXR7FcLnQU0gB7b8bAxsQUvk7NhY5CRI1o48aNasWm0tJSbN68GXZ2/73pOH/+fCGiERERVQsLTVrCxVKCxf59sORYsNBRKtXcQnf6Mz1JqQSLTFRnCqUS7lbWuJmRLnQU0hDbrkaht5s7+rbwEDoKETUCNzc3bNiwQe0+R0dHtZ5HIpGIhSYion9xOZxmYqFJi3RxdBY6QpV0qRH4k07F3Rc6AjURErGx0BFIg5TI5Zh1aB9+HjUWfdxbCB2HiBrY/fv3hY5ARERUZ+zRpEVaWlvD2ECza4MuFhKhIwiit1sL/PXiS/BuZi90FNJyMgWXzZG6ErkcMw/uxakH94WOQkRERERUJRaatIi+nh7a2TUTOkaldHVGk4O5Obo4OeOX516Au8RK6DikxdIKCoSOQBroUbFpH66kpggdhYgamEKhwC+//IJRo0bB29sbPj4+GDNmDH777TcouTspERFpARaatMwzGj5jRld7ND1mZ2qK38aOh5G+vtBRSEsl5uXC3NBI6BikgaTyUvx5PVroGETUgJRKJcaMGYPXX38diYmJ8PHxwTPPPIMHDx5g2rRpeP7554WOSEREVCUWmrSMpheaTsc/EDqC4FwlElgbmwgdg7SYm5WV0BFIQx29dxcKzmggarI2b96MkydP4tixY7h06RJ27tyJwMBAXL58GUePHsXx48fx22+/CR2TiIioUprd8IfKeMbeQegIlfrqTBiGt24DC7FY6CiCMjE0FDoCaTFzfv9QBVIL8nEz/SHaafibDkRUOzt37sT777+P/v37lzk2YMAAvPfee9i+fTteeeUVAdIREdVeTXaH405y2o8zmrSMp40tDPQ098uWUVSIdRHhQscQnKmGN20nzSaVsyE4VczR3ELoCETUQK5cuYJhw4ZVeHz48OG4fPlyIyYiIiKqOc2tWFC5jPT1Idbw/j+boy7iXlam0DEEZWrEHjtUe8n5eUJHIA3laWMLaxMuzSVqqjIzM+HgUPHsdQcHB2RlZTViIiIioppjoUnLJOfnoUAmEzpGpWQKBZafChU6hqBMDbj0iWovraAA1sbGQscgDdTVubnQEYioAcnlchhUMitaX18fpaWljZiIiIio5ri+R8vczsgQOkK1HL9/D6H3Y9G3hYfQUQRhyh47VEculhJkFRcLHYM0jFyhEDoCETUgpVKJadOmQVxBr0upVNrIiYiIiGqOhSYtcztTOwpNAPDZqRPo1txFJ4suuvicqX6ZsM8XlSM2m0tmiJqyqVOnVjmGjcCJiEjT8ZWMlrmjRYWmu1mZGLptMz7uNxADPFoKHadRsdBEdcUN7Kk8LDQRNW2//vqr0BGIiIjqjIUmLdPZ0QnXH6Yh+mGa0FGqJTEvF68f2INhrTzxv779dWa3JBaaqK70RCKhI5AGSi8sRK5UCssKltUQERERNaZOny2r9HjUB5Ufp6aJzcC1zETvDtj/0hSEvToDbpYSoeNUW9Dd2xiydTP23YwROkqjaGltAxtj7gxFtVfKXjxUAc5qImq6kpOTsXTpUtXtZ599Fl26dFF9dOvWDYmJiQImJCIiqhpnNGkpZwtLvNurN+YFHRQ6SrXly0qw5uxpjGnTFqImPltjwjM+eLG9NxJyc/HZqX8Qcu+u0JFIy5TI5UJHIA315emT2DTmeRhzd8taUyqVTf7/Q6SdfvjhB2RnZ6tuX758Ga+99hpsbGwAAEeOHMGaNWvw9ddfC5SQiHQBZylRXXFGkxYb4dkGrlo0qwkA4nJzcCczU+gYjUIkEsFVIsGCnv5CRyEtVCiTCR2BNNTZhHjMOXyAxchaSs3Px4S/AjF595/YFXMN+SUlQkciUjlw4ADGjh2rdt9bb72Fjz76CB999BE+/vhjHDlyRJhwRERE1cRCkxYTiUSwMDISOkaNHYvVrdk97eyaoa97C6FjkJbJLS4WOgJpsBP3Y/H234e5xLIWZh7ci8jkJJxNiMO7IUHosfFHLPz7ME7F3Yecn08S2P3799GqVSvV7cGDB8PMzEx128vLC7GxsUJEIyIiqjYWmrScNk79D7l3Bwqlbu2pNaNLN6EjkJbJLC4SOgJpuCN3bmFFWKjQMbRKfkkJrj21mUZRaSn23ozB1L278OyvG/DF6ZO4lZEOACguleHArRuYtncXVp4+iUKZDLlSKf65fw8rT5/E8dh7VV7zdob27BZLwistLUVOTo7q9u7du+Hg4KC6nZWVBT09/vlORESajT2atJyBFv6xcSklGaN2bsW7vZ6Fn4srfo68AAdzc4z1agexQdP8lvRzcYW3vQOi01KFjkJaQCI2Ro6UM5qoan9dv4bFvXo32d+dtXEvKxOmhoYwNjDAl6dPQU9PDx5W1vCwskZ2cVGlb3SkFuTj58gI/BwZAS9bOyTl5SGvRAoAOBl3HzujryC/pER1jr/v3sHem9eRXVSMLk7O8HNxRSdHJ9XX425mBl7dvwvbnn8Ru2KuoUhWiqW9+yKruAg2JqYN/8kgrePl5YUzZ86gc+fO5R4/deoU2rRp08ipiIiIaoZ/mWq59aOewxdhJ7FXy3Zzu5H+ENP374G5kZGqP8a34WewbdyLaGltI3C6+icSiTCrSzetat5OwrEyZqGJqievRIrT8XEY4NFS6CiCisvJhp2pGY7F3sX7x4LR3FKCPKkUyfl5tT7nzX9nNT0pVypVu30/Owv3/90FMCz+Ab47fxZifQN42dkhvbAAyXl5UAIY8Nsvqsf8fu0KFvv3wZQOnWqdjZquSZMm4X//+x969+6NDh06qB27fPkyPv74Y7z33nsCpSMiIqoeFpq0nL2ZOVYPHYFJ3h2wLPQ4bqQ/FDpSjTzZhDWlIB+v7P0Lf45/CU4WFgKmahhDW3uihZW16kUJUUXMtLD3GgnnyJ1bOl1oKigpwUu7fkdGYRFKFI8apN8qp0jUWKTyUlxJTanweIFMhtD7sSw0UbkWLFiAgwcPwtfXF4MHD4aXlxdEIhFu3LiBkJAQ+Pn5YcGCBULHJCIiqhQLTU1E9+Yu2D/pZXwRdhK/REUKHafWkvLyMHXvX/h9/CRYm5gIHadeGejpYcOo5zBp1+/IKGL/HaqYMZdBUQ2E3LuDErkcRvr6QkcRxLqIcCTn5wsdo0aO37+H84kJ6N7cRegopGEMDQ0REhKC1atXIzAwECdOnAAAeHp64tNPP8Xbb78NQ0NDYUMSkVbq9NmyKsdEfVD1GKLq4KuZJsRATw//598b5xPjEf1Us1NtcicrE6/t341tz7/Y5GZ2tLKxxebnXkDA7j9VfT+InqaNvddIOLlSKWYd3Itvh42EpdhY6DiN6l5WJn65pJ1vriwPC8XS3n1hbWyCltY20NPCzT2oYRgZGeG9997jEjkiqhKLR6Sp+GqmiTHU18eqISPg5+KGLo5OEOtrZy3xcmoK3ji0H9LSUqGj1Ltn7B3wy3PPw4SzVqgiOrYrI9Vd6IP7eP73HbiXlSl0lEajVCqx7MRxyBQKoaPUypXUFEz863cM2bYZxaWlKHhiKTnprqysLKxduxa5ublljuXk5FR4rDwrVqxAt27dYGFhAXt7e4wdOxY3b95UG6NUKrFs2TI4OzvDxMQE/fr1w7Vr19TGSKVSzJs3D3Z2djAzM8OYMWOQkJBQJveUKVMgkUggkUgwZcoUZGdnq42Ji4vD6NGjYWZmBjs7O8yfPx8l/L4nImqSWGhqgjxtbbF93Iv4a0IAQqZMw4jW2rk7SVj8A7wTfASlWvoiojK+Ts3x06jnYKSnm0tdqHKlChaaqOZis7Mw9vftOHE/VugojeLIndsIi38gdIx6EZeTjXdCjggdgzTAunXrcPLkSVhaWpY5JpFIcOrUKaxdu7Za5woNDcWbb76J8PBwhISEoLS0FEOGDEFBQYFqzJdffonVq1dj3bp1iIiIgKOjIwYPHoy8vP8a6S9YsAB79uxBYGAgwsLCkJ+fj1GjRkEul6vGBAQEICoqCkFBQQgKCkJUVBSmTJmiOi6XyzFy5EgUFBQgLCwMgYGB2LVrF955553afJqIiEjDsdDUxLlYSrBuxGjsHDcB7eyaCR2nxg7fuYWXdv2OxGq+e1eevTdikFlUWI+p6kdvtxb4dvhI6HO5BD2lWN70ZvJR48gvKcH0/bvxc2QElE14ZlyhTIbPT/0jdIx6IQIw8a/fUVgiEzoKaYBdu3Zh9uzZFR6fNWsW/vrrr2qdKygoCNOmTcMzzzyDjh074tdff0VcXBwiIx8tN1Uqlfjmm2+wdOlSjBs3Dt7e3tiyZQsKCwuxY8cOAI9mUW3atAmrVq3CoEGD0LlzZ2zbtg1Xr17F0aNHAQAxMTEICgrCxo0b4efnBz8/P2zYsAEHDx5UzaAKDg7G9evXsW3bNnTu3BmDBg3CqlWrsGHDhmrP0CIiIu3BQpOO6OHiiv2TXsZn/QfB2li7enhEJidhxI7fcPj2zaoHl+NKajL6b/kF6yPPa9xSvKGtPPHloGFCxyANUyBl/y6qPSWAL06fxBuH9yMyObFJFpzWnde+BuAVUQLIK5FCYiwWOgppgLt378LT07PC456enrh7926tzp2TkwMAsLGxAQDExsYiJSUFQ4YMUY0Ri8Xo27cvzpw5AwCIjIyETCZTG+Ps7Axvb2/VmLNnz0IikaBHjx6qMT179oREIlEb4+3tDWdnZ9WYoUOHQiqVqgpfT5NKpcjNzVX7ICIi7cBCkw7R19NDgE9HHH9lOl7t1EWrGg7nlUgx98hBvH8sGEWymr3r266ZPfJKpFh5+hQGbv0Fe29ch0KDXng93649Pu43UOgYpEGypcVCR6AmIPjuHbz4ZyCGbtuMDRcj8LCwoOoHaQGlUomtVy4JHaPeXUxOxprw04hISoDsiSVJpFv09fWRlJRU4fGkpCTo1eLvN6VSiYULF+LZZ5+Ft7c3ACAlJQUA4ODgoDbWwcFBdSwlJQVGRkawtraudIy9vX2Za9rb26uNefo61tbWMDIyUo152ooVK1Q9nyQSCVxdXWv6tImISCDaU2mgeiMxNsaHffrjcMAraGNrJ3ScGgm8dhXPBW5DTPrDaj8mITdH9e+kvDwsDD6CsYHbEJmc2BARa+Vln46wMzUVOgZpAAM9PeRwRhPVoztZmVgRdhL+v/yM2Qf3ISIpoeoHabDUgnwU1PANB22QnJ+HtefDMfGv3+H78w+YdXAvtl6Jwv3srCY5K43K17lzZ+zdu7fC43v27EHnzp1rfN65c+fiypUr2LlzZ5ljoqeW8CuVyjL3Pe3pMeWNr82YJy1ZsgQ5OTmqj/j4+EozERGR5mChSYe1trHFDyNGw9TQUOgoNXInKxPP/74dv12+VOUf33KFAn9djy5zf/TDNMw9fFBjltLdzsxAeqHm9ZGixmdtbCJ0BGqiShUKBN+7g7mHD6K4VHsLNfef2smqKcqXlSDk3l18dOIYBvz2Cz492TT6UVHV5s6di1WrVmHdunVqzbblcjnWrl2LNWvW4M0336zROefNm4f9+/fjn3/+gYuLi+p+R0dHACgzoygtLU01+8jR0RElJSXIysqqdExqamqZ6z58+FBtzNPXycrKgkwmKzPT6TGxWAxLS0u1DyIi0g4sNOm4ltY2+HLQUHja2EKbWlKXyOVYFnocsw/tQ1ZRUYXjcqVS5FYwOyS1IB87o680VMQaORXXNHZOorqzFLNPCzWsh4UF+ONa2QK8tojNzqp6UBPz25Uo3KjBTF7SXi+88AIWL16M+fPnw8bGBp07d0aXLl1gY2ODBQsWYOHChRg/fny1zqVUKjF37lzs3r0bx48fh4eHh9pxDw8PODo6IiQkRHVfSUkJQkND0atXLwCAr68vDA0N1cYkJycjOjpaNcbPzw85OTk4f/68asy5c+eQk5OjNiY6OhrJycmqMcHBwRCLxfD19a3hZ4mIiDSdgdABSHgjPL0wwtMLeVIpotNScTk15dFHSjJSCjS72WrIvbuITvsNq4eMQA+Xsmv3rU1MsNi/Dz46cazcx2+5fAnTOnVp6JhVOvXgvtARSECtbWxgJX40k0kkAu7q3utoamTrI89jcMvWcLKwEDpKjRSUlGB3zDWhYzQ6hVKJT0/+g23Pv1jlkibSfp9//jnGjh2L7du34/bt21AqlejTpw8CAgLQvXv3ap/nzTffxI4dO7Bv3z5YWFioZhRJJBKYmJhAJBJhwYIFWL58OTw9PeHp6Ynly5fD1NQUAQEBqrHTp0/HO++8A1tbW9jY2GDRokXw8fHBoEGDAADt2rXDsGHDMGPGDKxfvx4AMHPmTIwaNQpeXl4AgCFDhqB9+/aYMmUKvvrqK2RmZmLRokWYMWMGZyoRETVBLDSRioVYDD9XN/i5uqnuS8nPw+XUFKw9dxbXNfTd1OT8fEze8yfe7NYD87r7lWlyPtmnIw7cuoELSWV7MjmYmTdWzErFP9FHinSPjYkpzidqd98c0i7J+fkYsu1XvNWjF6Z27AxDfX2hI1UpVyrF9P27EZlccaPkpuxsQjy2XonClA6dWGxqwgoLC/Huu+9i7969kMlkGDhwINauXQs7u5r31Pzxxx8BAP369VO7/9dff8W0adMAAIsXL0ZRURHmzJmDrKws9OjRA8HBwbB4ogi9Zs0aGBgYYMKECSgqKsLAgQOxefNm6D/xe2P79u2YP3++ane6MWPGYN26darj+vr6OHToEObMmQN/f3+YmJggICAAX3/9dY2fFxERaT4WmqhSjuYWcDS3gL+rO+YdOYjQB7FCRyqXQqnE2vPhuJeVie+GjVL7I1xPJMIXA4dgxI7fUPLUTj4+FfQFaGwjPb2wLiJcddvYwADFGtI/ihqepvQKI91SIJNheVgodsVcw6f9B6Grc3OhI1Xq/WPBOltkemxZ6HGE3LuDT/oPgoeVddUPIK3z0UcfYfPmzZg8eTJMTEywY8cOvPHGG/jzzz9rfK7qNJEXiURYtmwZli1bVuEYY2NjrF27FmvXrq1wjI2NDbZt21bptdzc3HDw4MEqMxERkfZjoYmqxdzICBtGj8Wy0OPYcfWy0HEqdOj2LbS1O483u/VQu7+ltQ3e6uGHr86Eqd1/I/0hNl2KhKulJVwlVnC1lMDcyKgxIwMAZnTpioTcHBTISrB8wBAYGxhg780Y/Hb5Em5nZjR6HmpcFfURI2oMNzPSMeGvQHRxdELX5i7o5tQcvs7OsNKgxvTFpTIcv39P6Bga4XR8HIZv24LZXbvjja7dITbgn3JNye7du7Fp0yZMmjQJADB58mT4+/tDLperzSAioqarr8XIKseE5h1qhCREtce/TqjaDPT08Gm/gXCzlOCL0yeFjlOh1WfD0M6uGQZ4tFS7f7ZvdwzwaIWwuAf4ISIcWcXFOB0fh9PxcWrjbIxN4CKRYPWQ4WhpbdMomS3EYqweOgJpBfmwNTUF8GjJ34jWbeC74YdGyUDCSdPwXmikGy6mJONiSjJ+RgQAoI2NLXydm6Obc3N0c3aBs4UFpPJSGBs0/k6lZ+LjOcvzCSUKOb47fxb7bsbgk/4D0duthdCRqJ7Ex8ejd+/eqtvdu3eHgYEBkpKS4OpathclERGRJmKhiWpEJBJhpm83uFhK8E7wEUjlmveHvxLAgr8P4eLMN9X6NYlEInjZ2sHL1g49mrtg8u4/kVdSdiZJZnERMouLBFnOZP9vz6jU/Hw4mJtrfDN2qh8FMhkkYjFyOLOJNMitzAzcysxQ7c7pZG6OaZ26YEaXbo2epZmZGSzFYs7+e8qDnGxM3bsLo9u0xQe9+6GZmZnQkaiO5HI5jJ6aWW1gYIBSFlqJtBpnKZGuYaGJamWEZxs4mptj5oG9yCwuEjpOGTK5okxT8Cd52ztg83Pj8Mrev1Agk5U7prGXI+QUF+PInVvYdzMGEUmJuDX3baTms9CkK5qZmbHQRBotOT8ftzIy8Me1q5jwjE+jXruNjS1mdumGr8+GVT1YBx24dQNXUlNw/JXX2ChcyymVSkybNg1isVh1X3FxMWbPng2zJwqJu3fvFiIeET2BxSOiirHQRLXWxckZuyYEYOKuQKQVFAgdR41CqUBkciJ8nSpubtvZyRkbRz+Paft2lzszqzEKTdLSUhy/fw/7bsbgRGwsShT/NSsvLi1FSn5eg2cgzWBhJK56EJHAdsVcw66Ya3immT2esW/YzRQKSkpwLPYugu/eQeiD2ArfFKBHHuRk40JyIro5uwgdhepg6tSpZe57+eWXBUhCRERUeyw0UZ24W1nh7R69sOR4iNBR1MgUCkzZ8xd+HDEGfVt4VDiuh4sr1o96DjMP7FUr8gCAsX7D/3i8cXg/Ttwvfye/IpkMvVzd4C6xwoOc7AbPQsIy1GOTV9IeowO3oaW1Nbo4OcPX0RldnJqjlY0N9OppNo1cocAbh/YjLP5BvZxPV+y4egVdnZpzVpMW+/XXX4WOQEREVGcsNFGdvdDeG1uvROF6+kOho6gpLi3FzIN7sWrIcIxq07bCcX3cW2DdiFGYc/gAShUK1f0lcnmFj6kPOcXFOB1X8YuotIJ8tGtmj79efAmv7d+Nq2mpDZqHhKWoxjbURJrkXlYW7mVl4a/r1wAAlmIxOjs6Y8mzfdDG1q5O5/7m3BkWmWph380YSMRifNinP/QrWT5OREQVq2pJHJfDEVWNf4VQnRno6WH/S1Ow68WX0Ne94tlDQpApFHgr6BD23oipdNyglq2xeshwtXfjFx8NUis81beQe3cgq+T8+27dAADYmppiaCvPBstBmqFAViJ0BKI6yZVKEfogFgv+PlynzRSO3buL7yPO1WMy3fLblSjMPrQPhVxqSERERAJhoYnqhZ5IhM5Ozljs37vqwY1MCSA8Ia7KcaPatMXKQUNVt0/Hx2FVAzaePXT7VqXHd8dcg+zfWVX1tRyFNFdmkeY11SeqjRvpD7Em/HStHns/OwsLg4/UcyLdcyz2Hib9FYhcabHQUYiINEJfi5GVfhBR/eLSOapX7eya4Zlm9rj2ME3oKGrk1VyW9EK7Z+BkboE14acRmZyE9ZERGNf2GXja2tZ7pui0lEqPpxcWIvRBLAa1bM1Ckw5IK8iHvkhU7e9VIk3288ULuJyaggCfjhjSsjXEBgZ4WFiAZqZmFT6mSCbDnMMHkFfC3RfrQ/TDNFxJTcWzbu5CRyEiqraa7OTGJW5EmouFJqp3L3l3wAf/HBU6hpqa9L/p5eoGPxdXnEmIw/Yrl+Fhbd0gmexMzZBRxSyWP69Hs9CkI5QAHMzMkcSdBqmJOJeYgHOJCbA1MYGXXTOEJ8Tjm6Ejyu2Zp1Qq8cE/R3FDw3r9abu4nGwALDQRkbBqUjwioqaBhSaqdy95d0BRaSlWhIVqTINjubJmvZZEIhH8Xd3h79pwf6Dbm5nhZkZ6pWOOx97Dw4IC7iCkI2xMTFhooiYno6gIZ+IfLV9eFBIEPZEIIffuokdzF/R0cYW7xArbr17GnhvXBU7a9MRxx1IiIiISAAtNVO9EIhGmd/aFiYGBxsxsUijUC16lCgXSCwvgaG4hUKJHM5qqIlcqkV5UCF8nZ0xo743zSYm4n53VCOlICMaGhkJHIGpQrW1sMPfIQQCPdkgDACdzc6QXFgoZq8l6kJMjdAQiIiLSQSw0UYMZ27Y9Nly8AHeJFa6mpSCrWLimpOGJ8cgpLobE2BiXkpOwMPgIMouK8OPIMejl6tboec4nJuDIncqbgQOPel61s2sGAOjk6IRCmQxvHt6P0Af3GzghCYFLJKkp0xeJkCst238pOT9fgDS6gTOaiIiISAjcdY4ajKmhIf6ZOh2bx76Ao1New4T23oJlSS8sxPKwUABAgUyGBznZyCuR4tV9u3Ds3t1GzRKdlorXD+xBcTW2/36h3TNqt00NDbF+1FiMLqfHCWm/umwJT6TpfJ2ckZCbK3QMnXI7MwOrz55GFne1JCIiokbEQhM1CmsTE3wxaCi2Pf+iYBn+vB6NgF1/4OuzYar7ZAoFTsc/aLQMuVIpZh7Yi/ySkirHGujpYYxXuzL3G+nrY83QEXjZp2NDRCQBlTfbg6gpsDExQbSG7UaqC0oVCqyLCEe/LZuQI+CsYiIiItItLDRRo+rl6gZnC+H6IoUnxuNKaorafQUyWaNd31Isxu6JAZjp2w3mRkaVju3fwgN2pqblHtMTifBxv4GY171nQ8QkgaQVcAkRNU0trKxR2Ii/a0ldXolU1ROLiIiIqKGxRxM1ugntffDNuTNCx1Ap+vfFj7S0FOcSE3A+MQEDPVqis5Nzg1zP0dwC7/n3wZtde+D3a1fxa9RFJJez09jTy+aeJhKJ8HZPf3Swd8ThO7cQej8WmcVcHqHNCmQySMRi5HBmEzUhnja2uJicJHQMnff7tauY0qETdzElonrR12JklWNC8w41QhIi0kQsNFGjm9/DD6aGhqqeSUK7kf4Q844cQOj9+8iXPVrStuFiBKJmzYVJA+4CZiEW4/UuXTG1Y2ccun0LGy5GICb9oep4dZbXAcDAlq0wsGUryBUKXElNwaKQIMRyZzqt1czMjIUmalLkSmXVg6jBxaQ/xJW0VHR0cBQ6ChERETVxXDpHgni9S1d8O2wkjPT0hY6CO1mZOHT7lqrIBDzq3XQxpXHegTfU18fYtu1w8KUp+G3sePR2c8eAFi3Rvpl9tc/xx7WrGL59CxRQolShaMC01JD0RCIoFXxRTk1HV6fmuJeVKXQM+tfv0VeEjkBEREQ6gDOaSDCj27RFM1MzzDq4D3klmjeD43xiAvxd3RvteiKRCM+6ueNZt5pfs10ze2QUFeLl3X+hRM6dy7RVFydnXEhKFDoGUb2wMDLC7cwMoWPQEw7cuoGlvfvBrIoegURERER1wUITCaqniyt+HDkGL+/5U+goZZxLSBA6QrX52Dsg8IVJeGXvX0hlQ2mt1N25Oc6zyERNSFu7Zojg97RGKZDJcPD2TUx8xkfoKETUSGrSS4l9l4iovnDpHAmulbUNXu3UBUNbecLH3gEmBppR/4xKTYa0VHtmB3na2uL38RPhaikROgrVQkYRG7lT0+EusUIkG4BrpN+jrwodgYiIiJo4zXhFTzrNwdwcH/bpr7q98vRJrI+MEDDRIyVyOaJSktHDxVXoKNXmJrHC7+MnYureXVyyomVsTUxxl71sqIkwMTCAgk3ANVJUajJ+jbqIaR07cwc6okZQnzOKnpxNVJOxRESNjYUm0jg9mrtqRKEJAM4nJWhVoQkAHM0tsPOFCZi2bzei01KFjkPV9LCwQOgIRPWis6MTLqUkCx2DKvHpyX8QkZiALwYNhaVYLHQcIq3DJWZERJXj0jnSOL5OzmhmaiZ0DADAuUTt6dP0JBsTU2x7/kX4OjkLHYWqKTY7S2O+74lqy1hfH/G5OULHoGoIunsbY3ZuxYPsbKGjUAM6efIkRo8eDWdnZ4hEIuzdu1ftuFKpxLJly+Ds7AwTExP069cP165dUxsjlUoxb9482NnZwczMDGPGjEHCU30ss7KyMGXKFEgkEkgkEkyZMgXZT31vxcXFYfTo0TAzM4OdnR3mz5+PkpISaIq+FiOr/CAiouphoYk0joVYjD0TA9DOrpnQUXAxOQklcrnQMWrFUizGl4OHwUCPP+baooWVldARiOqkg4MT0gsLhY5B1RSfmwNjDemLSA2joKAAHTt2xLp168o9/uWXX2L16tVYt24dIiIi4OjoiMGDByMvL081ZsGCBdizZw8CAwMRFhaG/Px8jBo1CvIn/j4KCAhAVFQUgoKCEBQUhKioKEyZMkV1XC6XY+TIkSgoKEBYWBgCAwOxa9cuvPPOOw335ImISDB8BUoaydnCEn+Mn4QBLVoKmqO4tBRX01IEzVAXHlbWmOzTUegYVE2FMpnQEYhqzdncApdS2ABcm5gZGuFmRrrQMagBDR8+HJ999hnGjRtX5phSqcQ333yDpUuXYty4cfD29saWLVtQWFiIHTt2AABycnKwadMmrFq1CoMGDULnzp2xbds2XL16FUePHgUAxMTEICgoCBs3boSfnx/8/PywYcMGHDx4EDdv3gQABAcH4/r169i2bRs6d+6MQYMGYdWqVdiwYQNyc3Mb7xNCRESNgoUm0lhmRkbo7e4udAycS9DO5XOPze3WE+ZGRkLHoGq4lZEOMwNDoWMQ1YqtqSlkCoXQMagG8mUlmLZvF2Ye2IsMzkTTObGxsUhJScGQIUNU94nFYvTt2xdnzpwBAERGRkImk6mNcXZ2hre3t2rM2bNnIZFI0KNHD9WYnj17QiKRqI3x9vaGs/N/S/qHDh0KqVSKyMjIcvNJpVLk5uaqfRARkXZgoYk02um4OKEjIOjOLSRocc8RW1NTzPbtLnQMqgaZQoE2tnZCxyCqMR97B1zl5gNaq4WVFWxMTISOQY0sJeXRjG0HBwe1+x0cHFTHUlJSYGRkBGtr60rH2Nvblzm/vb292pinr2NtbQ0jIyPVmKetWLFC1fNJIpHA1VW7NmchItJlLDSRxipVKBCeGC90DEQ/TEO/LZsw78gBXNbSnZRmdOmKX8aMw4vtvWFlbCx0HKoEtxsnbWMgEiGziLNhtJlCyd89uuzpr71Sqazy++HpMeWNr82YJy1ZsgQ5OTmqj/h44f8mJCKi6mEHSNJYV1NTkK8hu5EolEocun0Lh27fgqGeHgz19WH0xMfH/Qaiv8D9pCpjqK+Pfi080K+FBz6TD0J4QjyO3LmF4Lt3kFlcJHQ8esKdrAyIACiFDkJUTV2cnHE+KVHoGFQHx+/fwwd9+gkdgxqZo6MjgEezjZycnFT3p6WlqWYfOTo6oqSkBFlZWWqzmtLS0tCrVy/VmNTUsjMaHz58qHaec+fOqR3PysqCTCYrM9PpMbFYDLFYXIdnSEREQuGMJtJYB2/fFDpCuWQKBQplMmQXFyOtoAAJubkQQXveCTbU10dv9xZYPnAIwl+fja3Pj0eAT0fYmpgKHY0A5Eql8LIVfsdFouqwMzHlkrkm4H52ltbO2KXa8/DwgKOjI0JCQlT3lZSUIDQ0VFVE8vX1haGhodqY5ORkREdHq8b4+fkhJycH58+fV405d+4ccnJy1MZER0cjOfm/77Pg4GCIxWL4+vo26PMkIqLGxxlNOiwqJRkmhobw0sCeMDHpD/Hb5UtCx6g2Sy19x81ATw/+ru7wd3VHd+fmWPD3YaEjEbT3+4l0j6tEgkssUDQJ84IOYt/El2HNXk1NSn5+Pu7cuaO6HRsbi6ioKNjY2MDNzQ0LFizA8uXL4enpCU9PTyxfvhympqYICAgAAEgkEkyfPh3vvPMObG1tYWNjg0WLFsHHxweDBg0CALRr1w7Dhg3DjBkzsH79egDAzJkzMWrUKHh5eQEAhgwZgvbt22PKlCn46quvkJmZiUWLFmHGjBmwtLSs2ZNq2xbQq9575TeS8zDL9NlKx4TmHarZ9YmIqEosNOmoXGkx5h05iCKZDNvGvYi2dpozg0KhVOKD4yGQK7Vn8VBTKAz8eT1a6Aj0r4Q87W0+T7rDy9aORaYmJCE3Fwv+PoRfxoyDfjVfxJPmu3DhAvr376+6vXDhQgDA1KlTsXnzZixevBhFRUWYM2cOsrKy0KNHDwQHB8PCwkL1mDVr1sDAwAATJkxAUVERBg4ciM2bN0NfX181Zvv27Zg/f75qd7oxY8Zg3bp1quP6+vo4dOgQ5syZA39/f5iYmCAgIABff/11zZ9UcvV/79iI2JeSiEgILDTpqJMP7iMx79E2sS/v/hMhU17VmHcxA6OvaN2Ll6ZQaJrwjA9Oxwu/y19TYGxggOLSUlgbm6CltTVkCgWkpaXIKipCWmFBlY9PysuDq6UE8Vq82yE1bSIA0tJSoWNQPTsV9wAJublwt7ISOgrVk379+kFZyRt3IpEIy5Ytw7JlyyocY2xsjLVr12Lt2rUVjrGxscG2bdsqzeLm5oaDBw9WmbkqcgBpVRSQ7EUlgEJR52sREVHtsNCko/q6e0CsbwCpvBSZxUU4l5iAYa09hY6Fh4UF+PLMKaFj1JisCfwxM7pNW1x7mIafIyOEjqLVWkiskFlcBB97R9xIf4jI5CS1421sbWFpZIzr6WkolMnKPYeLpSWKKjhGpAm6OjVHRDIbgDdFNzMewk0i4S50pLEyIcZrZgMqHRMquQwk8ncUEZFQODdaR1mIxRjo8d8uaeEJmjGTpUgmg54W/nH76t5dSCvIFzpGnb3r9yx6u7kLHUNrmRgYoFSpQK5UioikBOSVSMuMuZWRgQvJiVAoFPB1cka7p5attrG1RU6xFOncLp40lEQsxo2MdKFjUAOZfWg/JvwViCgtm1lMREREmoOFJh1mZmSk+nd4YoKASf7jJrHCTyOfg6GW9Ye4k5WJSbv+QHJentBR6kRfTw/fDhsJN0uJ0FG0Uvtm9kjIza3W2GK5HJHJSYhJfwgHM3N0d26Ork7OiM3KKrdARaQpPG3s+D3axEUmJ2F5WKjQMYiIiEhLadereao3B27dUGv+fCsjHemFmjGDontzF6wYOEToGDV2PzsLAbv/EDpGnVkZm+CnUc/B1NBQ6ChapbOjU5llctWVWpCP80mJuJCc1CSWYVLT1crKGpFcMqcTLiUn4YN/jiLmYZrQUYiIiEjLsNCkg+5mZmDJsWChY1RqjFc7rVxC9yAnu0k0yG1r1wxfDhomdAytYqinX/UgIi2nr6cH7dkPlOpCrlRix9XLGLlzK8b/sQO7Y65BoUW7wRIREZFwWGjSMYUyGd48fKBME2IXS0vYmZoKlKqs9MICrf2DtkBWInSEejHCsw3mdO0hdAytcTUtBc1MNOdniKi+dXF0wq3MDKFjkAAupiRjUUgQfrkUKXQUIiIi0gIsNOkQpVKJFWGh0Cun/1EnRycBElUsJV97G2vnSZtGoQkA3u7ZC33dPYSOoRWKSkvhImFvK2qaTA0McD8nW+gYJLCvz4bhFhvBExERURVYaNIxH/cbiMMBr2DXiy/Bu5m96v5ODppVaErO196m2vlNqEnuo+bgI9DCylroKFrhUkpymV3kiJoCb3tHZBYVCR2DBFYil+Od4CMokcuFjkJEREQajIUmHSISiVR9jzo7OWPPxMn4rP8gSMTG6KwhM5pKFQrcycxAqhbPaMovaTozmgDAUmyMTWOehyt3oquWAlkJf7FSk+JiaYmLKbVrdE9Nz7WHafg+IlzoGERERKTB+HpIh+nr6SHApyOOvfIq2j8xu0koWUVFeHXfLoQ+uI9rWrzLzVdnTiEs7gGUWtpjqjweVtb4a8JL8LF3EDqKxovLyUFXZxehYxDVG4nYGKXcDZGe8EPEOVxOSRY6BhEREWkoA6EDkPBsNKCB8Y30h5h9cB/icnPQvpk9IhITKp1BU+l+dJUcFFX+yIofV9HDlI9mij0pq7gYH504hp9GjoGnrV2trqeJmpmaYecLE/FW0EEci71XrcdYisXIlTadpYTVde1hKmxMTLjUiLReRwcHXE5NFToGaRi5UomX9/yJAR6tMLtrdy4ZJiIiIjUsNJHgjty5hXdDglQ74e28egX5Wr5zm6GeHtybYF8jU0ND/DTyOXwcehzbrl4GAHjbO2CgR0tcTk3BifuxqrHdnJtjRpeumHlwn1BxBVMgk8HLrhkLTaTVDPX0kFpQIHQM0lAFMhkO3LqBUoUC348YLXQcIiIi0iAsNJGg0gryMffwATy5yEzbi0wA0NrGFkb6+kLHaBD6enr4uN9ADPRohbZ2zeBgbg4AKJTJELD7D1xJTQEAzOzSDQNbtkK/Fh5qBShdcTE5CW1sbXErg9vBk3bq7OSM84kJQscgDXcs9i5ypVJYisVCRyEiIiINwR5NJKiQe3fRdDoZ/aepLyMQiUTo28JDVWQCHs122jj6UdNwO1NTeFhbIyU/D7O6dEP49Fn4edRzGNXGCyYGulPfLpErarlYk0hY9mZm7MFD1VIil+Pvu7eFjkFEREQahIUmKldDN7I+eu8OACC0ic50advEC00VsTM1xa/PjUOpQoH1kRFwNLdADxdX2JuZY1DL1vhu2ChEzJiDb4aOwECPlhjf/hn8NnY83u7ZC8+6ugsdv97dz85CV+fmQscgqjFXSwmk3MKeqmnfzRihIxAREZEG0Z2pBVQja8+HI72wAO/37gsRRJDK5ZCWlkIqL4WpoWGtG4jnSaVYFnoce25cx8WZc7B66Aj8eT0av0ZFIiE3t56fhXC8mlAT8JpqaW2DDaPHQiYvf5cqU0NDjPFqhzFe7aBUKiESieBj7wBHcwuExT9o5LQN70Z6OiRiMXJ0sCk6aS/9CndAICrrbHwcUvPz1Wa5EhERke5ioYnKlV5YgG1XL6saPj/Nu5k9+rVoib4tWqCTgxP09aqeHBeZnIiFfx9BfG4OAOBeVha6ODnj1U5d0N25OUYHbqvX5yCkpf+E4KM+AzCwZSuhowjC16l6s3gO3r6Jr86calJFxqfllUjR1ckZF5KThI5CVG2PN2cgqg4lgAO3buD1Ll2FjkJEREQagEvnqFyzunaHQSXFo+iHaVgXEY4X/wxE1w0/Yv6Rg9gVcw0PC8vuUFSqUOCb8DOY+NfvqiITAMSkP1T9u7WNbZN6Bz0hNxdvHj6ALO46VilpaWmTLjI9diE5Ce2b6eZyStJOtzMzYKjXNDc0oOpS4n/dC7DYt7Bao3+8cA6fhB5nA3kiIiLijCYqX3MLS4xr2x5/XI+ucmyOtBgHb9/Ewds3ATzqT2RmaAiZQoFSuRzZ0mIk5eWVedyKsFC4WUrQ270FxAYGeKtHL6wOP606bqCnhxGebTCu7TP4IeIczidp1x+vJQo59t+KwdSOXYSOorGaW1gKHaHR3EhPR4/mLohITED5iwqJNIdULkc7u2ZqbwiQ7mhvo8Av/S/DTv88AOBZx2GYGOSGInnFbwhlFRdj8+WLeNY2BAqbZ6FnMrKx4hIREZGGYaGJKvRG1x6ISk2BTC5HbHZWtR93o5ovTAplMkw/sAfzuvfE823bY273nmhja4sVYSfxnFc7BPh0gL3Zo34Pfi6uWBEWis2XL9XquQjl92vReL5te1iKjYWOopH8XN3w65hx+OzUCdzNyhQ6ToNSKJU4l5iA1tY2KJTJkJRftvhKpEksjLhdve5RYqV/HsY1PwAR8lX3tjcLQvi4dnjln2dxOb382c4WhkrsH3ETruJQIOcAlPrOEBl1bqzgREREpEFYaKIKuVtZIWjyVADA2vNnsSb8DMyNjJBfUlJv1yhVKLAm/AzWhJ+Br5MzRrdpiy8GDsHNjHSsCT+D6w/TYGxggA/79Ed2cXG9Xbex3Eh/iE7rv0c35+bYPm5CpcsRdVF+SQleP7AH8gbe5VCT3MnKhJmhIYz09FGi4K5epLkyi6u3ZIqajj+GJaOL5YFyj5mJYvDnwCSsvfE81l5WL0K2t1EgcNApmOLGv/eUQJn9BmDzJ0QGrg2cmoiIiDQNC01ULXO79YSDmTmGt26DOYf343R8XL1fIzI5CZEVNEweo+WNwiOSErHp0gXM8u0udBSNoVQqcTE5CU4WFjrRp+lJBTIZOtg74EpaqtBRiCp0JzMTFkZi5JVwx0RdINZToJMk7FFn7wroKXPwltdm9HYahcnBzpApRBjXqhQruu6DvjJdfbAiEyWZb0JquROWxmYNG56IiIg0CgtNVC0ikQgTnvEBAPi7uiMyOQnFpaUCp9Iu34SfxZBWnvCwshY6ika4kpqCaft2CR1DMIb6bLRMmq+ltTUup6YIHYMawZsdpdBTVm+ZfBfLgzj3QgeEpbbFcMe9ECnLznSOL2yNhRGjcS19A3o2d8UAj5YY4NESLpaS+o5OREREGoaFJqqx2V27I8CnIz44HqJqAE5Vk8pLMfC3X2BsYABzIyNMaO+Dmb7dYCnWzT4oHR2d0KO5C87p6A5F95p4TypqGlgQ1R3jPW7VaLyl6ApGOF4p99iB5PH48Jwj8ksezVY9GXcfJ+PuY1nocbSxsUV/j5Z4t1dv6DWh3WaJiIjoP2wYQ7ViKRbj8wGD4cp3JmusuLQU6YWF+OHCOQzYsglbLl9EiVw3e/XM6dpD6AiCySouRicHR1ixUTxpsMTcHKEjUCNoZalEM4MLdT5PfqklFl9aiLdP2SK/RFbumFuZGVgfGcFiOxERURPGQhPVmoVYjDVDR0Cf70jWWmZxET4O/QdDt23G4ds3odShptgA8KybO3zsHYSOIZio1BQoAXR2dBI6ClG5kvPz4WhuLnQMamCLumRChLoth7+a0wPPHXsdu28XVGs8l2QSERE1XSw0UZ10cXLG9yNGw8/FDSw31d6DnGzMPXIQv125JHSURiUSiRDg01HoGILKkRbjUkoyOjo4wtzQSOg4RGW4WHDmatOmRB/7i3U6Q2D8ZEwI6YIHOdUrMgGP+vSRbvrhhx/g4eEBY2Nj+Pr64tSpU0JHIiKiesZCE9XZkFae2D7uRYS9OhP/598bbWxshY6ktcLiHggdodG1trEROoJGuJyaAltTU6FjEJUhVyiEjkAN6LmWcohxr07nSCywgqyG3ydH793B3hsxOjeTV9f9/vvvWLBgAZYuXYpLly6hd+/eGD58OOLi6n83YyIiEg4LTVRvnCwsMMu3O45Mnor3/PuwyWctnEtMQKmOvahzl3AXvscyi4qEjkBUxt3sTM5YbcJmtq/7hgzP2l+r8WOS8/Ox8WIERPxbQaesXr0a06dPx+uvv4527drhm2++gaurK3788UehoxERUT3irnNU70QiEWb6doO3vQPeCjqIDL54rrb8khJcTU1BZydnoaM0GlsTE5gbGiFfVnZ7bF1ipK+PvBKp0DGIysiVStHK2gZ32by5yTE3UMLT7CxQx0lFnSVnsKm/CeyNU2FvlIR7hW3w5qlOyCyu/HfaoJat63Zh0iolJSWIjIzEe++9p3b/kCFDcObMmTLjpVIppNL/vodych5tTmAAKX7JP1bptXILHv1NkadUolRZfmN61djcR7sjVjVOE8Y+HleTsdrwvBpqbG0+XzUZqwmfA3kVv2cbauyTn6/qjhUqqyaMrdHn699JB8qHJTAbcLrysRmP+iuWKpTIy6+81+LjDFWNAwDRv2PrMutYpOScZWpAyXl5GBO4DRlFhUJH0Rrv+PnjzW49hY7RqEbv3IprD9OEjiEoR3NzpOTnCx2DqFzdnZvjfFKi0DGoHhnqKfF+t0JMcd/WIOePK/LEmKChyJdV/ILpwKSX8YwObwiha5KSktC8eXOcPn0avXr1Ut2/fPlybNmyBTdv3lQbv2zZMnz88ceNHZOIiP4VHx8PFxeXWj2WM5qoQTlZWKCbc3ME3b0tdBStcSY+XucKTe4SK8jkcrhJrHA09q7QcQTxsKAA1sbGyCouFjoKURmVFQtIsxnqKfFT/3T0sjsPPRRDD1JAWVTnXeaq4mZyG97NxiI8qfzvHWcLC7RvZt+gGUgzPb1cUqlUlruEcsmSJVi4cKHqtkKhQGZmJmxtbdXG5+bmwtXVFfHx8bC0tKz02tUd2xDn5FjNuL62jRX6+k15rNDX1+SxSqUSeXl5cHau/SobFpqowfk4OLDQVAORyYkoLpXB2MBQ6CiNZtWQ4RAbGEChVGL8HzsRlZosdKRGJ1cq4Wljy1kjpJFuZ6TDSF8fJXK50FGoBvq6yPGd32mYiWLqvDyuNp6xkSI8qfxjgzxasT+TjrGzs4O+vj5SUtR3HExLS4ODQ9mZbWKxGGKxWO0+KyurCs9vaWlZ5Quqmo5tiHNyrGZcX9vGCn39pjxW6Otr6liJpG67DrMZODW4Dg6OQkfQKiVyOb48EyZ0jEYlNnhU89YTifBJ/4E623g4s5j9zEgzyRQKeHJHUa2hL1Lg5/4Z2Njrt0dFJoG0t6r4TYNn3dwbMQlpAiMjI/j6+iIkJETt/pCQELWldEREpP1YaKIG592M/RdqanPURWyOuih0jEalVCoRcvcOlhwLFjqKYEQ6W2IjbWBmqDuzLLWZv5MCkePPYECzvyCCsJssPGN5o8Jj7x0Nxq6Ya3VqNEraZ+HChdi4cSN++eUXxMTE4O2330ZcXBxmz54tdDQiIqpHXDpHDU5ibAx3iRUe5GQLHUWrfHryHzS3sMTgVrqxK49IJMLgVq3R1bk5Dt6+iQ0XI5DwxA4NukDy1BIBIk3ysLBA6AhUCRGU+L5fFgbb74cImrGDpYfpNZgY9EFRadl+UJnFRXg3JAh7b1zH5udegL4e3/vUBRMnTkRGRgY++eQTJCcnw9vbG4cPH4a7e+1nuInFYnz00UdlltnVZWxDnJNjNeP62jZW6Os35bFCX18bx9YEd52jRrEr5hr23YhBWPwDoaNola7OzbHluRdgooMzCRJzczH+z51ILdCdndi4sxdpOonYGDlSNqzXNE5mShwecRYWoqtCRynjxdB3cSm18jcNfhkzDv1aeDRSIiIiImpofPuIGsUL7Z7BlrEvoKtzc6GjaJW+7h46WWQCgOaWltgy9gVIxMZCR2k0+SXc2Ys0W0tra6EjUDmM9KGRRSYA8Lap+vfazujLjZCEiIiIGgsLTdRoRCIRPuzTHwNatISRvr7QcbTC2nNn8cah/fj77m1Iy1l60NS1sbXDpjHPw8RAN1b5Jufr1lJB0j763CVMIz3IBZQwEzpGudpZp1U5JikvrxGSEBERUWPh0jkSRH5JCU4+uI/ge7chkyswo0tX3M/OwrnEBBy5cwu5Us3oL6FJLMVijPT0wnNe7dDVuTn0dOgF37mEeGyPvowLiYlIaaJL6cT/bh3PX8ikyezNzJBWwF5Nmih6wjEY447QMco4nTEIU4+1qnTMgBYtsXHM842UiIiIiBoaC02kcR4WFmD5qVDsuynclsyarrmFJcZ4tcVYr/bwtNWdLceVSiUScnNxISkREUkJuJCUiDtZmULHqjddnZxxITlJ6BhElWpuYYnEPM6+0zSnx12Bg8FZoWOU8UdCAN4/Y1HpmJe8O+DzAYMbKRERERE1NBaaSGOFxT3A7EP7UChj35rK+Do544/xkyDSoRlOT8ooLMTF5CRcT0+DRGyMZqZmsDU1xYK/D2ndzAs7U1PkFktRopALHYWoQl2dm+MCm9ZrnD0j4uBjfkToGGWsuvEmfrxS+dLvt3v2wrzufo2UiKhpyMvLw5IlS3Ds2DGIRCIMGjQIn3/+OSwsKi/s1rfExESEhYVBJBLB398fzZuzH6smKyoqwpUrVyASieDj4wMTE5Nyx8XHx8PBwQFGRkY4ffo0Ll26hKlTp9bp+0sul6NTp064erX6PQXlcjkePHiA4uL/NiJp3759rTM8VlpaipKSEtVtU1PTcsft27cPN27cwP/93/8hMTERmZmZ8PHxqfO1v/32Wxw9elT1szt//nwYNEKrkMLCwkqPV/R5qA32aCKN9aybO9/hrIKHlTVGeHpBrsP1YltTUwxu1Rpv9eiFaZ26YGQbL/R0ccWMLt2EjlZj6YWF6OTkVK2xJnIRvAqMAB3+2pMwZHIWQjVRXL5lmftiiwcgV9lBgDT/eZBX/ouYJzmYmTdCEmpKDhw4gNzcRzMrv/76a4wfPx7R0dF1Pm9ERITqhdgff/yBRYsWISmpbjON09PTMW/ePPTp0wfdu3dXfVSktLQUq1atwvDhwzFixAisXr0apeX06ZwzZw5kMhl27tyJHTt2oLS0FHPmzCn3nHK5HN9++y3mzp0LALh79y6OHz9ep+cFPHoR3rFjRwQGBmLHjh3o3LkzDhw4UOfz5uXlYe7cuWjXrh3at2+P+fPnI6+WvdwGDhwIAGjWrBns7e1VH49vNxWpqak4fvw4Dh8+rPp42pkzZ9CqVSvMnj0bM2fOROvWrXH2bPkzYZ977jkoFAokJiZi0qRJOH36NF577bVKM8jlcty7dw/Xr19XfTxJX18fLi4uKCoqqtZzOnLkCNzc3NC+fXv07t0bPj4+GDlyZLlj169fj5ycHADAm2++ia5du+LkyZNlxp0/fx4+Pj4wNjaGhYWF6qM8y5Ytw08//YRNmzYBAPT09DB79uwqc5eWlqKwsFD18bSFCxfi+PHjmDVrFmbOnIl//vkHCxcuLPdcNfnZvXjxIoYNG4Y2bdqgZcuWqo8nmZubw8LCAubm5qqPx7fru0itGx12SWs959UOEUmJ2HGVO9I8zdVSgqDJU2HIxurlCvDugJ8unEdGUeWVe01z/WEaWllZ4252VpljJnIR/BIMYBD1EHFn7kImlaGHux0UU9ojwq6knLMR1b+7mZnQE4mgYJFTo1xON4WT6SgAQGfLIOQp2mPI/tZQwhPdHHrgrY5p6G59AnrKnEbN9aAarw1tTervHVTSDUuXLsWVK1dw+fJlbNu2DW+88QbeeOMNnDp1qszY9PR0fPzxx7h8+bLarIjz58+XGfv666/j4sWLuH37NpYuXYrx48fj1Vdfxd9//11mbFBQEIYNG1blfa+99hr8/f3x999/Y9WqVVi/fj06d+5c4XNbuHAh7t69i1mzZgEANm3ahPv37+O7775TG/f4+T/2ww8/oGPHjuWec968eZDJZAgLCwMA2NraYtKkSYiIiKgwx4ULF1SzpQYMGICuXbuWGfPxxx8jPDwcrVu3BvDoRfCLL76I0aNHlxlbk6/DnDlzYGpqip07dwIAfv75Z8yZMwdbt24tN+vFixcRFRWldt7HRbdt27apnk9NVXf2T3XH3r9/HytXrsTdu3fViocVFQ4OHDiAvn37wtLSEl9//TXCw8OxbNkyeHt7q43bvHkzPv74Y2RkZMDT0xOXL19Gz549MWLECLVxCxcuxJ9//gl/f38AjwpPb7/9NsLDw8u9vrGxMQ4dOoRZs2bhgw8+qPD7C3hUFHr99deRkZEBMzMzZGdnw83NDbGxsWrj2rRpg969e2PChAkwN//vTYbyiqRLly7FmTNnMHbsWFy6dAnbtm2rcDbU999/j1mzZuH06dOIjo7G559/jkWLFpX5/po/fz42btyI2bNn4+TJk/juu+8q/Lru3bsXkZGRqu99JyenSgue58+fx/Tp0xETE4MnF43Jn3qD7sSJE4iKioKe3qM5P6NGjUKXLl3KPWdNfnanTp2KuXPnws/PD/oVvD5UKBQV5q9vnNFEGu/D3v3wTLP/3nEwNzSCuaGRgIk0w+yu3VlkqoSJoSFmdCn7R5Gmyy8pwb3sLPg6OcPa+L//8RnJRfDfnY4Ha07h7j83IJM+WlKa/iAd5oceCBWXdFC+rAStrG2EjkFP+eW6ESYENceEoOaYeeZVvHaiB5R4tKQ6IlUPLwc7IknaqVEzKZVAXG7Vm3ssDD6CHyLOcak8VdvjJSbBwcGYOXMmZs2ahYIKlsu/9tprcHFxQUpKCj788EPY29tj6NCh5Y7V19eHvr4+jhw5gjfeeAMrVqxAWlr5Oye+//771bovLi4O//d//wdjY2OMHj0au3fvxpkzZyp8bidOnMCBAwcwduxYjB07Fnv27MGJEyfKjJPL5WovegsKCip8EXnmzBls2LABxsbGAAArKyu1ZUNP27BhA8aNG4fk5GQkJSXhhRdewMaNG8vN8LjIBACtWrWqMENNvg5XrlzB+vXr0alTJ3Tq1Ak//PADrly5Uu7YlStX4vXXX8fixYtx7NgxvPfeewgJCVEdd/p3priTkxPc3d3h7u4OuVyOq1evwsXFpcLPQU1m/1R37IQJE2BlZYW5c+finXfeUX1UZOnSpbC0tFQVVAcPHow33nijzLjVq1fj4sWLaNWqFSIjI3H8+HG0bdu2zLji4mJVkQkAevXqpVace5JUKoVUKkVISAj69+9fYcYns545cwbt2rVDRkYGtmzZggkTJpQZl5ubCx8fH8TExCAiIgIREREVFgFFIhHc3d1VRbmXX365wq/B498Jx48fxyuvvIKhQ4eWOxNQJpOhR48eKC0thYWFBZYuXYr9+/eXe05jY+MKCzbleVzE8vHxQXZ2Nj755BN89dVXZcYplUq1nxOlUomKuhnV5GdXX18fs2bNQocOHfDMM8+oPipT1eyruuCMJtJ4YgMD/DBiDK6mpaB9M3u4SaxQIi/F8dh72H71Cs4mxDXIdY309DW6V87eG9fxQrtnYMRiU7keZGdjVBsvrI88j6wK/ieqqZQAIpOTYGZoiO7OzXElKQl9DmXj7unb5Y6Pu/QAPYa746qtDIX6nGVCDe/JIihpnn8Syn8fMUNqDpdGfJ8mS2aPvEpezD6WVyLF12fDYGZkiKkdy39Xl+hJcrkc4eHh2LVrF3799VcAj15AlicuLg779+/H9u3bMXr0aAwdOhTDhw8vd6xUKkVKSgoOHjyIL774QnWtJ925cwe3bt1Cbm6u2vKknJyccl+oGRk9+qETi8XIzMyElZUVEhISKnxuj1+EPp7tUNGL0FdeeQU9e/bE5MmTIRKJEBgYiKlTp5Z7zscvUh+Ty+WVzmxYu3YtIiMj0axZMwCPiggDBw7E66+/rjbO3t4emzZtwmuvvQaRSIQtW7bAzs6u3HPW5OvwuIj2eClPZUW0rVu34sKFC+jZsyd27dqFmzdv4n//+1+Zcf7+/jh+/DhKSkrQu3dvtGjRAgcPHsRPP/1U7nlrMvunumOLi4uxYsWKcq9XnvIKquvXry8zztDQENbW1qrCSp8+ffDee++VGWdqaoqjR49i0KBBAB4VNSvqyfPSSy/B0dERbdq0Qa9evZCcnFxp/57yikJ9+vQpM+7xz2t1GBoaAgBcXFxw4MABuLu7V/izo6enh8DAQPz+++84ePAgAJRbkHn8ObW1tUVUVBRcXFzw4EH5b9i6u7ur+o8pFAosX7680v5M5RWx+vXrV2ZZ3NChQzF06FBMnz4dIpEImzdvrvBnoSY/u/7+/rh06VKlMyYfq+7sq7pgoYm0gqtEAleJRHXb2MAQIzy9MLhlawTs/gORDbBT12cDBqGniysm/vU7kvNrty68IUUkJWLZiWP4fMBgnW0EXhknCwtM3fsX2to1w9mEeKHj1EqBTIbzSYl41sAWd49XvptU+vKTcAJg2cwSVm42MHa2hKKZCbKcxDjfjMvqqH7llWhX8ZYeSSk0RcdG7BMcV9S66kFP0LYNHEg4n332GWbPno2BAweiXbt2uHnzJjw9PcsdW5NCz9tvv422bdti4MCB6NKlC+7evQsrKyu1MadPn8bmzZuRmpqqNlvB0tISq1atKnNOLy8vZGZm4uWXX0bPnj0hkUgqfSFY3Rehixcvho+PD44dOwalUomVK1eWWbb3WIcOHbB9+3YolUrcv38fK1asKLcI8KTHRabH/y7vb82ffvoJkydPVvWP6dSpk2qp2tNq8nUor4j2yiuvlDvW2NgYxsbGUCgUUCqV8PLywv3798uMe/zi/7fffsPUqVOxfPlydOhQcQ+7msz+qe5Yb29vJCQkVDqT6knVLaiKxWIolUq0adMGa9euhbu7O9LT08uM++677/DCCy9ALBZDJBJBKpVi165d5V77gw8+wNy5c2FpaQmRSAQLCwv89ddfFWatblHot99+K/fx5X1933rrLWRlZeGzzz7DpEmTkJ2djW+++abcx3///fdYsWIFZsyYgRYtWuDWrVvlzsSaNGkSMjIy8P7776NPnz4oLS3Fxx9/XO45v/vuO0ydOhXR0dEwNTVF7969K/z+BqpfxPryyy+xfv167N69G0qlEs8//zxmzpxZ7jlr8rN75swZbNy4EV5eXmoFqvKWp9ZkCWFtcdc50nop+XkYvXMrMqrZWK661o98DoNbtcbgrb/iblZmvZ67Pi3rOwCvdKy6cq2L/r57G28cKn86rDbpLbdC0jtBtXqsmZUprv7PB0o9FiOp/hiIRDDU10dROdPSSXMt8S3E9Fbl9zhpCMfSRmLeKXeUVPMdUj2RCB/07oepHTvzDRSqN1OmTMG3336LrVu34vvvv4dEIkGrVq0QGBhY5WMVCgVKS0tVRZInbdq0CdOnT69RlrCwMGRnZ2P48OGV9lD5+eefcfToUSiVSgwePBgzZ85UzXB6WkpKCkQiERwcHCq8bn5+Pt555x3s3bsXADBmzBh88803MDMzK3f8uHHj0K5dO7z55psQiUT4+eefcfnyZezevbvC8yuVykqbCdf06xAUFKT2OaioiNanTx8cO3YM06dPh6OjI1xcXLBhw4YyvXzat2+P69ev47XXXkNAQAAGDRqETp06ISoqqtzz9urVC5988ona7J/333+/3GWP1R07bNgwnD9/Hs8++6xaIeCPP/4oN8OBAwfw4YcfYuDAgVi1ahVu3ryJJUuWlPk6HD9+HL6+vkhPT8fs2bORnZ2NFStWqPI8SSaT4ebNm1AqlWjbtq2qQFSe1NRUXLt2Ta1o9nTfp8d27tyJYcOG4d69e6qi0LfffouAgAC1cS+++KLq38XFxQgLC0PPnj1x5Ej97JpaWlpa7d3bZDIZiouLq2yCXVhYCIVCodZTqjxr1qzBK6+8gsjISIwfPx6lpaX45JNPsGjRomrnf1p5P7tr1qwpN0toaGi55+jbt2+Z+3x9fREZGQkfHx/Vz0q/fv3KXaZbWyw0UZMQFvcAU/f+hfr8Zg58YSK6N3fBkK2/4o4GF5r0RSJsHvsC/F3dAQAbL15AX3cPeNraCpxMeEqlEpN2/Y4ILd+KvW+BBRKWhlQ9sAIGn/XBTXPOaqL65W3vgOi0VKFjUA1MaiPDZ51+adRryhV6SC72wP2ilvj9Xkccia16hvDLPh3xv74DYFDBC2siANi9e3eZBtBffvllpY85ffo0srKyKi30VNZYGgBiY2Ph4eFRZketx+qy9bpcLsewYcPUegxV5MqVKwgICFDtite8eXPs2LGjzluvA0BaWhrmz5+Po0ePAgAGDx6Mb7/9tswubT///DPGjx8PG5tHffsyMjKwe/duzJgxo9LzV/V1+OWXX8rscFbefQAQHR0NDw8PFBYW4v3330dWVhY++OADdOrUSW3c3Llzcfz4cZSWluLatWvIz8/H4MGDK+wPdOHChXJn//j6+tZ67JYtW8q9VkVLHuvbgQMH0Lt3b9UsvaysLJw+fRqjRo0qM7aiBuOPm1I/SS6XY+/evXjhhRdqnCk2NhYffvhhuTOFfvjhhzL3SSQSdO/evcwMxuvXryMgIAAZGRmIj49HZGQk/vjjD6xcuVJt3MCBA/Hhhx+iX79+qvtmzpyJn3/+ucy1unfvXmY2UHn3laeyIlZSUpJqt7nHmdavX6/qJ1ZXqampEIlEle6q+Ph59OvXD9988w1cXFzQrVu3Ms3b64KFJmoy1p4/izXhFTdXrIm2ds0Q+MJEhNy7g/87+rfG764kERtj78TJsDExQZefv4dIJMKMLl0xt1tPmFTyToUuuJKagrG/bxc6Rp30TxIj7svy36WojpZv+iPEU3P7jZF26u7sgvNJFfcZIc0zsoUc33Yv29C3sSiVwP7kF7HsvGOVvZv6uLXADyPHwFTH/x9G5VuwYAHu3r2LyMhIvPTSS/jzzz8xePBg1TbkT4qIiEDbtm1VL/hyc3Nx69atcndRW7lyJX7//XfExcWhb9++CAkJwcCBA7Fnzx7VmFGjRuHgwYPw8PAo83iRSIR79+4BqHi5mVKphEgkqrDJ+KBBgxAcHFzhDKbHunfvjnfffVc1Q+Svv/7CypUry92NytfXF9OnT0dAQECZpYB1Ud6MoMpmCSUmJqp63vj7+6N58+bljuvSpQsuXrxY5X01oVQqcfnyZbRs2RKWlpZIT09HfHx8pcsYazL7pyZjqysvLw/vv/8+jh49CpFIhEGDBuHzzz8vU7woLCzEjh07cO/ePbUG2E8XXp/+2iiVSnTp0gWXLl0qc+0OHTogNDQUAwYMwKVLl3Dy5En89ttv5TaFBx71Bzp9+nStnme3bt3K/b4dPXo0Tp48iYEDBwJ4NHPr2WefxZUrV7Bs2TK1wmP//v3x6aefYt68ebh06RKUSiV8fHwQHR2tds7mzZvD3NwcH330kWq2VUXfW0/fL5fL4ePjU2GR+eTJk+Xe//RSt9GjR8PPz09VwP7pp59w+vRpHDhwoNzHnzt3rsxOheUtNYyJicGECRNUSxZdXV3xxx9/lNsYviFmXz2NPZqoyXizW0/czszAwVs3Kx1nbmiERb2exa9RF/EgJ7vM8TY2ttg6djwO3rqBD/452kBp61eOtBjLQo/h1+deQF93Dxy/fw8/XjiPg7du4uN+A9GvRdk/hnRFBwdHPN+2PfbcKP9/CprOWN8AuSF36nQOvZuZgKek6oE6xC/VCOHNpFxSWAepBflCR6AamuhZtmdHYxKJgOec/8QvlotwLb3yQtPJuPv463o0l4ZTuY4dO4bLly+jc+fOWLVqFRYvXlymUfVjs2bNUnsRa2pqilmzZiEyMrLM2Oo0lj548CCUSiVOnz4NZ2fnCjNWNFOmKj179sRzzz2HKVOmqC2PeXrJkkKhUFuGNH78+DKzNx5btWoVNm/ejA8//BCDBw/Gq6++iiFDhlS4RLW6M0nKm69QUaPiffv2Yfr06ejduzeUSiXmzp2LTZs2YfTo0aoxFy5cwLlz55Cenq6WIScnp0xj58WLF5d7nceeLrKIRCKUlpbixx9/hEgkwoABA8otNj72ePaPt7c3gMpn/zwuPDwuDt6+fRsSiaRMIa24uBg//PBDmRlzFS2dmzNnDkxNTbFz504Aj2aQzZkzB1u3qi+Bfv7552FgYABfX1+IxeIKn9PTHje5Lk91G4w/1rVrV5w9exZ+fn6VXvPJBvpyuRznzp2rdKl0dHQ0XF1dAQDx8fFYtGgRzp8/j0GDBqkVmvLy8vDss8+qPbfyin0ODg44fPgwRo4cibi4OLz33ntlvo+/+uorfPnll8jJyVGbFVRYWIjJkydXmPXJHQSLi4tx8+ZNeHt7lylixcfHqxWV3nvvvTIz8B5744038Pfff6NTp06q2X8ikajcQtOcOXOwZMkSVQEtMDAQb7zxhmrm1GMKhQK9evWCra0thgwZgoyMjGotIawpFpqoydATifDt0JHo6tQcn586gf9n77zDmjrfN/457CEqLlBxIu4BLkBRFLXura1a99a6WlfrqAt3ta2rte5tta46696iAoKKA0XBAQ6QPUOS3x/8ki8hCQREAno+19Wr5uTNe55AgJw7z3PfEg2/OM2MjNjYpTvWZuYERX7g0KMHxGX4w1W7lA1b/X1Ze/tmHlWeO9hYpr0Z6VmzFueD0z5NexkTzdB/D9K+SlV+bt4Smyxmiz9XJrs25cSTQJKlBctPpryFFbbbnhBx5+NG/0KuPKVOM1fuFRHH5wCc35vwbvFlWtSvwPPe5Qk2FyPVc0JIdBTWZuZEJuWuP57Ip0JOQ2s/fRdBcEJ1AsJ1C9jY6n+H/nUdMRD9mkQyYGZmhoGBAYIgIJFIsLGx4fVrzX8rZTKZyniWkZGRxthzxb66GEtDmvCjrXMH0hKrcoKiK+SPP/5QHhMEQU1oqlu3LleuXKFZs2ZAmv+Ts7Ozxj1btGhBixYtiIuLY9++fXh6ejJixAhevNCc3Hzy5EmNnSQ//fSTSidJ6dKlOXDggHJk6sCBA9ja2mrcc968eXh5eVGlSlpIQFBQEL1791YRml6/fo23tzfx8fEq4mDhwoXZunWryn7a/KW0sWHDBhYsWECPHj0A6NmzJ7Nnz9YqUM6ePVvl+1u0aFFmz56tUWjq0KEDL1++pMj/BxdFR0djY2ODiYkJe/fuxcXFBYARI0ZgZWXF5cuXmTx5Mlu3bs3UlP3u3bv4+/srb69bt4569eqprXv16hUBAQFZfg0KFy7MzZs3la8TLy8vreKCrgbjCi5fvszatWupWrWqikCaccwsvYG+kZER9vb2/P333xr3DA4OVopMkNahExgYiK2trZoPk5GRERKJRClavXr1SmtXoK2tLZcuXaJ3794EBweriW0jR46kd+/ejBkzRiWVsHDhwlhbW2v9GmTsyrp165bGcUmZTMabN2+UPyvv3r3TKNoCnD17lgcPHqilz2kiMjJSxROrT58+GsVnAwMDxo8fr/zeGBsb50oHXkZEoUnks0IQBAbWc8LRtjTjTx7jZUy08j4TA0PWd+xK47JpSQ/zWrRietPmHA18xJ77d7n79g0ATqXLMLuAdDKlp2bJNMW9VSV7rM3MiEz3ScnJp4FcCQlmcpOm9K/jiOEX5ntRxqowI+o3ZM1t9Uja/IqzcTGip10gIurjL+IlyRLMVt2h/JR6vDAvWGJbbmEiFUgxkGEuM0C+La2N+oVvCOYPQmkzpBFnHaRid1MOqFS0KJFvRKGpINCvWiomBOu7DI6/Vjcl1UZwVCSXQ4K/6K5cEc1YWVmRkJCAm5sbgwYNwtbWVuuFkomJCUFBQdjb2wPw9OlTrWstLCyQSCQ4Ojoyffp07OzsSEhIUFsnCAL29vZERERQPAtPzKCgICZNmoS/v79KF4u20bmM3Qfa8PX1Zdu2bUrh5unTpzg6OtK4cWNAc9JUQkICkZGRREVFKUURbejSSfLrr7/SrVs3pk+fDqR9rY8cOaJxP6lUqqwVwN7eXu0Cv2vXrnTt2pWTJ09qjXtXMGfOnEzvz8jq1avx8fFRpunNnDmTVq1aaRWaMpJZ90+XLl3w8PCgW7duQFr31o0bN2jXrh0TJkxQfi/8/Py4d+8edevWZfz48QwePJhevXppPadUKiU2NlYpBsXHx2usoU6dOoSFhWXp8bN06VK6detGrVq1kMvlPHr0SGUsND2enp7ExMSwbNkypcG4pk43BdrS4DKi6+sb0rqPFi1axJAhQxAEgS1btlCsWDGkUqlaF9S4cePo3r074eHhzJ07l+3bt7No0SK1PRWic6FChTh27BgjR45UG68rUqQIhQoVIjU1NceCMaSNt06cOFHt+NSpU3FycqJz584IgsCJEyc01gppYq4uIhOkPbcHDx4ofeIeP36sVWyrUaMGz549o3Llyjo+m+wjCk0inyV1bWw52rc/P549jd+bMCoULcpwp4Y0q1BRZZ2FsTHf1KrDN7XqEPDuLfse3MeogH5yWuP//3CaGBrStVoNtvqrzlvHSVKYd+kCBx4+wLNla+raaP7E6XNlVING/B1wj/cJ2uOzDQSBoY71MTE0Yp23fjraTA0NcX1uwIuVJ8jNV2JsRCxlNwQSO7YKkUaa3yh9rhjK5DRY94yiDcuBsQGBr/5n7p+SJOHZH9dp0bAiz3qWI+QL6G6qkGRMjQsfEAqZgJUJqZaGJFsYkmhmQKyJjBhTORGGqSRr9slVQUwGy//YF5az9ysfrA3Ux4T0wfEQK0C3jiaAbf6+otAkosaePXswNDRk+fLlrFy5ksjISPbv369x7Zw5c3Bzc6Njx45AWreOJi8nSOsYSUlJYcWKFcyYMYNnz56pjSkpsLS0xMnJiU6dOql0cGQc2Ro+fDijR4/m2bNnHD9+nNWrV1OxYkWtz00qlbJmzRqePn3K6tWrCQoKIiQkBA8PD5V1v//+u9Y9MnLo0CE2b97MzZs36dWrF5s3b6ZRo0Za1+vaSVKjRg0ePHjA48dpthXVqlXTarJeqlQpNm3axNChQxEEgW3btlGiRAmNa9u3b5+lKbuC6OhoZs6cqfQxatOmDQsWLNAopClEJsW/M/sblp3uH0U8vIKuXbuyePFilixZolK/Ij7eyMiIhIQErKystHbiQZoPj4uLC99++y2CILB3716NxuGzZ8/G2dkZR0fHTNPsXF1defDgATdu3ADS0vK0eXYpXm9FihTRyZxekWymzYj6/fv3WFpaYmFhAcD169fZt28fVapUYezYsRoFke3btzNhwgRWrFgBpPkwbdu2DYlEwvbt21XW9u/fn8qVK3PkyBESEhLYtm2bstsvPem7jgwNDdm0aZNG0dLQ0BC5XI5UKtX6ms5Ieu8mxVhgbKz637sBAwbg5OTExYsXkcvlTJw4US1EQDFi2KRJE77++mv69Omj8r3VlP63cOFC3N3dcXJKS2718/PT+vvr3bt3ODo64ubmpvL7S9sYZ04QzcBFRDJw8mkg353QbMaWn2ln78Dq9p0wNDAg4N1bOu9VT29QIABLW7elV83aeVdgPuBVTDTLrl3h2BPNPl7WZmZs6dqTcoWLsP3uHY48fkRwVGSe1VfOwooy258SfjX3Eh8yUr5BRa73s9VJRPhcsEs2xnT6lSzXmZibYDe0EWfsU+Ez7W4qITGkytrHvA/O2qvHzNIUy2KFMC9miUXlYkTULMydYilI0r12SphbEJ6o/mm/iD6QgwZ5+lK3AMqaqKcE6YMncXVof6JJth93pv9g7IuJSaoi6rx58wZBELCxscl0XWBgoDJBrW3btsrupo9h3rx5Go9nvGhVGAorYsTlcjkeHh5aOzvGjh2LRCLh6tWrPHz4kKioKNq0aaPRLFlX2rRpw9ChQ+nRo4dOHj6tW7fGw8NDpZPk7NmznD59moYNGyrNo2/fvk2tWrWwsLBg37593Lp1ix9++EGjd1VQUBDffvstfn5+CIKAo6MjO3fu1Pi90MWUXUG3bt0oW7YsI0eOBGDTpk28ePFCGQevoEePHtSoUYPvvvsOQRD466+/8Pf35+DBgxq/Bjdu3KBHjx7UqlULSDNaPnTokLJjLD1169blzz//pEmTJsrHjh49Gn9/fxUD7nbt2rFnzx5WrFjBlStXKF68OLGxsZkKOSdPnuTcuXPI5XLatGlDu3bt1NY0bNgQFxcX6tevryKKZBSlXr58qRzpu3btGnfu3GHQoEEaBbTo6GhmzJjBuXPnshTwFF+fzIyomzVrxubNm3FwcODJkyfUr1+f/v378/DhQxo1aqQyUpcTdE0qTE1N5ffff1cRJsePH682igcwa9Ys/P39s/RLU5A+IMDIyIgqVarg6empMakwPUeOHGHu3LkqpuwtW7bUul4QBM6fP6/xvvfv33Pz5k3kcjmurq5axdy8SEAUhSYREQ08i/zAv48fcTTwEc+jIildqBBhcfnf+HZwPSdmN2+JIAhsvuPDwisX0fYDPqpBI6Y31T4X/jnjGxaK5+WLhERH0q16TdpXqUp4QgKPI97zKiaGMQ0bU7GoNcuuXWazny+pWlqlc5PGJsWImXEBSS6MymVFla9qcbpdoS9mVMwxyoTYuZqTQDRRoXFlnvQoy0uzz6u7yUIq0GjbK17dfZnjPcwKmVGueRXialtzxyaVeEM55QoXURlTFsl7HIrI2NvmFn6R9gw7VwKF4DTRMYnxVTW/mdQHvwWOYY1f9n+fDqjryLwWrT5BRSIFlbt379KvXz9ev36NIAiULVuW3bt3U6dOnY/at0OHDuzYsUM5DhceHs7gwYM5duxYjvd0dnbm5s2bNGnShD179mBjY0PNmjWV6XQZUQgTTk5OygvPevXqqXj1QNqF/cKFC9WSxnSJXs+K0NBQJkyYwIULFxAEQRmBXqJECZ48eaL8OterVw9fX1+ePXtGhw4d6NWrF76+vvz3339a946Li0Mul2dqPFy7dm2lKbufn5/SlF2Tl49CwMvq2Lt375gwYYJKgtvvv/+eaQR8ZGSkTt0/V65coV+/flhYWCAIAvHx8ezevRsnJycOHDigvHhXdMfI5XJ2795NZGSkVqEnO9StW5e7d+9mua5+/fpcv36diIgIXFxccHNzIzU1VWM3oK4CnoKWLVsyYsQIFSPq9evXKwXVWrVqKX2kPD09CQwMZPv27SQmJtKoUSO18TUFuna26ZpUOGHCBIKCghgxYoTyeVWqVEmlIy39c8pIZiJPVty8eZOhQ4fy4sUL+vbtqzTufv36NZ6enhoNvrOLn58fDx48oF+/fkRFRZGYmJjpSGVqaqpGkS03EEfnREQ0UNm6GJNcmjDR2ZXQ2Fh+u3mdAw+zNtnTN1v971DayooR9Rsx1KkBZQsX5vv/TpCkwfQyRfrlxt3XL12GA1/3RSKTYZLuk592VRxU1rV3qMaxJ48J1dD2mluYGhrSJNiAkBW5OyqXGU9PB9CuRENONv4y/gQUiZNnY1AHQm49w+r+a1oPacj7UoaYJYNZshzjZBlXKkkLZDeYoUxO0yMfePYRIhNAUlwST07chxNgZ2JEhSb2CC0L81IMNdQbPexTWdzwKIbyd7gX9+dK96Z0PVETEwOBsdVOovXTBj1gYxbLjw1NKW4aRzHTaCwME/j7eSOOPI3LtMwDDwOY7NqUwqa6+VSIfP4MHz6cOXPmKFPX/vnnH4YOHaqx6yc7HkmhoaEqnkslSpQgNDRUax0HDx5UuwjOODrn7u7Ohw8fGDduHA0bNsTU1DRTX56MfixSqVSjL8/XX3/NwIEDGTp0aJajPeHh4cyfP1+tVm2iVJkyZfjnn3803pdezDM0NMTQ0JCTJ08yZswYfvjhB5ycVJMitUXBK8g4MgTZM2UvX7484eHhys6N8PBwlc4SBQYGBuzdu1flWGbm1gDW1tZau1fS06xZM4KCgnj8+DFyuZzq1atjYmICqHaILF68mFmzZiEIgjK9zNPTk1mzZqns17t370zH+jKONzVt2pR79+7pJLSamZlx/PhxRo0axaxZszSai0Paz016UWnVqlWZ7p+VEXX6TrobN27wzTffAGnjhNo807R1tqUXmrKTVAhw8eJF/Pz8lKN6nTp1on79+hrPnx0/KQUKo+/04m/58uUBmDRpEuPGjaNly5bs378fZ2dnunXrxvnz55VjlRn566+/6NWrF8WKFQMgIiKCgwcPKoWy9Pz555/88ccfxMXF0a9fPyIiIhgxYoRGYUwhRkVERPDy5Ut8fHzYt2+f1uTKnPBlXGWIiOQQQRAoW7gw1YqXwMzISKNgk99YfPUyNpaF6FKtBm3tHdjd42tGHD1ERKJqp4zkCxaaIO17a5LFG7N6NrYc7TOAH06f4FJIcK7XUM7CitI7n/Li8vM8E5kUBO72pkGV5vgU+/yT6Myis/9zm5yQzPO1ack/6XsZPfo25KRzAfvTKZfz1cUkAi8H5uq2qSmpBF18DBcf03Z0E/6rJk3LrxfJM5Y0jaFn2X8Q5P/rvittfI0rXUOJkJTFUK7ZbFhf9C2vPtLdyPoyo6rWYeHddlx9FaPxcQkSCfsfBDDMKfPxA5EvB5lMphSZAHr16qX1Aik7HkkymUzlE/6UlBSSk5M1rp00aRJBQUH4+PjQt29f9u/fT5s2bdTWKYSnfv360axZM6Kjo6ldW7t1Qd26ddm1axdyuZzg4GAWL16sMZnM2NiYqVOnat0nPUOHDqVp06acOnWKFStWsH79ejVBCFSj5zWRUXRJTk7mzZs3HDt2jCVLlgBpwlh6FN5YmhAEQWNnly6m7NOmTQPSTJ3r1aunTIM7fvy4Mi0vPV999ZVad4umY61ateLcuXNqHk5yuRxBELSauBsZGVG8eHFSU1N58yYtYEghMCg4ePCgmqik6ZimZLvM8PLyYvPmzVSrVk1FqMwoJCYnJ5OcnMyZM2eYNGlSpnvqKuApyMqI2szMjLt372Jra8uVK1dU0twSEzV38+/YsUPZ2XbgwAFlZ1t6spNUCGnfR5lMpqxNLpdrTXyDtCTF9GN23bt317p269atTJgwAWNjY+X+6V8ziYmJjBkzBkjz1Vq3bh1//PFHpkLxunXrlF1lAMWLF2ft2rUahab169fj5eWlHOG0t7fX+nr97rvvWLNmDePHjwfSur8GDRokCk0iInnN8PoNaWvvwM8Xz34SwSG3mXrmFCUsLGlSrjyOtqXZ37sv7XdtJ1n6vwvuL7mjKTtYm5uzqUsP1t724jev67nWHNDYpBgx0y8QEam/xK7i4alQTG+nzzMMPiRlvUhHAvd4U9/BHd9imi888iPt/SDwX/8s130MT/+8Tvu+DTnZyPCz9bfKT1gYyTnQ/hkO5poTUk15ThnjT+f1lts4FLrHzLoC7V+5al2zw/8Og+s5fXGpqSKaqVu3LleuXFGa/V69elVp2pyR6OhovvnmGzw9PalTpw7r16/Hw8ODGTNmqK1t164dffr0UV6E//bbb1qFknPnzuHv74+TkxMrVqxg2rRpGhPMjh49SrNmzShatCjlypVTpl1pExNWrlzJ5MmTCQsLw9nZmS5duqh1SSlqPXXqlEbPnoy8ePGCf//9l127dtG5c2fatm2rMdUtM58cQRDUhKbvv/+e6tWr06pVK+rXr09QUJDaeNnz59n/XaSLKbulpSWQ1hGVvisq4wV4amoqKSkpyGQyEhMTlaJCdHS0xkTBnTvTBHFvb2+d681KYDhz5gynT58mNDRUKZApatBERp+crMabdE1869u3L7a2tlStWpUmTZoQFhamNOfOiDYBT1F/xtdkVkbUS5YswcPDg7i4OMaMGaM0mz916pTSxykjunS2ZSepENI82tq2bcuwYcMQBIGtW7dqfdz8+fM5fPiwcqRt4cKFBAQEqAmDChYsWMCtW7e0Pp+MhuelS5fOshtRkwimLf3QxMRErTNK2+smNjYWNzc35W1BELR2luUUUWgSEdGRckWKsLlLD44/ecz8yxcI1/DHKb8gkckYffwIf/fqQ/XiJdh4x0dFZAJIFoUmnTEQBMY3dsXRtjTfnzrBh6Sci0OmhoY0CTEk5Je8G5XThuH7JKhqoucqPjFyOdF3w3J1y9TV3nzVpx5XqshJNMxHc0kaaBVkSOC2a3lyrsA93rSLqs251oVUDMNFcpca1nL2tr6KpZD5OEpBo4rlXWwtPXgTr/n364uYaO6+fYNTaXWTYZEvD19fX7Zt20aVKlUAePr0KY6Ojkqj5vSdHIqLJysrK0JCQrCxsSEkJETjvgsXLmTRokX88MMPQFps/fTp0zWuNTMzw8DAAEEQkEgk2NjYaEwQmz17ttIMGqBo0aLMnj1bo9AklUpZsGAB69evZ/369Zl+DVq1akXXrl0xNDTE1NQ0044bxRiXqakpHz58oGjRokrT5vRkd1Ro+PDhKuJapUqVlKbrmpBKpYSEhKiM72kanVN0fFlaWrJhwwaNe2lKCtPEwoULmTdvHoIgKMUpSOt4mTx5stp6hZ+NlZWVclxJQVBQkMZzZCUwmJiYUKhQIbUaSpcuzU8//aS1dl3HmxSJb1kxa9Ysxo0bR+HChREEASsrK60jklkJeBlp164dDx480GpE3bx5c96+fUtsbKyKGNmsWTMVwSM9unS2KWjfvj03b94kKChIZWwto+/RsmXLWL9+PQcPHkQul9O9e3eVjqH0/PPPP3h5eSnFuBEjRuDq6qpVaCpZsqTW1wCkdXmlN5PPeFvTKGvp0qU5cOAAPXv2BNI6rGxtNSeHlyxZksDAQGUn3o4dO1TSI9NjZGSERCJRrn316pXG5L+PQTQDFxHJAdFJSSy7foU997M23tMnxgYG1CxZCv+3b9TuE4A2lasw1KkBjcqUFWPKdSQ0NobxJ49x5032xQvFqFzE5fzRaVDJzYGzvT7vJKc6MSYk/Ky7EXh2sCpuhU3vOlxxkJOgo+BkIhUwkwvEGH16g/kmb0x4t/RKpi3hn4JKTarg1aMkcUbi24vcpl81CXMdj2Agj9B3KZ+En/x+YH9gvNb7t3TpgXtF7aMbIl8Oly5dyvT+9Bfe06ZN48cff+TUqVNMnDhR6ZGkaxeINjw8PDh27BjTpk3jw4cP2Nracu3aNW7evKmyLn3qmAJN5t4KWrZsqZPgU6VKFZYsWaKWNFahQgW1tQMGDOD3339nx44drF27liJFimBvb6/mWZSet2/fEhAQoCIKafIr0tWs+eTJkwwfPpyIiAgsLS2JioqifPnyGjueFGl3Gdm8ebPasdevX/Pdd98phRg/Pz8uXryoNho2ZswY/vjjD63PNyOVK1dm165duLqmdVru27ePKVOm8OLFC7W1Li4ueHl5Zbmnv7+/Vk8kTbRs2ZIFCxYwfvx47ty5g1wup06dOkrj7OnTp7N06VKtnk4KL6fnz59TqVIlrX5ZmsS+/MD9+/epVKkSCQkJzJgxg8jISGbNmoWjo6Pa2rFjx3Lq1CkcHR2VPw+CIKj5WWUHXY3mFeLXmjVrsLCwoF+/fiojjAqhKju/txQ8evSIrl27KkdSTUxMOHLkCA4ODmprnz59Sr9+/QgICKBkyZJYWFhw9OhRjcmOO3fuZO/evdy9e5ehQ4eyfft2Fi1aRJ8+fTKtMTuIQpOIyEfgHfqamefP8ORDwX7TX9fGlh+bNsfFTrPqLaLK27g43Lb8hTQbvz4bmxQjZuYFJHoclctI8XLFuTVZ/Q/V50T7y8kEHryT9cKPwKq4FaV61eZaVYjXIjiVSDGk4cNU3h59QOEyRXnVpyJBFp8u1a5elAnJi28gSdZPcl6ZWmV5NKgi703EzsncQc5vzaPpaHsAgfzvFZhTjoT2ZvJV7fO8hYxNWN2+kyg2ieSYly9fZuqRpKtoAWlCTNGiRZHJZKxcuZLIyEgmTJig5svTvHlzli9frhzt8/LyYsqUKVy9elVjDStXrkQikTBkyBCVSPWMI06KNLvscvXqVaKiomjfvr3WsZ2tW7cyb948IiIicHBwwN/fHxcXF7WatZk1Hzp0SG3P+vXrc+jQIbp168adO3fYuXMn9+7d0+gJs3btWuW/k5KSOHDgAE5OTirHFXTq1Ik+ffqwfPly/P39SU1NxcnJSU0MgLTv79WrVxEEATc3N8qU0d4heePGDQYMGMCIESN48eIFN27cYN++fcouuvQsW7YsU4EhPboYyCto2LAh3t7eKgmE6f999OhROnfunGVUfadOnTh27JhGj6WMPln79++nd+/eKsba6dEkIkLaCNykSZN49uwZUqlU2WGX0bMrJ+iSjObg4MC9e/fUzPQzokmUK1KkCK6urgwePFilq2fYsGFIJBJGjx6NIAjK7rqMgqeiszG9rKK4nRtfA6lUyuPHjwGoVq1apuN2MplMaUpfrVo1Dh8+rOyGysj169c5cuQIcrmczp07K0eRcwtRaBIR+UhSpFI2+Hqz+taNAu179EfHLrS1/7xFh9xk7PF/ORX0JMt1JoaGNA0xJOSXy3oflcuIIAiE/OL82Y45mUsF7OfeITE29zyaMsOqWCFK9arDtWr/E5yqxZlQ+VY0z07eJ1Xyv98PBgYCVXo4cdvZnHDj/x03lMmpkmhKmXAZEhMDrpbOvlm7fbwxlst9iI/S73hvifLFeTOmJiHm+hG7PhcKGck53OEJFc2yn35TkAhOqMawKx0Jidbe0QRgKAj80bELrSurX+yJfDmEh4czb948tSQ5TaMn169fV5rjKlBcTGckO6LFo0ePMh2TUXDjxg169OhBrVq1AHj48CGHDh1SGZlJT/oL3cwuVpcsWULRokX5+uuvsxQ3skvdunW5dOkSHh4e3Llzh8uXL7N9+3Y2btyosq527dpKs2Y/Pz+lWfPff/+ttmeDBg3w8fFR6Qhp3rw5ly9n3XWckJBAr169NJqVZyXGKDhy5AjDhg1Tjmldv36dTZs20blzZ63n9fb2xtXVlVKlShEQEKDmP6VA1++ZNgP5TZs2adzXxcWFK1eu4OzsjK+vL69evaJr1674+PhorfljmTNnDvPmzWPIkCFq9wmCoLGrDKBq1aqsXr0aV1dXFSEk/ahgdgkICODbb7/VKRlN19fSd999h6+vL3379gXg77//pkGDBgQGBlK1alVWrVqlXBsfH8/8+fM5d+4ccrmcNm3aMHv27I96TjnhyJEjPHr0iOnTpxMaGkpERIROCYOQZuquqQsvLxA9mkREPhITQ0O+a+RMR4eqzLpwlusv9fPD/DEUN7fAo2JlfZdRoOhXp16WQlM5CyvK7ArixaVn+U5kgjSDwXIpxjz7TIUA5zAjXuaRyAQQ+yGO2L9uUKWYJaU71UISGEGwVxCast5kMjmB//hic8qMRt3rQLKUpCcRhD0IRZIs4QVpYlT9Wc2VxuPGUrIUBW2TjSi27j4f9CwyAYS/iMD6Fz8KTXIiwOrzTzf8FNQrIWOHx2UseKzvUj4pD2PrM+iCGx+SMheZAKRyOa9iNKfTiXw5KFLU/vvvv0xT1CDNo2XUqFFMnToViUTCxIkTuXnzpkah6c2bN/Tv358VK1YAaT4m2jop2rVrh4ODA+PGjaNLly5aLQhcXV158OABN27cAKBJkyZaBQuZTMb169dxcXHJ6kugNDMfO3asVnEjY3KagqwS1IyNjbG2tlZ63TRv3pwff/xRbZ0uZs3p9wSws7Pj6NGjVKhQQaNPlCbMzc217mtkZKTSSRIZGanRLHnevHl4eXkpO5KCgoLo3bu3VqHpwIED/PDDD2zfvh0fHx/c3d3Zt28f1apVU1urzZw5I7oayCsYN24c3bt3Jzw8nLlz5yrHmxSkNxbXhKJTSpuvkYL04uS8efMA2LJlS5bPJz2FCxembdu22XpMVowbN07nZLQmTZrw9ddf06dPHxXhNeO45927d7l48SKmpqYAjBw5ks6dO3P8+HG1kTxLS8scpbApDOgVfIz4O3fuXKX31PTp0xEEgdGjR3Ptmm7+mxl7iho1apSpXYomsT6niEKTiEguUbGoNTu69WLSfyc4GvhI3+Vki541amKcReqBiCpVi2fubaRIlQvPR6NymigZK/DMPOt1BRHDq6F6OW/ch3iebNftD3VSXBKBO25rvE8mkyNb60v7ZvZE+r8mPiIOi3GNuFlKs2hjlWpAla3PCHsdmePac5vYiFhMF9+k8Q/O3Cohik3ZYUjNFH6qcxgDef75fn4qipm8J1mqu29Z0SxGI0Q+f3RNUYO0C6fBgwdz4cIF3r17R+PGjbl+/brGtbqKFgDPnj3j0KFD/P7770yaNIkxY8YwbNgwimd4f6Donkp/wbt8+XKmTp2qtqeBgQETJkzQ6WJPF3EjO8lp6VGYiyu6VCpUqEB4eLjauuyYNU+cOJHIyEg8PT3p06cPUVFRWn2y0gsoUqkUb29vrT5CvXv3ZvTo0cTGxrJ161bWrVvHsGHD1NZJpVKVsTd7e/tMv4YLFizg7NmzODg40LdvX44dO0bbtm21Cl6QtcCgq4G8gv79+1O5cmWOHDlCQkIC27ZtUxlv0rWzRmFErmmQKaM4qalrLD2afLoAOnbsmGmaooKkpCTWrVunNj6oyUspO8loijHS1atXq6zPWO+7d++U5viQJoC+evUKExMTpfi0ffv2TJ9DRoNxBbdu3WLYsGE8fPhQ5Wv9MaNzhw8fxsfHh4YNGwJp5uCxsbE6Pz6jqPTLL78AcOzYMQIDAxk6dCiQNi6bHf8wXRCFJhGRXEQQBBqULsOJJ4+z5d+jb3zCQolOSqKI+OZdZ2KSNcfbmxga0vSFISHL9Z8qpwuFo6VQSt9V5C41Y02ocDOKQC/N6TAFidiIWGIP+ylvJyy6TNthLvxXSw4G/3uFmUgFGu9/Q/BD/YhrmZGckIxk8VVaTGzKxfKfZ/dc7iLnjxYfaF3qEIK84I5jZwcb05dMcExk8W3d3pZOPXOK32/eoGJRayoVLUrFotZULGpNozJlMc/leGaR/ImuKWoAxYoVY+DAgQwfPpxChQoxYcIE5QVlRnQVLSBNFOrZsyc9e/bk9u3b9OzZk7lz5/Ltt98yb948pf/P0qVLuXDhAr/99hvx8fEMGDAAQKPQBFCjRg2ePXtG5cq6dZpnJm5oMgZX0LRpU61dEZ6ensTExLBs2TJGjx5NVFSURs+edevWkZKSwooVK5gxYwbPnj1TibRPj2JUqUGDBjx5knlHeHoBxcjIiDFjxmj1mZk8eTJ79uwhKiqKEydOMGHCBPr376+2rlSpUmzatImhQ4ciCALbtm1TSUXLiJeXl0pnTKdOnbReiOsqMFhZWZGQkICbmxuDBg3C1tZWq3AilUpxdHTk3r17aqOfCnRN3tO14wrSRFBtaBJuFKxbt46IiAgKFSqEmZmZ1q65ESNGYGVlxeXLl5k8eTJbt26lefPmGvfMTjKaromJ7u7udOzYkQEDBiAIAjt37sTNzY24uDjl74WjR49qfO7e3t6EhIRoFZomTJjAxo0bGT16NJcvX2bVqlWYm2v+NFfXBEYzM7NMPZkArX5acrmc+HjVTmGF4fjcuXM5f/688mvbqVMnWrdunel5sovo0SQi8gnwDn3NhJPHeBMfp+9SdKZ6iZJs7dqDUpaFsl4sgm9YKL3278FQEGhV2Z7TQU+xs7Ci7K4gwi89y3qDfELVr+tzsolJ1gvzIaVSjHB6KiXVwpAkUwMMpXKMLr0i5Hb+SPX7lFRpXZOr7YsQbyhHkMlp+18cT/4L0HdZWVL05+b4FBM7mzLjWMdgqlv+p+8y8hyJzIiu5ycR+EH3T2oz0qJiJVa360RwVCRPPnygdKFCOIshF58l2UlRmzBhAteuXWPfvn08fPiQcePG4enpqVGMANizZw+HDx9GLpfTpUsXresgbfxq3bp17Nu3j06dOjFixAjOnj3Lzp07uXs3LZk4JSWFH374gWvXrhETE8OoUaMyHXlq3749165dw83NTcUMPGPHx8d2T5QrV46XL1/qtDa30CV+/lMRFBTEt99+i5+fH4Ig4OjoyK5du7QKetkxhndxceH3339XExh++OEHlXVv377F2toaqVSaqYG8gvbt23Pw4EGtYoWC2NhYZsyYwdmzZxEEgTZt2uDp6YmVlZXG9bk52qUgJCRE4/GMYqfCo6tu3brcvXuX2NhYevXqxX//qf/dy04ymlQqZc2aNTx9+pTVq1cTFBRESEgIHh4eKuskEgl//vknFy9eRC6X07JlS0aPHq1V8AN4/PgxP/30E3fu3GHBggVafydo8iFr0aIFFy9eVFmXnQTGb775hvHjxzNhwgS8vb1ZtGgRDx8+ZNeuXco1mvy00qNpDNLBwYG7d+8qX1sJCQnUq1cvSxE4O4hCk4jIJ+JDYgKTT5/kUkiwvkvRmfKFi/Bf/8GYZpHsIALXX77g6MMHDKxelxrlyzB12z88mHKUlAj9e+Nkh8rNqnKmp/aUp/yMgQwclzwg+t2X6ddiXcYa68olkKXKCC4g3Vv27tU43d1a32XkawZWT2F23R2fdbqcNt4l25EgtaS48Vt2vujNCh/Nn1zripGBAb9+1YGOVdU9VUQ+H7JKURs5ciSrV69Wdiu8ePGCvn37auzmOXXqFO3atcvyGKR5NAUGBjJ27FiGDx+u4rtUu3ZtZQQ9wIoVK1i1ahUymYwdO3bQokULrc8nqwQxBbqKG9rQZBKsq+ePglevXjFq1CguXLiAIAh4eHiwbt06ypVTF3jHjBnDf//9l2n8fGaJZ4IgULx4cTp27KjS8TRkyBCNnjPpTas/fPhAcHAwDg4OyhEybSKMguwYw+sqMCQlJWFqaqqsVyaTkZKSojUpbeLEiVy7do2vv/5aRXTMmPw2YMAALCwsGDNmDAB//fUXsbGxat1l2REntRlra+s+AkhMTOTu3bsIgkCdOnU0CmSNGzfm1q1b1K9fn6tXr2JhYaH285IeXZPRxo4di0Qi4erVqzx8+JCoqCjatGnD7dua7Ql04c2bN/z8888cO3aMadOmMXbsWJWxu4wokiBbtGjBb7/9hp2dHY0aNVITkLKTwPj27VsGDRrE+fPnMTAwoFmzZuzatYtSpT5uHGHWrFkcO3aMb775BkApli9YsOCj9k2PeDUpIvKJKGZuwaYuPQiLjSVFJiVFKkUilXL8yWPW++T8l96n5EVMNDEpyZQUhaYscbUrx7vDAUzqMIkekzrRsnpZ/AqYyAQQ8+IDUDCFJpkB2LSuSvTunHlQFHQiQyOJDC1Y/j1Blx5TqW0znluII3Ta2P7IhLoletGtjHpnxudOKdP/jT6Nsd9AinQMq/10H/nISKpMxoRTx4hLSeab2nVzo0SRfEh6DxdN/PXXXyq3y5cvr/UiesaMGWqikqZjAMOHD6dHjx4aR3nSXzR37dqV1NRU7ty5Q3BwMP369aN///7MmjVLYw0KQSmrSHeJRIKzszOpqalYWVkxc+ZMWrRoobPQpAmFgPP06VMuX75Mjx49ADh06BBfffWV2voBAwbQoUMHdu/ejVwuZ+PGjQwcOFDjGNPZs2d58OBBpvHz9+/fp3fv3lrFgXfv3rF27VouXbqkPKbwroE0IefAgQMqxvD//PMPgwYNolChQqSkpPDvv//qFOOeHWN4hXBWvHhx/Pz8sLOz09jh4+HhwcmTJylSpAiQ1onUsWNHrl69qnHfmJgY6tSpw8OHD5XHNIlqd+/exd/fX3l73bp1Gsf8sjPaNXnyZOW/k5KSePz4MbVr18bX11fj+uvXr9OrVy9sbGyQy+W8f/+ef/75B1dXV5V1xYoVIzIykg4dOtC+fXuKFy9O6dKlNe65efNmhg4dqjI6qDim6fx+fn7K733RokVVurbSP5esPKJiY2NZvHgxGzduZOTIkTx69IjChQtrrDE9ffr0ISIighkzZtC8eXNSU1OZP3++2jpBEKhQoYKys69///5aBTwbGxtOnTpFQkICMplMRXD8GDw9PXF2dlZ2dnl6etKxY8dc2VuBeDUpIvIJMRAEymb4xSQAd8LCuBX6igaly1CtREn23r+LLJ80F8anpFDSIm9jOwsa8TEJhD59w6kt55HJ5Fzaf51dwX9gW6kUa8Zt5OXj/OeTo40PLyMwklUh9eMaB/RGSM2Pb/cWyVuqByTyvJH49iMzplwtQrWO7ahheUrfpeiVCQ5/UKlQL94nFyEx1Zjf7mT/76Qc+On8GWJTUhhev2GW60XyN61ateLcuXNqaWpZpagdPHhQ7cIyfXfO06dPCQwMJCYmRsUMOTo6Wqu5da9evZBKpTx79ixTnxVnZ2dlQlyxYsW4detWpkljDx48oF+/fllGuitEj8zEjcxS56KiotSOKzx/2rdvj6+vr9LYfPbs2UpvqfRERUWpeE1NmTJFZaQnPaVLl85UZALdEs/atGmjcvu7775TuT1mzBh69eqlvO3p6cm1a9dwdHTk7NmzzJ07l3PnzmVaB2TPGL5v3746CQwJCQlKkQmgSJEiah466dE1+U0qlRIbG6vs0oqLi9NYa3bEyYxi361bt7R22wH88MMP7N+/n6ZNmwJpws/333+Pl5eXyrrjx49jaGjIggUL2LVrF1FRUVrHJ9esWaMmKmk6Bqi9tqRSqcavgS4eUZUrV6Zw4cIsWrSIMmXKqAmB2nyqvv/+ewC++uorIiIiSEpK0tg5l90Exn/++UdlLFIhAH8sHTp0oE6dOlSsWDFX9suI+E5PRCSPqVXKhr29vuFdfJzSD6lbtRqMOHqY6OS8i2LXRpwG9V9ElR3z9uPkUZsgv2AA6req+///r0PxMtYFSmiSyeTYpZgQbFYwv+8PLJNp4mDL2ydv9F2KiI6kWpsCX4bJ9cfQ42R5bvRwoqjBHX2XojcEAbqU+Ud5+78XU3gYkTMPp0VXLxGTnMxEZ1cCI8LxDgvFybY0tUvZ5Fa5InnAzp07geylqU2aNImgoCB8fHzo27cv+/fvVxMrrl27xtatW3n79q2KGXLhwoWVHS0Z0dVnRSEypd9TU8KWgu+++06nSHdduidymjr38uVLlfS8YsWKaezQsbe35+nTp8o0t6dPn1KrVi2Ne+oaP6/A19dXTRwcO3YsZ86cybR2c3NzlWQ4hR8TQOvWrbWasGdEkzG8JoFDJpPRpEkTihcvnqXAIJPJiI+PV3aOxcbGIpFo7/BNTU3l999/VxEZxo8fr9ZZNXDgQFxcXPj2228RBIG9e/eqjVqC7p1XmmjcuDETJ07Uen9SUpJSZIK073f6713GGgRB0Op15O3tzc2bNwkPD1cZo4yOjtbYpQRQt25ddu3ahVwuJzg4mMWLF2vsEvLz81N6RI0fP57BgwerCJMAtWrVQhAEjaJpZobouo4bZjeB8cKFC8qv1dKlS7l16xZLlizRuF5Xrly5Qt++fTEwMODFixfcvn2bVatWaTXzzwmi0CQioifSm243LFOWpuXKc+JpoB4rSuNR+HvxjXcmBAe85OLf15BK/neh/N/WC8R8iGXC2uEEXHusx+pyRqlYCC6ogYOCgFXLSqLQVIAIKmuAKDRljUQm0OVkI851CsdYnreGvfmVlnaJPIzI+ePX3PZi0x1vEtMZEXdyqMb3rk2pVNSaFKkUIwMDDDR0gIjkDxQjNpmlqWXk3Llz+Pv74+TkxIoVK5g2bZpaR9GgQYMYNGgQmzZt0poyl5GZM2dy/fp1NZ+VjGQnzh10j3TXpXtC09cpICBAqxikoEaNGgwfPlz5tdiyZQvVq1dX3t+7d28EQSAmJoZ69eop67127Zoy1SojusbPQ9rF9N9//82LFy9wd3fnzJkztGrVSs2bCFR9paRSKd7e3ipdZXK5nMTERGV3Usbb2oyw06fZnTx5kokTJ/Ltt9+qrTMwMGD8+PHcunULSOtW0WYs/e233/LVV18pvZT++OMPjYKQgh9++IGgoCBGjRoFwKZNm3j+/DmrVq0C0kbrPnz4wLRp06hTpw7nzp1DLpczatQojSKOrp1XkNZZp0AqlXLz5k1iY7UL/RYWFpw9e1aZXHbx4kWVr+2AAQPYsWMHjRo10thlp/j6QZoRu7e3N/Hx8SqdVYULF2br1q0az79y5UomT55MWFgYzs7OdOnSRaPnkWJU0MjIiISEBKysrHj9+rXKmozeWrqi67hhdhIYjxw5gp+fn7LukSNH4ujomKnQ9PbtWwRByNTHadq0aVy6dEkpsjVq1EjrWGROEYUmEZF8Qj1b23whNP3qdY0ODtWwECOi1ZDL5aydsIkyVWw5t/uKyn03/vXG/2IAkpSCZ+Bb/F40NRsW4YllCpLME1TzJfftDSmoOtmXRjG7Ytw2SyFtiFgkK0LjBUZdaccmt70I5DyN7XOhpe0d1vnX+ag90otMAMeePObk00C6VKuBb1go9UuXYWnrthhpidAWyR/4+voyY8YMnj17ppJg9uyZeuqrmZkZBgYGCIKARCLBxsZG7cJSwbBhw3j79i0BAQEqopAmMURXn5XsxLmD7pHuf/31F7169aJYsWIYGxsTExPDhg0bGDFihNa9Ie2CP6sLyk2bNjF//nzGjRuHXC6nVatW/PLLL8r7O3XqpPx3evGlX79+WvfUNX4eYMeOHXh7e+Pi4sKBAwd4/PgxP//8s9q6+/fvc/LkSRwdHalSpQpGRkaMGTOGnj17KtfcvXuXQoUKqYzBKW4LgqBmhJ3REF2RCOfv74+/v7+aITqkCXPPnj3TmmCnYPr06dja2vLvv/8CaWN+maUaXrx4ET8/P+X3v1OnTtSvX1+l1jZt2lCxYkXat29P+/btgbSv348//qjsBlKIRm3btuXt27fY2dkpzfAtLS1JTk5WmuUrSO/XY2RkRJUqVTIdnVu1ahU9e/ZUmp0nJydz4MAB5f2KtL70ryNtdO3alU6dOrFr1y6dUwkLFSrE+vXrWb9+fabrsuMRlV2yM26oawJjmTJlVL43JiYmlClTRuOeDx8+5Ouvv1aO4ZUrV459+/apiMQKUlNTsbe3VzmWmdF5ThBT50RE8gm3Xr+iz4G/9V0GABMauzLJpUnWC78wLu27jmefX7GtVIo3zzX7QBRkjIwNsa1RBguHEiSXL0RocYEnFslIDfK/KOCx+x0ht9QvMETyF1W7O3LSXZQFs8uYOsn8UGM7Ajk3xv4ckMnB5dhEPiR+2jHzrypX4fd2HcUE1nxMnTp1GDduHK6uripJc5o6dTw8PDh27BhTp04lMjISW1tbrl27puywSc+2bduYO3cuERERODg44O/vj4uLi0azZhcXF7y8vGjfvj1jx46lQoUKdOvWTU3syk6cO+ge6e7o6Iifn1+WxzLi5OTEnTt5N5L7/PlzKlWqpNIhk56MnlaQZvDt7e1N3bp18ff3RxAEZaKXgnXr1jFz5kyqVq3Ko0eP2LJlS6541xgYGNCoUSPatWunUeBT+Filp3379ly7dg03NzcVs+bMRiR1oU6dOty5c0c5KieRSKhfv76yc65mzZpav67pk9wqVaqkdr9CyJRIJMTFxbFixQqNo4HZQSKR8PjxYw4dOoSjoyOdO3f+qP2aNm2qMR0yPdeuXaNp06Yq3mrpySgSS6VSDA0Nkcvl7N69m8jISAYOHKiT2XdOcHV15caNGyrHdElgVPD999/z8OFDZefbjh07qF+/vtIgPf3za9myJSNGjFAKvnv37mX9+vUaRd5mzZpx8uRJmjdvjq+vLwEBAQwfPlyt1o9B/AsqIpJPqFWyFAaCkC9Mwdf73KZ3rdqUtfo0v3QLIolxiayfsh3gsxSZAFIlUl7dfQl3/zem42BqjG3NMpg7FCfRzpLXxSHIXIIsn33Yb+pQDEShKd8TW7UwUDD9wPTJH/dMsTTuz+Aq1zHjqb7L0RsGArS0M+JA5pMGH83pZ09pvPFPyhYuzPG+A5DJ5RiKHU75CkNDQ+U4UVbs3buXyMhIfvzxR7Zv305UVBT79+/XuHbFihX4+vri4eGBj48Ply9fZvv27RrXavJZ+f3339XW6TKqk57+/ftTuXJljhw5QkJCAtu2bdOYkqapV0CbWXV6Muum2r9/P71791bxxUlPxtE1XcYCx40bx/Hjx1U6ZARBUHYUaepCs7CwQCKR4OjoyPTp07Gzs1MzZV+3bh337t3Dzs6Oe/fuMWbMmFwRms6ePcuWLVvYvXs3X3/9NUOHDlXr/MhInz591IRATQwZMkTj2NjmzZs1rm/bti1t27Zl2LBhCILA1q1bVRIQ04usGUl/noy+YRkJCwvDw8NDTWiSSqWEhIRkanbfpk0bli9fjqOjI+/fv6d58+Y4Ozuze/duHjx4wPTp01XWBwcHs3TpUrVunvPnz6vV1bBhQ27cuKGWXJeerVu30rRpUxVvNQUZRzOlUint2rXjzJkzCIKgcRTyY9B13FCXBEYFCuE4fXrmtWvXuHbtmtrzi4yMVOkq7NOnj8bxQUgz+G/bti2hoaEMHjyYU6dOKT3wcgtRaBIRySdYmpjgUKw4jyPC9V0KydJUVly/ysq2ms3uvkR2LzzI+1cfYQ5SQJEkS3h5JwTu/M8ssrqFKba1ymBapTinGxnqveOpSKoBr45p/kRPJP8gCAL3S4jeTDnlF19zfvH1YHCN5nxf2wtL4ct8zbcsHcSBJ5/eRzA2JZlH4e/56dxpbrx6yZE+31LUTHMMuEje07RpU+7cuaMSY6+JjRs3Mn/+fF69eoUgCNjZ2TFz5kzlOFRGjI2Nsba2Vl4AN2/enB9//FFljcLwt2zZssrOko0bNwKao+dzMqrTpEkTlUh3TZQuXZoDBw4ox8QOHDiAra2txrVXrlyhadOmGBgYKMUwX19flTEsSBtF6927t9oIkLbnpstY4LFjx4D/iR1BQUH8+++/VKlSRWvHy7p160hJSWHFihXKEcmMJsXGxsbY2dkBaZ0/maW3ZQcPDw88PDyIiYlhz549fPvtt5ibm7NkyRKcnZ01PiYzn6X0NGz4v+TLpKQkDhw4kOlreNmyZfz1118cPHgQgB49ejBy5Ejl/ampqcTExKh140RHR2dqMp6R0qVLq+wLupvdv379Wmm2vnv3btzd3Tl06BCRkZG4u7urCU1ff/01rVq1Yty4cZkKZZD2s7Z27VqqVq2q0imW3s9pw4YNgG6jmYpOJkVXU26j67ihLgmMCrIzcmpoaMiDBw+UYuDjx481duVBmrebg4MDp06dQi6XM2vWLKWpf24hjs6JiOQjDjwMIC4lmWXXrqj5SOQ1PWvUYnmbdlrvl8nlX4xh6qvAUEbU+YFUiXiRnBGbGc25XkqPHSoyOe1vpRK410d/NYjohF298lwaotlXQCR7OBSVc7zt3xjIo/VdSp4Tm1qU0V4jqFpEgkORCMpavOePB3XwfhPzyc5Z3NycUQ0a07d2XSxz2cNCJHsojIQlEgkPHjygWrVqKhds6S9At27dyrJly1ixYoWyI+L69etMmTKFqVOnMmTIELX9mzRpwrVr1+jVqxctWrSgQoUKTJkyhcDA/3loNmrUSO1xgiAQGhpKWFiYmudP+lGd9HHu2kZ1WrZsqVHUydjx8fDhQ7p166Y8n4mJCUeOHMHBwUHtsUZGRnz11Vfs379fmXhWv359Na8mbeNHCjKOIekyFpi+4yU0NJTatWvj7OxMcHAwgwcPVhMidKVmzZocOHBA2dnVq1cvlduaRvKyS1hYGFu3bmXVqlUsWbJEq6CkbeRMW6eSgoSEBHr16qX2dc/oE6V4TorXhcInav78+fj4+LB161asra2BtK6WYcOGUbduXebOnZv5E8yE+vXrc+jQITWz+4wdMulfRz169KB9+/ZKnzBNrzHFa0UXLl26pPF4esN5baODCjK+DmbNmoW/vz8DBgxQEa80+bBl18hfV3788UeePXumcwLj06dP1fzoNK09deoUAwYMwMnJCUEQ8PPzY8eOHXz11VfKNd26dePw4cNAmhm9wpj+UyB2NImI5CN61kjzFqhRohTD/j1IfDY+jcht3MqrJ5XI5HJ8w0I5/uQxj8PD2d3zaz1UlrfI5XLWTtwsikxaKHTjHXQtmvcnlslxe2cKh58Q+Cgs788vkm3Milvqu4TPhidRAqfffEU7G83jP58zVkZR7HJTHZFo3OQyY299x5VX/xObDASB3lXNEQSISjYkMlkgKklOVHIqkUkppEh1/50ekZjIoquXWHv7Jn1r16WwqSnhCQlEJKaN8sxq1oLtd++QlJqKXC5HJgc5cuSAuZERVayL41C8OPbWxTAXgzY+ilmzZvHhwwc10+WgoCCKFy+ucmzlypWcOnVKpXupQ4cO1KxZky5dumgUmjw9PYmJiWHZsmWMHj2aqKgotTGyjN0+Hz58wNPTk507dzJv3jy1PXWJc0/PlClTlP9OSkpi9+7dGjsNatSowYMHD3j8OC3ttlq1alq7NOrUqYObmxvu7u4cP34cGxsbjaN36cePfHx8aNiwoYrIkfHiVpexwOx2vABERUWxfv16tfGq9MJNQkKCWj2K29pG8nRBKpXy77//KhPeFObpmXWhNWjQQPlvXTqVFJibmxMcHKx2/JdffsnUJ0rBzJkzGTp0KOXKlVMKjE+ePKFnz57Mnj07y/Nnhq5m9wYGBrx69Qpra2suXbqkkoaWcdwR0ryjXr16pexGy4yMCYYRERHs2LFD5Xj6LiJNzyHj60Dh+fTHH3+orNMk3GTXyB/SxlffvHmj8rrN2EGZnQTGyZMns3PnTpWfb21r27Vrx4MHD7h58yZyuRxXV1dKlCihsiYk5H8TChs2bBCFJhGRL43GZe3Y2q0nQ44cJC5FP90iTcupC00jjh7mQnDaL+wOVarmdUl64fqR23j/56/vMvItzy89xqZ9E96a5J0Q5/zeBOMDTwgTBaYChawAJjLmZ2IlomChwNwogT+dV/G90QROB8dQzMyU390CcC12TuN6uRwSpYX453VP5t/U3Zw+OjmJP31uqR2/+iKYiMTELB8vAOWLFKVKsWI4FCtBtRIl6FK1usbuFRHNnDx5kjZt2qhdgL548YL//vuPrl27Ko9JpVKNI3IVK1ZU6zpS4OHhAUCRIkU4c+ZMprUkJSXx66+/8ttvv9G3b18ePHigclGnLcZdQfruq/RkvHDu2rWrxovKCxcuKLtF6tevn2kHjyAIzJgxg/Lly9O8eXMOHz6ssbb0YzpOTk4afXMgLZ59z549Oo0Fpu/YuH79uvK5WFtbK02uM9KrVy9KliypZvaeHk0CTWasX7+ePn36UKRIEb777jtu3rzJypUr1YSDsmXLUr58eYYOHaq8LzIyksjISEBzp9R3332ncnvMmDHK2HiAX3/9le+//56pU6cqv+5SqRRvb2+N++nqE2VoaMi2bdv4+eefVV4LWXlK6YLx/4vidnZ2HD16lAoVKijTzNIzY8YMGjRogLGxMS1btqRq1bTrg+vXr1OxYkW19R8+fKBu3bq4ubmpvDYy6xI6ffo0mzZtUv78KxLsIGv/qYxkZxTNz89P2bE3fvx4Bg8erPJ9zcjWrVuZMGECxsbGSoFQEATevVP1ds1ODUeOHOH58+dYWFhkuXbNmjX0799fJRUyI3n590YUmkRE8ikNSpflx6bNmXXhbJ6fu1bJUpTI8AtNLpfjE/YacyMjOletTmxKitLI8XPG54xu7b1fKjKZHMenMv77+A51nTE/EcJLUWQqcMhSxK7A3KSIif46XvMjpobJrGq4krVFR9C73L+UMQ/WulYQwMIojn7ldrLr8SSCouI+6ty6iEwAciAkOoqQ6CjOPU/70EYAulSr8VHn/5K4fPkyf/75p9rxAQMGqI30pKSkkJSUpOaFkpiYSHJyssb9hw8fztKlS5XdUeHh4cycOVMlMl0mk7Fx40YWLFiAu7s7Xl5eGlO9dIlx1wWZTKZyMR0TE0PHjh0JDg6mQYMGyOVyfvvtNypUqMCJEyc0juQpupL69+9PmTJl6NChg8Zuk/Rk9v7u0aNHABw/fhxDQ0MWLFigMhaYnux2vEDayNrZs7n7/nft2rWMGjWKa9eucf/+fRYuXMiUKVPUBD8zMzPev3/P0qVLWbZsmUrnl66dUhk7lf777z+OHDlCpUqVlOKLkZERY8aMUXpspSe7PlH29va5Ii6lR5PZ/W+//aa2rkePHjRt2pSwsDDq1aunPF6xYkUVA2sFffv2pW/fvlmePyQkhM2bN7N161ZKlSpFcHAwISEhyhFBTehiXg7w9u1bAgICVNZpEnOza+S/YMECbt26RfXq1bN8frrWUKFCBUx0HNn29vZmzpw5tGrViqFDh9K2bVu1n+Po6GhOnjyJXC4nJiZGbWxT2/heThCFJhGRfEzPGrVYfcuLt/Ef9yY4uzTVMDb3OjaGmORk2tk7sKR1W8ITEnifEE8py0Iadvh8sC5VRN8l5HuiTz+B6vZpkVB5gCRO8wWCSP5GKnY05SqLvK1p3M6JogZ5F1Oe3zEykDKxqroIkdl6x5JygqI+XU1ZsfTaFVztylPSMuvR0qikREKioylmZo61uTmWxsaf/Yc9GdE1ZQvSLoAHDBjAhg0bKFq0KJDWmTJy5Eit6WQ+Pj4qI3glSpRQG5WrXbs2ycnJLF68mPr165OYmKjiE6O4sP3zzz/Zs2dPtp4fQO/evVW6Xvz9/VU8VqZNm6bsNlJ0naSkpDB58mSmTJmi8eJ+3Lhxyn97eHhw9OhRVq5cme3aFCjq02UsMLsdL5AmnERHR1OkSO69B1N0T50/f56BAwfStm1bfvrpJ7V12e2UArLsVDp16hQbNmxg/vz5zJs3T6unU0YKFy5Mly5d+PDhA6tWreLRo0daDclzG4UY1KBBA548yTzq08bGBhsb1ZCGMmXUPRmlUik7d+7Mslvwq6++ws/Pj379+nH06FHq1q1LpUqVMhWZdDUv37p1K/PmzSMiIgIHBwf8/f1xcXHRKLBk18i/ZMmSOolM2alhxYoVdO7cmTZt2qiI5hkTIBX7xsfH8/fff7No0SJGjBjBwIEDWbhwoXJN+fLllR5f5cqVUxmX1TaSl1NEoUlEJB9jamTE8PoNWXjlYp6eN1GDN1TA+7S2z6/s02bAM3Y8fa4UtRGFpqx4HxxOk3c1uW6bN2OeyXFJWS8SyXdIk0WhKTd5FSfgerAR/7SzpVahk/oup8CSItOvUBMWF4vLpj853X8w9sWKa12XnJrK8SeBzE7X5WxiYMiiVm3o8f/+jl8C2UnZ8vT0ZNCgQdjZ2eHg4IAgCAQGBtK5c2eVC6/0ZBypk8vlat1PCQkJCILA7NmzEQRBa8eLwjspu6QfezEyMmLq1Km4uLgoj509e5bAwEAV7x4TExN+/fVXqlWrpnHPYcOGqdyuXbu2RqPq9IJZUlISDx8+VHl+CvHk3r17lCpVSutzSD8qlN2OFwArKysaNmxI+/btVS6uFRfIOcHAwIC9e/fy999/K5PwUnLJnqJQoUJKoUlbp9KIESNo0aIFjRs3Ztq0aSrfv4yjVTnxifoUnD17Vs2EWpPAoSsKU3yZTJap91RgYCBlypShWrVqSjEyK1F95syZXL9+Xc28PCMrV67E19cXDw8PfHx8uHz5Mtu3b9e4py4de/C/zrwePXqwZs0a+vXrp/K6zTj2lp0aFi9eTFhYGH5+firCrjYsLS0ZOnQoHTt2ZM6cOSxZskTl9112xvY+FlFoEhHJ5/StXZd1t72ITMq7i+v/gp4wx91DJVXuwft3GBsY4KGhPfxzpqjY0aQT0WtuUX16Ix5ZffpxnsRYUWgqiKSKHU25jkQm0PVEeY53akM1i8w/IRbRTIpU/x1BcmDCqePMbNaCJuXUPYWmnjnFiSeP1dJoU2RSEvQYGqIP+vbty4ABAzSmbPXp00dlrbGxMbt37yYoKEjpX+Pk5JRphLezszMTJ05k2rRpyOVyli9frkysU5CTjhdduHv3LgEBAcpks5EjRxIVFQWkdcwo0u7S+7+kx8jISOuITaVKlTRenGYcA8voD5W+uyG9iFa1atUsE+rSo2vHi4KqVasqO59yizVr1rBkyRJGjBhBxYoVCQwMpGXLlh+97+3btwkICCAgIABBEKhduzatW7dWdpsp8PHxYdCgQfTp04epU6dm2p2XE5+o3KZfv34EBARQr149nQQOXXFxcaFr166Zpr4FBwdz9uxZNm3axMyZM2nfvr3KiJkmdDUvNzY2xtraWrmuefPm/Pjjjxr31NXIXyE0KkTZCRMmKG8LgqAmYGenBl9fXwIDA3X62qempvLvv/+yZcsWbt26Re/evZXG4/pAFJpERPI5FsbGDHFswEqva3l2znfx8fiGhdKwTFnlsQfv3+FqV57Cprobp34OWIsdTTqRFJdEkTV3KftDHV6bfjpBQZDJSRI7mgokqWJH0ycjJK4o1b6MJtNcR98dTQoehr+n/6H9tKpUmZ/c3KlsXUx53/nnQWoikwKpXJZXJeYLcpKylR3/mhUrVjBp0iRlPHiXLl349ddfc1Srtq4fxcVnxi6WuXPnqnQeXb58mZ9++on4+HiWLFnCgQMHgLRun7t371K3bl2Vx/v7+2OpZQRT0cEDaZ1KO3bs0DiGpKuxsqmpKRUqqNss5BZz5szJ9T1dXFyUse6QJmalT/3KCTdu3KBDhw5899139OvXD7lczu3bt2nXrh0nT55UjrnNmjWLXbt28eeff9K2bdss980Nn6iPxdfXl4CAgEwFsZyga+pb69atad26NZGRkezcuZMHDx5Qrlw5+vbtq7GzTVfzclNTU+RyufL7X6FCBcLDw1XWDBgwgB07dmg19M/o6yWTZe/3sC41KKhevTrx8fEqopw2ypYti5OTE4MHD+aff/7B1NQ0W3XlNqLQJCJSABhYz5G/fG/naQLd8SePaVC6jPIX7IP37xjX2DWLR31+yGXq8b8imol+G02FjU+JG1WZaKNPc/FTSJ67b3hE8o7UpC+r8yIvCU/SzShURJ385lF/7vkzLoUE079OPQbWc8LY0JAYLcbVANIv7G/Up0zZgjRPHE0jZTkhu10/ISEhKh1F5ubmyu6m9F5PP//8Mx07dmTWrFm4uLggCALXr1/H09NT5eI9PbVqqY5XNmjQgFatWmXn6aiQXvj4VBw8eBA/Pz+VTpacjM79/vvvyi41TXzMON6yZcvYtm0bXbp0UR7r3r07zs7OLF68WClsBQcHc+fOHaVXWFZ8qq657FClShUSExN1EjiyQ3ZHt6ytrRk/fjzjx4/H29tb68+nrublnp6exMTEsGzZMkaPHk1UVBTr1q1TWaNItcstQ/+c1KDAysqKBg0a0LZt2yzHSL29vSlXrtwnqTkniEKTiEgBoLCpGQPqOvKHt+Yo3E/BNv87vImL44+OXZDL5VibmdO6cu4mWhQELuy5qu8SChRvn7yhwd/mXO1jS4ph7r8RtUrVPtMvkr8RR+c+He8SxLdzOSUlHzYEpcpkbPW/w1b/rI3ev7SOJgWfImVLga+vr5rAkRNfmux2/WT0C1J0MAHKkSlI83AyMjJi4cKF/PDDD0CacLRhwwbat2+v07kiIyOzHQufnjt3Pm0IwaRJkwgKCsLHx4e+ffuyf/9+2rRpk6O9FBfn2rq9PoYHDx6oiEwKunbtytSpU5W3d+7cmevn/tQsW7aMZs2a0axZs1zzyVJw4MABzp49iyAItGnThu7du+v0uIYNG9KwYUON9+lqXu7h4QFAkSJFtJqSN2jQAAB3d3ed6mrVqhXnzp2jZMmSKh1Q2roXS5QoQZEiRVRquHtXc8p1tWrVtHqvZaRIkSJ8//33PH/+nMOHD/PgwQP8/f11Svn7FIjvTERECghDHRuwxc+XJC3t858C8/9P6BAEgR3de2P9/zGfXwpSqZRL+2/k+r7GpsZIkj/f7o6Q28/xKGbBqbaFcj2JzirVAFGuKJikiB1Nn4w3otCUY/JbR1N2Sc3myIZI5ixdupS///6bFy9e4O7uzpkzZ2jVqlWOhKbsdv1kNDqvXLkykGZ0nprhvV+7du1o166dznunHwGSSqU8f/6cKVOmZKu+vOTcuXP4+/vj5OTEihUrmDZtGsOHD8/RXqNGjQI+zTieeSbvizMaQBc0JkyYgJ2dHUWLFs3V8bn58+dz+PBhpan2woULCQgIYNasWR+175w5c5gwYYIyNTI8PJy1a9cqv+81a9Zk9erVGjv56tevr+yQTE9wcDBLly4lKChI5Wfw/PnzKusUQqK3t7dOtQ4ePFjtfJqOKZ6XrowePZqaNWsqxatKlSrRr18/jUJTWFgYI0aM4Pz58wiCQKtWrVi/fn2uGs6L70xERAoIxS0saF3JnmNPcpZikhPuvAnjdUwMZQsX/uJEJkhr0f9hw2gW9vkVs0JmxH6I++g9nTvW5+Zx9T8knxtP/gugTZUmnHHIvYsg+wRjim16xLusl4rkQ1JTUkEmz3XxUQRC48VOv5ySIi3Yo2df2ujcp2bHjh14e3vj4uLCgQMHePz4MT///HOO9spu10+fPn0YPHgwW7ZsoUiRNH/I6OhojUbn2SX9CJCRkRGVKlXK1Ixb35iZmWFgYIAgCEgkEmxsbHj9+vVH7Tl//nyNx3P6/YW0LrSMyXzp7yvIvH79mocPH+b6vv/88w9eXl5KIW7EiBG4urp+tNB05MgR5s2bp7xdokQJDh8+rBRqwsPD6d+/Pz/88INKtxloF4W//vprWrVqxbhx4zIV2xTiTFYdjOHh4bx7904t0TE6Opr4+Hitj9N1jPTRo0fs3r1b2Q1pbm6u9bmNHDmSJk2aKEWyP//8k5EjR3L06NFMn0N2EIUmEZEChKlR3v7IhkRH0XP/brZ07UmNEiXz9Nz5habdGlO5XgVm75vM5f032Dbnb5ITc/bmoWKtctg5lEZ/+Q95S9zJp2BfKVeEBdd3JsSsusU70Qi8wGJdxhoDBMT+i9zn4QcBqVASQ/l7fZdS4CjwQtMXOjr3qTAzM8PMzAyZTIZcLqdatWp55pczc+ZMBg8ejJ2dHVWqVEEQBJ48eULXrl0/6iJcKpWyceNGduzYkYvVflqsrKxISEjAzc2NQYMGYWtrq5bill1iY2OV/05KSuLEiRO4uLh81J4JCQlqJtYKciOhTZ84OjoSFhaWqx0ukCbqpO/2srS0zLL7LzU1FaMsroE07SFJl8ppZ2fH4cOH6d69O97e3mzZskVZh7bvVVJSEosXL870vOnx9fVlxowZPHv2TKUDSmHevmvXLn777TdCQ0NVXjdFihTR6iGWnTHSjKmTiYmJWr+2L1++VBGVfvzxRxwdHXV6nroiCk0iIgUIuVxO1WLFCfwQkWfnfBcfzzf/7OVkv0GU/f927i8N186NsKlQkt5TuuDWw5kf2y4gNOhttvYwNjFi6tbvmN15ySeqMv/x7tk7GkTXwMdau5FtlsjktAsQeLLpcu4VJpLnGJkYkTimDjKDgv0Jb34lMllguncXljfYicBH/Lx9gaQU8I4ggwJ+MZvfsLCwQCKR4OjoyPTp07GzsyMhISFPzm1kZMTOnTt5+vSpshvKycmJKlWqfNS+hoaGH90NlNfs2bMHQ0NDli9fzsqVK4mMjGT//v0ftefy5ctVbs+dO5cRI0Z81J75wbT7U/Hhwwdq165N06ZNVTya9u3b91H7Nm7cmIEDBzJ69GgEQWDDhg00atRI49qAgAC+/fZbIiIiePnyJT4+Puzbt4+lS5eqra1atSorV67k+++/Ry6X8+uvv1K9enWVNeXLl+fq1auMGjUKZ2dnDh8+jL29vVYxpnbt2rx69Qo7OzudntugQYMYN24crq6uGjugJk6cyMSJE1mwYIHWlMyMZGeMtGXLlixatIjk5GQuXrzIypUr6datm8a1MpmMN2/eYGtrC8C7d+9y3eRfkOdFbICIiEiuMPn0SeqUsmH+5ewlNuQGQx0bMKt5izw/b37gw5tIitmmxQDL5XL62I1CECDqXQzS1KwNPsrY2/DDhjHERycwp/vHmygWJBw61ObUVzlLLLGUCridjObp2Qe5XJVIXlPh+2acryB6NH1qZjaKZ0ilgmc6q0+aHp/E2/hEfZeRY84OGEJl62L6LuOz4f79+1SqVImEhARmzJhBZGQkkydPxtU1f6buvnv3jsePH9OsWTNSU1ORyWRqXQ0AixYt4uXLlwwZMkQlRaxmzZp5WW6+o169evj7++u7jHzJtm3bNB5XJCHmlPj4eBYsWMDZs2eRy+W0adOG2bNnazRrb9myJQsWLGD8+PHcuXMHuVxOnTp1uH//vtra0NBQ+vfvz/Xr1xEEATc3N7Zv367syMrow7Rq1SoWLlzI5s2bmT17tkZ/pHbt2nHr1i3c3Nx0EtscHR3x8/PT6eugEHrSdz6VL19ebV2jRo24ffs2jo6O3L59G2NjY62eUqmpqSxfvpzDhw8jl8vp0qULP/74o8ZusB07djBt2jQ6d+6MIAicOHGCxYsX079/f53q1wWxo0lEpAAhl8v19unl3wF3meDsQmFTs6wXf2YYmRjhfzGA4ICXPL3znA9hkVhZW/LrlQU8uvmEf1Ye5d2LcLXHGRga0HtyZwbM6U3w/Zd49vlVD9Xrl+dnHlKspTMfjLM33lEh0Ri7rU95+jjsE1UmkldU7eHESVFkyhMW3raklnUXGhf9V9+lFBhSpAV39MyjYmVRZMolLCwsWLt2LUOGDAHSxnk2bNgAaDcK1jcHDx5Ups4FBwcTEBDATz/9xIkTJ9TWKp7LqVOnlMcEQVCO9OQ3WrZsqXGcKaMJc3ZIHx8vlUq5efMmJUqUyPF+nzsfKyhlZPz48axevZpDhw6xZIlu3f2xsbG4ubkpbwuCoHWEskyZMpw/f17pdZRRuMrYWzNhwgScnJz45ptviI6O1rhn3759s5XY1rRpU+7cuYOTk1Om67Zt28b48eMxNjbGwCDNY1FTOh1kb4zUyMiIn376iZ9++inLWgcMGED9+vW5cOECcrmciRMn5rrwLApNIiIFCDn6S5iJl0jYc/8uoxo01sv59YmVdSGq1K+ETcWS1HStSsu+brwLec+mn3Yx/8h0ylSxZVYn1RnuKk6V+GHDaBzqV+b6kdss6vdbjr2dCjKpEikNn8Hp9MmsMjmWckMsZAIWqQaYSwVMpQKmEjkmEjCLl/Jupw9vovJmXEHk01HOsTznmpqR9ttLJC/49rQtl7s3pbTxNX2XUiAoyELTUKcG+i7hs6FYsWIsXrwYb29vfv/9d5UOgPw6/LFo0SJ8fHxo3bo1kNadExISonHt8+fP87K0jyZ9Il5SUhK7d+/+6BHC27dvK/9tZGRE7dq1WbNmzUft+TmTlJTEunXr1Eyoczo6d+XKFQBWrlypc9eMkZEREolEKTq+evVKKcxk5OjRo7i7u1O4cGF++eUXvLy8mDt3LrVr1wbSEtky0qxZM27fvo2np6fafVKplJ07dyoT3DJDkeookUjYuHEj1apVU+mAunXrlsr6+fPnc+vWLbXRvvTExMTw4cMH9uzZg5GREcuXL2fFihXcuXOHf/75R+NjsmN47+npyaxZs6hVq5basdxCFJpERAoQcuR6jTLe6neHIY4NMMnFmNOCgCAIWBa2wLKwBbYVSymPO3rU5sCvx/h2Vk+qOzvw+NZTSpYrTpex7ej1QycMjQw5/tcZfh+zId++Uc0LjP3Ccf0vipT4ZJLikkiKV/WQkfz/fx+f6SeSnyhcworHfcuTYpia9WKRXEOOQLNDtbEwqkVJc/ivw1GM5GJnoDYk0qzHn/MjNUqUxNWunL7L+GwoVaoUFy5coF+/fri7u3Pw4EFsbGyA/GvqbGBgoIxyV6BpbA7SLsKbNWtG0aJFAYiMjOTatWt06tTpU5eZIzp27Khyu2vXrlpNt3Vly5YtasemTJmiksgn8j9GjBiBlZUVly9fZvLkyWzdupXmzZvneL9y5cpRp04dnj9/TuPG6h9aZxRjAMaNG0f37t0JDw9n7ty5bN++nUWLFmncf+bMmdy9exd/f3927tzJmDFjGDNmjFLgGjVqlMbHlS1blj/++EPtuKGhIXK5HJlMplXcUjBr1iw+fPhA5cqVVY4HBQWp/YwClCxZMlORCWDatGm0adOGnj17qpxnx44dLF68WKVDT0F2DO8PHjyoJippOvYxiEKTiEgBQi6HIqamejv/2/g4Bh76h541a9HW3oHCeqwlP2BbsRS9Jnfm9ZMwFp+ciYmZMRGhkfwybB2Pbz+hZd9mHF59ErlcjomZMaUr2xAa9BZJ8pc1RmRsZMi7Z+rtwCKfLwYGAsLY+oSZisbU+iIhVSAkFmKlpbE2EIUmTcjlkKLHD28+hqFODfKtAFJQKVKkCMeOHePnn3+mQYMG7N+/H1dX13z7QZGVlRVv375Vvg4uXLiAtbW1xrWzZ89W8Y4pWrQos2fPzrdCU0ZkMtkn6crat2+fKDRpwc/Pj3v37lG3bl3Gjx/P4MGD6dWrV473O3jwIL6+vvTv31/NmF0b/fv3p3Llyhw5coSEhAS2bdtGs2bNNK5VdCGePn2akSNHMmrUKNavX5/jegFcXFzo2rUrAwYMUPE2yyh6njx5kjZt2uDu7q5y/MWLF/z333907dpV5XiPHj1Ys2YN/fr1U+l8Sp/Gd/nyZf7880+1mgYMGKDRDB10M7w/c+YMp0+fJjQ0VCXpTtv44McgCk0iIgWItvZVqFmyVNYLPyG3Ql9xK/QVsy+cxaNiZbpUq0HLipUwzSJ29HPF3NKMctXKAhAa9IYpLefy/lVaKuDdSw9IiE1rN5Ykp7Lo5EyKl7Hm/csIXj8JY/PMPQR6B+mt9rwiv75JF/l0VOnhyMliosikT4qZymhSWka/sw35qUFFmpa4hqE8e2mZnzspsoL5YUkJCws6OVTLeqFIthEEgQULFtCwYUO6du3KvHnz8q2gt3TpUjp06MDz589p0aIFT548UYkrzwxBEJDlY5G1d+/eyq+7VCrF39+fr776KtfPI74/0Y65uTmQJuAkJCRgZWX1UemFxsbGODs78++//1KjRg2dH9ekSROaNGmS5TqpVIqXlxcHDhxQdq9JJB/3we61a2kj6Ok7ngRBUBOasisK/fjjj0CaT5QgCMjlcgRBQJquw1ZTal36GnShePHiBAWpXmeYmJhQqFChtGmNdD5WpUuX1snbKTt8mVeGIiIFlPZVqvLiEyjOOSFFKuVU0BNOBT3hz45d+MreQd8l6Z1CRS0pbW+jFJpiI+OxsDJHJpUhTZVy68QdOo1qg23FUthWLMW+X74Mw96UpC/Pm+qLx0KzUaVI3jG1QTy97XaTSFXOhtXnTbIDZU1EoSk9xgbJbPF4ju8He7zfFcLvXQKJqfl/1HNgXacv9sOdT0VGwaFr165Ur16dHj16EBgYqKeqMqdhw4acP3+e69evI5fLadKkiXI0LiOFCxfm5s2bODs7A+Dl5YWVlVUeVps90ndaGRkZMXXqVK0jQB9DfhUR9Unfvn3Zs2cPxYoVIzIykg4dOtC+fXuKFy+uTHDLCfv376d3795cuHCBCxfU07PHjh2r/LfC80gbmsbsPD09GT16NK1ataJGjRo8fvwYB4ePuzbRVKcmsisK6SLypqamEhMTQ+HChVWOR0dHaxXQdDG8d3d3x93dnW7dulGvXr0s6/gYxL9SIiIFCEEQ9JY6lxn5sSZ9ULi4FUv+m8WacZtITkxh+vbxCILAvuVHuHb4Fl8NbqGyPjYiVvNGnxkxEaL7kohIXnP7rTnNbV0pZXSTzqXz54WyvjEQoFmJ0zQrAVSFVJkhzU6M431CUpaP1Remhkb0q1NX32V8dmgy0a1WrRo3b95k7dq1eqhIOwkJ/wvKMDY2VhnXSUhIUBm/UbB06VK6detGrVq1kMvlPHr0iEOHDuVJvdnh7t27BAQEKBPPRo4cSVRUFABTp06lUaNG2d4zfXdUeuRyOR8+fPioej9HHj16BMDx48cxNDRkwYIF7Nq1i6ioKAYOHJjjfe/fv0/v3r1VTNkVZPz+KMYZjx07RmBgIEOHDgVg69atWsWRzp0707lzZ+XtatWqcfDgQbV1MTEx/Pzzzzx//pwjR47w4MED/P39tabLHThwgLNnzyIIAm3atKF79+5qa3IiCmVF3759GTBgAFu3blWOxEZGRjJs2DD69Omj8TGaDO9Xr16tskYh+F27dk3ZsZWe9ILfxyLIxZ5BEZECxeuYGJpt3aDvMlTY2Lk7HpUqZ73wC0Eul5MYl4SFVVrbsSRFQlxUAtaliqisG1xtAmFBb5DJPu9fw8amRkiS83+XgEjuUcq+FI/GVCHSKP+OZnwp1C0u46eGb2lY9AKC/MsQtz+GruenEhAeo+8ytNK3dl0WerTRdxkiesTAwCDTbg+pFoP7yMhIbty4AZBp95M+6dGjB8OGDVOagVevXp2ffvqJ+Ph4zp07x4EDB7K957Zt2zK9XyFqiaRRv359fH199V0GAC1btuT8+fMqY5StW7fW2ml08OBBtZS8ZcuWqazp168fNWvWZO/evdy/f5/ExERcXV1VPMwUzJ8/n8OHDysFtp07d9KtWzc1w+z58+fj4+OjURSqW7cuc+fOBaBVq1acO3eOkiVLqvwMK0bn3r37n5+pVCpl6NChHDhwQNmZ9eTJE3r27MnmzZsz7aLKjDlz5jBv3jyGDBmidp8gCGzevDlH+2pCFJpERAoYobExuG3JX0LTug5daFdFHJ3LLrGRcfw1ZTuntujWmlsQKVqqMFHv8u9Fm8ino5xTBW72L0Oiofg2Iz/gYitjc/PTmKA5/lwEElMt6HVxLI8/5E9BzsTQkP++HUyFfCgQiOQ9np6emJqaMnLkSORyORs3bsTIyIhJkyZpfUxqaiopKf8bZ9fU/aRPGjRogI+Pj/K2k5MTd+7cAdKi6BUJYiKfDmNjY62m8oCKGJIdTpw4ken9mlIFHRwcuHv3rtIvKiEhgXr16vHkyRO1tZMmTSIoKAgfHx/69u3L/v37adOmDZs2bVJZpxDS0r+26tWrh7+/v9qedevWxcvLS/lzEh8fj6urK3fv3lVZp6soFBYWRunSpQkJ0fx3uEKFCmrHgoKClMJf/fr1sbe3V1tz+fJljfspyJgWKJVKOXz4sEqi3adAHJ0TESlgCOS/MbVVt27gUakyJjlU179UkhNTKFzcijrNa2BbqRQx4bHcPJ4/PkXKLYqWKiIKTV8oL++E0KyoOae7FAFxvFbveL0xoNXxtvzbzgdrQ5+sH/CF8Sy+JuNvdMi3IhPAd42cRZFJRMnJkydVRl+mTJmCm5ubRqHp1q1bDBs2jIcPH6r4UWnrftIX6UUwQKWDKTIyMq/L+SKpWrVqlqJQTsgsaU6TwTbAN998g6urK9988w2QlhKobWzs3Llz+Pv74+TkxIoVK5g2bRrDhw9XW2diYqJyOzExUaspvFwuVxFjLS0tNa41NDRk27Zt/Pzzz5mKQgqPK02Ckjbs7e01ikvpmTx5stoxQRAIDQ0lLCxM7efc0NCQlStXikKTiIiIKvnRD+lR+HvW3b7JJJesUyFE/kcx26IMXdyPxNgkLIuk/SH7Z8VRNv6487MZp1OMD4p8mSS+iwWhqL7LEPl/wuIFmhxqwKH2Jahu+Z++y8k3HAvryUyv0sRL8q/IVKmoNSPrZ9+fRuTz5cOHDzx9+pQqVaoA8PTpU8LDwzWunTBhAhs3bmT06NFcvnyZVatWKbtE8hMZvW4qV06zZYiOjia1ABj1fw6YmppmSwjRFV2NtdPj6emJi4sLFy5cQC6X4+npqRyrzIiZmZlyrFQikWBjY6MxJa9ly5YsWrSI5ORkLl68yMqVK+nWrZvGPRs3bszAgQMZPXo0giCwYcOGTH3CdBGFACpVqqRx/PXZs2dZPlYTGX2vPnz4gKenJzt37mTevHkaH9OwYUNu3LiBq6trjs6pC6LQJCJSwMiPQhPAOu+bfGVfhZolS+m7lAKDgYEBkDZCd3bnZe5decjLR6+xLGpJ7IfPw0DbyFj8M/MlY9qiIpC/PjH/0pHIBDodr8jKZt/Qvsw1BKTK/0CCgfzL6UBMlpqx6MFodj1MBD4uBvtTs6BlazFpTkSFhQsX4uLiQoMGDQC4c+cOf/31l8a1EokEZ2dnUlNTsbKyYubMmbRo0YIffvghL0vOkj59+jB48GC2bNlCkSJpvpbR0dGZGiCL5C554arz9u1bAgICVLyUNHU0QVoCYfoUQm1YWVmRkJCAm5sbgwYNwtbWFmNj9QTcBQsWsHz5cqysrJg2bRpdunThxx9/1LjnqlWrWLBgARMmTEAul9OmTRtmz56t47PUzrFjx5T/TkpKYseOHZmOK+pKUlISv/76K7/99ht9+/blwYMHaqlzCi5fvszatWupWrUqhQoVUh7XlOiXU0SPJhGRAsb7hHicN/6p7zI04mRbmgNf99N3GQWayHfR3PjXm2uHb3Ln7D0kKQX7E7xaTasRcO2xvssQyWNMLUwp8V1jLpfN3xfvIur0rJLK+NpPKGtyHYGC/fsnM14kOjD+RlcCwvNvF5OCrtVq8GtbzRdhIl8279+/x8vLC7lcjqurKyVLltS4rnHjxty6dYsWLVrw22+/YWdnR6NGjXj+/HkeV5w5qampDB48mCNHjlClShUEQeDJkyd07dqVrVu3YiSKrQWerVu3Mm/ePCIiInBwcMDf3x8XFxeuXr36Ufu+ffuWokWLIpPJWLlyJZGRkUyYMIHy5ctne6/x48ezevVqdu7cSf/+/T+qLl1RGIXnBJlMxsaNG1mwYAHu7u4sWLCASpUqZfqYS5cuaTyePsXyYxGFJhGRAoJEKsXY0JC3cXG4bl6v73K0cnP4aEpaWOq7jM+C+JgEbp+8w7XDt7h53JfEuPwbua0NUWj68jAyMUI2pwlPLFOyXiySb3G2kfFX86tYCg/1XUquc/ptF6bfqEBsSv5/jVqZmHJ24BDx76rIR/Hrr78ycOBAfHx86NWrF6mpqcyfP58pU6bouzSNPH36VGnU7OTkpBwP/BhOnTrFpEmTePbsGVKpVJn0ld98qj536taty6VLl/Dw8ODOnTtcvnyZ7du3s3Hjxk9+7tu3b/PLL78QEBAAQO3atZk8ebLaOJyjoyN+fn55lsAXGRlJgwYNcjw6V7NmTZKTk5k3bx7169fXeH9GNm/ezNChQ7M89jGIQpOISAHhZXQ05YoU4Veva6y+5aXvcrSyql1HOlWtru8yPjsS4xKZ0GQmwfdf8v1fo3l08wknN+Xsk4+8pG7zmty9/EDfZYjkMVX7NOCki3rLukjBYGjNFH6qvReBRH2XkqukSE345dFoNgck67sUnZnfohX96zrquwyRAoxMJuP27ds4OzsDaWN0SUlJWFlZ6bmyvKVq1aqsXr0aV1dXlWh4S0tRxM1LFMmCderU4d69ewA0adKE69evf9S+LVu21Oh7dP78eQBu3LhBhw4dGDt2LI0aNUIul3Pr1i3Wr1/PyZMnlT8fAJ07dyY4OJjnz59rFGk+drysUaNGylqlUinPnz9nypQpzJgxI0f7VaxYUbmfIAgq44+CIGgUsDSJaLktrIn9hyIiBQCpTEZobAwGBgJ/+Xjru5xMufHqpSg0fQLMC5nz8/7JTGs9n68GudN+mAenNp/Pk1n6j0Eqlem7BBE9ELjXh1Ylm3LOXvykWJ9YGMlxt5PjaptAbesobMw/8CG5CEGxRbgXYcGhp0Z8SDZQe9yWB8a0LdeaBkWO6qHqT0NoYiUm3urFnbcFx4Oqro0tfWvX1XcZIgUcAwMDxo8fr7w4NjY21uhd87lTuHBh2rZtq+8yvnhMTU2Ry+VK4a9ChQpaTewhLXnw7NmzCIJA69at6dGjh8Z16bvzkpKS2L17t0on3LJly9i2bRtdunRRHuvevTsuLi4sXryYw4cPK48fPHgQX19f+vfvn2laXk755ZdflP82MjKiUqVKlClTJsf7BQcH67zW29ubmzdvEh4ezrp165THo6Oj1VIfPxaxo0lEpADg/yYMC2MTVt++wbHA/D2GVKFIUS4MGqbvMj5bTm25gE2FEvhfDGDf8n+RJOdvD5wqTpV4eid/eUCI5A0GhgYU/cmN2yXy/3jS54S5oZwNHm9xsr6HCS8y9VlKpjJ9z7XibkSa2FS7uJwpTu9xLn4LI/kb5EJhDOQFP1L84vv2TLnuQFRywelkMhAEDn/zLbVL2ei7FJHPgEGDBjFnzhxlituXyJw5c2jUqJFOxtIin47z58/ToEEDwsPDGT16NFFRUSxevJjWrVurrZ0/fz6HDx9m4MCBAOzcuZNu3boxa9asLM+TmppKhw4dOH36NADVqlXj8WPN11BVq1YlMDBQ7fjDhw+pUaNGdp6ezrx//x5zc3MVI+684MiRIxw+fJh///1XRXQrXLgwAwYMoGHDhrl2LlFoEhEpAKy9fZOOVarisWOzvkvRiT09vsbZrpy+y/gsCXn4Cgsrc3xO+2NkYoSRsSGGxkY88gpk3y//6rs8NWwqluRt8Ht9lyGiJywKm5MwvSFBlvlMEJXLKSQ1oLjEiFgjKR+MP4/Ou9blpPzmegEzgnR+jFQowbHXrXGzCaKYoQ8Cn8fXAiBVZshvgWP4824+e/3pwOB6Tvzs7qHvMkTyMampqRw4cICgoCBSU/8nKP/8889qa9u3b8+1a9dwc3NTubDdt29fntSaHyhZsiQREREUKlQIMzMzpUfTu3fv9F2aiBbq1q2Ll5cXFhYWAMTHx+Pq6srdu3ezfGxKSgq1atXiyZMnwP98lzSR8b79+/fTu3dvlY6f9IwdOzZ7TyQd69atw9PTk7dv3wJQq1YtVq5cSevWrYmKiqJo0aI53js7nDx5kvbt23/Sc4ijcyIiBYDgqEiM082T53d+PHeaE/0GYv4FtmZ/aspVK4OBgQHthqpegLh1b0zk+2jObLuEoZEh0tT8MbL0LiQc20qlePNcfCP3JZIQk4jlch9aDGvARbsU0OCfkJtYSAVKSIwomixQKAnM42UYx0kQYiTIohJJ+ZBIQngsMe9jSUlM67QqJgg4NqyIUcPSBJY3JNi84IkSCn5xuZEtkQnAUB5O1zJ7P1FFnxa5XPtL6m1yOb6/1YdbYQVnVE5BKUtLvndpqu8yRPI5ffr04c2bNzRu3FjFc0jb2j59+uRRZfkTb+/8bT3xubNkyRIsLS0ZP368yvGlS5ciCALTpk1Te4xcLleKTJDmp6WtR6Z3794qvkf+/v4qo5IpKSk8fPhQ4+Mzjozdv3+f3r17c/v2bbW1mnygdGXDhg2sWbOGTZs24erqCsD169eZPHkyy5cv56effsLHxyfH+2eHFy9eEB0dTZEiRRg3bhxeXl6sXLmS5s2b59o5xI4mEZF8TlRSIj+eO82Clq1x3vinvsvRmSGO9ZndvKW+y/hsSYxLxP/iA0rb21Chhh0AKckSfE7749SqDud3X2XbnL/5EKb/sZcazg48vPlE32WI6JnK7lUJ6FCKUFPto1w5pYTEEJu53iTFf/xolE0VG4q4lCfUwYK7VknIDT6tOJZbfO2QyiKnTfouI8+IkVgz/PpwZjtepk6Rmyr3XYtozffXa/EhseAldQKMadiYqU2a6bsMkXxOtWrVePToUbYufFNTUzEyEvsMRPKeevXq4eXlhbm5ucrxhIQEmjRporHbaOjQoaSmpjJ69GgEQWDDhg1AWjpaRrZt26b8t5GREfb29ri4uCiPpTfMzog2w+zcpk6dOhw/fpzy5curHA8ODqZq1ar88MMPLFmy5JPXAWndYnfv3uXatWvMmDGDGTNmMHv27I82Ok+PKDSJiORzjgc+5t77t3zX0Jl669fouxydEYAR9Rsy0bmJSmfTb17XKW5hQe+atTAzEjuecopcLufU5vPsWXyIFRfnUdKuuNqaxPgkJrv/zBNf/XsklXUozesnYfouQ0TPmFuZUWpoQ85XlORqd1O1OGPkc6/neiefVXErSrtVJrpWEe4Ul5BomH/fMl3pfp/Sxtf0XUaeIJEZMcLre66+isHKxITvnWIAAYnMkPeJFmy6n0L+/U5lzYHefXEqnXNjWJEvgzZt2nD8+HFMTEyyXPvgwQP69etHREQEL1++xMfHh3379rF06dI8qDR/EBQUxKRJk/D39ycp6X8itDg6lzfUq1cPf3//bN0XHx/PggULOHv2LHK5nDZt2jB79uxPnhR44sSJTO/v0KFDjvatVasWAQEBGu/T5hP1qVAkzC1YsIAyZcowbNgwMXVORORL49KL5zQuY0e8pGAZ6sqBv3y9Ofn0CQtatqZ5hYoAHHn8kJDoKFbdvMFgx/oMqFuPwqZmeq21ICIIAu2HtaJmk2psn7uPcauHYmpuymPvIMJfRdC0W2PMLc34cedExjaYRnKifl8/lkUtsl4k8tmTGJtEyO9XafFDMy6Wz50RNROpgM3fzynepBp3Lz/IlT0VxEbEEnvEH45ABVNjyjexJ9WxJPdKy3hvkj/GUyHNxNvW+Ia+y/jkRCTbsC24J89jLLj6Km0kLjYlhfk30/8NKVh/KzNSwsKCeral9V2GSAGgatWqeHh40KNHD8zM/vczoMk/5rvvvmPNmjXKsaX69eszaNCgL0poGj58OKNHj+bZs2ccP36c1atXU7FiRX2X9cUQFxen9MVKj0wmIzY2Vm29VCpl9OjR7NixQ6f9v/76a7VjRYoUwdXVlcGDB2NgoJ6wqo3MkuYEQcix0JSSkkJSUpLKzytAYmIiMlne+iMaGBiwd+9e/v77b44dO6asL1fPkau7iYiI5CpyuZzLIcHYWxfj1NMnlCtcBJMC5NUE8DImmsFHDjDz/BkAulSrDkBEYgIrblxl0n+Zf2ogkjkVatgxfs0wjq9P+7RHmipl79LDHFt/hkCfICwKmzN8aX99l0ng7SAq1LTTdxki+QTzD7n3ZqaVVzKv770i4PojStt/uoQuSbKEoAuPCPn1CoWnXaPNoQ8Y5xOt6X4E3IrqrO8yPjmFjSP4656ck8/VL0o+F1pVssfgE3uZiXweJCQk4ODgwL1797h9+za3b9/W6kMUGxuLm5ub8rYgCBh/YT6a0dHRfPPNNxgYGFCnTh3Wr1/PmTNn9F3WF4O7uzuenp5qxxcvXoy7u7vacUNDQ16/fq3z/iVLluTly5e4ubnh5ubG69evMTc3Z9++fUyaNClbtV64cEHrf+fPn8/WXunp0aMHAwYMICoqSnksMjKSgQMH0rNnzxzvmxPWrFnD3r17GTFiBBUrViQwMJCWLXPX8kTsaBIRycc8igjnXXw89sWK4XnlIgPrOXH22VNuvn6l79KyzZ77d+larQajGzTmnwcBhMWlXShcf/mCuJQUCunQ+i2iGRMzE2q5VWfP4kP0/L4jTh61+X3MXwC0G+rB9SPqZob6wNj0y3pTK6Id+bsE4ONb35u9NiZwvxcA0lQZxiZGGBgIyGSffnDq2aVAWpdpyEnn/PBWSuDb07bMce5P/wp/I1BwDc0z42FsQ1Lz+FPfvKZ1JXt9lyBSQNiyZYvOa42MjJBIJMpuklevXmWrw+NzQCGsWVlZERISgo2NDSEhIXqu6sth6dKluLu7c/z4caURtpeXF1FRUVy6dEnjq1AlrAABAABJREFUY1q3bs2YMWMYMmSISlpizZo11dbevXuXixcvYmpqCsDIkSPp3Lkzx48fx9HRMcd1v337loCAAJVxy5x2NHl6ejJo0CDs7OxwcHBAEAQCAwPp3LmzRhHuU+Li4sLhw4eVt6tWrcrq1atz9Rz54d2RiIiIFi6HPKekhSXRSck8jghnS9cehCfEF0ihCeD3m9fZ1eNrZri5M/7U/7dpSqVcDgmmg0NVPVdXsKnW0J7TWy/QudAAzAv9ryW3SddGDFvcj6mt5hF8/6UeK4Snd55TuW4Fnt0V39h96SSHxfCxQlOlBGM+rFM1rXzx8DV1m9fM9RE6bQTu8aZJheZct80f41rzbloSGDmAeU6HMJDrPwggt9kf4gok6LuMT4aZkRFNM5jEiohkhq+vL35+fioXwelH544cOUKnTp0YN24c3bt3Jzw8nLlz57J9+3YWLVqkj5L1hru7Ox8+fGDcuHE0bNgQU1NTevfure+yvhhKliyJr68vu3fvViarjRgxgr59+6oZhCtQmH+fOnVKeUybcfe7d+9U/MqMjY159eoVJiYmSvEpu2zdupV58+YRERGBg4MD/v7+uLi45FhoMjY2Zvfu3QQFBSm9kJycnKhSpUqO9ssJv//+OxMnTtSY8gewbNmyXDuXKDSJiORjFGNzx548omu1GhgZGPLv40f6LivH3Hj1kpuvXtLBoSqXX9Tm4MMApHI5Z549FYWmXGCIZ1+uHPAi8m208lh8dAJFSxZBngcdHrqQ1zPoIvmTqJcfgJz70JhJBcruCCJMQ8rcw5uBlKpQgnch4R9Roe7ErrtNuRkNeWmWP7qI9gQaU8SkK5Nrbkfg8/l5S0gtxNFn+eNr/KloVr6CGJIhojNLly7l77//5sWLF7i7u3PmzBlatWqlIjTNmTOH0aNHM3DgQGbOnMnhw4dJSEhg27ZtNGv2ZSUbKi6g+/XrR7NmzYiOjqZ27dp6rurLwszMjKFDhzJ06FCd1j9/rnuYjbu7Ox07dmTAgAEIgsCOHTtwc3MjLi5OTWg6ePCgmkCrSWBZuXIlvr6+eHh44OPjw+XLl9m+fbvONWnD3t4ee3v9dK8q/KE+taE6iEKTiEi+5WH4e269fkWf2nUJjY1liGN91tzyUo6cFVQ2+/ngbFeOpa3b8r1LE/4OuMeJJ4FIpFKMC5j/VH6jUFFLRv0yiCUDVimPxUcnkCpJ5VVg/kh8C77/EocGlXni8+ljZEXyLzHhsdSMNeGBVc46gVpeSSTwYajG+yTJqVgWzjvz+YSYRCpuC6JC1yr4l0gl1kh/4s7o2skMqRZAccP8MS6bm5x625G4lM9baGoljs2JZIMdO3bg7e2Ni4sLBw4c4PHjx/z8888qa/z8/PD29mbLli106tSJmjVrMmzYMBo0aKCnqvXPs2fP+Pfff7G3txeFpgKAVColJCRERRTSNDq3du1a/vzzT/755x8A2rVrR+nSpSlUqBBeXl7KdZMmTSIoKAgfHx/69u3L/v37adOmjcZzGxsbY21tTWpqKgDNmzfnxx9/zM2nl+eMGjUKSBOhPzVf1nCuiEgBQSqT8dO500jlcuyti7GgZWsqFrVm933V6E8by0Jadsi/3HkThlye1l1jW8iKic5NONZ3QIGOos5PePRzw7FlLeXt+OgEXj8Jy/XY948hKS4p60Uinz2p867RNkDAIJu6TIsXxgQe9st0zfN7L6jTrEbOi8smoQ9DCVtymdI/3qT1vnDaPDGkQmLedqaYG8qZXHPbZykyAVwILafvEj4pAuAhCk0i2cDMzAwzMzNkMhlyuZxq1aoRHBystq5hw4asXbuW0NBQxowZw65duyhbtiwjR47M+6L1QJs2bfDz8wMgNDSUhg0b8t9//zF16tQvKnWvIHLy5EnKly9PzZo1adasGXXq1KFjx44a1xobGzN+/HgWLlyIvb09CxcuZPHixWrrzp07x5EjRyhZsiQrVqzg9u3bvHv3TuOepqamyOVypX/Rv//+S3h43nRLf0pu377NN998Q+3atalduzZ9+vTh9u3cf+8gCk0iIvmQLX6+3H37BkiLOgYwMjDgm1p1ALD8f0PDJuXKY1zAzBzDExJ4Gx+ncszY0LDApenlVwRBYPzaERgZp30946MTCHmQvzy9Xj4OpYaLg77LENEz0lQpTzfcoPmOMFoFGeKQYAI6jHia+On2Ji/QJ4jiZaw/tsxsIU2V8vz6U56tvYbRT1eoGZN3IQfVi8kRPmPJvn6JD/ou4ZNSv3QZ5d97ERFdsLCwQCKR4OjoyPTp01m1ahUJCdo9zExNTfn6668ZM2YM9vb27N27Nw+r1R+vX79WmkHv3r0bd3d3Tp48yY0bN9i1a5d+ixPJlJkzZ3L9+nVq1KhBREQE27Zt4+uvv1Zbl5CQwNatW2nWrBkeHh5s2LCBc+fOKb2g0mNmZoaBgQGCICCRSLCxsdGabufp6UlMTAzLli3j33//ZcGCBaxbty7Xn2decuPGDb766iuqVKmCp6cnCxYsoFKlSrRt25abN2/m6rnE0TkRkXxGTHISW/z+94txx10/OjpUQxAERtRvxM67ftQuZcPN1694Hx9P71p12H3PP5Md8x/3373FtpCVvsv4bClfvSzzDk/HxMwYh/qViI9JxMTMmJSk/DN28vzeC+yqleHVY83jTyJfDi/vhMCdNIN4x2KFsKlfHlm1orwobUSgRTJyA9Wod8Pimk1DM5KckELVhvZEhOrHFLuYXTFuF0omrVdFHfsEY4omCfgUSxsfNJTJKSwzJDKHo3c1iuWfrsXcRC4HQYDWNpdZSCt9l/PJEMfmRLLLunXrSElJYcWKFcyYMYNnz56xY8cOjWvv3bvH5s2b2b17N/b29owePZo+ffrkccX6QeFJA3D9+nWlkbO1tTVGRuKlsD7QNclNEAQqVKigHF3r378/zZs3V1kzcuRIDhw4QLNmzZg6dSodOnTAwcGBWrVqqe0HaamDCQkJuLm5MWjQIGxtbZWJhBnx8PAAoEiRIpw5cyZHzzW/sWzZMrZt20aXLl2Ux7p3746LiwuLFy9WSaL7WMSfLhGRfEZhUzOuDhlJSHQUfm/ecPdtGFdfhtCsfEVKWFgwoK4jyVIpPmGh+L0NY3Grr/gn4D4psoJzkSGTf76fuucXGrd3UhpvWxaxpNv4DuxbfkTPVf2PpPhkYiNiKVG2GOGvP+9OBRHdif0QR+zZB3A27XbtIhaU7uvI6apS+H/BSWads/SYvKZYrdLKmlWQy2kdZMTrjV4kAE0nulL4bTJvT6YFPZSaUI/Hltn3rrIvnH+E5I9BKjPAN9qNc2/qce6lCcmpMjzKyWlZ+hH2RQsRFBWX9SYFEFFoEskuCn8hS0tLZTpXRtatW8fmzZt59eoV/fv358KFCxr9bT5nDAwMePXqFdbW1ly6dIklS5Yo78usA0zk05CdJDeFAGRnZ8fRo0epUKECr16pdunv2bOHBg0aMGrUKNq1a4cgCAiC5g94FOsNDQ1Zvnw5K1euJDIykv3796usWbJkCZaWlowfP17l+NKlSxEEQWtiW0HgwYMHKiKTgq5duzJ16tRcPZcoNImI5EMEQaBiUWsqFrWmW/Ua/Op1jSZ25TE0MMDFrjw2hQpR0sKS8IR4LIyN6VO7Dtvv+um7bJ2obG0tvqHOIwRBYNG3v1O1gT0WVrp1geQl0eGxWBUrhH29iphamvLqcSgxEQXb7F4kd0mITiDoz+u0buqAf9dSvDeRkmSVjbcuetS0n/4XQNvyrsRbG2EikWOYLMMwWUbqowieX3uqXPdm6WXepHuc+ZJb1P/eGd9i6ol6mVGuUGIuVa4fvCObsy+4ERdeSohMSgZS/v8/2PkQdj6sAHyeIlMxM3OqFCum7zJEChgdOnRgx44dFC9eHIDw8HAGDx7MsWPHlGuOHTvGTz/9RJcuXbR2bXzuzJgxgwYNGmBsbEzLli2pWjUt5fj69etUrFhRv8V9gWQnyW3ixIlERkbi6elJnz59iIqK4rffflNZExYWxt69e5k/fz4jR45k4MCBSCTaP3ixsbFR/nvmzJka1+zZs0fFQFzB+PHjadKkSYEWmszNtV8PWOTy+LYoNImIFACqlyjJkccP6VGjFi52dpgZGVOjREnl/VOaNONB+Hu8QzXPGOcnRjVojGEB85UqqAiCQOtvmzGr85KsF+uJ2A9xxH5Iu3gsU8UWWaqUuGjxE0YRVZ5fe4Ld4zdUGu1EnKX2TyrzG0833Mj2YxJjk5Asvkqz75twpYzuXUq2FgVThEmVGbLm6SjW+kmRf6ZCUlY4lS6d6SfwIiKaCA0NVYpMACVKlCA0VHUc/cSJE3ldVr6jR48eNG3alLCwMOrVq6c8XrFiRf766y89VvZlkp0ktzZt2mBtbU2DBg148uQJgJoZd6FChRg+fDjDhw8nICCAzZs3k5KSQpMmTejfvz9jx44FoHfv3pn+nt23b5/KbU2CjIWFhTLQqKCSkpLCw4cPNT6PlJScJQFrQxSaREQKAOUKF2H73Tv0qFELMyP1T6QKmZiwuUsPhv57MF+LTaULWdG1Wt4lQYlA4w71qe7swKObT/RdSpaEPn1DueplkUplJIrJdCIZiAmPBc/LVGldkygdH1NQ3xCmSqSELrtCm++acMZBN8+mYiYxn7iq3CcsqTw/3P6G22EFr/bcpH7pMvouQaQAIpPJSE1NVfoMpaSkkJycvU7ILwUbGxuVThaAMmXEnzt9kDHJrUKFClqT3L766it8fX2zPKagVq1arFixgqVLl3L48GE2b96sFJo6deqkc41xcXHI5XI1YUomkxEbW7A77xMSEjSOKQK5/oGHKDSJiBQAfvW6nuUb0YIgNvWrU1dMl8tjBEFg0Lxv+Kmdp75L0YmXj15TqU55Xj8Jy1fm5SL5h6dnH+i8Vq5Dil1+5tna67Tv34iT9Q00+z2lo7CxfkzPc8r59x2YfqMKkUlftsgEUN9WvOAVyT7t2rWjT58+TJo0CYDffvtNa/S7iEh+IX2S2+jRo4mKilJLcktNTSUlJQWZTEZiYqLyQ6Po6GidfLWMjIzo1asXvXr1Uh4bNGiQzjW6u7vj6enJ7NmzVY4vXrwYd3d3nffJjwQHB+fZuQR5Qf24T0TkC2LXPX8ehr9nnrtHlmNncSkp9Ph7F08j85/B8q9tO4gdTXpALpezdNBqzu28gqGRIdLU/G8cX8WxIsEBL0mV5P9aRfIvNVyq8tArUN9lfDQOnepy1sOC1Ex+/T/+5iCG8vd5V1QOeJ9chgV3+2FuJOPAk3h9l5MvMBQE7o4ej/kX6p8jknMkEgmLFi3i+PHjAHTp0oXp06d/sV5MIp8P8+bNY968eQiCoNKZXLhwYSZPnqwmAOnC77//zsSJE7X6Ky1btkz57/fv3+Pu7k7hwoVxdXUFwMvLi6ioKC5dukSpUqWyff4vEVFoEhEpICy7doV7796wsm0HSlpYZrp21oWz7L7nn0eV6c62rj1pVqGivsv4Yrm0/wb7fzlCyz5u+F28z60Td5BJcxalnhdUbWjP0zvP83WNIvmbgjI2qguV3Ry43r0E8Ybqb9tMDWTc77URQZ/u51kQnFCNoZc78iJGFJjSU7uUDf/26a/vMkREREQ+Kfv376d3795q3UuQ1n1fvHhxOnbsiKXl/65xxowZwx9//JEr51+/fj2jRo1i3rx5Gu+fM2eOyu2kpCR2796Nj48PAA0aNKBv376ZmmmLqCIKTSIiBQSZXM7k0yfxexPG+YFDM52j3ejrzaKrl5S3DQWB712asvmODx+S9JdMdPibb6lrY6u384tA1Ptodi04QJtB7hQvU4yDvx1n3/Ij+i5LKzWcHXh06wniXyqRnFC1kT2Bt4P0XUauUaZGGSwrl0DyIZ6kiHhi38dSpkllwr+xZG/r9fouTyv3Yxox7FITIhJF77WMDKrnxBx3D32XIVJAOXjwIH5+fiQl/e9nK31nhohIfmHOnDnMmzePIUOGaLz/3bt3xMXFcenSJZXjfn5+PHjwgH79+hEVFUViYiKlS5fOi5JFPhLRo0lEpIBgIAgsbd2WIUcO8ComhnJFimhdW6moNTVKlMTVrjyPIt5Tsag1Yxs5Y2pkxMIrF/Os5oy8iokRhSY9U7RkEb5bNRTv0/4YGhkyfMm3RIR+4NyuK/ouTSMPbz6hVtNqBFx7rO9SRAogcunnpVCGPgyFh6qpUk+O36OJZT2SmphhZpH/hJzrEa0Zc7k68ZL8V1t+wMlWvGASyRmTJk0iKCgIHx8f+vbty/79+2nTpo2+yxIR0Yiik2jLli1a12R8/f7555/88ccfxMXF0a9fPyIiIhgxYgTnz5/PcR3z58/XePznn3/O8Z4imhGFJhGRAoSJoSF/dOxCcFQUJS0tWHPrJk8/RBAvSSE+RUKCJIXE1FTWduhMWFwsA+o6UqFoUeXje9eszW9e14iX6Mdk2SfsNR0cqurl3CKqNPyqHvExCUiSJUz8YwSB3kG8fByqtq5ctTKYWZry7kU40eH6SdqIehetl/OKFHy+hLHLKk6VuHXoPksTv2LWuqMYahit0xehiRUZcbEqyVLR2F8bDUqX1XcJIgWUc+fO4e/vj5OTEytWrGDatGkMHz5c32WJiGSJr6+vWife2LFjOXPmjMq69evX4+XlRZMmTQCwt7fn3bt3H3Xu9KlxSUlJnDhxAhcXl4/aU0QzotAkIlLAKGxqpuwKGtWgEUuuXeb0/acqayISE/AeMRaDDON1hU1N6VWzNtv87+RZvenxDVMXMkT0h2VhCwAWffsb1V0cqOFaFUmyhGf+IYQ8eAVAy75udBvfnvtXH/Fz16V6qfP1kzfYO1YkyC9YL+cXKbhIP3Ohyd6xIiEP0kzzrx8NYUO5LoyelX9GYcuYB7PQNZzp14phbmSElakxYXFZJwZ9KZSytKSMlZW+yxApoJiZmWFgYIAgCEgkEmxsbHj9On+mDouIKFi6dCl///03L168wN3dnTNnztCqVSvGjh2rttbExETNE8nI6OPki+XLl6vcnjt3LiNGjPioPUU0IwpNIiIFGCtTUxZ6tKGDQ1V+OneaVzFpMdETTx1nRZv2tKpsr/aYgfWc2O5/Ry+WsQHv35EokYjpOvmMMSsH89e0HQTdDWbiHyMpW8WWsQ2nU7leBVp80wQr60I0bu9EsdLWfAjTT4S6oZGhXs4rkvtUb1wFI2MjDAwNkMllyFJlJCemkBSfTHxUPNERschluv2GEgwEkMu1enjJpJ9vamHluhV4+eg1kuRU5bFD64KxKdee7oNO6rEyVbqV2Uf5Nm5UtnjEw7h6DDhbRd8l5Rvq25bJ1G9RRCQzrKysSEhIwM3NjUGDBmFraysmzonke3bs2IG3tzcuLi4cOHCAx48fax1bK1myJIGBgcrfkzt27KBcuXK5Wk/x4sUJCtLu5fj27VsCAgJUuq86dOiQqzV8rohm4CIinwnxKSksu36FHXf9lMdGNWjEZFc3jAxUM7Fvh75i2pn/CImOytsigb09v6FxWbs8P69I1vhduM+a8Zuo06wGfX/qTqnyJVXu3zxzN3sWH9JTdWBTsSRvg/N3fLuIdsrY22BuZa5TZ1qhopZYFrXAwsocUwtTjIwNMTAwQC6XIZFIkSRKMDI1IvTpG2I/xGFgaICxqRHGpsYYmxhhZGyEkYkREaEfSEn6/Ma2KtYuR9iztyQnpKjdJwgCP28rRJPWV/VQWdYMvTGVyy9j9F1GvmCGmzvD6zfUdxkiBZS3b99StGhRZDIZK1euJDIykgkTJlC+fHl9lyYiopWGDRvi7e1N3bp18ff3RxAEnJ2duXnzptrap0+f0q9fPwICAihZsiQWFhYcPXoUe3v1D9J1JX3qnVQq5ebNm4SFhXHu3Dm1tVu3bmXevHlERETg4OCAv78/Li4uXL2aP/++5jdEoUlE5DPD69VLfjz7Hy9i0nxtnMvasapdJ0qmiwsFSJRIWHHjGlv8fPK0u2mKqxtjGznn4RlFsoMkRcL+X45yctM5hnj2pWWfpspPkkKD3jDIYbzeaqvtVp37Vx/p7fwiOcOysAWV61Ug4NojZDp2Kolop0JNO96GvCcpPlnrGlNzE5YdSqR63ft5WJluPIytT5eTjfTSVZvf+Kd3X+qXLqPvMkQKOG/fvkUQBEqVKqXvUkREsqR58+acO3eOYcOGYWtri52dHRs2bODevXsq66RSKYcPH6Z79+48fvwYuVxOtWrVMDT8uA739Kl3RkZG2NvbM2rUKKytrdXW1q1bl0uXLuHh4cGdO3e4fPky27dvZ+PGjR9Vw5eCKDSJiHyGJEgk/HLjKtv8fJEDDcuUZV+vPhrX+oS9ZtqZ/3gelTcjUU3KlWdn9955ci6RnBP2/C1rxm8iVSJl1PKBlK9RluSEZPqWG01inH7So0zMTTAxMSIuOnOPFwNDA2o1qUZY0Fv+j737Do+srB44/p2e3nvvPdt7pSy7NOkgvYogYkeaIApIExH1JygKglgQUQFpC7jA9sIWNpteNtn03tskM/f3R2B3Q3oyM3cmOZ/nycPkzr3vexKyydwz5z1vU02Lg6ITX6bRQNbqNI7mVtLV2q12OLOCT6A3imKls2Xi76dvsBe/equS8OhjDohsau448ANeL+lSOwxVGbU6Prv1dkwz7Dci5q78/Hwuu+wyqqqq0Gg0REVF8eqrr5KWlqZ2aEKM6ciRI8THx9PT08O9995La2sr9913HwsWLBhx7urVq9mxY4fjg/zc4sWL2b9/P9nZ2ccTYatWrWLnzp2qxeRKJNEkxCy2r6aKuz58n6URkTy+YdOY5/UNDvDUrh08f9Ax1U2PnHYGl2fNm/J1AxYLRc1N+Lu7E+HtM+H5VR3tRHr7SA+MaVIUhe3/2csf7/4LXn6eePi4c2iLuhUS2evSydmaP+bzITFBmDxMVBZU4+HtTmxmFPm7ix0YoYCh/kH9vf1UF9epHcqskrosicK9JROf+LmolGB++fqn+Pi12S+oafhj2U089uncTrAsCgvntcuuVDsM4cJOPfVUbr75Zq68cujn6JVXXuH3v/89H330kcqRCWEb3/nOd7j88stZuXKlTcfds2cPpaWlDA6e6HF47bXXjjhv1apV7Nixg0suuYRTTjmF2NhY7rjjDoqKimwaz2wliSYhZrnegQEqO9pJCQwa85wBi4XDDXXsq67m70cOU9lh3+3kjVodr1zyVRaEhU/6mp9+soW/HzmM2WIhKziEf156xYTvBNd1dfJZfR2bEpNnGvKc1tPZy59/8ir/+fU7qm8X7x/qS3tT56hxZK1Opfjg0RF9azJXp1IyynFhe4ER/gRHB1GwR5J7tpa+IoX83VN/cZu1OopHX/4Ao5vz/Px/5X93kN/cOfGJs9gNCxZx/7pT1Q5DuLAFCxZw6NChYccWLlzIwYPq7CwsxHh6e3t58cUX8ff357LLLuPOO+9k8+bNpKWl8fTTTxMZGTnimoULF5KTk0NKSgpeXl7Hj+/du3facXzjG99g8+bNLFiw4PgyPI1Gw6uvvjri3C1btrB48WKampq49dZbaWtr49FHH2XDhg3Tnn8ukUSTEOK4vdVVPL17J7urK+0+V5inF29ccTXBHp4Tnww8uXM7z3x6olHg1xYu5t61p0x43dfe/A+/O/f8EQ3RxdSVHa7gV994jrxd6r6Tk74iGb1BT3+vmY6mDno6+4hMCiN/nORGSGwQJjcjlYU1Dox07jC6GUhdlkTBnhIG+mdf8221+QZ5MzhopbtteksQT/tqHHf98g0bRzU9hV0LOOcd6dMnjcDFTC1evJiXX36ZjIwMAAoLC7nyyivZv3+/ypEJMdLVV19Ne3s73d3daLVa4uLiuPjii9myZQsFBQX897//HXHNJ598MupY69evn3YcycnJ5OTk4ObmNu0xxORIokkIMYyiKGw7VsEvdm0np6HernOFe3lz75r1nJ2cMuHytg9KS7jl7eE3Sn867yLWx8WPe91dH25mUVg4X53GUj0xktVq5b0XPuKPd71Mp4v13dHpdWSsTCFn29hL78T0RKdFUllQrXYYs1bq0iQK901+ydyXaTQaXi8uwM1Dnf5qJ3s8/3b+kCPJyCc2bOKSjCy1wxAu7L333uOaa65h4cKFaDQaDh06xMsvv8zGjRvVDk2IETIyMsjLy6Ovr4+wsDBaWlrQfv4mcFZWFkeOjN6awWKxUFlZSVxcnE3iWLduHVu3bh33nH/+859ceumlw3ao+4JGoyEwMJBzzjkHT8/JvVk+V83tBfJCiBE0Gg3rYuNYGxPLB2UlPLV7J0XNTXaZq7ark2+99xZ/yYnix+tPIz0oeMxz54eFjTj2vfff4cFTTuec5NQxE1XLIqP4xc7tnJeajrvBYLPY5yqtVsvZXzudlV9ZzI3p36VrmhUWarAMWsjZlk/SwngaK5tob5rbS3dsSW+c2S4wYmwZK1PJ21U4ozEURaGiNInUbHV7rFmsWt4s0wOSaPJ3c1c7BOHizjzzTPLy8tizZw+KorBy5UqCgsZukyCEmkwmEwBubm7Ex8cfTzIBGI3GUa/Ztm0bV1xxBVqtlmPHjrFv3z5+/etf8/LLL095/nfeeQcY6rt02WWXcfnllw+rajr77LOPPz5y5AiXXnop+/btG3WshoYGfvvb345ZcSWGSEWTEGJcVkXhraICnt6zi3I77kyn1WhYEh5JUmAgyQEBJPoHkhwQSIin5/Ek0uoXfk9t18iditbHxvHgKRuI9vUd8VxlezvrX/ojd65ay61Lltkt/rnoLw+9xksP/EPtMKbFO8AL7wBPakrsW7U3V2SsSiVv58ySIWIk32AfLObBCXdanIzv/TqEMy/5wAZRTZ8smzvhn5dezuLwkT1JhBBiNsrIyOBf//oXiqJwySWXHH8McMkll5CXlzfimpUrV/KXv/yFSy655HjvsczMTHJzc6c8/6mnjt0TT6PRsGXLlimNd8YZZ/DBB+r+TXV2UtEkhBiXVqPhvNR0zk5O5d/5ufx67y5qOm1fCWJVFPbWVLG3pgoAvVZLgn8AtZ2dXJ6VzbXzFjJWWvyTinI2/fVFvrN8JTcuWIxBd6K6IsrHhwvTMvjd/r1cnpWNn7yLbDNX3XcxHj7u/OHOlxkcsKgdzpR0tnQRmxEliSYb8PBxx+Ji//9dRWhcMEX7Sm0y1tF8D5uMMxN6jVQyfcHPJP1BxMy89957fPe736WsrAyLxYKiKGg0GiwW+X0snE9PT8+wqqGTH4+1KmFwcJDExMRhx8aqfprIdHdjPHDgAIcOHaKv78TS89tuu02STJMgiSYhxKTotVouy8zm/NR0/pGbw2/37aGxx37LpgatVi7LyGJldAx9AwNc9Orfxp2vb3CQx3dso6y1lcc3bDp+XKPR8IuNZ7G5tJjX8nKl+aoNaTQaLvrOOWStSeNnVzxNTYlrbWVf+lk5BpOegf7BiU8WI4TGBRMSHUTR/tIZ9Q8So8tclUquDavEjuaqf/Ppru1VOwSnIW96iJn69re/zW9+8xtWrlx5fPcsIZxVeXn5lK9xc3Ojq6vreCIqNzfXJk286+vryc3NHZY8Ojnx9YXHH3+cf/zjHxw7doz169fzwQcfcPrpp3PbbbfNOIa5QLZhEkJMiUmv59r5C/n4upu4Z806/O24a8PPd25nb3UlV//nn5NOar1dXEi3eeQ23psSk7kye76tQxRAyuJEnt3/BKdftVbtUKakt7OP5EUJaofhcpIWxZOyOIH68kZytuXT3zPy35uYGb8QX44eOWbTMQcHrDYdbzrcdCOXPs9VvrLjkZghHx8fNm3ahI+PD56ensc/hJgt7r//fjZt2kRNTQ3XX389p59+Og899NCMxnzxxRdZsWIFF1xwAffffz/nnXcejzzyyKjnvvzyy+zcuZOoqCj+9a9/sW/fvmlXVM1FkmgSQkyLu8HAzYuW8s6V15EcEGiXOfotg/z0k4/oHZx8xUnPwACbS0ff5t5DmoHbjYe3O3f9+Vv88E/fxM3DpHY4k9bZ2o27t9zwTcRg0pO1Jo3wxFBKDhylaH+Z2iHNWn4hPrh7udHTYdvqn/Ql6v/+c9e6zuYB9uRtNKHXyktwMTPnnHMOb731ltphCGE3Gzdu5C9/+QsPPPAAy5YtY/v27WzYsGFGYz711FMcOHCAxMRE9u/fz5YtW0hLSxv1XDc3N9zc3LBarSiKQmpq6rQqs+YqWTonhJiRUC8vXrn4q9zw5r85XO8cS6f+lZ/HRemZaocx52g0GjZedwppy5P52eW/pOxwhdohTaiyoJrwhFA8fTxoqm5ROxynFBITRE9nL0e2F6gdyqwXFBUIKNSW2b53WNoi+23mMFluum6uy3Djpby+iU+exexZCSxmv+DgYDQaDYqi0NzcjJeXF25ubsd7NDU0NKgdohA2Ex8fzze+8Q2bjWcwGPD392fw8zex161bx9133z3quR4eHgwMDLBgwQLuuusuoqKi6OmZ+eYcc4UkmoQQM+bv7s5fLryUW956nV1VlWqHw+6qY/zl8CEuzcjiYF0tH5aV8lF5GT9ZfxprY+PUDm/Wi0mL5De7H+H3d/yZN5/ZrHY4E6otqyd7XYYkmsbgH+pLw7EmtcOY9cLiQ+jr6aetvt0u46cvKLLLuFOh0cD9Wb9idejZ3L0riZa+frVDUoWfu/RnEtP36aefqh2CEA4RHx8/aqPwsrLpV1WbTCYURSElJYXf/OY3xMbG0tQ0+mucZ555BrPZzC9+8QvuvfdeysrKePnll6c991yjUZSx9nESQoip6R8c5FvvvsWHR22zS9JM6bVaBq0n+pKcn5rOLzeNbPYn7Gf7f/bwi5uepavNuZfMZK5OJXeH7RovzybZa9PJ2ZavdhizWnRaJK31bXS12uffSXC0H3/Z84ldxp6uhv4ofvjpFeyo7lA7FIdbHxvHn86/WO0whIs7duwYISEhx5sj9/X10djYSHR0tMqRCWEbubm5xx/39fXx8ssv4+/vzwMPPDDtMbds2cLixYtpamri1ltvpa2tjUcffXTGS/LESLJAXAhhMya9nt+e/RUuSE1XOxSAYUkmgDUxsSpFMnetuXA5vzv4czJWpaodyrgGzervyOWsxth1WNhIfHYMTVXNdksyAWQs87Pb2NMVYqriT6t+TqKfl9qhOJw0Ahe2cMkllwz7XFGUEceEcGWZmZnHPxYvXszTTz/N1q1bZzTmaaedhq+vL4mJiXzwwQfs27dvRJKpt7eXZ599lldeeQWr1codd9xBdnY2l156KdXV1TOafy6RRJMQwqYMOh1PbjyLa+YtUDuUEdZKokkVobHBPPXxT7ny3otGLYF2BuY+2TltLAPmyTfjF1OTvDiBqqIaervs27Ooo8WCxeJ8//a0Grg8Wf3eUY7m7yZL58TMmc3mYVu9u7u7098/N5ejirmhtbWVo0ePzmiMzs5Obr/9dtLT08nIyOA73/kOnZ2dw865+eabeeedd3juuefYuHEjbW1tPPHEE8TFxXHrrbfOaP65RHo0CSFsTqvR8JP1p+FrcuP/9u1WOxwAYn39CPGce++cOwudXscND1/B/FOzePyaX9NS16Z2SMPY+0bflfV0yvfGHtKXJ1P4aSlWi3Xik2fo4EeV/O6h87jtgTecrkLtwsg3efLAZfRb5k5VoZ9UNAkb+KLxd0hICAD19fVIRxQxmyxduvT4G5QWi4WjR49yxx13zGjM2267DQ8PD/7+978D8Nxzz3HbbbcN67104MAB8vLy6OvrIywsjPfffx+tVstZZ51FVlbWjOafSyTRJISwC41Gw/dXrsbHZOKR7er3Bqlob+PnO7dxx8o1TltVMxcsOj2b3x16kieu+w2fbv5M7XCO626XXUTG0tncOfFJYkrU6Hv15nPlhMeezUU3vOPQecdzoG01+5oziPR2p6ytS+1wHEYqmoQtfPvb32bNmjVce+21APz5z3/mvvvuUzkqIWznySefPP5Yr9cTHx9PRETEjMY8fPgwn3124vXnM888w/z584edYzKZAHBzcyM+Ph6t9sQiMKPROKP55xJJNAkh7Opri5bgYzJx75YPsKr8Ttuzn+6ly2zmgfWnoZVkk2r8Q3z52dv38ttvv+A0u9J1O3mzcjW1NdhnF7S5yCfQm9C4YNWaqz93Xw0hkWtZs3GbKvOfrK4vhlu3Lv5857m5k2QC6dEkbOOGG24gPj6ed94ZSh4///zzrF27VuWohLCd9evX09jYiLu7O15etlmVYLFY6OzsxNvbG4Du7m6sX+rp2t/fT35+PoqiDHsMQ03JxeTIrnNCCId4p7iI721+mwGr/ZeJTOSitAwe27AJvVba1Kmpu72baxJvp7PFOW4yPX086O6QyqYv8w7wcpr/R64saWE8jZVNtDepWyFmdDPw89f7SZuXo1oMg1Yd1+z4Pvtq596OcwAvnn8x62Lj1A5DCCGc1jPPPMPDDz9MfX09MNQY/KmnnmLDhg20tbXh5+c3rXGfeOIJXnrpJa666io0Gg2vvPIK11xzzbAleXFxcWOuftBoNJSVlU1r7rlGEk1CCIfZWlHON95+g95B9ZsLb0xM4jdnnotBp1M7lDnt1Z+/wR/u+ovaYQAQEh1IQ2Wz2mE4ndiMKCryqtQOw2XpDTrSV6aQs1WdKqbR+AZ78au3KgmPPqbK/L8o+CbPHlb/74BaXv/qVcwLDVM7DOGi7rrrLh5//HEuvfTSUW+GX331VRWiEsJ2/vCHP/DLX/6SX/ziF6xcuRKAnTt3cs899/Dzn/+ce+65h/379097/Pfee48PP/wQRVE444wzOPPMM20VujiJJJqEEA61v7aaG9/4D51m9XdG+eDq60kMCFQ7jDmtv7ef65K/RXON+jtPSUJldBkrU8jbVaR2GC4pNDYYg5uBqsIatUMZISolmF++/ik+fm0OnfeTxrO46aMYh87pDFICgzg/NY1V0bGkBQZh0kv3CjE9//3vf/nKV77CSy+9NOrz1113nYMjEsK2srOzefvtt4mJGf63ory8nJSUFL7//e/z2GOPTWnMjo4OWlpaiIuLG3b86NGjBAYG4uPjM9OwxZdIokkI4XD5jQ1c+/q/aO5Vd5nSKxd/lWWRUarGIODt5z7g6VufUzsMVRo0u4J56zI4vDVP7TBcTubqNEoOlNHfa1Y7lDGtPCeWn/zhTZuN1znoxzu159Ax4E672Y02s4GOfh1tZg3t/dDWP0hDd59TLKFWy3tXXUesr58kmoQQYgyZmZnk5uaO+lxKSgpFRVN/8+vWW2/ljDPO4OKLLx52/OWXX2bXrl0888wz04pVjE3+ygkhHC49OITXL7+Kp3fv5D8Feao1CW/p7VVlXjHcphtO5dUn36SmpE7VOIoPlOEX6ktbvTS/PllVUQ0+gd50yO5zk+Lh405MehS5OwrUDmVC4XG2He+5kqtOWhI38PmHOFmnuZ+qjnapphXTduedd477/BNPPOGgSISwD7PZTF9fH25f2jiht7d3ROPuydq6dSu/+93vRhy/5pprePzxx6c1phifdMIVQqgi0tuHn59xJu9ffT3npqSqEkOLyhVVYojeoOf6By9XOwz6uvsJjw9ROwyn01LXRkC4Hzq99DObSFBkAG6eJgr2FKsdyqRsuNh2SyJreuN4IVeK5CeytaIcH5PsOiem78knn+STTz7B3d0dT0/PER9CuLqLLrqIa665hra2tuPHWltbufbaa0dUJE2WbpyerGM1/hYzI4kmIYSqEvwD+PWZ5/L2lddyRkKiQ+fOaain3wkakwtYf9lKEhfEqR0G+buLnSIOZ+Lp44FPgDdGd4PaoTi9wMgAWmrb1A5jUhLnh5GYZruqq18VXEy/xWKz8WarLUfLCHB3VzsM4cI+/PBDUlJS+Nvf/obZbObqq6/mgQceOP4hhKt7+OGHMRgMREVFsXDhQhYtWkR0dDR6vZ6HH354WmMODg7S0TFyp9P29nYGBqT61h6kR5MQwql8VlfLL3fvZOuxcofMF+juziUZWVyRNY8YXz+HzClGV5FfxY/OfoT6ikZV4wiNC6apqhnL4NztIwMQEOZHZHI4xQfK6OtWv3m/s0taGE/JwaNqhzFptzwSwUXXv2uTsQo6F/KVd5chLygnFuzhyZ6v3ap2GGIW6Ojo4O9//zt/+tOfcHd357HHHmP58uVqhyWEzZSWlnLgwAEAFi5cSFJS0rTHevDBB9m/fz8vvvgi/v7+wFCV1E033cS8efP4yU9+YouQxUkk0SSEcEp7q6t4atcO9tY4bhewtTGxXJk9n9PjE9FrpeBTDc21rdx37qOq37BLA2xImBdL2eEKtcNwCSmLE2ipa6OpukXtUCbtmS39NqtounHXD9laOfKdYjFSZnAI/73iGrXDELNEbW0tL774Ir/+9a957LHHZMc5IcZgsVi48cYb+de//kVycjIAxcXFXHzxxbzwwgvjLq0T0yOJJiGE01IUhe2VFfx8xzaONDY4bN5QTy9uXLiImxctddic4oSezl4euuwXfLr5M9ViMLob8fLzcJllULYWHB1IU1UL8hJhbHqDjtSlSbTUtVFbVq92OFN29x8COPWcj2Y8zo7mDVz3P8cue3Zl62Pj+dP5F6kdhnBhFouFN998k+eff56jR49yzTXXcN111xEeHq52aEI4vZOrpBYtWkRiovz9shdJNAkhnF5Ddxfr/vRHzFbH9v946fyLWRsb59A5xZDBgUF+detzvPenmd8IT1f68mTyXaSpsy1FJofT3d5DW4PsvjeWrDVpVBXVuvT36OLb4/j6vW/MaAyrAhd8dAd5TbIj4WRdmpHF4xs2qR2GcGFhYWHExMRw4403sm7duhHPZ2RkqBCVEEIMJ4kmIYRL+OEH7/Gv/FyHzhnr68d7V12HSa936LxiiKIo/OXB1/jzT19VLYbotEgqC6pVm9/REhfEUVNaR29nn9qhOK3sdenkbM1XO4wZy14TxZOvvj2jMfoG3Vn19tfo6DfbKKrZ77Yly7lj1Rq1wxAuLC4u7vguWRqNZljlqUajoaysTK3QhBDiOLl7EkK4hBsXLnZ4oqmivY3f79/Ht5evdOi8YohGo+GaBy4lOCaIX379d1gtjm/ObXSbOzutZaxMoXBfKZZB2TlsNBqNhsxVKbMiyQRQcqgJi0WDTjf99xvd9L1cmqzh+SM2DGyWC5Ht58UMlZeXqx2CEEJMSLrdCiFcQnpQMGuiYx0+7zOf7qGqw3WXx8wGZ95wKg+/dQ/uXm4On7v0UDkRSaEOn9fR5q1LJ29XkSSZxqDT60hdnsSRHYVqh2IzvV19VJfPvDfFVfHvorFBPHNFkIckmoQQQsx+kmgSQriMmxYudvicZouFzn7Z2l1tSzct4KlPHiQg3N/hc/uF+Dp8TkfyDvDk8Cyp0rEHo7uRhHkxFOyeff26io7EzHiMGPdiTo/1sUE0c4NUNAkhhJgLJNEkhHAZ62LjODMx2eHzRvv6OXxOMVLSwnh+vfNnBEcHOnRevX52b3nr6eOhdghOy8PbnYjEUIoPHFU7FLtobZp6laBVgaeLvsFfK67lWO/Q7+Nrkg7aOrRZSxJNQggh5gLp0SSEcBkajYanNp1F43+62V9b45A5gzw88DIaHTKXmFhobDBfvfMC/u9bzztszt6u2d0Y202FJYnOKHN1Ku1NnXj4uGN0M6LVaGiubaX8SKXaodlNcmbDlK/5ZeE3efbwIOAOnEas71dYG2HFwzBAz8CgzWOcbYJl6ZwQQog5QBJNQgiX4qY38Ny5F3Dpa3+nrLXV7vPFSjWT09l43XpevP8Vutq6HTJfY1WLQ+ZRi8ldEqkA5r4Bqgodk8B2FsmZU+s51W8x8UaZETiRUKpo76ZC2thNipfRiLth7mwwIIQQYu6SpXNCCJfj7+7OQ6dscMhckmhyPu5e7pzzdcf8/wdoa2jHy3f2Li/TG+U9p9C4YI7lV6kdhkNFJQfh6d05pWtMun4eWib9vKZLqpmEEELMFZJoEkK4pEXhEbjr7X+DHOvnZ/c5xNSdf/tZ6BzYOykmM8phczmaVju3XwoY3Qzo9Fr6e8xqh+JQyQu9pnVdv0Uq4KbL5IC/WUII27j++uvRaDQ89thjw46//vrraDQj99pMTU3FaDRSXV094rlTTjll1LEAzj77bDQaDT/5yU9GnP/lj1tvvXXmX5gQDjK3X10KIVyWSa9nWWS03eeRiibnFBwVyPrLVjpsvrydRWSvSUNvmIWNwUd5wTyXpCxOpKakXu0wHK6hcmDEMcuglr4edyyDY788zGufvUlXe5MdTIVwLW5ubjz++OO0TtCqYfv27fT19XHppZfy4osvjnpOdHQ0f/rTn4Ydq6mpYcuWLYSHh484/+abb6a2tnbYxxNPPDHtr0UIR5NEkxDCZa2OnvnW3OPRaTRkhYTadQ4xfRd991yHzpezvYCE+XFodbPsT6eiqB2BajJWpnBkR4HaYagid1c1jXVhxz9vrAvj+5ds4vykFM6OyeasqAWcl7iUizNWcsWitVy78hRuWn86O8p8VIzatXVIokkIl7JhwwbCwsJ49NFHxz3v+eef58orr+Saa67hhRdeQBnl7+q5555Lc3MzO3bsOH7sxRdfZOPGjYSEhIw438PDg7CwsGEfPj7y+1e4jln2alkIMZesiYm16/i3LV1Ogn+AXecQ05e6JJHstekOnbPo01JSFifMqiKg/t65tWTsZFaLVe0QVPXd81L54+Pn8783T+ObmxIp2HuiGbrVqtDfa6arrYeWug7qK1qprW4nv3tqfZ3ECZ3mfizWuf0zJ4Qr0el0PPLII/zmN7+hqmr0Pn6dnZ3885//5Oqrr+aMM86gu7ubjz/+eMR5RqORq666alhV04svvsiNN95or/CFUJUkmoQQLis1MIggD/s0ac4KCeX2pSvsMrawnR+++E3+b+9j3Pb0DWi1jsn+FOwtIX1FikPmsid3bzfSV6RQ9Gmp2qGopmBvCfPWZagdhmqaqtr456/KeeLWZtobuyY8P/TsdPosgxOeJ8bWZZ67iV0hXNGFF17IggULeOCBB0Z9/pVXXiE5OZnMzEx0Oh2XX345zz///Kjn3nTTTbz66qt0d3ezdetW2tvbOeecc0Y995lnnsHLy2vYx0svvWSzr0sIe5OuhEIIl6XRaFgdHcsbhbbdBem81DTuWb0eg24W9uOZZcLjQwmPDyV1SSKRyeE8/NWn6O3qs/u8ebuKSFuWhNFtqDGyAgz0mynYU2L3uW0hJCYIq8VK/u4itUNR3eGteaQtT6ZgT7HaoTg9zdJwoF3tMFxaR38/vm5uaochhJiCxx9/nNNOO40f/OAHI557/vnnufrqq49/fvXVV7Nu3Tra2trw+9KGMvPmzSM5OZnXXnuNjz76iGuuuQaDwTDqnFdddRU/+tGPhh0bbYmdEM5KEk1CCJe2OjrGZommeaFh/HjdqSwKj7DJeMKxlp21kKe3P8x9X3mUxspmu89XsHd4UilpQZzd57SV0NhgcrbJNvVfKDtcgV+IL20NkkQZz+DHFazWatAFebBniRv9FovaIbmcjv4+wFftMIQQU7Bu3To2bdrEvffey/XXX3/8eF5eHnv27GHfvn3cddddx49bLBb+/ve/841vfGPEWDfeeCO//e1vycvLY+/evWPO6evrS1JSkk2/DiEcSRJNQgiXtjp65n2aQj29uHPVWs5PS0c7m5rvzEEJ82L5ze5H+fH5jzt8SVj9sSaHzjddBpOe0kPlaofhVPxDfKmvaFQ7DKdX/+6JxunLBxeya7k7A9JzaEqkIbgQrumxxx5jwYIFpKScWDr//PPPs27dOn77298OO/fll1/m+eefHzXRdOWVV3LHHXcwf/58MjLm7tJtMftJjyYhhEsL9/YmcQYNu7++aAkfXnMDF6ZnSJJplggM9+cXH/+U1Rcuc9icQVGBxGVGk7EyhUQnr2yKnxdLT2ev2mE4leAoafo/VdV/PcjqXIv83pyidkk0CeGSsrOzueqqq/jNb34DwMDAAC+//DJXXHEFWVlZwz6+9rWvsX//fj777LMR4/j7+1NbW8v//ve/cefr6emhrq5u2Edra6tdvjYh7EESTUIIl7c6OmZa162PjeOu1evwNBptHJFQm5uHifv/8X2WbJpv97miUsJpqmomZ1s+ebuKKD1Ujn+oL6nLkkhenEDC/FhiM6KITA4jc1UqEUlhEw9qR0bT6P0g5iqfQG8K9s3dhugzUfn7PayrkF52UzG0dE4I4YoeeughFEUB4M0336S5uZkLL7xwxHnJyclkZ2eP2RTcz88PT0/Pcef6wx/+QHh4+LCPK664YuZfhBAOolG++NcihBAu6sOyEr7+1htTusak0/PeVdcR+6VGjWJ26e7o4Xtr7+dozjG7zZG9Lp2crVPrd5S0MB6NVkPx/jI7RTW2eesyOLw1z+HzOquMVank7SxUOwyXFvx/Z7N7sEXtMFzCvWvW87VFS9QOQwghhLArqWgSQri8dbHxpAYGTfr8eaFhvHH5VZJkmgM8fTx4+L93ExDmZ7c5WuvapnxNycGjFO8vIzwhlMzVaegNjqsKsUpPnWFKDh7FL9hH7TBclqKBCoMsB5usTrN8r4QQQsx+kmgSQrg8o07HE2eciW6CXiFGrY47V63ltUuvIGUKiSnh2kJignnov3fj5mGyy/ievh7Tvra2rJ7cHQV4+HiQvS4d74DxS+ltYaB/0O5zuBJzr5noVNlpcroiv7qA2t5utcNwGdIMXAghxFwgiSYhxKyQHRLKLYtHb/7sptdzcXomb115DbcuWYZeK7/65pqUxYnc89fvoLFD4+LCfaWkLZ/ZFsQdzZ3kbM2nv3cAk4d9e4b19ciN7pfl7ioiJDpQ7TBcTug56eSu91c7DJfh5+aGVTpWCCGEmAPkbksIMWv8YOVqnj3nPJIDhm4Y54WG8fCpG9h90638/IwzSQqQG8m5bNX5S7n1F9fZfNzM1amUH6m0yVhD1TWRNhlrLD3tPXYd3xVZLVYCI+X3w1REf38N+zb509IvOxhO1mlxCcwLVXczACGEEMIRpBm4EGLWsVitVHa0E+cn77SL4RRF4f++9TxvPrMZD293ejqnf5PsG+RNaFwIRZ/adscyezfrNnkY6e8x2218VxaVEk5VUa3aYTg1jV5D2BNnsl0r22xP1bPnnMfi8EiCPKa/3FYIIYRwBXq1AxBCCFvTabWSZBKj0mg03Pb0DWSuSqX0swpe/fnUdiv8glanRWfQ2TzJBNDZ2mXzMb9gcpck03jcvdzUDsHpecQEUOTZD1LINCUmnZ61MXF4GAxqhyKEEELYnSydE0IIMafo9DpOu3ItG69bT1h8yLTGSF6cQEttm20D+1xlQTUGk33eB/IO9LLLuLNF8YGjZK9LVzsMp9Zd1kzM7wtZoQ/ATSfvV07W6ugYSTIJIYSYMyTRJIQQYk6KzYjmN7sfIWNV6pSvtQxa7BDRkJSlSQwO2Gf8iXbIC4oNwjvQ2y5zu4qcrflkrUnDDn3jZ43WA9U03v4OCT89yKnVRlI8/dQOyamFenrx9cVL1Q5DCCGEcBjp0SSEEGJOM/eZeerm3/G/v26b9DXZa9PJ3VmI1WK1aSz27s+UujSJwn0lYz6fcsNy3p0HkWYDca1afGr6GChrpeFINd1tc6uJeOrSJEoPHbVb0m+2CVwXj/HCNA6beugwy86GX7gqez53r16Hp9G+u0kKIYQQzkQSTUIIIeY8RVH468P/4qUH/jHpa2LSo+hp76GppmXG82u1GtJXppK7o2DGY40na3UaR8aZI+W8ebx72ihVT4rCqRUGjj293Y7ROZ+E+bHUltbT29WndiguQ+dhIOL6JTQv8CenZ+x/G6u0AVS6DVDZ0+nA6BxvZVQ0f73oMrXDEEIIIRxKls4JIYSY8zQaDVfffwn3/u27GEyT66NyLL+Knq5eYjOiZjx/8uKEcZNMAWF+M54DQKMbfz2YuX6MRuQaDbuiLbjNsWbZZZ9VEBQZgI/0tpo0S88Alc/soufr77D4hQrW9fkQ7DYyeWnoHsT7/t1kewQcP+ZnckM7y9YsRvn4qh2CEEII4XCSaBJCCCE+d+rlq3ngtR9M+vyejl58gmbe0+hYfvWox+OzY4jLiqalro30FSkERwfOaB7FOn4R83jP9+kUYk6fej8rV1dZWIOblxuBEbKT5VS1Ha6l+u738bntI9Z9amaxWwB67dBLT4tRS399J73f3Mxq/Al0cyf5T6WssvipG7SNXTNvAQ3d9ttJUgghhHBGkmgSQgghTrLs7EWkLU+e9Pn2WFYVkRRGyuIEjuYco/xIJQD5u4toqW0je13GtMcdNA+O+/zAqdFjPpfZaaK7tHnac7uyhoomLINWQmaQ6AuM8Ccg3M92QbkSq0L1Xw7Qdus7ZDyVzymtHug7BwBQBizUffddwn66n5a9lTQ99DGh7uM3rXcVC8PCSQ4I5MOyUrVDEUIIIRxK9qUVQgghTqLRaLji7gt54MInJnV+Q0WTzeYOigwgJDaY/F1FjNZC0TJoIXdHAZ4+HnR3TL05d3+veey5YwLZETby+UCzjmW7uin6z25Gr7uaG9oa2klbnkxD5eSTbdGpEXj5eVJX3kBzTSsA/mF+hMUGo9Vryd1RaK9wnVZ3eSvdP90y4nhfbQcAA629pO5sp37h5JawOjOrovCXnM/wNZnUDkUIIYRwKGkGLoQQQnyJ1Wrl6/N+QEVe1aTO9wvxpa2hfdrzhUQHEhoXQv7uokntcpaxKoW8nUVTnyc2aMzEmJuXG6E3LWFL3ACc1Cdn45vtlG7JP/55ygULqJ/ni8Gq4Fc/QMkfdk05DlcWkRRGTUndhOdFp0XSXNNCT0fvmOdkrkolb1ch8kpsJP/fnc2nfTNvtO8M/nbRZayIGrtaUAghhJhtZOmcEEII8SVarZbrHrwcv2CfMc/RaDQkzI8la00avZ1jJxMmo62xg5xt+ZNKMgFYBq3TmqezZexeMX1dfVT8ajsb/tlMVN+JgufO5cHDzqtY5MOBgH72BJnZnKmQeMvKacXiqnwCJ+7JFZ0WSXP1+EkmgNydhVNapjmXDDy5Fy+DUe0wbCLKZ+zfI0IIIcRsJIkmIYQQYhRrL1rOq3V/xP2knda0Wg2JC+LIWpOGd4AXZZ9VcGR7wbhL0ibD3DcwpfOP5hzDYJra6ne9UU9v58T9pI7uLMH3oX1kdAzd5O8O7icwamhnsICoAPK8+4ed/1nixC8lfENnz85bBXuKiUgKG/P540mmSSYfC/eVotPLy7Ev6yppYsmx2bEDnWaW7aQnhBBCTERe2QghhBBj0Gg0xGfHkL4ihczVqXj5e1J6qJwj2wvoaO5ULS5zr5mkhfFTusZ3Crvj9XX3M6AbWs81r8OE1qADIGhtwrBldQBJLbpxx/L096Tkh5kkfGMVeuPsaA3Z1dpN6tIkstelk7w4AZ9AL2DqSSYAq8VKcHSQvUJ1acee+IQ0Tz+1w0BvBZ9BLUFmHRH9ejQT7N74ZTsrj9kpMiGEEMI5SaJJCCGEGEfSwnjydxeRu6OQjmbn2aa8cG8JmatSCYoIGPV5v1BfEufHHv/c03fyO3kZ3Y2Uug+wuMVI10+20ni0EYCaNM8R5/ocG78pefhX59Oht/JBqhUeWEVYytjVQI6SctVSIn64FreTqtWmoqO5k8J9JeRszad4fxkdzV34h/nRWNU8pSQTgMFkQKuVipfRaBTwebGAYDf770KnHWc16oYtPQTfsRPfO3fgftd2zvy4d9zzv2xbRfmM4xNCCCFcyex4a1EIIYSwk698YxNvPrNZ7TBGsFoVcncWotPryF6TRu3RBnyDffD0caepppWakjoGzYPHz/eYQqIpLCOCfC1YT8p/+AT7cMi7DxieFOnLbxx3rNYgPTC0tLDQ00zFLfGctjeSwn/sn3Q8tpR080rezVSAAdbFB1GdM7mG7xNprWub8jUmDyNRyeGUflZhkxhmo+Yd5XjvKCfxtCRMp8dTE6KjuLttWmNFe3gTohiwAu6tA/gUdaBUddFZ2kTj0QYCogMJmB9JX6I3R0M0lLuZ0ShQt7Ns2DhFbx5m40AWH5zhiWUSScLtlRVYrFZ0Wnl/VwghxNwgiSYhhBBiHHGZ0WSvTSdnW/7EJ6vAMmghZ3sBAE3Vw3fp6mrtJjIlnOqiWnonaEx9MrekQAB6T9phPmx9IsqXbqpNFqg5Mn6iJvBwO5zmfvzzPp3COysNLE9ah/n3B+loctwSxIRvrGJz6olSFPcIX7BRomk64jJjKNxXotr8rkIDNG4pgS1D36v5SUH4X5BBe7IX+eYO+iyDY15r0GpZYPDD9MExav69m7bPj3fptISuTiNnWz5fbMDcVNFE0+e7MuqAhcE+BKaEcnSUJvrF7x5hw2AGW870YWD81aO09fVxpLGB+aHqV/MJIYQQjiCJJiGEEGIC595yhtMmmiYSEOqHh7c7xfvLxjzH6GYgICYQz0g/9KGelGd6AmZ69Apf5JoaMrz5ojLpC2mdRrom2Cmv8qNCjOsXYtYN72uzJ9hM6J3z8L13N5bBye22NxPxt6/mg6Th81iT/EjxW4TFz0TlS59OuSn7TFkGx06QiLF1lTTR9eRWAGK9jYRemM3gklCKjX009g0t5Qx39yS1XkPLC/tpKW8FhtfiWS1WDm/NIy4rmq7W7hFJWoCOxg46GjvGjKPkgzzS9rgTuTqR3qwAPgux0GYY/Wd5+7FySTQJIYSYMyTRJIQQQkxgzcUr8P3un2h3YPWNrfT19tPXNXy3ubDUcNw3JNAYoqPOw0q9bgCGVSsNJZS6dVb8GGrofcivny8vmwutG2SirlW9nX0sbjKwK3TkznwxHTpa7JxkipoXjbIpjg8jRyaRPki2QLIRUEi+fyWhLxRSX1pv13hOZvIwOWyu2Wqw00z1n/fDn8EbSDwtCUOwJ9Wv7qZyEj27y49U4u7lRuaqVHJ3Fk55/p6OXorfPQLvQrBWw6LFcegXh1MYq6PC/cTP3NaKcr65dMWUxxdCCCFckSSahBBCiAkYTQY23XAar/78DbVDmTLroIXKwhq0Oi2JG9KpXxHIDr9+0FiAL5I8o/eZ6dQOJZoi1yVxeJReNJri1gnn9w31pTBg9Mod4wAkrE+l81gLzRVNWKe4m9doNBoNMUvj0S0NJy9GwyemQWDiSqViTzOR56fAU45LNOl0E6y5ElNyfIkdY/1Ej663q4/cnYWkrUimMr+a7vbxG9yPxWpVqNh3FPYdJeOKJVQsP/Ey+2BdLZ39/XibJLkohBBi9pNEkxBCCDEJy85e6JKJJu9QX5JvWM6hNAPvmQYZqlaa3G24WaegN+ppyfLly8vmUBTqD03c30j79fm0GEZWMwHsCDfDhf6AP3prIjH9BsL/VExdUd2k4juZ0d1I+K3LORxhpcRwchJt8kpCFLKvXkpPTj01OZU2SXyN54veQMI5FOwuHtqtMT6O0kPlMxqrO9KdkxOcg1YruysrOCMpZWZBCiGEEC5AEk1CCCHEJAz0u14/Hb1Bx0cbPGkxKMD04veP9Gd/wMhEUWyfkc7m8ZcSply1hHcDR08yfdmgFrzNmmklmQDiNqTxbuzMeixVuQ1StUQHSyLwHowiq0VPx6/20NfdP6NxxzJgdr2fqdmurb6dtvp2stelk7+7eNjOjVNhfi2fsG+kUWcaJKXLSMKuVnpN5SCJJiGEEHOA7LMqhBBCTELvl/ocuYL4DemfJ5mmz++UhFF31YpvGv+6yKwoPlw0hfezFIWgd6a/A1zjQr9pXzuaTr2VSh+r3ZJMwIjeWcJ55GzNJ31F8rSvbyxvIv65Ija+3orlvq0Uv52DXisvu4UQQswNUtEkhBBCTIIrJgWalgYwYsnbFB1JNTBaNZR7+dhtwI3uRiqvjGdAN/kKo6UtbpTvGXtnvPH4R/izf5Rm5TOVWgvlNh1xuM7WbjuOLmbCy9eDoznHZjRGQ2kDDaUNxz/XG+VltxBCiLlB3loRQgghJsHVKpoCowP51G/m1ThVbqMvHerMG7tpdvgtyzjqMYVlbIqCx5tHpxraccEbklFGaVY+U/ojzTYf82Ttje12HV9MX/y8WLpsnAjUaGz/MyqEEEI4I0k0CSGEEJPgaommgE3JYIfkyxcMnsZRjyedkcGWKfZK0ioaLDPoV1SUZqedvBL8SFifik+Qt12GHxyw4OXvaZexxfRFJIWRu6PA5uPueH2PzccUQgghnJHU8AohhBCT0NftOokmjUbD4WQ9020APhnHLoomtLWX+tJ63DxNRK1Joi8rgO0Rg6CZWl8oqxZar0xC8+PaKe/EFjU/hk+mUj01BZszFcj0hwv8CBswsHBvN0WvHbTpHL6B3javnBEz4+ZhssuOgzvf+JSa0joiEsNsPrYQQgjhTKSiSQghhJgEV6poCkkModZgn+TLF0o9Bjh4WwJ+P15H8YOL2HyWN59ED9Ctm94Neo9OmVYPG/PZcdOab0o0GuqMg7y3ykjShgybDavT67BYrTYbT8xc+opkyg5X2GVs3yBv/vPrd+wythBCCOFMJNEkhBBCTIIrNQOvL6ln0+Yu9HbOYfTqFPYHmDFPM7n0BZ1VIeaVcgb6p5Yci//manaFzqzZ+VQoWg2fnOVLzKJYm4yXtiyJurKGiU8UDmF0M1Bf0Wi38d08TZR+Vk5Xm1SwCSGEmN0k0SSEEEJMQq8LLZ0DKN6cy6lvtOBmcf4GxGccgarDlVO6JuXaZXyYbLFTRGPr0yl8dkUkCWuTSViXgoevx7TGmbcug9ydhTaOTsxE2rJkWmrb7DZ+XXkjy85axIcvb7XbHEIIIYQzkESTEEIIMQmuuGNU2SdFrHqlDu9B5/hzr7EqxPcYCDXr8LBoQFHI7DRS+tK+KY2Tct583l2o3v+P6KgQ/ndJEB9cFED1fQtIuXQR2ik0Xs9ancbhrXl2jFBMVXRapEMSfwe35OAT6IVl0PFJUiGEEMJRNMpUu24KIYQQc1BdeQO3Lvwh3e09aocyZZHZURy5NoYWgzr9gHRWhbXVRsyvF1FfWn/8uFanRavVMDgw+ZvuhPWpbDnfD4sdd9QbT3pQCCUtzQxYh8ec3G0k5q1qyneVjnt9ypJEiveXIq++1Je9Lp3yI5XojXq623sw9zpmGeZznz1JR3MX80/JdMh8QgghhKNJokkIIYSYpG3/2s2Dl/5C7TCmJTQ5jLKvJVFnst9OdKNZ3GJE/2IuTceaZzxWaFIoB7+RQO8Me0JNV1JAANUdnfQOjtFLSlFYVW/C8vc8miqaRjwdnRZJQ0Uj/Q5KaIjxuXu7EZ8dQ3lOJT2dvQ6b96LvnMP5t5/JQP8AsRnRDptXCCGEcBTnqKUXQgghXMDai1fwlVs3qh3GtNQX1xHzf/nE9E59Z7fp8hrUoPnDYZskmQB8UoJVSzJF+/jQ2N09dpIJQKNhZ5iZg99OJumWlbh5mo4/FRQVSHtjhySZnEhvZx89Hb0OTTIBFB8sIyIxjOriOpfr/SaEEEJMhiSahBBCiCm49anrSJhnm13HHK25spmgp3NI7jY4ZL61+wdotWFzZY2HY+I+mb+bO8siIukeGKC9v39S15h1CpvTFRoeWELK+fPxDvRCq9PS0dxp52jFVHn7ezl8zorcKhRFIWNVCn+48y8On18IIYSwN0k0CSGEEFNgdDPyo1e+h5uHaeKTnVB7fTvuTx4gs9Nov0kUhdW1Rkr+sd+2wzo40bQsIoqO/j721lTT0jv1qpdGo4XNp3kQdloyIdGBZKxKJTQumNjMaLLXpZO4II7QuGBi0iPtEL2YjCPb88lclUr22nSHzdnR3ElrfRt+wb4czalg55tTa4YvhBBCODvH1c8LIYQQs0RMWiS3/99NPHnjM2qHMi3drd24PbaHhXcs56C/bZdyRfTryXqvidKPCmw6LoC1sgPdAl+HNAIP9fTi09pqrDNsZbm2w5Pif+4a9xy9QUfm6jRyd9j+eybGpygc320ufUUy+buLHTJveW4VAWH+rPzKEp762rOkHU4iIMzfIXMLIYQQ9iYVTUIIIcQ0bLzuFE6/eq3aYUxbX3c/vY/tIqPDdpVNq+uM+P10n12STAClHxVw2uuteFjsn2iK8fWdcZJpvkcAlT/+cMLzBgcs5O4oIGtNGnqDbkZziulrrml12FwVuZUArL1kBea+AZ688Rlkfx4hhBCzhSSahBBCiGnQaDTc/Pg1aB1QXWMvA/0DdBmsNhvvqL8VnZ0TJWVbi1j652oCzSfmCffyYllkFLE+vjaZY35oGDkN9TMex7+yD80UcgdHthcQFBVIxsoUstdlkL02nYyVqSQuiCM8IRRPX48ZxyRG5+Xviaef476/XySawuNDefS9+ziyvYAnb3qGwQHH7gophBBC2IMsnRNCCCGmKTDcn0VnzOPTzZ+pHcq0hKdHsN3ddje2NaZBMq5eyNHf7rDZmKOp+uwYKZ19WO9eRrenliONDdR2dQGwICyc5p5uKjs6pjyuSacjOySMT2urbRJnRYweDTCVVGTd0QbqjjaM+bzJw0ji/DjydhXNOD4BcVnRAHS19XD08DGHzVueV3n8ceaqVB597z7uOfNhWmpbuf/VH+Dh7e6wWIQQQghbk4omIYQQTsvcP8Bbv/+A75/yY+4562EOfHhY7ZBG2HD1erVDmDav5dE2H3PQzTEvLRrKGihva+VI4/CkzKG6Wqo6OlgYFk6Uj8+kx4v38yPYw9NmSSaAo90dhG5Msdl4AP09ZvJ2FTFvXToajetW06nNL8QXn0BvzL1myo9U0lTV7ND5y49UDlsql7kqlUfe/RG5Owr5wSkP0FzruGV8QgghhK1JokkIIYRT++23nydnaz6fbv6MuzY+xIH/5agd0jCrLliKm6dr7kBXnmj7ned0g47pMxOWEka90TLqcwpwsK6W6o4Owr28yQgKZnF4BMsjo1gcHkFaYBAhHp7Hz18aEUlVRwdVnVOvgpqI5txEm48JcHhrPkmL4vHwkcqX6fAO8KKjuZOa0pkvkZyO7vYeasuGz521Oo1H3v0R1cW1fGfVj6jIr1IlNiGEEGKmJNEkhBDCaRlNBuLnxQ479uz3/oRlcPQEgxrcPd1Ye8kKtcOYssDoQAq8bLvjHIDWQYkm30WRE56jALVdneQ1NbK/toY91VXsr62hoLmJhp5u9Fot/m7u7KupZsBqu15VJ9OZ7ff9KN5fhpe/F2HxIVO+1mAykLU6lfQVyaSvTCZjVQoZq4Y+dyZarYa4FYk27Z8UEh1IZYHtKtem628/+/eIY1mr03jknXtpb+rge2vuI2dbvgqRCSGEEDMjiSYhhBBOLXXJ8IqQ8iOVfPLqTpWiGd2m6091uWVMgWviwQ4xawbsk7D5MsWiYJhhvnHQaqW1r9c2AY0i0dOXuvsm3nVuJhoqGmlv7CBlydQqpxIXxnFkRyH5u4vJ31VM3s4i8nYOfZ64IG5ayStb8w/3o+OxVfzv8mAi19suARYSF2yzsWbi/Zc+puTQ0RHHs9ak8+i7P2LAPMhdGx/ik3/uUiE6IYRQl7nPTE1pHQ2VTbTWt9HZ2kVvd58qbzY29nTz+/17uf+jD8lrHLuPojhBo8heqkIIIZzYey9s4Rdfe3bYsV9ue4is1WkqRTS6ssMV/PHuv7DvvUNqhzKh4Phgjt2aSo3Jtjtc6awKp73eStlWxzSqDooJxPjVDLaFm8HJdv9z0+nJfrmClr2VE59sI/PWZXB4a96E52WvyyBngvO0Oi2Zq1KpKqqhtb7dViFOSeB969gbNFR1t7LBSMMjW20yrlanJXN1Krk7CrFaHJMYHcvC07N5/P37R01UH9mezz1n/Yz+HjO3PHktF3/vXBUiFEIIx+po6eS/z7zP//62jZ6OHno6eunt6jv+vEajIT47hsxVqWSuTiNzdSqhscEzfsOvobsLT4MRT+NQWwGL1cqOymO8cuQwHx4tZfCkyudFYeFclb2A89PS0brYG42OIokmIYQQTq21oZ3f3/ESH/1tO1argk+gN6/W/QGdTjfxxSo48OFhnrvzZUoPlasdyqjCUsMpuimBxjH6G02XwQKnvdNOyf8cv9QnKjuazgsTOBDQ7/C5x3JqtZFjP7dNYmQq4rNjMLobKdpXymgv8bLWpHFke8Gkx9NoNaQuTWKgf2BaP9Oe/p5oNNDV0j2p85PPnYc12otOfz27Qk4s7TRZIPH+g/T32O7/cXRaJAP9A+Pu8ucID791D8vPXjTqcznb8rn37J/R193PI+/+iKWbFjg2OCGEsIHWhnZydxSQu6OQvF2FWK0KfiE++AX74hfii1+wD34hvvT39LP3vYM017RSX94w6Tc60pYnk7EihYikMNJXJJM4Pw6dfvKvEw/V1XL9G/8i+PP+jWlBQRyqq6O9v4+rsueTHRLGXw4fYnf18DePHjntDC7Pmjf5b8QcIokmIYQQLqGqqIa/PfpvtBotd7xwm9rhjMtqtfK/v27jzWc209fdR0NFEz2d9luiNRVunibCb1zCh/GD06sCUpQRS+5MFlj3RovDKplGk7Qpk81neas2/8nC3b1wv+VD1HyPMygqgPCEUEoOHqW3c+id4OTFCZQcKGO6r/zC4oIJjg6i9FD5pH6ekzdlsu90P6J6dPT9bAeDA+MnN0MSQ9j9zXiUMX4uN73TScn7udOKfSx6o57E+XEU7iux6bhTEZMeyXOf/WLMm6Jnvvsn/vPrd/jVjofJWJnq4OiEEGJ6BswD/PmBV9n+nz1UFdXadS69QcfaS1Zw7i0biU6LpK+rj6CoAKqKainYU0zy4gTis2JG/T3b2N3Npr++yF2r1/HVzGxqOzv5pOIoPQMDXJqRhbdpaMOXR7Z9zB8P7h92rbfRxAfXXE+Ip5ddvz5XJIkmIYQQLsVisZCzNZ8/3v0XPH098PTzxNPHg1OvWMOi07PVDm9UO9/YxwMXPqF2GMPELkug9MJIKtwHpnSd3gpn7DazY5kbHXorHhYNK19roHxXqZ0inZzo76/l45ipfS32ogEyHs+jr9b2u9hNlZuniaiUcNoaOmiqbrHJmCZ3I8mL4mlt6KC6ePSbB99QX47cmYFZN/Qyc32lgapfbBt33NjvrWFL7NjLOddVGah+cvwxpiN7bbrqTbe/9X9f4yvf2Djq0o9vLrubok9L+Xvl7wiKDFQhOiGEmJrW+jYeuuwpVX63xmfHkLI4EXdvN9w8TJTnVnJ4ax6KVSFteTLzbl1L2soUlkSc2FSkpKWZpIDxf79e+5/X2F5ZMeL4mYnJPHPOeTb/OlydJJqEEEK4lN6uXr4+/44Ry12y1qTxy60PqRTV+BRF4a6ND3HwfzlqhzKM0c1A9I1L+SDJMmYVyWhOf6WRtvImPK6dh+GjKir2jWxo7GjtT6ymycbLAWdifZ5C1XN71A7D7uKyovHw9qDo05JhFUuJt6zk/fThLzHPPKRQ/OLo35PA6EAOfjeZgXFWOvgMagm9a7fN+yqlr0wmf1exTcecDq1Oi7uXG1fddwmX/uArWCwW9r5zkJ9c+AQGk4E3Ov7stEuGhRDiC0X7S/nJhT+nsapZ7VBGFfO9NexMgL9ffBkJ/v54G03j9ncqaGrk6T07eb907MrXZ885j02JzrVrq9r0agcghBBCTEVnSxenfHU1Bz48TPH+MhRFYcM167jt6RvUDm1MGo2GJRvnO12iydw3QOkzO1m/MJbKS2Mo9ZhcRZAhPYi23aW0PWH76pLpiJoXTakTJZkABrLmRuVJ+ZGhfhU+gV7EZkZTU1JHT2cvu5I1wPBE03vz4MwzMyl+L5ewlDB8MsPoj/PiWLCWfW79KBPshdyht7JsRQJHd9h2mdtAv22b4k+X1WKlu72Hpqpm/vmL//LfZzdTW1YPwIZr1kuSSQjhtLo7ejiyLZ+D/8vhv797H3Ofc1QYj0qjod8ywEWv/g0AT4OBMC9vwry8CPPyJvzzx4EeHrxVVMDbxRO3BXjg4/+xIjIad4MBRVEw6nQutxuxrUlFkxBCCJfV3tRB3dEGUpcmqR3KuLraurk+5Vu0N3WqHcqY9EY9cdcv5cM0K5YJqpsWtxhpe9Dxja7HknzDct6b71wv6MLdvfC45UO1w1BF+rfW8VaiedTnjBYNboqGDv30qpI2lOo4+psdMwlvhJj0SI7lV9t0zJk4/5tnsvW1XcOa4D6f9zQxaZHjXCWEEI7R09lLTWkdNSV1FB84yqGPjlD0aanqu3hOliOW2h/8+jfxdXOz6xzOTiqahBBCuCzfIB98g3zUDmNCf3/k306dZAIYNA9S8twuVmdHUXt5PMWeY78Iq/W04u7A2MbjG+pLaZIJGD2xoZba3i4WLYig/VCN2qE4XFt9OySO/hNi1imYmf57nEeiNHhO++qRfAK9cfd2IzYjioq8KhuOPH2DAxZOu3It//rlWwCsOHexJJmEEA6jKAptjR3UltZRU1pPTUkdNWV11H7+uK1R/f6Dzq6jv18STWoHIIQQQsxm9RWN/OfX76gdxqRV51SRsCaG4nE2t0qvUih3WESji10az8BpUewKHWBQ61xJpi/4bkyek4mmvqMtsMo+iZE60yCnLIih8tCxGY+VsjiBuvIGCveW4hfsg7u32/Ed+tR06KMj3Pu37xxPNF3y/a+oHJEQYraxWCw0V7dQXfJ5Aqm07vOPempL651mp1xX1WnuVzsE1UmiSQghhLCjAfMgA2bn6AEzWS3BBmDsF0mDWysdFwyQct58MOqwNPegC3CndKE3W7zMgBP3gAAGQp2l7suxOgvqAftV4JiWRsIME03JixMo2l92/PO2xg48fT1mGppNVBfXUpFbRcK8WLQ6LfPWZ6gdkhDCBZn7B6gvbzhRlVRaR23Z0OO6ow0u99rEVhQHrLTv6JdEkySahBBCCDuKTArD29+TztZutUOZtFLvsV98JnYbqPps5tUkYzG6Gwm7dRmm/DYaD1Xift183g3/omLJ+Pl/nbOC6WTZHgE0fG9u9mga7DST6ulHYXebXcYvTtDz5fuEiMRQ6sobJ90jxM3TNOxznV5Ld3uPjSKcub889E/OvvkMgiID5nxDWSHE2L7olzRUlVRPTUktNWVDVUkNx5qQdswjOeJXaqckmiTRJIQQQtiTRqMhdVkSn27+TO1QJqTVaoj87hpKDWNXCqXk9zHx/ivTF3d2Ju/GDkKsF2xKA43zJ5W+LNPTH/P3P8TS7Xqx24r7z/cT8L0sWvptv/yizH2A+EfWsiDXjLmkmeriWmpK68lcnUrujsLJDfKlmy/fIB9a6tpsHut01ZTWo9HAuktXqB2KEMLJmPsH2Pbabt58djN5Oyf5O08c54jcW4csnWOCjWSFEEIIMVNpy5LVDmFCeoOOkDvH34nFaNFQt3noRa1WqyFpQwae/rZszQzFi71PfOJilRxajYblhgAsP/yYwc65m2QC6CxqZF6R/ZY2HvUYoGF5IAV7SuhsGaoWbKxqmXT1T/8oW28bTIZRz3X3Vqeh639/975UMwkhjquvaOT5e/7KVTG38tg1v5Yk0zQ5YumcVDRJRZMQQghhd1qd876vExwfjG9SME0rg9gRMH5yRAeErUkg1NvI4Uwjm02DLF61GO3PtttkW+O4lYn8z8P1EjQaYKkxAOXFHJr27lI7HIfReRoZ7DaPWMamMeiI+slp7PDuBjvudt1vHD5zQ0UjmavT6GrtGrGDnFarITg6CL8QH4zuJo7lDe8z1lLXRtryZAr2FA877unrgQZIX55M/pees7e6ow28/9InnP210x06rxDCeVitVva//xlvPruZPW8dkKVwtiA9mhxCEk1CCCGEnZXnOrZ59lg8/TyIPCMNc4QHDYFayjwHKNV98aJ14gRPr07h3fVfVHcM9XHaH2Am+8drMOuh3mghvVWHX2EnjTuP0lrbNqX4tItCsWtmwg6WuAWifTmX5h271Q7FcbQawp46kwP6TvQaLbFGT/zbFXRl7Viae6jeEMbH3e12/V+Z5RHAACNvuHJ3FAAQEO5HREIogwMW2ps6aDjWRH1FI/UVjWOOWbCnmOx1GeRszTt+LGF+LDlb8+nrUeem4a8Pv8YZ167DYBy92koIMfuY+wfI3VHA/vc/Y9u/dlNTWq92SGKKDtbV0NjdTbCnbau+XYlGkbSoEEIIYVc3ZnyXyoJqtcMgLDWcHd+IdcxkikJat4nYcjPm/bVUHjo24TuxKRcuOCmR5dxSPP0I+GsxjR+Xqh2KwwWtiWfPJaF2ncPLYMRstWC2WI4fM+p0LMGXgb8coWXPMbzTQugsaLD53Flr0tBoNCiKQnluJYpFob+3n7isGPQGHQV7S2w+53i+8+zXOfeWMxw6pxDC8Y7mVPDij//BgQ8Oq5bcngsif7iOrZH2r542aLWcnZzKY6dvxKSfe/U9c+8rFkIIIRzI3GemurhW7TAA6G7sdNxkGg0FXmYKsoCscAKviCK7XovbkRaqd5XR0zGySXRHbh2sj3NcjDMQWdLLsTmYZALwWBGNvXf+W1qro/mvR/C7bRnFPoOktGhp/f0+6stbj59jjyQTwJHtBcM+9/L3xMvfi5KDRwHIXJ12vHLKEf72s3+x8fpTMI7RQ0oI4do6W7v48wOv8uazm22yDF2MTxmlGtYeBqxWCpub5mSSCSTRJIQQQtjVsYJqp3nh2NnShc6qYNE6vsFws9HCx9EWiPZGv2k+89pMhJb20L77GPWfLwuoK6rDZzCBDr1zfL/G4qbT0/mBY6tanEl3gheYW+wy9hqrH/qaHmp+v4PBTjPdP3wPD6Bqwivtp6u1e9jnuTsKyFyVSq6DGvE2VjXz3vNbOO+2TQ6ZTwjhGBaLhc0vfMQLP/ob7U0OfCNIOMxFaRlqh6AaSTQJIYQQdnTgg8NqhzBM4KCBBuOgqjEMauFAQD8E6GBpPLG9KaRUWVA+a8S3wzD0nBNbUWCh8oD6SyEdTaPXEP7zM9lmpyQTgMWgpfbJrXYb31YK95Vg8jDS3+OY5vV/e+RfnHnjqRjdjA6ZTwhhX3m7Cvm/b79A8f4ytUOZexz0XptOo+H8tHTHTOaEJNEkhBBC2EFDZRPPfPdP7PjPXrVDGcZ/QEuDk92rVrgPUJEMJAcCzp1kWqP4U/nbd9UOQxWRPzmdTzStE584AznaLkK1GrA6dwvRpEXxFOxxXFVbc00r7/zhf1zwrbMcNqcQwvaaa1t5/p6/8sGfP1E7lLnLQYmms5JTCPaYu83AJdEkhBBC2NjhrXn86JxH6OueWdLEN8QH/69m0+qvJ6jOTMWf9jI4YJn4wnH49AJz93XPjKR7+lN32/tqh6Ga9hAj9Nh3jgyNF81OnGTSaCAmPYpj+Y6vaPv7o//mrK+dhsnd5PC5hRAzZ7VauXvTQ5QfcY6daOcik4eJ4gD7/435/TnnsyEh0e7zODOt2gEIIYQQs0lrfRs/u+LpGSWZPHzcSfr6SvLvyuR/iRYOBPTzfoaC1z2rcfOc2U2myqvmXFagmzuGR/eizDDR56oU4JjFzlkmwG23c2/jnb02g4q8qlGb2dtbS10bb//+Q4fPK4Swje3/3iNJJpVFXb2IOpN9XwilBgZxRmISGo3j+2E6E0k0CSGEEDZisVh47Jpf01I7veVFRjcDKdcspfL+RWzOUOjVDX/XbX+AGe5ejlfA9EqSAqMD2Rc8MK1r5zK9Vkva2/V0lzWrHYpN6b2N+GaHT+pcn9QQWvr77BqPj9FE7T8+s+scM1W0X92dBl95/D+y7bkQLshqtfLyg/9UO4w5LSQhhI9S7V/NNNcrmb4gS+eEEEIIG/n7I//hwIc5E57n6edB+CXzUbRDS3EUQNFqyInTkm8aBMaumsn1NpPww0WkHupB6exnoLWXmkOVmHsnbkpsuiIDs04STVO1ps5I5X/z1A7DdrQaQn51Fp9pOumzDLJUvxCPxn6U1j4sjT0M1HbQU9FGz7EWlMGhF+W+q2PtHlbWgCf1/c5bcmdyN854OexMtda3899n3+fSH3xF1TiEEFOz681PaWvowMPbnZ5Ox1dECrBemcaAzv4bOGyIl0QTgEZRFOddCC+EEEK4iEMfHeGuMx7EOkF/Ga1Wg9+9a9kXZLsXO2tqDNQ+sW3cc6IXxPDxteGgndul3FO1zBhA023vOKp3qEPE/HAdH0VO/POnAfxMbvjqjZgVKzU9XXaLKdsjgIE7tjDQYd+qqZkIjPCnuca+zdAnwy/Yhz+X/RZ3Tze1QxFCTNKDFz9BgI+RN17aoXYoc1LiKam8f4G/3ecJ9vBk1023oJ3jy+ZAls4JIYQQM9ZS18ojVz49YZIJIP6WlTZNMgFsjxgg5col457TeV6cJJmmKMHTl/a7PpxVSSZTiCcHEyb38k8BWvv7KO/usGuSaYF7AP3f/cCpkkw6vRb/ML9hxzx8PNQJ5kvaGjt487eb1Q5DCDFJ3UePcft7j/H1v9xNitKidjhzjt6op3BTiEPmOj0+QZJMn5NEkxBCCDEDFouFR6/+Na317ROem3zuPN5PsU8z6feX6IhflTTm8yU+zrskyRl5G434/TaHwU77l9k7UuBda2mzc6+lqVhiCqD72+9j6XGuJZ3pK1JorWvDL8SHlKWJzFuXgX+Ir9phHffqz9+Q5TdCuIjeCy4joKcV42A/X6FM7XDmnPjLF1Hhbv+/MRrggrQMu8/jKqRHkxBCCDENVquVfe8e5B8/f4OcrfkTnh81L5qPTvXAXuUxFq2Gjy4J5IzMYI6+uJfBk3ZH02g0dGgt2G3yWWhxoYXKQzVqh2FTfkui2GXoAKvakQyJ9fCh7bZ3j/eBchaZq1M5sr0AgLaGDtoaOqY9VsqSRAb6B+jp6KWztctmu9V1NHfywZ8/4fxvnmmT8YQQdvLuuwQd3nP8U72z/AKeI/zD/dg6X8dQja593bNmPcsio+w+j6uQiiYhhBBiGg58mMO7L2yhIrdqxHPaLy1R8wn2oeiqWPp19o3JotXwXqaC9Sericw68WLHw88DRZbNTZq30UjVM7vVDsPmrDfPY9DqPDc50V06p0oyxWfHkLkqlcK9JTYZT2/QUfRpKUdzjlFf0UhPRy9BkQE2GRsgd2eBzcYSQtjBkSMoX/3qsEMV+KgUzNzkfnU2PTr7/525ImseNy1cbPd5XIlUNAkhhBDTsGTjfJZsnI/VauVYfjXF+8vwD/MjKiWcgDA/vrvmPooPHEVv0GG9fQG1JsctwSr2NFN2YyRn5EZR9tI+PPyco7eMq+g0m1l4+QKqX96vdig2E3HFArb1OldvEF1Oo9ohHBeZHM7RnGM2HdM70JvWurZhxwwmg83GL9hjm4SYEMIO+vrgvPPQdHYOO2yRymKHiV2WwJYIM/au5l4VHcNP1p+GRnozDSMVTUIIIcQMaLVa4jKjOePa9SzZOJ+wuBCMbkbufOlbGEwGIr65ks98Hd/nx6LV8F42aH66Gv+FUso9VUVr/DD4zI5dvTQGHcdOdUwj1Klo216hdgjH+Yf6Ep8dQ9KCOJuN6eXnOeKYyd1os/Fry+ppa5y4N5wQQgXbtsHRoyMOS6LJMbRaDdXnR4Gdkz8J/v789qyvYNDZuWTdBUmiSQghhLCDuMxovvba7XwUp24T7kJPM++utd3N7VxR19tNyP2nqB2GTYRflEVFz/T7DNlLwFXz1A7huCPbCziacww3L9skF6NTI0a9vzG42a6iCaBwX6lNxxNC2Ej+id6Nyhr3448tcvvtEEkXL6TQ075v8vm5ufHHr1yIr9vseFPK1uQnXQghhLCTC85eyXJnaAwp5dzTssPYTuC6eLXDmLGaf3zG+kLw0Ns2yTFTNZEGB7Rnnbz4eTHHm4BPVsL8WDx9hy9NzVqdRmVhDcfyq0ecrzfatmvFK4/9h76efpuOKYSwgYKTfpfEnfjdKxVN9heWEsauZe4TnzgDBq2W351zPnF+/nadx5VJokkIIYSwE61Gww0LFqkdhpgmi6LQfk0qyiy4L6h6djeZfy4nzlP9RrRpnn6sz7UyeMtmp7nlMpj0dLf1TOma7LXplH1WQU9HD9nr0o8ftypjN1wv2ldC2vIkUhYnjNg0YDqObC/gpxf/HHO//bfuFkJMwUmJJkUSTQ5h8jCReOsq9twaR5vBMvEFM/DI6Rtlh7kJSKJJCCGEsKO2vj61QxAzUNjdRuwP16sdhk207K3E7QdbSfD0dfjcGmCxWwCrPmhn4Ob3qPrDXrA6Tz1T2rJkGo41TepcjUZD1upUcrYNLY1RFBg0n7ip6e8Ze7mGZdBKwZ4SivaX4RPkQ/a6dEJjg2cU+6ebP+ORK37J4IC6y3SFECf5PNGkBOrA+0T/HiNWApReQpRuIpVOYpQODIp9kyJzQdLGTNoeWMr7aVYG7ZjhcNPr+dlpZ3Bxeqb9JpklZNc5IYQQwk4URSG/yXl21hLTo/TPnhv4gY4+Iju1lDnorUZ3vZ5Fg970vXSYtoO7HTPpFMWkR5K7Y3JL5rQ6LalLkziyo3DYcb3hxI1kT0fvpMZqa2inrWGomXfyogSKD5RNMuKRdry+j5/f8FvufOl2dNKUVgh1tbdDbe3Q4yQDWE4k1W/nELdzaNjpLZj4urKRdo3JgUHODsHxwVivSmdzkBmw79/qeaFhPLXxLBL8A0Z9XlGUYTvPtff18Vp+LldmzcPd4FxL1x1BEk1CCCGEHRyqq+XhrR9xoK5W7VDEDKzv9qbyVx+oHYZN6Y91Qpx95wgwuTOvSU/TM3uoq3W+RuRf0Om1DJgHsU6iukpv1JMwP5b83UUjnlOUE9d3NneOeH4ittiNbsvftuPmYeK7v79FttkWQk2FJyWik4wQMH7yN4B+QummHUk0TZbBZCDu6sVsydBg1tm36bdOo+G2pcu5femKMXeXe6e4kIe3fkxqUDBnJibR1NvLHw7s4/51p87JJBNIokkIIYSwCaui0NzbQ01HBy9+dpA3CvMnvkg4tRX6ACp/9M6s66jRe6gW4ma2XGssoe6eZBT2U/XMNir7nL8SLHNVGoe35k14nsnDSFRKBEVj7PLW1z3UkDsyOZzq4qknl7U625SYvfPH/2HyMPGNX14vySYh1FJ90kYAYXrY5Ilyqx/k9YNBM/Sh06B5uwsAK2DAikZRUDQafJR+HmAX3ph5mBUc06jfW8+ZJKxPoeCsUN5zGwA7bykR6+vHUxvPYmF4xJjnFDU38e333saqKNR1d/FJxVEAVkfHcFFahl3jc2aSaBJCCCGmYNBq5a2iAgqaGqnt6qK2q5O6rk7qu7oYsI7dBFi4lnkeATR903maVdtS864KDBeF2uXnNbnXyLGn/mfzce2lp3PiZW4ePu4ERwdSeqh81Oej0yKoKq4le106uV9aUjdZtrxV+s+v38HD253rH7rchqMKISYtOfnE4wIzuGlRHvhScr9h8HiiSQs8zce0YmKfEkYwPcxjqGfcfezmduV0zBpZEhsQFYDh6iw+CO0Hjf03QAj38ub1r16Fr5vbuOc9vmMbVmX4b3E3vZ6HTz1jTif8JdEkhBBCTNK2inJ+tv0Tipon1zRYuKYAkxsD93yMMjA7G7Ra+weJcfemtLvd5mNrB5ynwfdk9Hb1odFohi19O5lPoDfeAV5U5FaN+ry7lxu+QT4M9A+Ss3XiKkaNVkP68mR0Bh25OwqxWqzEpEeOuhxvJv76s3/h5mni8rsvtOm4QohJSE8HLy/o6oKDY2wIEqhDucALzetdxw/5089GKoadFk8Ht/AZv2Hu7mCr0+tIvHIxH8/X0aszgwPeAtIAv9h41oRJpl2Vx/iofGR/ve8sX0msn599gnMRkmgSQgghJlDe1sqDWz/i4/KjaociHCBZ8aCpeWpb3bua4H4doy8CmxnNgGtV9VUX15K1Jo0j2080A89YmYLVakVv0NNY1TzuUrjUZUkc2nJk0vOFxgaTt2soqRSfHUN/r5nOli4GzbZfZvj8vX/DzcuNC24/y+ZjCyHGodPBkiXw8cdoagZR6gaHltANO0eD8mw4yn0D8FEPmv91w9YeND0jk97nUcYBJZQdmkgHfQHOI25FIuXnRfCuh/2XyZ3s5sVLWREVPe45VkXh0R1bRxzPCArmpoVL7BWay5BEkxBCCDGBzaXFkmSaQ9yL2/EJ9MY/1BcPH3cq8qomvZOYq3Cv64Ug24+rNbteFdix/GrcvNzo6+rDJ9CbitwqujsmTjQmLYyfUpIJhu9IdzTn2JRjnarffvsF3DzdOPOGU+0+lxDiJEuXwscfDz3O7R+ZaPpCpAGu9kW52hf6rSh7+9Ds6UXJNEGzBe0PGwD4PvspVPxp0ng4Jn6V+Yb44HXdfP4XYXbIMrmTZQQF8/0Vqyc8779FBRxpqB92TKvR8OiGTei1Dtra1YlJokkIIYSYQID73HhhN9cldhtI+bSTis159PeY6fh897C4zGiaalroau1WOULb6dlxDLeLwumz2LiSpt/1Ek0dzZ2kr0ym7mgj4Qkh5O2ceBmbTq+ls6VrwvO+zGBy/O5Dv7z5Wdw8jJzy1YlvnIQQNnLyclzTJJd6mbSw1gNlrcfxMZSPe9C83YUPZu5mL3cq67HO4r4/Wq2GpK8uZvtiI536ARyxTO5kJp2eX246B+MYu8udrKy1ZcSxGxYsIjsk1B6huRxJNAkhhBATuCA1nVeOHOZg3dR3kxLqCxrQEWjWobOC3go6K+gU0FpAr4B+QMG0t56yT4oYLcWg0+vwCfCaVYmmpo9Kyeoy0/H1TIq622w3cL/z7zQ3mvxdxWg00FrXNqnzM1alTqon05fpjY5v6Gu1Kjx2zW8wuhtZdd5Sh88vxJxUWXniccQ0b7k1GpQnQ+BgH5qaQebTxOUU8DfSbROjk4lZFEvNRbG862VmaC8+x7tnzTqSAwMndW5mcMiwz5dFRPG9SVRCzRWSaBJCCCEmYNDp+NWZ53Du31+mo79f7XDEJBkscHqBhoqX92LuG2AQmM7/vbLDFWg0YHQzYO6bXAl/fHYMXn6eDPQP0NvVR2drFxqNhpbaVsboO+1wrfsqiUwNpmiJ0WZjKr2umWgCJvz/EpsRhU+QN1aLlcJ90+twZTCq89LbMmjh4cue4uG37mHRhnmqxCDEnHJyoil8Bv/u/XQovw2Di6vQWOFa8jiohJCvmVwyxBV4BXgScN1CPooeAK1ZtTjWx8ZxzbwFkz4/86TKpY0JSTx95tm46R1fteqsZPGgEEIIMQlRPr48dvomtcMQk7S4xcTSZ45S/Iddk04OjUVRFKxWhfDEyZXDa3Vautq6ydmWT8HeEiryqmipbaO5ppXkxYkzisXWdLG+Nh3P2uPYXhqOpDfqydmaT+6OQsy907sZ0unV26J8wDzIAxc8wZHtU6/EEkJM0eeJJiVAB+4zvOVe4Q7fCwBAh8K97MFTUS8hY0spFy3k2L3z+Sh2ELTqLQkMcHPn8Q2b0ExhWWKElzf+bm5clpHF/539FUkyfYkkmoQQQohJOjMpeUrvdgnHCzHrOfP9Ltoe/IT60vqJL5gCb3+vSZ2XsTKFxspmm85tL8d+9hHr9g8QYHKf1vUaIMHTl1Vaf049qsOvzoxepaode+vtGmOb8ikwuk+uekyn15G6LInstelkrUlDb7BNgqqvp58fnfsohZ/aY89BIQQAFgvU1Aw9jrTN70PluwEoS90ACKOH73Bg4jJMJxaZFYXHT9fx7joTrXr1dyt95PQzCPGc3N/4L2g0Gh49fSOPnr5Rmn+PQqMoLvwTKoQQQjhY/+AgF7/6N/KaGtUORXxOZ1VI7jYSUzlIzd8P0ts584TAaDJXp5G7o2DccwwmPZ6+nrQ1tI/6vFarwSfYh7b60Z9Xi3u0H8YfreJA38jmpuPJ+nk+vdXDv5botEi627tpqW2zYYTqi06NoLKwZkZjRCSG0lTTOm5FlJe/J1qt9ngzeoCAMD8iksIo2FvCoHnmyxO9A7z4xcc/JT4rZsZjCSG+pKoKoqMBUDZ5orwYYZtxKwfQnHEMTftQYuZJlrBZE2ebsR3Ew8ed0GsXsSXBgtVJcjNfzczm0dM3qh3GrCOJJiGEEGKK/pl3hLs+3Kx2GHOW/6CWjCY9PlW99Bc2UXuketpLmabCO8CL8MRQrIMW3L3c6e7owd3LHa1Og7lvgM6WTgIjAiZsEp29Ln1ajaTtTQFSH9rIu94dkzrf12gi6LZPRn3OO8CLkOhASj+rsGGE6vL08SA4JhAvP080Gg2F+0qmtSwzc1UquTsLx3w+e206OdtG//nwC/UlOiWCgr0lDPTPbJmif6gvT33yIFEpNroJFkIM2bULVq0CQLnRF+VnIRNcMAVvdaK9uQ6AXnTcxgaqNN62G9+OUs6dx7513jQZnWd3UoNWy56v3Yqf2/SqesXYZmdtsxBCCGFHi8PlxsyhFIWMLhMx5Wb6DtRSdegYdYpCnYPD6GzpmnBL+5qSiZfrdTR1TniOGjRA+/MHWXv7Yrbp2yY8P8BgGvO5zpYuutu6x02auJrujh66j/Qc/3yihNFYcncWkrk6Fa1Wy6B5kLKcCvp7TiRK2xrHrnZrq2+nrb4dvxBfolNnlnBqrW/nzg0P8tTWBwmLs+GNsBBz3UmNwJXp7jg3lnO9Ua7sQfO3DtyxcC97+I5yKgMa9fq/TSQsJYyeK1J4198MOE+SCWBdbJwkmexEEk1CCCHEFMX7+ePn5kZbn32WaIkheiusqTFgebeMmtxqitUOyEYm26fH0dKWJVGwtwTN3ZvJfuYscnrGX0bno+gZL+1mtSrkbMsnfUUyA+ZBDCYDOp0WFMjdWeDK7UUA6GwdP+k4ntwdJxJUqcuSKNxbAgwtrassmHh5XltDO20N7fgGeeOXFEZFbuWE14ymsaqZe89+hP/b8yge3nKzJYRNnLzjXITtG0QrDwXD3l40JQMk08aNHOH3zLf5PDNl8jARde1itqRYGVRxN7nxnJuSpnYIs5YkmoQQQogp0mg0LAgL5+Pyo2qHMiv5DmpZUaTQ9GYelXXO1cvIFoxuzplo+qLZtTKooPx0B2E/XkJdb/eo52o1Gny31Y+baPpC/u6RKcLkxQlUFlTT190/k5BVdSy/mqiUCKqKZta3qXBvCdnr0hk0W+jrnlryur2pk5iMqBnNX1lQzVM3P8uP/v69Ke24JIQYw7FjJx7buqIJwEOL8rtwOLsSjVnhEorZr4TyqSbM9nNNU9LGTHJO9yfPNPOecvbiptezId65doKdTZykBZcQQgjhWmT5nH2cVqYn8sf7KXluF22zMMkEoNWNfzPv5etBxqpUEufH4Rfs45CYEubFUpFXdfzz3up24v5ejmGMnXTWN7lT/fL+ac9XvL+MwAh/3L3cpj2G2rz8Pcdd5jYVOVvzyd9dxNGcYxOffJKY9EjydxXNeP5PXt3Ff379zozHEUIALSdVg9qrrCPThHJf4PFP72Qffor6VdbB8cEE3reOzWd7U+PESSaAtMBgPI3O+cbPbCCJJiGEEGIaFoZJosnWUruNVD+7i/4e161ymYzCvSUkL04YcdzN00T2unSsVoW8nYWUflZOW2MHHt7uxGZEkbkqlaw1afgG2b7xq0Y7MvnV+HEpCw3+I46v1AVQ8dCWGc/ZVN1CvwOauNtLbHoUXa2jV3w5gpe/J11t3QwO2KbnyXM/fJkjE+yqKISYhBUrjj/UvGrHnnxf80PZ4AGAP/3cyT40Kq1JNpgMJN+0ggO3J7E3yDV+r5e0NmN19TXcTkx2nRNCCCGmodtsZtkfn6V30LnfsXMZisLa5yqpyZ/ZMiRXodVpSVuWjM6gxTJoQafTUZ5bOWGzcRhaupm1Js1mTbbHa9gdfkEm2085kdjK9PTHfPsHWPtn/nOfvCiB4gNlU77OYNKTvCgBc98A7p4myvMq6WxxbMIncX6s6jvqJS2Mp+SgbZfvBkb48+z+J/AP9bPpuELMKR0dEBkJXV0oHhqUg/HgY6dm3U2DaE4/hqZhKOH8e+bxmibFPnONIWF9CgVnhVLpNrOdMNWw5dobifMb+YaKmDmpaBJCCCGmwdNo5MfrTlU7jNlDo0Hvbvumqc7KarGSt6uQnK355O0sImdb/qSSTACKotBcM36j7snKXpcxbsKq5vVc4jyHlu9FeniheWCHTZJMMFTBNRVxWdFkrU5Db9STt6uIkoNHydlewOCAhey16TaJaTL0Bh2dbepVMsHQ/zdbJ5kAmmtaeeTKp7EMOtfOUEK4FB8fuOYaADQ9Crxmx6qmID3Kr0OPf3ojOSQrrfab7yQBUQGE3r2ODy7wd8kkE0BuQ4PaIcxakmgSQgghpumyzGzOTExWO4xZ46Orw+h7fA1uLty3x1HqK5rQ6ka+jAuM8Cd7XTqRyeGkr0gmaWHcmGOkr0ghZ2veuPNogPiSfrwNRiL+WEhvTccMIz+htb5tUucFRvgTGhdM+ZFKjuwooLdzeB+S3s4+WuomN5YtZKxMpaGiyWHzfVnKkoQJ/7/NxKGPcnnx/lfsNr4Qc0Lgif5JmsN27p203hPlm0NVOQYU7mUPbor9qq11eh0p1y7jyPdS2RlmBhfeROBIY73aIcxakmgSQgghpkmj0fDI6WcQ7uWldiizg1ZDtWmQsMyh/lf+4X7EfXsN3gHy/f0yy6CFjJUp+AR64+XrQdbqNOKzY2iuaSVnaz7VxbXk7y6m5GA5QVGBzFuXgV+o7/HrE+bHUry/dFJz1T63l2V7e2nZWznxyVPgF+I78UlAeEIo9eWN454TEOZng4gmFhYfQt6uQofMNZqgyACqimrtPs8rj7/Ozjf22X0eIWal7dvh0UcBULSgXDG533UzodwZiDJ/qEo0ii5u56Bd5olbkYjlwVW8u0hLr861O/AEe3hypEESTfYiPZqEEEKIGdpTVcmV/34V+YNqG2d+poAGPskceiHrbtEwr9lAQFEXjTuP0lrjmGUBrkKr1WC1TvzTp9VqSFqcgMFo4OjhCno6eyc9R1h8CP09/bTW23YnwPQVKZQdLqe/Z/TmsT6B3vR29THQP/6yDHv0KxpNfHbMlHeGsxW9UU9YXAhVRY7pY+bp68Fv9z1GZFK4Q+YTYlaorYXly6FyKDFvvSMAfhA4wUU2ctSM5oxjaLqH/h78jOV8rIm2ydC+IT54XTefrRGuXcF0sq+kpJEeFMwti5eimSVfkzORRJMQQghhA0/u3M4zn+5RO4zZQVHGfiGrKHhbdCyo1zHwz3way9VbwjTXBEb4Yxm00tZg22RTaFww/b1m2kZJYs1bl8HhCZaJ6Y16NBoYsFHvqLFkrk4ld4d61UwpSxIo+nTqzdNnImFeLL/a+TPcPKbWT0uIOWnLFrjySqgfqpJRVrijvBYJOgcmMf7ZgfbbQ/N3o+dWzqBO4znt4bRaDUmXLWL7EhOdequtonQKbno9j52+kQ0JSXgY5k6PSEeRpXNCCCGEDXxn+Urmh4apHcbsMN47ixoNnXor2yIH8D810XExzXEhMUEERQbYPMkEUF/eSHRKxIjj7t5uFB+cOLHi5mFi0HwiyRQSG0xEYij+YX6YPIw2idHTz5OK3CqbjDVdbY12bCg8hrLDFfz1odccPq8QLsVigQcfhA0bTiSZIvQovw11bJIJ4FIflIuGdgr1ZJB72INOmV6CKHphLNoH1/LuCsOsSzIBnJeSxqDVirter3Yos5IkmoQQQggbMOh0PL3pHDzlXTGHaQuXKgtHyF6bTnNNC4X7JtfTaTpKD5WPSAolL0wY0fh7NF1t3cRnxwJDvadaalqoKa2nta6N/h4zWq0GLz9PotMiCYme3hKWvq5evAPV7RXWeKwRvdHxN0Sf/HMXsgBCiDE0NMCZZ8IDDwxV4wLKKR4om6MhQp3XA8pjwSixQ3Nn0MI1TG3zAK8AT2K+t4aPrwmj0Gv0Zc2ubklEJEkBgTT19MiyOTuRRJMQQghhI7F+fjx4yga1w5j9rAqnHjPQ+3v7NDsVw9WW1mMZtO+72T2dvSQvSsDkbiRrTRrhCaETLpk7WVdbN2nLkqgtq2dwwDLsOatVoautm8qCanq7+4nNiJpyfJZBK3qDDq1WvRsSRYHQ2GCHz1tbVk/5EXX6Ugnh1PbtgwUL4MMPgaHG39a7AlH+GgFBKlbJeOtQnglD+TyEKyhgntIwqUtTLlrIsXvn81HsIKj4+84ewr28uXnREu5evY5nzj4PPzc3LsnIVDusWUt6NAkhhBA2pCgK33v/Hd4sLFA7lFkprdNA2L+PUXmwQu1Q5gS/EF+7LJcbjXeAF5YBy5SalE+H0c1AfHbMtCq0JtMzyp7SV6SQv7vI4fNe99OvcvX9lzh8XiGcWkYG5OcDoIQMJXdY7aFyUCf5TQvaR5oBaMSdW9hAp2b0SuDIrChaL00gx3d2VjABPL5hE5dmZB3/vH9wEJMsm7MbqWgSQgghbEij0fDgKRuI8vFRO5RZKebDBkkyOVB4fIjD5ups6bJ7kgnA3DdA0adlJC9OmPK1ebsKCU8ItUNUk6PWCo+db+xVZ2IhnFVT04kkU6IB5YMY50oyAXzTH2WNOwDB9PID9h9f3vcFDx934m9fzfYbo2Z1kinM04vzU9OHHZMkk31JokkIIYSwMR+TiV9uOhutrPu3OV2Yun1y5hqdUad2CHahN+pprGqe9PmxGVEkzo9lcMCC0c2gyhI6g0lPWY46S9iKDxyl4VijKnML4ZRyc088Xu8BIU6YtNBqUH4ThuI/dMu/mhrO5cQGCynnzqP2vkV8mGTBOsuzAjctWoJRNzv/njmrWf4jJYQQQqhjcXgkd65aq3YYs07RfA9V++TMNe2NHWqHYBdpy5Joq5/cksCAcD9a6too/awC/zA/fIK8WXBaNkERAYTFhxCVGkFcdjRhCfat/kpZnEhf18TN0e1l5xufqja3EE7nyJHjD5UU2+xuaRdhepSnT1Rh3spnLIo14vPAOt7d4EGT0TLOxa4ryMODeaFhrIiMJs7Pn8szs9UOac6RRJMQQghhJ19fvJQ/X3AJ4V5ShWMrpR4DJJ03X+0w5gSju5Gqolq1w7A5N08T5bnDK4NM7qPfKOoNOjx9Pels6QKgta6NnK35HPjwME01LdQdbaCqsIbynEqCo6a3o91kBIT5UZ5babfxJ2OHLJ8T4oSTK5rSnHwH1I1eKDf6AmDCSnpMJQf9Z+8yOYCL0jN5/atX8beLL+POVWvxNDpxMnCWkkSTEEIIYUdrYmJ596rruCgtQ+1QZo3PVnqpss37XKPRMKKfx2yQsjiRzpZu3DxNZK5KJWlhPAP9A0SnRZK9Nh1PP8/j52asTKWyoHrSY2euTiUoKsCm8Xr6eOAX6kt3e49Nx52qw5/k0dHSqWoMQjiNkxNNqc6fxFCu9T3+2LNfvcpIR2no6jr+eH1s3NjndXfR0qvu79bZShJNQgghhJ35mNx4cuNZPHvOeQS4uasdjsurMQ2ScOE8tcOY9fp7zEQkhasdhk15+LpjsVpIX56MZdBK7s5CSg4exWpVqCyoJmdbPv3dfaQuSyJjVQoF+0omPXbO1nxydxTS1dZDxqqUGccamxlFxqpUzP0DlH2mfgN8q8XKnrcPqB2GEOpTlONL55RQHfi5Vu8f6xzoH1nc0kxnfz8A7gbDmOeVtbaytUL936+zkSSahBBCCAfZlJjMu1dfx+LwCLVDcXndMZ4TnyRmzC/Ed+KTXETGqlR6O/rI3V5I/p5iBvoHRj1vcMBC4d4S8nYWYe6d+vKSvq4+8nYWkb4iBXdvt2nH29vVj3XQOmacatj5xj61QxBCffX10NIy9DjVyZfNfcF64qEyBxJNuY0NrH7hOR7e+jHd5hO/xyvb2+kym+no76e8rZVBq5UB6+zsU6U2qTsXQgghHCjYw5MbFixmf22N2qG4tDav2f9C2Rk42/2Il58HRnc9LbVTb1J+LL+KwMgAmqaw29xM5O8uImlhPCUHj07r+oaKRhoqGonLjKahsomejl4bRzh1n753iP7efkzuLnJzLYQ9uNiyOQBOWgU9FyqaALoGzLxwaD/fXbGK/MYGnti5nU8qhn4fh3p6Eefnh5vewM2Llqgc6ewkFU1CCCGEg62JiUHnJC/0Ev0DWBIRSaS3t9qhTEm9h3Xik8SMtdS1qR3CcVqdlnv/aOGCr/tM6/qu1m4MRv2MqoymwifQm9rS+hmPU55bSWhssA0imrm+nn4OfJijdhhCqOvkHedcJdE0xyqavuBlNHL/Rx9y7t9fPp5kAqjv7mJPdRXH2ttYGRWtYoSzlySahBBCCAfzMbmxIEzd3jc6jYZlEVEcbW3h05pqajs7WRweQZjn5HfIi/P1w8/NMTftX1avGyB+VRIp588n+aYVRP1gLb4/Xo+Hj/TAsqXa0npMHs5xI3XLz0JZvGovZ166i6DI6S3pqy2rJzYjCu8A++8E2dHcSUCEn03G8vB2np/rna/L7nNijhu245xz/H6ckPVESdPs2+JhbF1mM28U5o/5NV+ZPR/NHEq8OZIkmoQQQggVbEhIVHX+7JAw9tZUHX+T0wrsr62hsaebpRGRBHl4jHltgn8A80LCKG9vw9fkhq9JhWU0Wg0fXhbEu6e68142fBI9wIGAfqLOyXR8LLOYoihEJqvfEPys6+M4/5r3APANaOHPu7Zzzx/9pzWW0WSkq7WLxIXxZK1Jw8vffv2+PLw9MLkbSV2aSPba9GmPo9U7z0v2Xf/9FItFepqIOezkRFOKqySaTnqolcQKgJ+bGxeny47A9uI8f7WEEEKIOeT6+YvICglVbf767q5Rj1sUhX011bT39bE0Igr/k3bJSw4IJDsklLLWFg431AFQ0d5GgLs7Pmokm0aRO89N3p20MbWrabJWR/HNn7wzrF+UTm9lxSl7pjyWb5A3hZ+WoChQevAoR7YX0N3eQ9KieOKybL98onBfCZZBC4X7SsnZlk/asiT0hqnvUDU44DyJnfamTvJ2FqkdhhDqOHnHuQg9eLvWjnMAVs3cTAFEeHtzw4JFmHR6VkbF8PYV1+InOwHbzdz8KRNCCCFUZtLr+c2Z5+JlVOfd0NquznErkQasVvbVVNEzYGZpRCRZwSEUtzST0zCy58zRtjaC3D1U+1pONqgF3TRu5MVIYfEhpK1I5sj2ApXmD+Cmn0bx0+e3YTCO3HnN6Db15tiRyeH09wzfSU6xKpQcOIq3nSqbTk4SFewtISY9asp9oqqLashel05ITJCtw5uWHbJ8TsxV1dXQ8flmBK6ybA6G92hSLwrVPHb6Rj657mtsSkzmyTPO5OULLyHcxXpTuhpJNAkhhBAqifXz47HTNzp83iT/ALJCQmjv75/w3H6LhX011RxpbBj3vLK2VkI9vVRPNs3f3sGgeVDVGFxdSEwQGStTqDvaQMHuYofPv+CUaB76uwcvbP2Yy25+Gy+f0XeY02qHqp2morerb8znWhs60Ontn6QsO1yBl58n2evSSV4UP6lrOpq7yNmaT8OxJiKTwwmKDLBzlOPb+cY+FGUu3q6KOc8Vd5yD4T2a5ljV71lJKVyWmY1Oq2VZZBTnpKSinWPfAzVIokkIIYRQ0dnJqfzstDPwNtp/6VmCvz/ZIaGUtLZwpGH8xNF0lLa2EO7pjYfBYPOxJyO9y0jRfw+rMvdskbUmjcaqZvJ2qbc06rSL+1m2fhc63cSJjJ/8cTvxWZNfgtrR3Dnmc1WFNSQvjkfrgP4ljZXN5GzNn9Yyz+riWrR6nUMamo+ltqye8iPHVJtfCFUoCrz77olPU51jyfiknPTr1DqHkiweBgP3rT1lxHGz9JmzO0k0CSGEECq7ImseH157Axen276Rtbtez6LwCDKCgylrbR116ZstFbc2E+alQjm6ohDxVrXj551l2ps6UKzqVqoc2j52I/ov8/Zt52d/PYRP4OSWvbXUtY2bSCrYU0La8mSH9PkyuhloqW+b1rUNFY34hfiQvSaN7LXpxz9SlybZNshxvPTAP+jrmbgqUohZob8fbr4ZfvWrE8cWqrPr6rTM0Wbg56emD1si93H5UU596Xke3PoRRc1NUplpR3q1AxBCCCEEBHt48vMzzuTSjCwO1tUQ4jG0DO2Wt9+Y0jjzQsIw6nX0DQ5i0unIbajnQG2NnaIeXVNPt0PnA1jZaKJ8d6nD551tfALV71lx6JMWFAUmm+sJDG4gdfFy9r0/8c+dYlUIiPCnuaZ1zHPydhWRuTqV3B2Fkw15XGnLkjCYDCiKgqIM7eRntVjp7eylIq9q2uNWFtRQych/2xkrUyg7XEFft32TQDte38d3Vv+IB167g4jEMLvOJYSq6uvhootg587jh6w/DHCdHefgSz2a5k6iKSUw8PjjouYmvv3uW3QNmNFXabksI0s2D7EjSTQJIYQQTmRZZBTLIof6zhyqq53w/BAPT6J9fSloaiTE04uCpkbMVvVKwj0NBjom0ftp2qwKS9pMBFf0URfvziGfPrSA5lXbJAXmMjdPE20No/dDcqSWug4qy5KISSyZ9DWxaRr2vT+5c30CvcdNNAHk7igka02aTRqhK4pCzrb8GY8zWb1dfVgt1olPtIGyzyr45tK7ufvlb7H8nMUOmVMIhzpwAM4/H6qGksKKmwblqVC4UP2k/JQoc7NHk49xqOqspbeHm//7Ol0DQ5tB3LJ4KfNCJUFuT5JoEkIIIZyUTqvl7tXriPT24VB9Lc8f3D/inBg/Pz6tqcag1dLc26NqkgkgxNOTo21tNh832KxjUYmVts0lNFU08UWaYEGwD4EpIRwtse+SwNlOp9cRlRJBycGjaocCwKHdiVNKNMWlTr6Kzt1rcstdjmwvIHtt+oyTRJ2tjqvwi0wOp768EXPfyF367KWrrZv7vvIYK76ymJDoIG5+4hrcPFyod40QY/nHP+CGG6B3aIdLJVyP8qdwmO9CS+a+MEd7NN2z5X36LIO8UZBPZUc7MNSu4JKMLJUjm/0k0SSEEEI4qeyQULJDhhodn5OSSqJ/APd/9CGWz9+ZDPHw5NDny+IGrFYG7FlJNEk+Jtu9ANdYFZa2mPDf00TZlgJKRqnS6GjsoKNR/SocV5e6LJG8neo1AP+yz7a7cd5Vkz8/NrmOyb6s1Rsm//I3Z1s+89ZlcHhr3oTnZq1JQ6PVUHqonJ6OoRvTjJWpFOy1z859IdGBhMaFYLFYjlcxtdW309PZa5f5JrL7v0OJ8JXnLWXJxvmqxCCETVit8OMfw89+dvyQstgN5YVwCHHR2+eTl87NoUST2WLhR1s+GHbsqmz5/eQILvovRQghhJh7Ls+aR4J/AH84sI9PKsqJ9fOjQYV+SOMx6mz30uLMnWaKXttDs81GFKPJXpdOzlbHLe2ajM+2NmC1gnaS29bEJJQBKZM6d6rNXw9vzZvwe3Ty8x4+7sxbl2G3JXMZq1LpauvmWF4VDZXO96/j0JYcSTQJ19XZCddcA2+c6I+ofNUb5fEQMLnwPlonbfIwlyqavszX5EZaULDaYcwJkmgSQgghXMgXPZyae3p4t6SIQauVg5Po5eQ4ttvBxdKkTmXGXJK91vmSTAA6o4HHv3chcWkDxKW2Ep98jJDIyjETTzr9IB7ebvR09k049nSav+ZszR9zGV3WmrRh38Oejt5JVUBNl7mnn2MzaCJubwe3HFE7BCGm56OP4Gtfg7IyABQtKA8Ewc1+k9+dwFmd9Kd5LlU0fdmyyEi0c/jrdyRJNAkhhBAuKNDDg6vnLeDqeQsob2vljcJ8Xi/Ip6K9DQAN4G4wYLZYGLQ6pjEwQN/goG0GUhT6mrpsM5YYVdryZIc2qZ4sjVaDX7APH/+z7KSjAbh7RZC1KoRrfnCU1OzhyYz3/30qPZ2T69PV3zu9JaY524aSTV1t3Xj7e2LuH6CuvNEmDcOnwujk/Y+K95fRVNNCUESA2qEIMTkdHXDnnfD73x8/pPhqUX4XBqd4qhiYDQ1bOqdeGGpbHhmtdghzhiSahBBCCBcX5+fPd5av4tvLVtJp7sek02PU6dBoNPzwg/f4V36uw2LpMpvHP8GqgHacV7mKwtIWNzzfKqfyiPNWbbi6+HkxlBwom/hEFYTGBFF+pHLE8d6uPva9f4x97+tYe+H5XP/Dw2i0Vt756wLyPtURkQg1pRMnm9pm0NPLGRJzer1O7RDGpSgKd5z6Ex7bfB9hcSFqhyPE+N55B2655fiucgDKcjeUp0MhzqhiYDY2R5uBf9mKKEk0OYokmoQQQohZQqPRjGjGHefn79AYgj09Odo2+tbxvoNasp8vx3JhErtCRiakFrWY8Hv3GBX7jtJi70DnsIjEUOrLGxkcUHeHwrHUH2tCb9CNG9+2/5Sz400/rBYrUA6AVqshe206R48co2uMnd40Wg1NVa7902V1YIXidFUX13LL/DsIjAzAYNJz79++S2x6lNphCXFCUxN8//vw8svHDykeGpT7g+Ba3/HfEHFFwxJNLtxragakP5Njzc2fMiGEEGKOiHdwouloSwu6Md4tXflRJ7X5NTQ8spWzdg1gtJw4L6PDSPuDn1Cx76ijQp2T/MP86O3qO74rmjNSrAqhk6iEsX5pF0Krdaj5ttViJXttOlrdyJe5wVGBWAadM8E2Wc6aIPyyns5eKguqKfusgg///Ina4QgxZP/+oT5MMTHDk0zrPFA+joXr/WZfkgmGNQOfqz2apD+TY0miSQghhJjFzkpK5rVLr+Dq7Pn4u7lNfMEMNfb2kB0SNuL46lojxW/nHP+86B/7Wf7CMeJ7DABEb3e+3bNmG5OHETcPE6317WqHMiHfIO9pX9vT0UvOtnyCowNJXpwAgN6gI3lxArEZrl9Vo7hARdOX/e+v27BYXCNBJmah3l546SVITYUlS+D554eOAYqPFusvQ1BeiYBog8qB2pH0aJL+TA4mS+eEEEKIWUyj0bAoPIJF4RHct+5UtlWU83phHh+WldFvsVHj7pMpCpF7WgjN7cDSbWag28xAVz/NoyxXqsmtxv3hJjZduZDSD+y3S5cY4uZhorZscg2z1RQWF0xLXduMx6kvb6S+vJGolHCaqlso3l9GVGrEzANUmdVqu50dHaWxqpnPPs5j0enZaoci5pKSEvjd74aafHeN3FxCuckX5fYACJsDt8QnJZrmao8m6c/kWHPgX5UQQgghAIw6HacnJHJ6QiId/f1sLi3m9YJ8dlcdwxa3rlorbNo1QME/90z6mv6efkr+uNsGs4uJeAd4097UqXYY48pak0bR/jLMvRM0lZ+CqqLa44/7uqe345wz+fKSQVfx4cufSKJJOMbBg3DPPbB585inWF+NhLUeDgxKZXO8Gbj0Z3I8STQJIYQQc5CPycSlGVlcmpFFbWcn/y0q4NW8HMpaR2/kPREPi4Y1b7VS9JFjt3oXk2MwGZy6N5GXrwdRqREc2W7fnx+D0fVf+iouWNEEsO1fu/nW/92Eu5e72qGI2ezgQVi/HjrHTqpbfx4yt5JMAMrc7tEk/ZkcT3o0CSGEEHNcuLc3X1+8lLevuJaL0zOndrFVYe0fKlnwTBmlkmRyWmnLkpx22ZxGA27e7hTsLbHrPG6eJmbDfYann2veIPd19/PfZ99HUVwzUSZcQEkJnHnm+EmmnbFwta8Dg3ISw3o0ue4vQr12eukL6c/keJJoEkIIIQQAJr2eJzZs4oH1p465c9yXxfUbqcmtpr7UOZMYc01EYijpK1KOf67RaMhel057cyfZ6zIITwxVMbrRxWXH0FRl/2bwMelR1Lj4z2nGyhRytuarHca0ZKxM4b0/fcRtS+5ix+t7sbpgU3PhxGprITkZGhpGfVo53QNrYQLEGx0cmJOYBUvnNiYmsTh8en32pD+T40miSQghhBDHaTQarpu/iJcvvJQAt4mXuMSM7PEtVGTyMFFdXIOHjzs+gd4kzI8lZ2s+x/KqyNmaR21pPSlLE4lMDlc71OO8/DztPkf2ugyKPi21+zz2FJsRRfGBo2qHMW15u4pIX5HMV27dyLPfe5FvLLqTj/+xg/5e1++bJVRiscB778FVV8Hy5WOepoToUB4IBh+dA4NzMidXNOF6iSaDVss9q9eTGTz1N0ukP5M6XH+huhBCCCFsbkVUNG9cfjW3vv0GuY0j3yHWWRUWtLlh2FqpQnRiNAnzYik7XAFA8uIEGiubKT1UPuK8on2lJC6Ic2xw46gtG70CwVa0Oi315fadw978Q31pa+xgoH9A7VBm5P0XP6a2rJ6ndzzMjv/s5Znv/omiT0tJWhhP+ooUwhOcr+JOOKH6evj1r+GPfxyzgulkmgYLrK+As71QbveHBW4OCNLJnNTbzap1nUSTUafDbLFww4JFxPr5kRkcMuUxpD+TOqSiSQghhBCjivTx4dVLLue81LThTygKp7/ZRtuDn1C+p0yd4MQI3R09xx8X7y+jraF9zHMrC6rR6R3z7r7eoCN7bToePiMr5CKSQu2+bM5qsWJ0N6J34UbgkcnhtDd2qB2GTdSVNfDIlU+z8PRsXir5P8762uls+/cerk/9Nk/e+Aw1pXVqhygcob8f8vLg3/+GRx+F666DCy6APePsWnrsGHzrWxAXB488MnqS6eKLobsbamrgrrvAxwcAjQKat7vQnlUJbzn37pt2cdLSOVfp0ZTkH8DrX72KYA9Pvrl0BQCZIVNPNJ2fmm7r0MQkuO5fXCGEEELYnbvBwC83nk1WcCiP7diKVVHYUGag9ONCtUMTX9JQ0YTRzYC5b+KqF3PfALGZ0VTk2rcizc3LjcikMHK25eMX7EPMsshhTb+DIgKpKbF/36Sqwhqy1qZzZJtr9jcq3FeCX4jvuMlDV2Ew6bnvle+x771DPHXz//AL8WXlV5aQMC+WN3/7Hh+8/AmnX72Wq350MZFJzrPEU0yDokBjIxQWQkHB8P+WlcFofbrefx/efBM2bDhxrLgYHnsMXnhh4jnPOQc8PIY+HnsM7rkHfv97+OUvoW4oian5tA/lXG8bfZEu4qRvtSv0aIr38+ffX70KL6ORxzZsxNtkAiDBPwCTTk+/ZXBS41w3fyFnJ6faM1QxBkk0CSGEEGJcGo2Gry1aQlpQML/812aqnvtY7ZDEKBRFITwhlIq8qkmd7xNo3xst3yBvvAO9jy/fa2vsoK2xg9SlSdRXNNLW0E6rAxInoXHBuHkM7TgXnRpBZWGN3ee0tYH+QaKSw2dFoqmmtJ4rom7BetJSnh3/2YunrwfLzl5IX3c/n753iA9e+gSDyYDeoENv0KHT69B9/t+xPo9KjeCGh68gKCJAxa9wDrJaoahoZDKpoABaW6c2Vm8vnHsu/POfkJoKDzwAr7wy9vkrVsCqVRAbC4sWwZo1w5/39YU774Tycnj2WQCUZRP3H5x1lFEfOiWTTk+AuztexqHG7afGJRx/Tq/Vkh4UzKH62gnHWRoRyb1r1tstTjE+STQJIYQQYlLWxMQScfomvmfa7vK9YmYrb3+vSZ/b191ntziCowOBoUqiLyvcV4K7lxsLTs3i0EdH7BbDF+rLGwmM8J90As5Z5e4qJCQmiIZjTTYdNzQ2GJ9Ab/6/vfuOj6pK/zj+uTPpPSRACDXUhCYlSreAIkqzwuouq65iwUZRf2JZ21rWdcWCBdaCbUVdxYoI0nuP9BZCCSSEVNLL5P7+GBgISUjPpHzfr1de5J577rnP3AyReTznOfu31N4y2HOTTGdkpmWx9MvVgD1J6enjQXZGToV+1+xau49V367ntufGM/aBEbW2PLTRKyyEnj0hv3w/K9PTgA5u0MkVs4MbdHSD9q4YzyVirM62L6u74QZwd7cvgyvN4MGwaBF4lFFzyTThp58ch5Y77UkKc2oTzEeDyhVzvVekRlPdrp6TaysgPS+PN9at4f6L++FqLfr32FqOGlNBnl7MvHZ0sWul9ijRJCIiIuXWvmdbnvn2UZ645kVsBTZnhyPnq8CKiKN7jmGxGCV+6C+Li6uV1uEt8Qn0IetUFtkZ2QS1aEJebj75ufkkxiZxKimj1OuzM3KIWrqDHkMi2F4Ly9latG9O0vEKzqyoY8xCk6DQQLIzcvAJ9MbTxwN3TzfSkzOJ3Vf5WVqnktM5cfgkYT3aABCz/Uh1hVxpaYmVr6GTlZ7Ne1Pn8NucpTz4zl10HxRe9kVSITabjROHTnJ0zzFidx4m6Pu5XF5CkskMdYGOrtDR7WxCqYMrtHCBc5MFv2Zg3BePEX3OGAUF9q/SdO4M339fdpIJ4H//g9jiiWbj9WTMv/jb42nozvk1Xx+Wzh1KTeHqDh2LJYo2HT/G5riyf9/1CgmhqVfN72gqpWsEf6tERESkOvUZ1oOrb7+c+R8sdnYodYqbhyuePh54eHuQkpBGXnZerceQkXqB//t/npzMXFqHt+TonmPl6h/Wow2+gT5kpGVydM+xYgmJytRa2r5yN10HdGHX2pqt+VWQV756HnXd7nX7AUhPPpvEaxISgIe3OzmZuZUaMzs9h1ZdQh0/z05925OdnlOl5FVdcHDbYaYMeZoRd1zB5Fn3aHZTFdkKbLwy4S0O7TjKsf1x5J/+O2WYJp+wwNGv8LEguNLLPmPJq+yZM8a/kjBeTy69Q1AQ+PjAE0/AkCH2GUz5+fCXv9jPlcU04d57Sz411geaN5L3RQnlsOqyJwZfRkQJO8y9s/ECxeLPEerrV90hSQUp0SQiIiIVdrAOzHpwpm4Du5CaeIrczFxyMnPJSs8mLyefvJx80hLTa22mzvniY8re6vtcAc38y5VoCmjmX2MzXXav30fnvu3Zt7nmlm4d3hWLxWqh0FbPPm2VQ3J8apXfb4HN/B3LHPef/jmE9+9E6om0Cr+n6poFHy+l/UXtuP6ha50dSr1ls9k4lZROfm4+h87bQMA0DH4xw7gL+zJYI7MQs0c5ZhkBZBXCu2XMNLz4Ypg/H87Mwokoxw5ipmmvEfXTT/ZZT8lnE1lmNzfMm/3gel9o1og+CtejYuBXhnVgQs9exdq3J5xg+eGYco3RwqeRFXuvgxrR3y4RERGpLo98NIkZd7/PztWNb/e58Es6snPNhV/3rrV7CW4VRGJsUi1FZZeTmUuz1kEkHC3ffXOzyzcLpnWX0BorRG0WmhzaeZS2XVvVWB2l7Iwc2vdsy8Fth2tkfGfbvnI3bSJacWT3hZ9fQDM/MlIyKcgvuuy1pDpIe9btxzCg26AunDh0ksRjF5h1Usd98sxXePp40LZba9p2bYWXbyMsBl1Jx6PjefX2mVx0WTeuvmMoq7/fWKzPb7TjNnbiiglfnoJBnmDBnhwyKPoF0MQK4e6wOgsjp4ylu3fffTbJVJaYGJg5075r3YEDxU4XftoCrip/HbsGxTy3RlPdTTSFePvwzyuvxijhZ/7OxnXlHifUV4kmZ1OiSURERCqsbUQrXl/+PL/MWsQHj39BVnq2s0OqNQXlqE1lKygkqEUgKfGppdayslgtdOjVDg8v+7bNOZm5JMenknS8ah/om7YOLneiKXbvcdw8XMnLuXAR35r++ebl5JN0LJmQsGbFZtB0G9gFq4sV0zTZu/FAmbGWxjugYdfrKMgvKHHWVmBzf1p1DiUjNZOY7UfoPiicHav3FOkTf+hkiWOaJuxcvReriwW/IF9OJVW+dpIzZaZl8e+73nMcN20dRNuurWgb0Yo2XVvTbWBn2nZt7cQI6578vHzmvTmfz57/hpzMXFzdXLj4mt4l9k01PFhltuIKjmIk2zBuLXvZpTmlCeYQr7IDueEGmDTJvvytfXvwLuXv8f799rpNJd2rgyvmfYGNN8kE5+06VzcTTRbDYMbV1xLoWTwRvDcpkYXRxZOHpWmhRJPTKdEkIiIilWKxWBh939X0G9WX5258jX2bop0dUq2wlnMXm70bD9CifXM8vN2LLDsL69EGb38vDu866limdC43D1eatQnGN8gXF1crBfk2Th5NIqCpHwe3HS5z+deBqBjaX9SWg3+UPXsn61Q2PS/tyrYVu0rt0+PSCLavqPllgBlpWbh5uhEYEkBKfCpgLz5/7uyxsmI9V0BTP1JPnnIcp5xIrc5w65zjB+Idz6dJiwBadmxBekoGh3YcJeXE2dloCbFJGIaBeXqGQ2BIAH5NfC44Y81WUEibiJbsWLWn1D71ycmjSZw8msSm3/4AwNvfiw92vE5wy0ayA1kZNi38g3cf/oij5+wauWfDAdLO+ft0vnl05DKOUu79zBZnwmNBFH7XCvblQgGQb2J5roRdFd991/4FEBICHTpAx472Pzt0sNdqGjGiyCVmb3fMMb5wlbe9XlRjVw+Wzt1/cT/6tSo54dvOP4BnLxvKu5vWk3ChnQhPU40m5zNM06z4ViMiIiIi5zgeHc89vR6pdEHi+qTbwC5lLp07X1BoIL6BPpxKTic5LrXS9+4+qAs7Vu+ldXhL/IJ8MAwD4/QyiEM7jjqKRLt5uNImohUHtpZdz8LV3QW/IN9iu7JZrBYi+neq9eWRIe2bYRgGGamZtOzQnD0bziYwXVytNAkNJOFwCR9GT3P3dKP9Re3YvzmaiAFd2L1un6MYuH+wb5V2NKvrXN1dCO0QUuYSxPBLOrJnwwHCerYh6VjyBXcIPKNTnzD2bylffZT66OJrevPiz9NLXLLTWMQfSuD9aZ+wet6GEs/f8PBIvnvzl1KvjzTj6UrS6fky5jkr5uwfNw3gT9h/n5i93THntyk+SL6JMeE4xvKsqrwUCpe2sS/PE7sPU7E8ZZ+5OHnCrfwY2ccpYYzq3IVRnbrgZnXBzWrF3cXq+L5DYBNcLBdOVeYU5PPlju28t2k9iVklv0cshsGe+yeXOZbULCWaREREpFr8MnsRb9w729lh1DhnFfo+o9ugLuTnFhSbQdakRQDe/t6O4t4ubi6E9WhT4qyp84X378Se0zuaAXj6etCyY4tyJapqW8feYaXG1bxdUywWC3EHz+6A17R1EP7BfhzYGkPnyA6NZubdhbQOb4l/sC871+zFLCzfRwGL1YKHl3uDXiY77cNJjLjjCmeHUSkF+QXkZueRm5VLblYeOVm55GXb/8zNysMn0JvQDs1JTThFRkoGGalZpKdkkJmaRUZqJonHkln06bILLk1t1bkFsfviKh2jYZos5FsAzEgPzJ9KX65oPJmA8VHxWXZmsBUjsezly4VftYRLy7E0r7H4TwqWv9sT9A/d9md+7lPyMsia5Gaxsuz2OwmphkLd2fn5fLH9D/65egW289IZLXx8WP23e6p8D6kaLZ0TERGRanHtxCtZ8+NGNszf6uxQapSzZzyUNsMoOS6VU0kZjhlXBXkFHPzjMOGXdCgyK6gke9btdyy3a9IiAA9v9zqZZAI4sDWG8H6d2LP+bGLML8iHNl1bcWDrIXIycor0P7NMqm3XVkoynXZ0zzE8I9uXO8kEUGgrpF331uxau68GI3Ou96Z8TJ8re9CsdbCzQykmdn8cCz5czN6NB0hNOHU6gZR7OrmUV2otuDMm/P1mrp04jK9f+4FFnyyvXAxVSDIBWM4tFFTWZBOv4h3MSYGYTwdjZhbC4XyIyYfD+RiH8uDXTMg1IbMQOrpBD81mKuKcpXPOqtF0Y9du1ZJkAvB0deWuPpH8emAfW+OLvi87BGoJbF2g+WQiIiJSLQzDYOp/7sMvqGEX4azLk8EL8grYuWYv3QZ2wbeJD7YCGy7u5atPkpqQRrvurclOz+H4gRNlX+BEJw4lEBjiT7eBXejYO4yMlEx2rNxTLMl0rpra0a7eqsTbOOtUNq7urtUfSx2RdSqbGXe/X2f+jttsNtb/spmv//UDO1bt4U+PX0/C0SQO7TxKfEwCKSfSyDqVXWaSCSC0YwibFm6j75UX1ULkJbOe+6ZzuXCyw5zaBPOqs4W/zdYumE+fTgB6W6CrO4z0gUmBmK82x9zeHnNfB8wjHTGXt4XA8tXSazTOefTOqNFkNQzu6XtxtY87oFXR5ZeuFgtPDLms2u8jFadEk4iIiFSboBaBPPzeRGeHUaMqMgvEWXau2UtBfgE9hkSwo5zL/JLjUjm04yjZF0jW1BUpJ9IIaduMnWv2cmBrDIX14GdS1xQWXriofEkO7TxKm/BQPLwb7myRTb/9wa8fLnFqDKeS0vlj2U7W/7yFDr3DGPvACLoP6sKeDQeIi65cEviff32bb1//iVmPfFLN0ZZfkRlNZeWBPC2YH7bA/NPpos7DyrlrpLXx1ti6oHN3nXNComl053Da+AdU+7gDWhddfvlwv4GEBzet9vtIxWnpnIiIiFSrS28awLA/D2HxFyudHUqNKM/sgbogOz3HqbWkalp9nlnTObIDhbZC8nLyOLL7WK3fP6J/J3afU5OrIqL/OEzbrq04GZtE1qmGWa9p1rRPiBzek2ZtavcDa3ZGNukpmWCarPx2HbvW7ePkkcQiuydWxaGdR6tlnMqynrt+y1KOZIergTmjOeaLTUtcSicVcE4y3hmJpvsi+9XIuH1bhOJmsZJfaOOi5i24uwZmTUnl6G+siIiIVLtHPprEvxY/w01TR9O6S6izw6lW9SXR1NDZbPXz59Cxdzv2bYrmwNYYcjJysFhr95/jHj4exB1MqNIYh3fFEtg8AG//hllsOSs9m39PrJ0ldAlHE1n02XJM08TD24NmrYNZ/MUqfnhnAfs3H6y2JFNdUGRGU0WmOyjJVHXn5Phqe+nc1R060SmoZuomebi4cmefvni7uXFP5MXaaa4O0U9CREREqp2Lqwu9rujOPa/9lY92v8kn+99m0ht30Hf4Rbi61d8J1W27tiLxWLKzwxCol7Npwi/pyIGthxzHeTn5FNoqvoStMjy83ekxJALfQG9SE4rv5lVRx/bH0bZr6buG1XdbFm1j/n9+r5GxU0+m8dN7vzHl0qf5c9v7OLTjKLYCG8nxqaz8dh1znv6yRu7rbEVqNGmJW+1yYo2mSRfXzGymM8ICAsnIy6NTExUBr0vq77/0REREpN4I7RDC9Q9dy/UPXUt2RjZbft/O+l+2sH7+FpLjUpwdXpmsLla6DuzMjlV76kWNpsbgZGwSzds25cThk84OpVxcXK0knfdeD2nfrFZmrPS8tCsHomKqfSmlpYEnC2Y98il9h19ESLtmVR4r81QWa77fyNK5q9i8aFuRBOMPM3/l63/9UOV71HXWitRokup17q5ztfjXdkSHTvRo1rxG75GRl0fnoOAaqQElladEk4iIiNQqTx9PBl13CYOuuwTTNDmwNcaRdNq74UCd2fHpjNbhLSm0FbJ9RcOtd1QfZaRkkpGSSavOLQgMCSB2Xxwp8anODqtUEf07F0v01EadqZ6XdmXbil01Mnb8wQQ8fDwuuNtffZadkcO/73qPfy58GkslluTk5eSxedE2Fn22nPU/byYvJ7/EfrnZeVUNtV6waEaT89RyjSZfN3ceHTiYW7r3rPF73d6rD12bNtOyuTpGiSYRERFxGsMw6NSnPZ36tOcvT99ESkIaq+dt4Pu359f6dvSGYdCue2tH3ZmM1ExOHDrJ0T21X6xZyi92Xxyx++Lo2DusziaafAK9ORAVU6z9VFJGpcZr1iYYD28Pjuy+8N+RrgM611iSCSDxeDLte7bF29+LrPRsoqMO1di9nCVqyQ5evW0m4//vOsK6tymxj81mI+5gAod3HuXwrlgO7zrKoZ1HObrnOPm5+XSO7FBqkqkxKTKjKb9u/Q+FxqSml86FBQQy98bxNPUu506B1aBPi4ZVC7IhMMy69r8NRUREpNEzTZMtv29j3lvzWf/Lllq5Z/N2TTlxqH4sw5LirC4WXD3c6uTsGp9AbzJTMzn/X91dLu7I/i0Hy1WnycPHg069wzi2P47k0wm1gOb+tO4cSmZaFjHbjwDgF+yLX5Avvk182LfxAAX5tVM0vVPf9oD952BYDFxdXck8lUV8TAKZaVm1EkNN6zW0O2MmjcBqtXBo51EO77Inlo7uOXbBRJKnrwdg3wmyMQsys5nLL45jc2IA5tPB4KrZTTXNeC0J49/2+oK333sXKyLCa+xed/buy5NDLq+x8aV+UKJJRERE6rSje4/x/du/svCTZeRk5tbYfTr3bc++zQdrbHyped0GdsGwGOTl5HNsf1ydSnB06NWW6KjDxdrD+3Vk36YLJ5s69W1P0rFkR4KpJB7e7uRm59XJGmLBoU0IbtUEVw83stOzObC1+Oyuhi4oNJCk43W/Hl2NMk0eYiujOft71uzngTm7BTSrxEKbmckYX6dDbiEUAAWmfaaUCXR2w7zMCy73hovcG/1SPePVJIwZ9kTTX++byKrwLjV2r/dHjmF4h041Nr7UD0o0iYiISL2QkZrJrx8u4YeZv9ZIAegeQyKqvViyOE9d+3leKJ6I/p3Yu+EAhSUkiXpcGtHg6oPVtZ9NbWjWOoiEo0nODsP5TJNRHGQSUbieXkpnNrfak02XeJZ/nPgCjD4xGOX4JGv6W+AyL8wpTSDcvZKB12/GK4kYb9oTnRMm3c3qLp1r7F4b77qPIC+vGhtf6gdVzBIREZF6wSfAm5unjeaT/W/z92+mMeSm/rSJaInVpXq2LzLR/3trSHat3UvT1nVnu+vY/XGlntu9bj9d+nXEOK92SpuIVg0uyQSwfeVuOkd2cHYYtcrTtwJJlIbMMPjZ6MBULicB+zMxTtgwboyFD1Iptr60NIfyHUmmbKwk4sEJvDiGt2Ncxy3TCjF+zMAYfgRmJDfO+lDnvOSarNHUJShYSSYBVAxcRERE6hmri5UhN/ZnyI39AcjPy+f4gXh7Ed6dsRzeba+bErv3eIXq0+Q1kp2fGgtbQSFBoYGcrKFZJBaLgZuXO27urri6u+Dq7oqLqwu2AhtxB08U658Sn0rbrq1KLXK/e+1+ug7szO61+zFNE4vVQkF+QY3EXhdkpFSuEHp95eHjUav3CzBzyMdCpuFWq/ctrz1GEPebw3iC9fTmJEYBGE+fxFyUiflUEPQo43nFnq2JNYdufGcUnaHTzMykLwn05QS9OYEf+Rj59iVk5vwMzNeblX2PhuSclbk1tetciLcP744cUyNjS/2jRJOIiIjUa65urrTt2pq2XVvDTWfbC/IL2LsxmuVfr2HF/9aWWR+lsjuASd21Z/0BelzalcRjScRFF0/+VEabiJbExySQl5NPTkZOseLjLq5WmrUJJuFIYrFr/YL9Ljj2rjX76DaoCztX76XboC4NcjbTGbmNLLG7d8MB2nVrzaGdR2v0Pi5mIX9lJ+PYSyEGa8yW/Eo7ttC8Vra1r4hUw4PHzSH8jR2MZx8AxoosjOFZmNf5YD4WBGGlJMqOnU3CJlB8Bk2C4c2vhPErYbiaNiawi3Hsw4qJsSMXrj0K1/iAvwU8LeBlYHpawNMALwtc7AFdGtAyuyrMaOoQ2ITolOQL9gn19eWL68fRNiCgEsFJQ6QaTSIiItLgFRYWsnP1XkfSKeVEWpHzhmFgdbE4ZkCFdmjOX58dT2ZaFglHTnI8Op7V328s1+5gUjf5B/sS2ikEi8VKRkoGnj4euHq4gWmSm51HZmomTUKbsH3FrlLH8Anwxt3LrcykZbO2TSnIyyc5LtXRFtjcn+BWQewvR8H58P6dOLAlhoK8hjujySfQm4yUTGeHUat6XtqVbRd4f1WZafI8axhA8WWa8XixhDYcIIBD+HEMHwqNulNFZYB5nPuIogVnC/ibLthrKhnYv+Ds98cKME7af1/fz1D2GU3KvEdnM5lpbKY9aWX2BShc1qbBJJuMFxIx3rX/3hr/0CQ2dmh/wf4uFgtju0QwsU8knZoE8cPe3Ty3fClpucV3Tmzt588XN9xMKz//Gold6iclmkRERKRRsdls7Fi5h2VfrWbVd+tJPXmKJi0CHEmB4bdfzv1v/g2v82qqHNx2mDfuncXudfudELXUlgsV3+7Ut325EkUATVoE4OLmQsLhRHoMDudA1CGyMxr39vbncnFzadCJtJJ0ubgjezceqLHxW5un+IiFAORjkIEbgZS8U2ceFmLxZSdBfEI30gznJlR6mgkEkUMQ2YxjX6lxl+QmRpc7fhezkFvYzZ/YixsX/h8HhW80h/EXnoVYXxjPncR4PxWAcQ/dz6YOYaX2bePnz5c3jqeFr2+R9pOZmfx92WJ+iz7738C2/gF8ccPNhPo2jOck1UeJJhEREWm0bAU2/li+i23Ld3JkzzGG3NCfK/40qNT+hYWF/DL7dz6c/gWZaVml9pP67UyyqWmrIIJCA4k/dJLW4aEVXsrmF+RLkxYBHNpRs8ul6qMeg8PZvmqPs8OoVQFN/Ug9earGxr/GjGEqmwH4iG58TRcGEMc1xBBJfKm7QH1OOJ8Y3WssrgsyTW5jJ3/B/l4oBPYTiIFJW07hSiEm9pVfhmNak/3jqw0LP9Oe94xeFb6th1lAENm4Y8ODgtN/2uhPHNcSY49lRjP4U8OYpWM8cxJjdioAN01+gC1h7Urt27N5CN+P/3OJ50zT5NcD+3hm2WKSsrOZcfW1jO0SUQMRS32nGk0iIiLSaFldrPQZ1oM+w3qUq7/FYmH0vcMZOPZi3p86h2VfranhCMUZtq/YTe9hPdi3MZqTsfZi4qkJ5Vtuc65TSemcSkqv7vDqvZD2zdi7KdrZYdSqc2dN1pTunK0Lto2m2AwLq2jJKloSbGYRQTJtOUVbTtGJFFpiX7roQfk3TahOFrOQh9nqSOyAfUv0LhRfmrqQtvybyGrbMS3HcOEYvsXaA82cs/E0pOkYFajRdKF5KIZhcG2nLvRr2ZrnVyzFz71hLC2U6qdEk4iIiEgFBbUI5MkvpxDRvzPvTZnj7HCkBmxdvJ2uA7uwa81eZ4fSoLi4WrFaLeTl5JfduQFJO5lOt4FdSI5PLXFXwurQ7XSiKQ8L+wgsci7R8GIlXqw8fXyZeZSnWA9AMrW/+5rFNPk76xjE8XL1H85homjKItrVaFznpliMvXmYy8+rI3Z+kub8nE1Fj2ty7HOP488uUy0rf1aeBU9BXl68OWIk+TbnJCml7lOiSURERKSSrn/oWrat2MXqeRucHYrUgPN3lJOqi+jfme0rG+5ueqWxFdjYeTpp2blve7IycojdW74kS3k0MbMdM5T2Eki+Yb1wf86+t2sz0eRq2mhJBv2IK5Jk+gf9CCeZm9hPAp68wiWk4U53EpnCFgB6cbLGE03nZmeMWakYs1Jr+H61r6zdBwsrUFnH1Xrh95k0Xko0iYiIiFSSYRhM++A+DmyJ4cThk84OR6qRf7AvMduPODuMBqVTn7BGmWQ6377NB2nWJhjDYmAWVs/6rG4kOb7fQXCZ/YPIdnxf04kmq1lIbxK4nKMM4jg+FJ3NFo0/y43WrDRbspKWRBNArmH/mBpvevMwW7AA7ai5+lZnHC5hOV1DYrq68trEe7E1bWo/LiGp5KbkkVQDJZpEREREqsA30IcnvpzM1Ev/jq1AywgaitbhLdnRyIpV17SUExWvc9VQJRxJpNugcHaurp732Ln1mcqTaDp3RlMSnhfoWTkW06QHJ7mcowzhGP7kldr3IPaC24WGhV3nxZ6HhTTcCSSXFmRUe5zn20UQTzOQF54eVvTE+QmZmj6uiTENA2PkSDqGq3i31DwlmkRERESqqGv/zvztxVv4z/997uxQpJpkncouu5NUSIv2zUk8luzsMOqM+JgThF/SAauLC9F/HCInM7fSY3U/Z0bTLoLK7F9TS+csp3eRu5pDBFF86WkmLmwkhExcsWCSiSvf0qnU8XqSSCD25+JLPs+Ya4gmgG/o7Jj1VK0Mg3WEwvPPV//YIo2IEk0iIiIi1eCmaaOJWraTjb9udXYoUkVaNlczju47joubCwV5BWV3rqAuF3fEMGDPhgPVPnZNSTqeQtJx+w5rPS/tSsyOw6QnZ5ZxVXGeZj4dTu/UFoMfGYZbmde4Uuj4vgBLhe9Zmis5zK0UnaWVjZV1tGA5rdlASJn1o84VRtFZcIM5zmCO40se79GrOkIWkRpQfb9VRERERBoxi8XCY3Pup0mLwLI7S53WqkvLcu28JBWTeiKNiEs6VuuYzdoE06lve/ZuPICbR9kJlrpq24pdZKZm0aFXO7oPDsfLr/zL2cJJ5kzqpjzL5gDi8XZ8H1pNS9K8zHxuYp/jeA0t+Af9GMdoXjL6s9poWaEkE8ASWrOY1hzDm4JzCnWP4iBBZs3MOjTKKJYtImVToklERESkmgQ09eeZ/00juGUTZ4ciVWCx6p/INeVYdDxWl6oXG3bzdKPHpREkx6Wwf/PB0631OzlYWGgSHXWIHav20L5n23JfV9H6TADH8HF837IaEk0tzXTeZglhpwt27yGQZ4xBLDdak1OFJW7phjuvGP243biGkVzPt9gTlW4UcgP7qxx3SZRnEqk6/VdUREREpBp1HdCFD3bOYPR9Vzs7FJE6JzkulYh+pdfkuZDOkR3ocWkE3QeH4xvozfYVuynItxfgt7pYyEjNqs5QnWrf5oN4+3mV2c9iFtKXE47jHeWozwQQW42Jpr5mPG+zhDakA3AKV96md5XGLEmhYeFrujiOu6B6XyJ1lWo0iYiIiFQzbz8vHnrnLv781I24urtweGcsjw57TrvSiQDxMQlYrBYKbYVldwYsFoNug8LZvnJ3qX26XNKJXWv2VleITpeXnUf4xR3YtqL019zUzOJJ1tPtdMIlAU8SKDs5BUVnNLU6nSCqMNPkRvYzkW2OpXsx+PEMA4kzfC54aWWlc3Z5pEkNTT3SlCaRKtOMJhEREZEaEtQiEL8mvvQYEsHd/5rg7HBE6oTE48lE9O9crr5efp60v6jdBZNM0DDr6hyPPlHquYHmMWaxiG6nd5srwGAWF5U7SXL8nERTDxIZbh6inZkG5axN5mraeJRN3HtOkmk1oTzMFTWWZAKwnLM8sqYWSjbE95JIbVOiSURERKQWXP/QtVw+fqCzwxCpExKOnMRiufAH+uZtm+IT6MOBrTFljrd/czQhYc2qK7w6IfFYMj0v7VqkzWoWcr+5ledYiy/5AMThxRQuZ4XRqtxjZxuuJOEBQCiZPMom/sMi/sKFE3oAQWY2/2YZwznsaPucCJ5jANmGa7ljqAylgETqBy2dExEREakFhmEw9T/3knryFFFLdjg7HLmA9ORKLiWScjt5NIlug7pwKimDo3uOYXWx0qJ9M/yD/TAsBplpWcTuO05+bkG5xsvLycdiNXB1dyU/N7+Go68921bsov1FbTn4hz2p81d2cR3RjvMraMnr9CXTqPiOe/PoyN/YUWTmwa3sZqnZmmOGb4nXhJtJPMtagsgBIBsrr3FxhZJcVXHujKbenOS/5i/sIoidBLGLIPYTQKFRtbkUmtAkUnWGqb1bRURERGqNaZpELd3BnL9/1aBqyjQ03QeHs2PVHmeH0SgENPMnPTkdW0H5ajZdSEP8uYV2aM7x6BP4mHl8wXy8KCAfg3fozS+EVSkzEmDm0J40ruIwV3IEgLW04O/GoGJ9rzQPM4XNuGH/OZ3Ai2cYSLQRUOn7V5RhmnzOfJqRXeL5/QTwEEMpqEKyydXNhfk5X1b6ehFRoklERETEKUzTZNPCP/jk73PZuzG67AukVnn6euDu6UZqwilnhyIVFH5JR/ZsOODsMKqFi5sLtvwCTBNuNXdzBzsB+In2vGX0qbb7eJgFfMwCgk/PVJrOYDYZIYB9Z7uJbOcm9jv6byOY5xlAmuFebTGUV1Mzi2uJIYIkIkjGi6Kz3qZyGduNppUeX4kmkapToklERETEiUzTZP0vW/jkma/KVYtGak94/07sWbe/7I5Sp3j5eeLl60nisWRnh1Itelwawb7l2/mc+QSQhw24nRHEV3PR7aHmEaazAYBYfHicIWTiypOsJ5Kzhcl/oj3v0qtKs4aqi8U0aUcaY4hmJPbfn6sJ5TfasYEQbJWI0dXdlfnZ/63uUEUaFSWaREREROoA0zRZ/f0GPn32a2K2H3F2OHJai/bNiTtY+u5fUje17dqKo3uPU2ir+nK8uuC+9uncEP0bAEtozctGv+q/iWnyBsscO9nlYiEVD5qTBdh3tnuHXvxsdKj+e1dRhJnEWywt0raNYB7j0gonm9w8XPklS4kmkapwfhpaRERERDAMg8HX9+P9rf/iqblTaBPR0tkhCeDt7+XsEKQSDu+KpfugLs4Oo1p4mAVcFr3ccTyXGnpdhsHr9CXx9G507hQ6kkypuPF/XFonk0wAe2jCCor+zuxJIuNQHTwRZ1CiSURERKQOsVgsXDZuILO3/Zu+wy9ydjiNnqu7Nmmur7at2E2PS7vSoVc7fJtU7zKz2nQzex27vK0ilJgaLL59xPDjTq7mWzpiw15kPBp/HmAY26pQ96immYbBC8YAbmA0r3AxttPtf2E3QWbJhcNLY2jbOZEqU6JJREREpA6yWq088PaduLop0eFMVhers0OQKti+YhfRUYfwCah/M9O8zHweNLfwV3YD9qVrH9Cjxu+bZbjyvtGLOxnO8/TnYa7ghOFd4/etDumGO0tpQxz2xKIbhbQko0JjKNEkUnVKNImIiIjUUa06tWDco2OdHUajZrHon8sNQdzBBJq2CnJ2GOU2wDzOByxkDAcdbd/RiWOGb63FcMzwZaXRilyjfiW7r+YQrU4nl6LxZwfBTo5IpPGpX781RERERBqZW564HovVwuIvVnA8WkWpa1thYcMoJi0QEtaMk7FJzg7jgpqY2dxPFJdyzNGWjZU5dON7Ojkxsvpj4DnPbhY9KTxvhpKruytuHq64e7rh5uGKm6cbbh5up/90xSegfszeEqnLtOuciIiISD1gmia71+3j989WsOzrNaQnV2w5iFSOq7sL4f06sWvNPmwFtrIvkDorrEcbkuNSSE/JrHO70RmmyQhiuJvt+JDvaN9Ac96iT71ZulYXBJnZzOUXAPJ69yVj1ke4dAjD3dMNV3dXzVIUqQVKNImIiIjUM/l5+WxcEMXvn69g3U+byc/NL/siqZLQDs1x9XDj8M6jzg5FqoGXnyc+AV54+nji7uWOq7sLFqsVA/sstvy8AvKy88jOzCEzLYuM5Exq6mNTKzOdKWymJ4mOtlTceJdeLKU1qGZQhQwwj/MU63DjdDLRxQUsFigogOHD4fvvwd3dqTGKNHRKNImIiIjUYxmpmaz43zp+/3w521fsdnY4DV73weEc/OMwWekV28lK6j+fAG+8A7zw9PGwz45xc8GwWgET02ZisxViK7BRkFdAfm4+uTl55GXnkZOZS05mbolj9jITeJFVZ5MiwELaMouenDKUDKmsTmYKT7OWFmQVP/nUU/DCC7UflEgjokSTiIiISANx4vBJlvx3Fb9/vpwju4+VfYFUSkBTP0LaN2fP+v3ODkXqEQ9vdzy83HHzcsfd0xUXNxf+enwxg0/+AUAc3rxBH7YYzZ0cacPgY+ZxJzvoRiI2LLQjDRdM+wynTZvgooucHaJIg6VEk4iIiEgDY5omB7bG8PtnK1g6dxUpJ9KcHVKD1DmyPXEHE1QvSyrtQXMrY4gG4AGGstdo4uSIGq6/mjuZwOlZn337wrp19qSTiFQ7VUITERERaWAMw6BTn/bcN+N2vjw6i5fmP8GwPw/Bw0tLcarTvk0HCWoRiKu7q7NDkXoqB6vjezdUbL4mfUk4MfjZDzZvhtdfd25AIg2YZjSJiIiINBLZGdmsmreBxV+sZOvv2ygs1D8Dq0N4/07sWadldFJBpskzrGUwxwGYzmA2GSFODqphCzeTeJOl9tkW7u5w111w553Qu7ezQxNpUJRoEhEREWmEEo8ns2zuan7/fAXRUYecHU69FxQaSNLxFGeHIfXIzeZe7ma74/g5BrDKaOnEiBqHe8w/uInzEsOzZ8PEic4JSKQBUqJJREREpJGL2XGExZ+vYMl/V3EyNsnZ4dQ7zdoEk3AkseyOIud41VxOb046ju/lSqKNAOcF1Ei4mjbuZRvDOYTHmeWK/v4QEwOBgc4NTqSBUKJJRERERAAoLCxk2/JdLP58BSu+XUfWqWxnh1Qv9BgSzvaVe5wdhtQzb5hL6YY9sft3BrLWCHVyRI2Ll5nPVDZzGbH2hieegBdfdG5QIg2EEk0iIiIiUkxudi5H9xwnLiaB+JgEju07zor/rSU9JdPZodU5nSM7sG9TtLPDkHrmHfN3OpNKAQbXGDc6O5xGqZmZyRwW4IoJ3t6wfz9s2QLHj8Pll0OnTs4OUaReUqJJRERERMolJyuXJf9dxQ8zf+XgtsPODqdOsFgtuHm4kpOZ6+xQpD4xTT5kIW1IJxsrY4zrnR1Ro/WAuZWxlJAotlph1y7o3Ln2gxKp5yzODkBERERE6gcPL3euvWsY72/9F68tfZYel0Y4OySna9u1lZJMUiGhZgYvs4o2pAOQg4uTI2rcviScVNyKn7DZYM2a2g9IpAHQjCYRERERqZT0lAwm9pjK8Nsu57s3fiE3O8/ZIdW6HkMi2L5yt7PDkHrA1bQxnr3cwh7cKHS0f01n/mP0dGJkEmJmMp69DOdQkZ8Nfn4wYgRccon9q08f+xI7EbkgJZpEREREpNJ2r99P577tWfDREt64d7azw6l1Ef07sXvd/rI7SqMWaObwL5bT9vQsJoAEPHmHXqwhFAzDidHJGf5mLqOJ5jZ2ldzB2xveegv+9rfaDUykntHSORERERGptIh+nbC6WGkd3tLZoThF4rFkZ4cg9cAgjjmSTDYMvqYzd3I1a4yWSjLVIWmGO58bXRnLWJbQmhysRTtkZsKdd8Izz4Dma4iUSjOaRERERKTK8nLzWfDhEr58+btGk3zx8fciIy3L2WFIPTDKjOZhtgIwk178YHR0ckRSHhazkHacogsp9OUElxF79uQdd8CsWeDq6rwAReoozWgSERERkSpzc3dlzKSr+WT/2zzw9p0EhQY6O6Qa1apzC3yDfZ0dhtQTuefMjLGhGUz1RaFh4aARwK9GGP8w+vMePc9WcPr4Y3jgAWeGJ1JnaUaTiIiIiFS7vJw85n+wmGVfrebwzlgyUjOdHVKVePt5YXWzUphvo/1F7di5Zi+2Apuzw5J64lLzKE+zHoD36cm3RmcnRySVNcSM5XE2nC0a/vPPMHKkc4MSqWOUaBIRERGRGmWaJknHkzm0M5ZDO45weOdRDp3+ysnMdXZ45dKxTxgHtsQ4Owypp/qZx/kHawD4mG7814hwckRSFdeaB5nCFvtBSAjs2AFBQc4NSqQOcXF2ACIiIiLSsBmGQXDLIIJbBhE5/CJHe2FhIQlHEjm040zi6QiHd8ZyeFcs+bn5Toy4uANbYugc2YF9m6KdHYrUQ63JcHxvQf+fv76bTxiDOM4lxEN8PLz7Ljz9tLPDEqkzNKNJREREROoUm81G3MGE07OfYjm08wiHdh7l6J7jTluu1qlve47tiyMrPdsp95f6q4mZzUf8hjcFANzPUPYZTZwclVRVT/Mk/2a5/aB/f1izRjsIipymRJOIiIiI1AsF+QUc2x/HoR1HObjtMEvnribu4Ikav2+PS7uyY+Vu9M9mqYzp5nqGchSwz4SZYfR1ckRSHc6tuwXAV1/BuHHOC0ikDtHSORERERGpF1xcXWjbtTVtu7bmsnEDue358WxcEMUP7yxg469bq/1+bh6udOjVju0rdlX72NI49DZPOJJMabjxAd2dHJFUlyQ8izYcOOCcQETqIM1oEhEREZF679iBOH56byG/fbyUlp1CuOJPg4no34l/jJ/BydikSo0Z0a8Tu9fvr+ZIpbFwMQuZxSLakA7Av+nLAiPMyVFJdXrfXEQH0uwHoaFw5AhYrc4NSqQOUKJJRERERBoMm82G9ZwPerH745h2+TMkx6VUeKyOvcM4sFU7zUnlRJhJvMVSAKLx5z6uxFQNnwblQXMrYzhvg4B27WDCBLj7bmjVyilxiTibxdkBiIiIiIhUF+t5swladWrBvxY/Q0Az/wqPZSgpIFVwGD9ysL8fm5KFC4VOjkiq2zpCijceOgQvvGBPOH3+eW2HJFInKNEkIiIiIg1am/CWvPr73/EL8q3QdYZFiSapvCzDlVW0BMCPfAZw3MkRSXXbTAi/0o5YfDiFKzH4nU0n2mz2mU033QRPPw0JCc4MVaRWaemciIiIiDQKB6JieGzYc6SnZJarf5eLO7B3Y3TZHaXecXVzYdAN/Vg2d3WN3uciM4HXWAHARprzhDGkRu8nzhdkZjOXX4qfuOkm+Oab2g9IxAmUaBIRERGRRmPvpmgeu/I5sk5lF2n38HanWZtgfAK9cXFxIS8nj9h9cWSkli8pJfVHaMcQnv5qKh17hzHn73P54h/f1ti9DNPkExbQgkwKgb9wLScNrxq7n9QN15gx3MJuWpB1ttHNDU6cgIAAp8UlUlu0dE5EREREGo0ukR14+dcn8fTxcLRF9O8EhsGR3cfYtWYf21bsYs+GA0oyNUBX3DKI9za/Ssfe9t3fbntuPGPvH1GsX2iH5tVyP9Mw+I22gP2D11UcrpZxpW771Qjjr8a17KTJ2ca8PNiyxXlBidQiJZpEREREpFHpOqAL//h5Or5NfOg+KJzd6/aTk5Hj7LCkBrl5uDJl9r1M//xhvHw9He2GYTDpzTvoP6qvo99Tc6fw8d63eG7eY3Tq277K915IO0fdnqs5hKEFJY1GE3KLNlxyiXMCEallSjSJiIiISKPT89KuzFj5PJ0jOxDQ1M/Z4UgNah3ekpnrX+bau4aVuJNg0vEU9qzfT0Azf15b+hyXjRuIxWJh4NiLeXP1P2jaKqhK9z9peLEF+wypUDLpwckqjSf1Q0sznQDOSWDPnAk+Ps4LSKQWKdEkIiIiIo1S24jW3Dfjdr6MncVz3z/G4Bv64eJqdXZYUo3adm3F9M8fokWH4tvQ5+Xms3/LQRZ/sZKA5v68ve4lIvp1KtLnm9d+4mRsUrFrW3ZqwRP/ncwHO16ndXjLMuPYSjPH92GcqsQrkfrEahbyDGvxxGZvGD8eJk1yblAitUjFwEVERERETjuVlM7ejQc4uuc4R3bHcmTvMY7uOU5qQpqzQ5Mq8gvypVmbYCL6d+aymweQm52HbxMf2vdsQ0G+DW+/s0W6bQU25v/nd96f9gl5OfnFxuo+OJwZK14AIPF4MtMuf4bjB+JLvfer5nJ6n57JdD9D2Wc0KbWv1H8dzFTe5/ezDVu2QO/ezgtIpJYp0SQiIiIiUoZTyenE7j3OkT3HOXo6AbVz9V7SkzOcHZpUgoeXO01CAwlu2YTglk0YdN0lXHrTAAA2LtjKrEc+5fCu2FKvDwlrxmfR7ziOE44m8tak/7Bt+S6yT9f7CglrxsAxF7P8jf/xX37BAsTiwx1cDSUs4ZOGw9W0MZ95Zxt27IBu3ZwXkEgtU6JJRERERKScTNNk/5aDHNx2BIvFYNYjn3IqKd3ZYck5vPw8efHn6RTk28jPK8B2+s+CvAIK8k//mVdAQb7N8afFauGmqaM4sjuWNT9sIis9m+yMHHIycxzfpyakER+TQNapbCxWC3f84xZG3XMVPgHejnsX5Bewb1M06ckZRI7ohdVqZfWgcQxa8w0AnxLBZ4YSDg1dOzON/7DobMOmTdC3r/MCEqllLs4OQERERESkvjAMg859O+Dh7cG3r//kmL0izufh5U77Xu0YfH0/ug+OqNQYYT3aEtaj7QX7pKdkcOLQSY7tj+O9qXPw8HLHMAwyUjNp2jqYdt1aM/TWwY7C4wPyDzuubUEm4WYS+2hCoWY1NVjHOK/o99y5SjRJo6IZTSIiIiIilZRyIpUf3lnAj+/+pmV0TuLm4cqdL/2ZsQ+MwOpS+8Xck+JSWPz5CpZ8uYroqEMA/OXpm7jtufH2DpdeCitXFrnmFK5spTmbac46WpBieNRy1FKTXE0b3/AT3hTYG37+GUaOdG5QIrVIiSYRERERkSrKzsxh4ZxlfDvjZ+IOnnB2OI1GRP9OPDbnAVp1DnV2KNhsNrYs2sYvsxex9qfNhF/Skd5De9Cvoxdd3nwWy9atJV6XgStPMJjdRlAtR1x/WEyT29hJV4rvAFhetfmhN4JkPM7sOAfw0Udwxx21GIGIcynRJCIiIiJSTWw2G2u+38jXr/3InvX7nR1Og+Xq5sJtz/+Jm6aNwmqt/VlMZUk8nsyCD5fw64eLSTiSiJuHKw8+ciUjWttg4UL4/XdITXX0j8afSVyp5XSlGGse4AGinB1G5akYuDQySjSJiIiIiFQz0zS5+6JpHNpx1NmhNEgvzX+Ci0fU/e3ibTYbm377g19mL2L9z5u5/uGR3P2vCVgSE+1LqTZtcvSdQR/mG+2dGG3d5G/m8jEL8CXf2aFUXLNmMHs2jB3r7EhEapWKgYuIiIiIVDPDMOjQq50STTXA1d2VrgM6OzuMcrFarfS7tg/9ru3DydgkFny4hNmPfsZdvodwOSfJBHAx8cxHiabz/Y0dZ5NMEybArFnVf5Oamnvh7g51cMadSE3TjCYRERERkRpgmiarvlvPu5M/JvFYsrPDaRC6Dw5n6n/upXWXls4OpdJsBTby/286Hq//q0j7C/RnhdHKSVHVTV3MZN5iCRYAX1/Ytw9CQpwdloiUQYkmEREREZEalJWezZofNpIcl0JyfCopJ1Ltf8ankhyXQnpKprNDrNM69g5jwOhIBoyJpGPvMIyGUMfo6FHo1w/i4hxNSXjwHhexnFbQEF5jFRmmyVssIZwUe8Prr8OUKc4NSkTKRYkmEREREREnysvNJ/V08smRgDrz54mzx8lxKeTl1MM6NRXk6ubCRVd0Y8Doi+k/ui/NWgc7O6SakZ8PM2bAc89BVpajeTPNeJveHDN8nRic840wY5jGZvtB164QFQWurk6NSUTKR4kmEREREZF6wDRNstKzSYlP5diBeL7+1w9sW77L2WFVC98mPvQf1ZcBoyPpO/wivHw9nR1S7Tl8GB5+GH74wdGUh4W5dGEu4eQbja/Gj4+Zx8csIIA8e8PixTB0qHODEpFyU6JJRERERKQeMk2TLb9v4+OnvmTvxmhnh1NhLTu1YOCYSAaMuZiuAzpjdWl8CZUifvwRHnwQjhxxNB3Dh7fpxWajcdUlut/cynWcfk+PGwdffeXcgESkQpRoEhERERGpx0zTZO2Pm/j46S/r9C53FotB14FdHPWW6nNB7xqTmQkvvAD//jcUFDial9GK97mIJKPhz/QKM1N5j9+xAnh5wZ490Lq1s8MSkQpQoklEREREpAEoLCxk2Vdr+PTZrzm2P67sC2pJeL9OjL53OJdc25uApv7ODqd+2LkT7rsPVq50NGXiwhy68SMdKDQsTgyuBpkm/2Y5PUm0H7/4IjzxhHNjEpEKq9ZEk81mIz+/4RcoFAFwdXXFam3kU7xFRESkzrEV2Fj4yTI+e/4bTh5NclocbSJa8rcXb2Xg2Isbxk5xtc004ZNP4NFHITHR0byPAF6mH7ENsFj4FeYRnmCD/aBjR9ixA9zdnRuUiFRYtSSaTNMkPj6e1NTUaghJpP4ICAggJCRE/3gSERGROicvN59fZi3ivy99R2pCWq3dt2mrIP767Diu+utlqrtUHZKS4PHH4YMPHE2ZuPAqF7PGaDjLDz3NfD7mN4LIsTf88gtce61zgxKRSqmWRFNcXBypqak0a9YMLy8vfeiWBs80TbKyskhISCAgIIAWLVo4OyQRERGREmVn5vDD27+y+L8rObwzlpqqnOHbxIdbpt/AmEnDcffULJRqt2YNTJwIu87uNPgF4XxKNwobwOevu8xtjGef/WD0aHtxdBGpl6qcaLLZbOzbt49mzZoRFBRUXXGJ1AtJSUkkJCTQuXNnLaMTERGROi8jNZNda/exc/Uedq7Zy571+8nNzqvQGBarBavVguX0l5uHK9dOvJJxj47FJ8C7hiIXADIy4K67iuzCtoHmvEI/0g03JwZWNa3NU8xmES6Y9qVyO3dChw7ODktEKqnKiaacnBxiYmJo164dnp4NfxcEkXNlZ2dz6NAhwsLC8PDwcHY4IiIiIhVSkF/Aga0x7Fy9l51r9rBz9V6S41Md5//85I3c8sT1jqSSxWLR6gVnM02YMQMeewxsNgDi8OZZBnDQCHBubJVhmrzCSvqSYD9++ml4/nnnxiQiVVJtiSZ90JbGSO9/ERERaUhM0yQ+JoEdq/eQdvIUN04ZpcRSXbV0KYwfDydPApCDlRn0ZYnRxsmBVcxg8xjPsNZ+0KYN7N4NXl7ODUpEqsTF2QGckXgsic2LtpF1KhsvP0/6XtWT4JZaiiciIiIiUlsMw6BF++a0aN/c2aFIWa64AjZvhhtvhI0b8cDGdDbQxUxmNj2xGRZnR1gmd7OAe/jjbMOMGUoyiTQATk807d0UzZcvf8e6nzZjK7A52q0uVvqP7sst02+gS6TW54qIiIiIiBTRujWsWAEPPAAffgjADRygI6n8w+xPilG3Z9yPZy8hZNkPrroKrr/euQGJSLVwapp71bz1TBnyNKvnbSiSZAKwFdhYPW+D/fz3G2olnt9++43+/fvj6+tL06ZNufHGG4mJiSnSJzc3lyeffJK2bdvi7u5Ohw4d+Oijj4r0eeONN+jSpQuenp60bt2aKVOmkJOTU+I9X375ZQzDYPLkyWXGt3z5cvr27YuHhwft27fn/fffL9bn22+/pWvXrri7u9O1a1fmzZtX/gdw2uzZs7n88svx8/PDMAxSU1OL9dm3bx9jx44lODgYPz8/Bg0axNKlS4v0efjhh+nbty/u7u706tWr2BjPPvsshmEU+/L2LlpEsjyv+3xHjhxh9OjReHt7ExwczEMPPUReXtFCl9u3b+eyyy7D09OTli1b8vzzz9fYLiwiIiIiIjXCwwM++ABmzQJXVwB6ksi7/E6EmeTk4EoXYmYwnr32AxcXeOst0DJNkQbBaYmmvZuieenWN8nPzb9gv/zcfF685Q32boqu0XgOHjzI2LFjGTp0KFFRUfz2228kJiZyww03FOk3btw4Fi9ezIcffsjevXv58ssvCQ8Pd5z/4osvePzxx3nmmWfYvXs3H374IV999RXTp08vds+NGzcye/ZsevbsWWZ8MTExXHvttQwZMoStW7fyxBNP8NBDD/Htt986+qxdu5bx48czYcIE/vjjDyZMmMC4ceNYv359hZ5FVlYWI0aM4Iknnii1z8iRIykoKGDJkiVs3ryZXr16MWrUKOLj4x19TNPkb3/7G+PHjy9xjEceeYS4uLgiX127duXmm2+u0Os+n81mY+TIkWRmZrJq1Srmzp3Lt99+y7Rp0xx9Tp06xVVXXUVoaCgbN27k7bff5rXXXuP111+vyKMSEREREakb7r7bPrupZUsAgsnh3yxjpHnQXkC8jrmPP3Cj0H4wZQqc85lKROo3pxUDf/bGf7F6XvlnKg2+oR/P/O+RyoRYLv/73/+45ZZbyM3NxWKx599++uknxo4dS25uLq6urixYsIA//elPHDx4kCZNmpQ4zgMPPMDu3btZvHixo23atGls2LCBlStXOtoyMjLo06cP7777Lv/4xz/o1asXb7zxRqnx/d///R8//vgju3fvdrTde++9/PHHH6xday+eN378eE6dOsWvv/7q6DNixAgCAwP58ssvK/xMli1bxhVXXEFKSgoBAQGO9sTERJo2bcqKFSsYMmQIAOnp6fj5+fH7778zbNiwIuM8++yzfP/990RFRV3wfn/88Qe9evUqMm55Xvf5fv31V0aNGsXRo0cJDQ0FYO7cudx+++0kJCTg5+fHe++9x/Tp0zlx4gTu7u4AvPLKK7z99tvExsaWu+ilioGLiIiISJ1y4gSMG2dPOp32Pzoxi551ZsbQJWYcL7LaftCiBezdC76+zg1KRKqNU2Y0JR5LYu2Pmyp0zdofN5F4rOamfkZGRmK1Wvn444+x2WykpaXx2WefMXz4cFxPT0H98ccfiYyM5NVXX6Vly5Z07tyZRx55hOzsbMc4gwcPZvPmzWzYYE+iHTx4kPnz5zNy5Mgi97v//vsZOXIkV155ZbniW7t2LcOHDy/SdvXVV7Np0yby8/Mv2GfNmjUVexhlCAoKIiIigk8//ZTMzEwKCgqYNWsWzZs3p2/fvpUe94MPPqBz586OJBOU73Wfb+3atXTv3t2RZDpzTW5uLps3b3b0ueyyyxxJpjN9jh8/zqFDhyr9GkREREREnKp5c/j9dzinNMdN7OcutteJmU2upo1J5xYA/9e/lGQSaWCcUgx886JtFNoKK3SNrcDGlt+3M/y2y2skpnbt2rFw4UJuvvlm7rnnHmw2GwMGDGD+/PmOPgcPHmTVqlV4eHgwb948EhMTmTRpEsnJyY46TX/60584efIkgwcPxjRNCgoKuO+++3j88ccd48ydO5ctW7awcePGcscXHx9P8+ZFd/9o3rw5BQUFJCYm0qJFi1L7nLucrToYhsGiRYsYO3Ysvr6+WCwWmjdvzoIFC4rMfKqI3Nxcx7LDc5XndZ+vpGsCAwNxc3NzPIv4+HjatWtXbNwz58LCwir1OkREREREnM7V1b6DW9eu9iV1wHj2UYCFOWY3p85supH9tCTDfjB4MNx6q9NiEZGa4ZQZTVmnssvuVI3XlUd8fDx33XUXt912Gxs3bmT58uW4ublx0003OQpEFxYWYhgGX3zxBZdccgnXXnstr7/+OnPmzHHMalq2bBkvvvgi7777Llu2bOG7777j559/5oUXXgDg6NGjPPzww3z++ecVXmp1/nKuM3Gd215Sn/IuAysv0zSZNGkSzZo1Y+XKlWzYsIGxY8cyatQo4uLiKjXmd999R3p6On/961+LnSvP6y7rmjPXlfWsyhpXRERERKTemDgRztlI58/s4S/svsAFNSvYzOLWM/e3WGDmzDqznE9Eqo9TZjR5+XnW6nXl8c477+Dn58err77qaPv8889p3bo169evp3///rRo0YKWLVvi7+/v6BMREYFpmsTGxtKpUyeefvppJkyYwF133QVAjx49yMzM5O677+bJJ59k8+bNJCQkFFliZrPZWLFiBTNnziQ3Nxer1VosvpCQkGIzkxISEnBxcSEoKOiCfc6f3VNVS5Ys4eeffyYlJQU/Pz8A3n33XRYtWsQnn3xSbFZSeXzwwQeMGjWKkJCQIu3led3nCwkJKVYAPSUlhfz8fMezKG1coNqfl4iIiIiI09xzDxQUwAMPAHAbu7CZBl8aEbUeyt1sw5PTu41PmgQXXVTrMYhIzXPKjKa+V/XE6lI8mXIhVhcrfa7sUUMR2XdaOz/Bc+a4sNC+zG/QoEEcP36cjIwMR599+/ZhsVho1aqVY5wzxcTPHcc0TUzTZNiwYWzfvp2oqCjHV2RkJH/+85+JiooqMckEMGDAABYtWlSkbeHChURGRjpqSJXWZ+DAgRV9HBeUlZUFUOx1WiwWx7OqiJiYGJYuXcqdd95Z7Fx5XndJ1+zYsaPI7KqFCxfi7u7uSPANGDCAFStWkJeXV6RPaGhosSV1IiIiIiL12v3325fSnfY3dnKzubdWQ7jITOAKYu0HwcHw/PO1en8RqT1OSTQFtwyi/+iKFY0eMCaS4JYlz2CpDiNHjmTjxo08//zz7N+/ny1btnDHHXfQtm1bevfuDcCtt95KUFAQd9xxB7t27WLFihU8+uij/O1vf8PT0z7bavTo0bz33nvMnTuXmJgYFi1axNNPP82YMWOwWq34+vrSvXv3Il/e3t4EBQXRvXt3RzzTp08vsozs3nvv5fDhw0ydOpXdu3fz0Ucf8eGHH/LII2d34nv44YdZuHAh//znP9mzZw///Oc/+f3335l8TiHA8oiPjycqKooDBw4AOBJjycnJgD1JExgYyG233cYff/zBvn37ePTRR4mJiSlS9PzAgQNERUURHx9Pdna2I7F2bnIH4KOPPqJFixZcc801xWIpz+ueN28e4edshzp8+HC6du3KhAkT2Lp1K4sXL+aRRx5h4sSJjhlYt956K+7u7tx+++3s2LGDefPm8dJLLzF16lQtnRMRERGRhmfyZHvh7dPuZjs3mPtq5dZWs5D7iTrb8MorEBhYK/cWkdrnlEQTwC3Tb8DVveQZKedz83DlT49fX6PxDB06lP/+9798//339O7dmxEjRuDu7s6CBQscSSQfHx8WLVpEamqqYxbS6NGjeeuttxzjPPXUU0ybNo2nnnqKrl27cuedd3L11Vcza9asCsUTFxfHkSNHHMdhYWHMnz+fZcuW0atXL1544QXeeustbrzxRkefgQMHMnfuXD7++GN69uzJnDlz+Oqrr+jXr5+jz5w5c8pMpLz//vv07t2biRMnAnDppZfSu3dvfvzxRwCCg4NZsGABGRkZDB06lMjISFatWsUPP/zARedMf73rrrvo3bs3s2bNYt++ffTu3ZvevXtz/PhxR5/CwkLmzJnD7bffXuJsrvK87rS0NPbuPft/ZKxWK7/88gseHh4MGjSIcePGcd111/Haa685+vj7+7No0SJiY2OJjIxk0qRJTJ06lalTp17w2YiIiIiI1FuPPAIvveQ4vI9tXG/ur/Hd6MYQTRin7AcXXwx33FGj9xMR5zJMs2q/VXJycoiJiSEsLKzCxa1Xf7+BF295g/zckrepB3B1d+XJLycz6LpLqhKmnPbss8+ybNkyli1b5uxQGoSqvP9FRERERJzi+efhmWcch2tpwUx6kWB418jt/mv+QlNOb+y0eDEMHVoj9xGRusFpM5oABl13CTNWvsDgG/oVq9lkdbEy+IZ+zFj5gpJM1ei3334rUvBcREREREQamb//HZ5+2nE4gDg+YCH/MpfzhLmOS82jWKpxltNxzklgvfUWVKKuq4jUH06d0XSuxGNJbPl9O1mnsvHy86TPlT1qtCaTSHXQjCYRERERqbe++QYefhjO2UTnjMP48indWEFLqGIN0xAzk3f4HT9Or2T5xz/gySerNKaI1F11JtEkUh/p/S8iIiIi9VpaGjz1FMycWeLp5xjAKqNllW8TacbzIqvsS2oMA375BUrYDEhE6j+nLp0TERERERERJ/L3h7ffho0bSzw9nfXVcptNRghz6GY/ME249VaIjq6WsUWkblGiSUREREREpLGLjIS1a4s1u1GIi1k9NZXmEs4qQu0Hqalwww2QlVUtY4tI3aFEk4iIiIiIiED//vYd6c7TjcRqGd40DP7FxRzFx96wbZu9MLmINChKNImIiIiIiIjdE0/AzTcXaQols9qGN4F03M427N5dbWOLSN2gRJOIiIiIiIjYWa3wxRdw442OpvvZSm/zRJWH9jLzeZlVdCXZ3hAYCC+9VOVxRaRuqTOJpviMdP63awdzorbwv107iM9Id3ZIIiIiIiIijY+rK3z5pb2GEuBOIS+wusrJpslsoRtJ9oMmTWDxYrjooqpGKyJ1jIuzA9h2Ip53N61nScxBCgrPFplzsVgYGtaeSZH96Nk8xIkRioiIiIiINDKurjB3LowfD/Pm4U4hz7OGp81BRBnNKjVkO9LOHixeDL16VU+sIlKnOHVG02/R+xn3v7ksjD5QJMkEUFBYyMLoA6fP76/2e69YsYLRo0cTGhqKYRh8//33xfpkZGTwwAMP0KpVKzw9PYmIiOC9994r0mf27Nlcfvnl+Pn5YRgGqampRc4vW7YMwzBK/Np4zhaiR44cYfTo0Xh7exMcHMxDDz1EXl7eBV9Dbm4uDz74IMHBwXh7ezNmzBhiY2OL9ElJSWHChAn4+/vj7+/PhAkTisVYllWrVjFo0CCCgoLw9PQkPDycGTNmFOnz3XffERkZSUBAAN7e3vTq1YvPPvus1DFffvllDMNg8uTJpfa55557MAyDN954w9GWnJzMgw8+SJcuXfDy8qJNmzY89NBDpKWllTrOGe+++y5hYWF4eHjQt29fVq5cWeS8aZo8++yzhIaG4unpyeWXX87OnTvLHFdEREREpEE6k2waOxYAD2y8wGouMhMqNdypc2szdepUHRGKSB3ktETTthPxPLzgF/Jstgv2y7PZeGjBL2w7EV+t98/MzOSiiy5i5syZpfaZMmUKCxYs4PPPP2f37t1MmTKFBx98kB9++MHRJysrixEjRvDEE0+UOMbAgQOJi4sr8nXXXXfRrl07IiMjAbDZbIwcOZLMzExWrVrF3Llz+fbbb5k2bdoFX8PkyZOZN28ec+fOZdWqVWRkZDBq1Chs5zzTW2+9laioKBYsWMCCBQuIiopiwoQJFXlUeHt788ADD7BixQp2797NU089xVNPPcXs2bMdfZo0acKTTz7J2rVr2bZtG3fccQd33HEHv/32W7HxNm7cyOzZs+nZs2ep9/z+++9Zv349oaGhRdqPHz/O8ePHee2119i+fTtz5sxhwYIF3HnnnRd8DV999RWTJ0/mySefZOvWrQwZMoRrrrmGI0eOOPq8+uqrvP7668ycOZONGzcSEhLCVVddRXq6lnGKiIiISCPl5gZffw1jxgD2ZNM/WE3PSiSb0nA/e3DyZHVFKCJ1jGGaplmVAXJycoiJiXHMFCmve3/5gYXRB8rd/+oOnXhv5JjKhFgmwzCYN28e1113XZH27t27M378eJ5++mlHW9++fbn22mt54YUXivRdtmwZV1xxBSkpKQQEBJR6r/z8fFq1asUDDzzgGPfXX39l1KhRHD161JFYmTt3LrfffjsJCQn4+fkVGyctLY2mTZvy2WefMX78eMCehGndujXz58/n6quvZvfu3XTt2pV169bRr18/ANatW8eAAQPYs2cPXbp0qfCzOuOGG27A29v7grOW+vTpw8iRI4s8q4yMDPr06cO7777LP/7xD3r16lVkxhLAsWPH6NevH7/99hsjR45k8uTJF5z59M033/CXv/yFzMxMXFxKXg3ar18/+vTpU2RGWkREBNdddx0vv/wypmkSGhrK5MmT+b//+z/APmOsefPm/POf/+See+4pcdzKvv9FREREROqVvDy46Sb46ScAsrHyFIPZZjQt1+XBZhbvsJgm5NobYmKgXbsaClZEnMkpM5riM9JZfDC6Qtcsjomu9QLhgwcP5scff+TYsWOYpsnSpUvZt28fV199daXH/PHHH0lMTOT22293tK1du5bu3bsXmb1z9dVXk5uby+bNm0scZ/PmzeTn5zN8+HBHW2hoKN27d2fNmjWOcf39/R1JJoD+/fvj7+/v6FMZW7duZc2aNVx22WUlnjdNk8WLF7N3714uvfTSIufuv/9+Ro4cyZVXXlnitYWFhUyYMIFHH32Ubt26lSuetLQ0/Pz8Sk0y5eXlsXnz5iLPCmD48OGO5xATE0N8fHyRPu7u7lx22WVVelYiIiIiIg2Cmxt88w2MGgWAJzb+wSp6mGXPTDJMk7+z7mySadgwJZlEGjCnJJpWHTmMrYITqQoKC1l99EjZHavRW2+9RdeuXWnVqhVubm6MGDGCd999l8GDB1d6zA8//JCrr76a1q1bO9ri4+Np3rx5kX6BgYG4ubkRH1/yksH4+Hjc3NwIDAws0t68eXPHNfHx8TRrVrxQX7NmzUod90JatWqFu7s7kZGR3H///dx1111FzqelpeHj44ObmxsjR47k7bff5qqrrnKcnzt3Llu2bOHll18u9R7//Oc/cXFx4aGHHipXTElJSbzwwgulzjgCSExMxGazFXvG5z+rM22l9RERERERadTc3eF//4NrrwXsyaYXWUX3MpJN3uQTQbL9oFkze90nEWmwnLLrXEYZRa5Lvy63miO5sLfeeot169bx448/0rZtW1asWMGkSZNo0aJFqTNyLiQ2NpbffvuNr7/+utg5wzCKtZmmWWL7hZx/TXWNC7By5UoyMjJYt24djz/+OB07duSWW25xnPf19SUqKoqMjAwWL17M1KlTad++PZdffjlHjx7l4YcfZuHChaUuMdu8eTNvvvkmW7ZsKVd8p06dYuTIkXTt2pVnnnmmzP7nj1nScyhPHxERERGRRsvdHb79Fm64AX79FU9svMQqpptD2GkEl3hJBq6k4kYAeWCaEBRUy0GLSG1yyowmHze3sjuVeJ172Z2qSXZ2Nk888QSvv/46o0ePpmfPnjzwwAOMHz+e1157rVJjfvzxxwQFBTFmTNFaUyEhIcVmzaSkpJCfn19shs251+Tl5ZGSklKkPSEhwXFNSEgIJ06cKHbtyZMnSx33QsLCwujRowcTJ05kypQpPPvss0XOWywWOnbsSK9evZg2bRo33XSTY/bS5s2bSUhIoG/fvri4uODi4sLy5ct56623cHFxwWazsXLlShISEmjTpo2jz+HDh5k2bRrtzptam56ezogRI/Dx8WHevHm4urqWGndwcDBWq7XYMz7/WQEX7CMiIiIiIoCHB3z3HYwYAeBINnUzE0vubxhEE2D//uRJ0IoBkQbNKYmmwW3a4mKp2K1dLBYGtW5TQxEVl5+fT35+Ppbz4rRarRQWFlZ4PNM0+fjjj/nrX/9aLCkyYMAAduzYQVxcnKNt4cKFuLu707dv3xLH69u3L66urixatMjRFhcXx44dOxg4cKBj3LS0NDZs2ODos379etLS0hx9Kss0TXJzLzzD7Nw+w4YNY/v27URFRTm+IiMj+fOf/0xUVBRWq5UJEyawbdu2In1CQ0N59NFHi+xed+rUKYYPH46bmxs//vhjmUW43dzc6Nu3b5FnBbBo0SLHcwgLCyMkJKRIn7y8PJYvX17lZyUiIiIi0uB4eMC8eXC6fq0XBbzEKrqWkmxyJJoAoqJqPj4RcRqnLJ0L8fFlaFj7Cu06NyysAyE+vtUWQ0ZGBgcOnL1/TEwMUVFRNGnShDZt2uDn58dll13Go48+iqenJ23btmX58uV8+umnvP76647r4uPjiY+Pd4y1fft2fH19adOmDU2aNHH0W7JkCTExMdx5553FYhk+fDhdu3ZlwoQJ/Otf/yI5OZlHHnmEiRMnOnacO3bsGMOGDePTTz/lkksuwd/fnzvvvJNp06YRFBREkyZNeOSRR+jRo4djWV9ERAQjRoxg4sSJzJo1C4C7776bUaNGVWjHuXfeeYc2bdoQHh4OwKpVq3jttdd48MEHHX1efvllIiMj6dChA3l5ecyfP59PP/3Uscubr68v3bt3LzKut7c3QUFBjvagoCCCzptG6+rqSkhIiCPe9PR0hg8fTlZWFp9//jmnTp3i1KlTADRt2hSr1QrYE1vXX389DzzwAABTp05lwoQJREZGMmDAAGbPns2RI0e49957AfuSucmTJ/PSSy/RqVMnOnXqxEsvvYSXlxe33npruZ+ViIiIiEij4eEB338PY8fCwoWOZNN0cwi7jaL/ri+SaPrjD7jmmloNVURqj1MSTQCTIvux7FAMeTZbmX3drS7cF3lJtd5/06ZNXHHFFY7jqVOnAnDbbbcxZ84cwF68evr06fz5z38mOTmZtm3b8uKLLzqSEwDvv/8+zz33nOP4zC5rH3/8cZGd5T788EMGDhxIREREsVisViu//PILkyZNYtCgQXh6enLrrbcWWaKXn5/P3r17ycrKcrTNmDEDFxcXxo0bR3Z2NsOGDWPOnDmOZAvAF198wUMPPeTYTW3MmDHMnDmzyP3btWvH7bffXmwp3BmFhYVMnz6dmJgYXFxc6NChA6+88kqRAtyZmZlMmjSJ2NhYPD09CQ8P5/PPP2f8+PEljllZmzdvZv369QB07NixyLmYmBjHErvo6GgSE8/+35Tx48eTlJTE888/T1xcHN27d2f+/Pm0bdvW0eexxx4jOzubSZMmkZKSQr9+/Vi4cCG+vtWX4BQRERERaVDOJJvGjIHff8ebAl5mJY+bQ9hzTrIpGv+z12zdWvtxikitMUyzgtu/nScnJ4eYmBjCwsLKXMJ0voXR+3lowS8XTDa5Wa28NWIkwzt0qkqYUors7GyaNGnC/PnziyTepHyq8v4XEREREWkwsrLsyabFiwHIxIX/41L2GvZVHj3Nk/yb5fa+N98MJWyQJCINg1NqNJ0xvEMnvr7pT1zdoVOxmk0uFgtXnz6vJFPNWb58OUOHDlWSSUREREREKs/LC378EYYOBcCbAl5hJZ3NZACGc+hs3xtucEKAIlJbnDqj6VzxGemsPnqEjLxcfNzcGdS6TbXWZBKpCZrRJCIiIiJyjqwsGDUKli4FIANX5tKFv7AbD2zg7w9xceDp6eRARaSmOK1G0/lCfHy5MaKbs8MQERERERGRyvLygp9+siebli3Dh3zuYsfZ8xMmKMkk0sA5demciIiIiIiINDDe3vDzz3B6oySHm2+Gl192TkwiUmuUaBIREREREZHq5e0Nv/wCt90GgwbZ6zd9/TX4+Dg7MhGpYXVm6ZyIiIiIiIg0ID4+MGeOs6MQkVqmGU0iIiIiIiIiIlItlGgSEREREREREZFqUWeWzpm2eMhdA2YGGD7gPhDDGuLssEREREREREREpJycnmgy87djZrwPuUuBgnPOuGC6X4Hhcy+Gaw9nhSciIiIiIiIiIuXk1KVzZs5CzKRbIHcRRZNM2I9zF2Em3YKZs6ja7/3ee+/Rs2dP/Pz88PPzY8CAAfz6669F+jz77LOEh4fj7e1NYGAgV155JevXry/5tZgm11xzDYZh8P3335fYJzc3l169emEYBlFRUY72P/74g1tuuYXWrVvj6elJREQEb775ZpmvITc3lwcffJDg4GC8vb0ZM2YMsbGxRfqkpKQwYcIE/P398ff3Z8KECaSmppY59rmWLVuGYRjFvvbs2VNi/7lz52IYBtddd12R9vI883Pdc889GIbBG2+8UaQ9Ojqa66+/nqZNm+Ln58e4ceM4ceJEma/j3XffJSwsDA8PD/r27cvKlSuLnDdNk2effZbQ0FA8PT25/PLL2blzZ5njioiIiIiIiIid0xJNZv52zNSpQF4ZPfMwU6dg5m+v1vu3atWKV155hU2bNrFp0yaGDh3K2LFjiyQWOnfuzMyZM9m+fTurVq2iXbt2DB8+nJMnTxYb74033sAwjAve87HHHiM0NLRY++bNm2natCmff/45O3fu5Mknn2T69OnMnDnzguNNnjyZefPmMXfuXFatWkVGRgajRo3CZrM5+tx6661ERUWxYMECFixYQFRUFBMmTCjr8ZRo7969xMXFOb46depUrM/hw4d55JFHGDJkSLFz5XnmZ3z//fesX7++2PPKzMxk+PDhGIbBkiVLWL16NXl5eYwePZrCwsJSY//qq6+YPHkyTz75JFu3bmXIkCFcc801HDlyxNHn1Vdf5fXXX2fmzJls3LiRkJAQrrrqKtLT0yvymEREREREREQaL7OKsrOzzV27dpnZ2dkVus6WPMm0xXUq/1fy/VUNtUyBgYHmBx98UOr5tLQ0EzB///33Iu1RUVFmq1atzLi4OBMw582bV+za+fPnm+Hh4ebOnTtNwNy6desFY5k0aZJ5xRVXlHo+NTXVdHV1NefOnetoO3bsmGmxWMwFCxaYpmmau3btMgFz3bp1jj5r1641AXPPnj0XvP+5li5dagJmSkrKBfsVFBSYgwYNMj/44APztttuM8eOHVvm2CU989jYWLNly5bmjh07zLZt25ozZsxwnPvtt99Mi8ViptvH7pwAAAn4SURBVKWlOdqSk5NNwFy0aFGp97nkkkvMe++9t0hbeHi4+fjjj5umaZqFhYVmSEiI+corrzjO5+TkmP7+/ub7779f6riVff+LiIiIiIiINEROmdFkL/y9pGIX5S6xX1cDbDYbc+fOJTMzkwEDBpTYJy8vj9mzZ+Pv789FF13kaM/KyuKWW25h5syZhISUXLz8xIkTTJw4kc8++wwvL69yxZSWlkaTJk1KPb9582by8/MZPny4oy00NJTu3buzZs0aANauXYu/vz/9+vVz9Onfvz/+/v6OPhXRu3dvWrRowbBhw1i6dGmx888//zxNmzblzjvvLHOs0p55YWEhEyZM4NFHH6Vbt27FrsvNzcUwDNzd3R1tHh4eWCwWVq1aVeK98vLy2Lx5c5FnBTB8+HDHc4iJiSE+Pr5IH3d3dy677LJKPSsRERERERGRxsg5S+dy1wC2MrsVVQB51fuBf/v27fj4+ODu7s69997LvHnz6Nq1a5E+P//8Mz4+Pnh4eDBjxgwWLVpEcHCw4/yUKVMYOHAgY8eOLfEepmly++23c++99xIZGVmuuNauXcvXX3/NPffcU2qf+Ph43NzcCAwMLNLevHlz4uPjHX2aNWtW7NpmzZo5+pRHixYtmD17Nt9++y3fffcdXbp0YdiwYaxYscLRZ/Xq1Xz44Yf85z//ueBYZT3zf/7zn7i4uPDQQw+VeH3//v3x9vbm//7v/8jKyiIzM5NHH32UwsJC4uLiSrwmMTERm81G8+bNi7Sf/6zOtJXWR0REREREREQuzDm7zpkZlbuusJLXlaJLly5ERUWRmprKt99+y2233cby5cuLJD6uuOIKoqKiSExM5D//+Q/jxo1j/fr1NGvWjB9//JElS5awdevWUu/x9ttvc+rUKaZPn16umHbu3MnYsWP5+9//zlVXXVXh12SaZpFaUSXVjTq/T1m6dOlCly5dHMcDBgzg6NGjvPbaa1x66aWkp6fzl7/8hf/85z9FknCljVXaM9+8eTNvvvkmW7ZsKTW+pk2b8s0333Dffffx1ltvYbFYuOWWW+jTpw9Wq/WC9z5/zJKeQ3n6iIiIiIiIiEjJnDOjyfCp3HWWSl5XCjc3Nzp27EhkZCQvv/wyF110UbHd3ry9venYsSP9+/fnww8/xMXFhQ8//BCAJUuWEB0dTUBAAC4uLri42PN2N954I5dffrmjz7p163B3d8fFxYWOHTsCEBkZyW233VbkXrt27WLo0KFMnDiRp5566oKxh4SEkJeXR0pKSpH2hIQEx6yckJCQEndjO3nyZLGZOxXVv39/9u/fD9h3gTt06BCjR492PIdPP/2UH3/8ERcXF6Kjox3XXeiZr1y5koSEBNq0aeMY5/Dhw0ybNo127do5xhg+fDjR0dEkJCSQmJjIZ599xrFjxwgLCysx1uDgYKxWa7GZSec/K+CCfURERERERETkwpyTaHIfSMUnU7mA28CaiMbBNE1yc3PL3efxxx9n27ZtREVFOb4AZsyYwccffwzAW2+9xR9//OE4P3/+fMC+C9qLL77oGHfnzp1cccUV3HbbbUXaS9O3b19cXV1ZtGiRoy0uLo4dO3YwcKD9OQ0YMIC0tDQ2bNjg6LN+/XrS0tIcfSpr69attGjRAoDw8HC2b99e5DmMGTPGMRusdevWpY5z7vOcMGFCsecZGhrKo48+ym+//Vbs2uDgYAICAliyZAkJCQmMGTOmxHu4ubnRt2/fIs8KYNGiRY7nEBYWRkhISJE+eXl5LF++vMrPSkRERERERKSxcMrSOcMagul+BeQuKrvzGe5DMawlF9uujCeeeIJrrrmG1q1bk56ezty5c1m2bBkLFiwAIDMzkxdffJExY8bQokULkpKSePfdd4mNjeXmm28G7LNgSioA3qZNG8fsmjZt2hQ55+Njn5XVoUMHWrVqBZxNMg0fPpypU6c6ZtVYrVaaNm0KwLFjxxg2bBiffvopl1xyCf7+/tx5551MmzaNoKAgmjRpwiOPPEKPHj248sorAYiIiGDEiBFMnDiRWbNmAXD33XczatSoIkvhyvLGG2/Qrl07unXrRl5eHp9//jnffvst3377LWAvxt29e/ci1wQEBAAUaS/rmQcFBREUFFRkHFdXV0JCQorE+/HHHxMREUHTpk1Zu3YtDz/8MFOmTCnSZ9iwYVx//fU88MADAEydOpUJEyYQGRnJgAEDmD17NkeOHOHee+8F7EvmJk+ezEsvvUSnTp3o1KkTL730El5eXtx6663lflYiIiIiIiIijZlzajQBhs+9mLnLgbxy9HbH8Cm9MHZlnDhxggkTJhAXF4e/vz89e/ZkwYIFjrpIVquVPXv28Mknn5CYmEhQUBAXX3wxK1euLHE3tKr45ptvOHnyJF988QVffPGFo71t27YcOnQIgPz8fPbu3UtWVpbj/IwZM3BxcWHcuHFkZ2czbNgw5syZU6RW0RdffMFDDz3k2E1tzJgxzJw5s8j927Vrx+23386zzz5bYnx5eXk88sgjHDt2DE9PT7p168Yvv/zCtddeW6HXWdYzL6+9e/cyffp0kpOTadeuHU8++SRTpkwp0ic6OprExETH8fjx40lKSuL5558nLi6O7t27M3/+fNq2bevo89hjj5Gdnc2kSZNISUmhX79+LFy4EF9f3wrFJyIiIiIiItJYGaZpmlUZICcnh5iYGMLCwvDw8KjQtWbOIszUKVw42eSGETADw6PihbGlbNnZ2TRp0oT58+dzxRVXODuceqcq738RERERERGRhsY5NZpOMzyuwgj6EtyHU3xylQu4D8cI+lJJphq0fPlyhg4dqiSTiIiIiIiIiFSZU2c0ncu0xUPeGijMsO8u5zawWmsyidQEzWgSEREREREROctpNZrOZ1hDwPMGZ4chIiIiIiIiIiKV5NSlcyIiIiIiIiIi0nBUW6KpiivwROolve9FREREREREzqpyosnV1RWArKysKgcjUt+ced+f+XsgIiIiIiIi0phVuUaT1WolICCAhIQEALy8vDAMo8qBidRlpmmSlZVFQkICAQEBWK1WZ4ckIiIiIiIi4nRV3nUO7B+64+PjSU1NrYaQROqPgIAAQkJClFwVERERERERoZoSTWfYbDby8/OraziROs3V1VUzmURERERERETOUa2JJhERERERERERabyqbdc5ERERERERERFp3JRoEhERERERERGRaqFEk4iIiIiIiIiIVAslmkREREREREREpFoo0SQiIiIiIiIiItVCiSYREREREREREakWSjSJiIiIiIiIiEi1UKJJRERERERERESqhRJNIiIiIiIiIiJSLZRoEhERERERERGRaqFEk4iIiIiIiIiIVAslmkREREREREREpFoo0SQiIiIiIiIiItVCiSYREREREREREakW/w9nr8Bd91/3LAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks',k=3,\n", - " query=['Chiapas', 'Campeche'], orientation='b')" - ] - }, - { - "cell_type": "markdown", - "id": "4d47f6a0-a6e6-4980-ae85-f8c21b3328b5", - "metadata": {}, - "source": [ - "## Subplotting" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e086b17c-b5f9-44c2-8c39-1ffad3b422f1", - "metadata": {}, - "outputs": [], - "source": [ - "import seaborn as sns" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "20df407d-d5ad-4336-af1a-de2712f256c9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "fig, axes = plt.subplots(2, 2, figsize=(10, 8), gridspec_kw={'height_ratios': [1, 1]})\n", - "ax0, ax1, ax2, ax3 = axes[0,0], axes[0,1], axes[1,0], axes[1,1]\n", - "\n", - "sns.kdeplot(data=gdf, x='PCGDP2000', ax=ax0)\n", - "gdf.plot('PCGDP2000', ax=ax1)\n", - "pen(gdf, col, name, ax=ax2)\n", - "pengram(gdf, col, name, xticks=False, legend=False, ax=ax3);\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e5b7c249-001d-4f2d-b5c8-c015da479924", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/shutz.ipynb b/notebooks/shutz.ipynb deleted file mode 100644 index 62735bc6..00000000 --- a/notebooks/shutz.ipynb +++ /dev/null @@ -1,600 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "cfa03ecf-6e5d-4cb7-8060-048cd4e1ca6c", - "metadata": {}, - "source": [ - "## Schutz Measures of Inequality\n", - "\n", - "The Schutz class calculates measures of inequality in an income distribution.\n", - "\n", - "It calculates the Schutz distance, which is the maximum distance between the line of perfect equality and the Lorenz curve. Additionally, it computes the intersection point with the line of perfect equality where the Schutz distance occurs and the original Schutz coefficient. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "b5841f7c-a8bd-4ecb-bb34-10d51aa36fef", - "metadata": {}, - "outputs": [], - "source": [ - "from inequality.schutz import Schutz" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "471d3791-e3c5-47bc-92fa-9dd5b3e5c2a5", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "7879bc81-3d53-40f6-8108-ee2fbc07529e", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "9f32cb7a-2210-4a50-bc5c-9cd1bbbd9ee7", - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.DataFrame(data=np.array([1000, 2000, 1500, 3000, 2500]), columns=['GDP'])" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "f52b60af-f136-46d9-8fb9-91ccdb7b1601", - "metadata": {}, - "outputs": [], - "source": [ - "s = Schutz(df, 'GDP')" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "8b72184b-86c8-4bed-b946-70d2e472a1cc", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.15000000000000008)" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.distance" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "acd62bd1-5830-4b2b-ba22-f9dc9381d9c4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.6000000000000001)" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.intersection_point" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "2d4bdf0a-72c7-4eda-83aa-8b82eb8e3706", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
GDPunitupctypctucpctycpctdistanceslopecoefficient
0100010.20.100.20.100.100.50-5.0
1150010.20.150.40.250.150.75-2.5
2200010.20.200.60.450.151.000.0
3250010.20.250.80.700.101.252.5
4300010.20.301.01.000.001.505.0
\n", - "
" - ], - "text/plain": [ - " GDP unit upct ypct ucpct ycpct distance slope coefficient\n", - "0 1000 1 0.2 0.10 0.2 0.10 0.10 0.50 -5.0\n", - "1 1500 1 0.2 0.15 0.4 0.25 0.15 0.75 -2.5\n", - "2 2000 1 0.2 0.20 0.6 0.45 0.15 1.00 0.0\n", - "3 2500 1 0.2 0.25 0.8 0.70 0.10 1.25 2.5\n", - "4 3000 1 0.2 0.30 1.0 1.00 0.00 1.50 5.0" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.df_processed" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "ff41b6d0-f4f2-4dc1-b485-5cac4fb2d29a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(7.499999999999998)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.coefficient" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "5294f208-5b2e-4e86-aa7f-190b82555a2f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "s.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "156b5de7-88b7-4bf8-9fd4-237cb1e72f90", - "metadata": {}, - "source": [ - "### Increase the inequality" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "a2ab7983-d0c6-45eb-a393-45464b6d8a7a", - "metadata": {}, - "outputs": [], - "source": [ - "y = np.array([20,50,80,100,100,100,100,120, 150,180])" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "c2fa9119-df17-4dbb-b6de-71c486355ced", - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.DataFrame(data=y, columns=['GDP'])" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "f4cd0cf8-3458-4a05-87a8-6a387d0f05c4", - "metadata": {}, - "outputs": [], - "source": [ - "s = Schutz(df, 'GDP')" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "8fdc3fb5-f926-46a2-ae79-15f2b82dd192", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(14.999999999999996)" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.coefficient" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "0a77128b-2b2c-41ab-b479-2cc30339e3d4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
GDPunitupctypctucpctycpctdistanceslopecoefficient
02010.10.020.10.028.000000e-020.2-8.0
15010.10.050.20.071.300000e-010.5-5.0
28010.10.080.30.151.500000e-010.8-2.0
310010.10.100.40.251.500000e-011.00.0
410010.10.100.50.351.500000e-011.00.0
510010.10.100.60.451.500000e-011.00.0
610010.10.100.70.551.500000e-011.00.0
712010.10.120.80.671.300000e-011.22.0
815010.10.150.90.828.000000e-021.55.0
918010.10.181.01.00-1.110223e-161.88.0
\n", - "
" - ], - "text/plain": [ - " GDP unit upct ypct ucpct ycpct distance slope coefficient\n", - "0 20 1 0.1 0.02 0.1 0.02 8.000000e-02 0.2 -8.0\n", - "1 50 1 0.1 0.05 0.2 0.07 1.300000e-01 0.5 -5.0\n", - "2 80 1 0.1 0.08 0.3 0.15 1.500000e-01 0.8 -2.0\n", - "3 100 1 0.1 0.10 0.4 0.25 1.500000e-01 1.0 0.0\n", - "4 100 1 0.1 0.10 0.5 0.35 1.500000e-01 1.0 0.0\n", - "5 100 1 0.1 0.10 0.6 0.45 1.500000e-01 1.0 0.0\n", - "6 100 1 0.1 0.10 0.7 0.55 1.500000e-01 1.0 0.0\n", - "7 120 1 0.1 0.12 0.8 0.67 1.300000e-01 1.2 2.0\n", - "8 150 1 0.1 0.15 0.9 0.82 8.000000e-02 1.5 5.0\n", - "9 180 1 0.1 0.18 1.0 1.00 -1.110223e-16 1.8 8.0" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.df_processed" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "191b0379-fa2b-48a8-83e3-4b1513b9ef33", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.15000000000000002)" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.distance" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "fe18ada3-a3b1-4543-b31f-290236823e24", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.30000000000000004)" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "s.intersection_point" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "dc17f5bc-9d85-42eb-9cfe-fbc153439e89", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "s.plot()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/weighted.dbf b/notebooks/weighted.dbf deleted file mode 100644 index c998af848392b5af853920e5ef09c8a173e3e579..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 43746 zcmcJY%Z?mJc7_EQ1K11OfLDfB`2e0m-Y-jFTVI<`>TKb6(1+% z)z{B|`}?n+82zRF`8)e_P#(R0`Y8T)zW&eucyN)gkH3EMG*TYh=d1Xi<>Td}7pvD_ zJ$?Pvi>Gg&zK-`lZvWBa*H7Ps#^n9KeERq;JX#fb{ng`VPhM41TdrU4K5@PO#P#75 z*T+v>pH{EeW$9i2^3lsTU%xCHum9otGFk4=_f8n|;uY%WLhrEw8ofw!HN9w@=@^<(d^azc05xUj4qBuS@xVb@S8x`|aKJ&4(}K zb;F0B=AY~9KgHj3kNN)p6zcB&{x-;l{a^C;XS*I4l-J|E-QT~t+umJ;yGj24zF11v zwf#`m)7Vv;ikp^YGgfUs4KKbetEEzo&qv?iZ$G}j8nJinwf3> z)B}iFR83b-^{^?Yc%dq%aq5dA^mH?g?G(z`mrV&L6@6|uODplyIPB|2(#N4v^r|n1 zQM6N6WnC*e)!{QO+_oNuQPnq=9!hUS`__))|8wZ&rrnMI+!1SpQf_*Kzy_M~E z$Mcd~KBl&<$1ZZ6;UhPHhb#qNYZJGs?#7`^28Wt!5@D66z8$Kro9ec&hl_Dq4Ru!! zUDXU-I(=Yeeb}FKzyI6zkK5ugSovQ!w;!&z#mk%9yQ^~=t;@D-s(RCmJL#K%&uWV9k{bzh!bs(l+R)&3eiS34d?gJlx4pzo%|2KxXLCDyRwO+DNf>l6jL#4PBt zeK5xQO5F9@r>>e^|jE3k6z z=w|4nf`KBy6T+C7_(9TnCJHioVx{RrsW7x|wSHPpD6XP?9-*zmAW*(k_cc~k{WW?o z?rZfQin-o>(JNC>vBoLri4Mk9Qom!xE3Emohl!~;h554kq9;mh0u%SrXWy(c1$ufR zkfAq{Pp~gOYGZS|`mO9Q^=11f z2wMqlgO-BWn{C-&ic@ZYe$|Z)NOFRe?O}h;{r-6S<4;%bemF~&On9iep)-B3YP)Dt zgNY>o+DvGa<7ViFKyO>rz@dm8-3)aUNlxdU-^Y*zI5$n5g}C z%!|~s7@uVt!@$nHD!{~AVwoIIe$!}dHLR5P#gFOG_pY6pp}>#np%N24zo$b#^%Y2x1=dqJ9nW~}g;h31vz&h9`{gu^(13=WTc^sumduXTbFdamF9;}UrS)P99 z(I485;>Tvoqxvu1N%_)l?Nx-f3(w zj@$84oYoyn2#jeuSWM;*tjssibocQMKzaRsTRgccez(2det+|q^I((b`_Q77jm;9* z#<$y|AXfxlfWQ^m9W;!>S(3)?z-C5pWflRZPA1W7bV2F%e5ZVM^Wg zqpaVTQh%&Rd}4|pSoJW`qo>P`j$3~ziqAEAvNmk|=2pz6?oyE3(WUKd`lhl;p-1;} zn45$4O=~zPyY@BR!%FB1v&=`~(2?8267LK4d2~4r)K|WRQy)YTps8#fWAclf_TPHHn}y@$W!|TwaP(Li9u342E`3W7#Tvz5qV&F^$0$gq4dI#Vm*}&Hf)wZsCYe`)j>B4Eam8~~*|s%a1cj}3 zYgK=ZuK2Y29`-$yjt#yHbLhA=PVx0k&o8;Sk>mJRnb9*`6i=={-rZi`-4y?R_1)F& z_Wj{lecty9eRAwJL%Cod`u707o0FHA$zXnkxuBaj_!B};H~5a1(pt=i3&U8Y(?f-s zj#-~fTcD#>$`}r}8C5$(LXTW9p&g*TvYAc__hsTWMsw|W*&^Wo_-2eN(=%k zlWr{v4tk};INy&+c=WIs^Arz5!L0Pgp*rKHvDmk%J9*#M@q0pdFmzD#>SSJCT)+F_ zX8Z1!|M?I(KJ&wJGDtc+vz7hN^ULq9?Z_(9LvBk?0??319re~Ef|Wo=r=}qQRNACn ziqm?)RBd1uXikGWFTM>r*RDrretB|#yZ!L}&6%wn{G238a=)hy9^HtEcM_Gx z%V#96W(6NT=|m*ChJF%njd63L(~m zVH4vv$acWWW%+~!5N>PZ;9;n2A8eKULzmBtlXaC_KFk+iHu>VoAOXP>2c$nqUB|o3hj)%qMOG=CYLnQ{S*x(ZTd<@mLd9%^+ zck(V}`(S8XJ@Lclg@WHx@(;F3tb{JxcQE%zb>iN+<%1{*vYpS3mYcsY%wenps|`;% z!ZWP?Q>P3>XdL+SV{rM?CxE|0JPLQytWY;%QKwr?jbp&g@3j9$?z zrS0rvBL11f68UF6ICP!c%N`;U@Q2?clp%H!gOKN*NA|Hk*zB- zC;5YS5Y=*@qaI>aMeL~MsE7JsW*Ky6j^B{jH*$|;+W4VO?nIMX^_Sw5ZF%f}LB%+E(8h@-?Z}qv)JP}Xsj$XRt}Z)OM;0ycYP%5>2Ot8 zH&_|CJx}*_#I@zib{K=*-&kMivv%pBn420Mflq4(taS88FYi+3)|j5CFv#dik2AWo zd9k%q&@v_|zOC)q&Tia%H^lRo&^*|uV^+}Bv*h$y_-6Z|cz%EVv3PZJck}U=|BdZ_ z_6JFe6I#S)|Ni)g`Q>+ahsY{BjT<(;*)E<$D5$q45w>zHf0}iIvl9L3Vw{rhj>(F# zNkV$UAy}Dp-%iYlU`3E@`}I3^ho7lql3P&Oo#S-E; zMId$*Uw)(yJqca2k;3*Fg;|*M8Y?mLC1&B`Qu-;|zDuRw*p)bob ztWw6<%E>x;e0~4j_B#`f7r*>9gId9XgM=aS`75)_Zx{#r8(Bq~(QnWU(cBK9h#G4W z!AclOMCZ&60z)0g;9QDRJM59ImV!#z|x#;QkG{H)dY+VS;D*Vb106d0#-xmRrP z-E_^`Bqz%q%I#INOj(G#8eyJa}DxhQnhSNiYiddMvwgpS$dm`~lw z&0m z73r7~D>>IwVgybLiE*W!5f?;d_t$0`R9AW&`Iw#3``D~?9H03k@Jc2*{z|qipPpa2CJ`oamYYCwB}dVW zU4JP~@$K1$Ky*pA?<8UlR_0US8IhOwSAV)Go?qQ$+Lu6nYRMTE6?^QK2R-9NSf8Lb zyBpcDSug%dCShud*ip__h{jvR*&D$pYr8s=&a>QMnHfTFJrwvrw}efFaXc8MtxXKC zO9wZ!1J)l6dZcqyv4?#gW_fgp_4Lha-=ljNioa6Y!r0~xU7tw-hDvPmFwvv0fA*tU@Z1@Zw4YE2pvNHF_l~4;#WS#VJYEb&s*%kQbkd)r)WIMVHz2>YOiMZ-3st z%efyMtr2%4=M0fA5Q-%MO*o3#^TgQ`ZQK}49v%mf_eJdJUJt@E()Dw!9}i|SJ0=X) zSCo1k^Fgi!hT`8ml>uvqWBFu#f_~|s$NLhWm-T5%)?cA3OgEMu+KzgbSUY}fM`MuL z0XDq5VvSII+g$3E)c5?A8jI04C00UT9<_m`zz%w!=f~8!L|}B<;axk@_CGQ+xpi*& zu+4ZwpD#R{o4+_d_7PbH+_Aq=AC59|tjdZ+*h;|1#dZ@cN1$@N6sM@I?6GI6nrTQ? z6R&OcAFvM>M|$O#841B7yV$<(#X$lTGB9CbM2lqKbV zBz;}m;GBpev6Zt*6$bI#ll#ZT@p@DA5h$i=J71JXJ>ern2YY&+8&1b z*vBjH4vUQ&1>4-A>zo@fQThQr4E6ks=!qVNN;;V6&{OqsvAwY6o%%ZVb)xV8h682Z z-QNEt4Ac34IXi2d!YfkFZ;Tf5%kPe@$SRI((+zEtTe8}ywEUw^n`OL+16=FDWF$Ox=+eE5j$E%}nR?VkJ` zGFmypnD}EVED1NBLW)FT$%XFQN9uyI?*aUg9rtR*eyDK^#)K+0G97+9= z$f?A{hK=iXKkcVx%A7tREJQ! z(7`O(KK@6?2KV$wFTc`#2U)_-o*$XRbn5TUEg!7iDMT)9n$9n|`8(t&@LJ;~Lo-Bf z(?w3rHHk2-W#pV-JNcVKyX)>!oRU?*{yxizK0eYLtjxM^C(X6JJ{+pg`(BX}L6qhA zJWBEh@LupP*>N$_u*KOCUFYgI#?OL(}SeOw?y&I5zm{IRnRU)QWt3_6P3);H?4q(*Cl` z@4jb|)n-onAwqMs5rc{dwJQ-wBIdVcVDb(}yl?fTIK`2QS~il*c`W8&Wj@C+-F}quM{sf5rQadJA$&6aZmULPhf7!d+jKm% z9n~*u2dq?BU|8w+B~#OR(aTuz=>=%*SCl|06el2OLFKG2(13O~*+o)MWpHD-pIru-hkcm;nHC(J#d* zhwrq!`2Z{-%|8)Curi+lPj}yL|FF$^b_SfI$8ny}PAjnOIW>D3F}W?5d+|%!TOG*_ ziXFvgzhEm#=^=h)uYgNBPm?y6=KoN1W=7hoc4JYWv!ciY-LV5;xZ| zC4S@SiRt7;{;4ndgznY%=!$=u0n6mM--e;mZwQ7;%)tsTjjhDNCDwEPxx{qzO4%>;N>%^VSCd;l$g$ucvwT>Yo4+u>^WVs7&6Z+P zBn|QsVWG~NL{OPbX*;BdX9FRN@=~1gHUyRsSjp)Tsp`1=*4E>FH>Lf*__N*ZuuaXOtxXZRF>TQ%_tfEL{`mH ziHnujR;P=QN^25fdL^+5#G5TYcJTM5IK?AM>dd@L(4M?=A(%_j4Op4)p+tAzzTf`* zZksd1k}ZoR@kEj*118$md-EGic04-z-7aZ`(5m1j4A~A2;dJ^#JJ|T-Fh%B<4~B|eL2{qCtt^GnYjkzrwfYZjAFP!6lz* zQJ7*jxJO^6J&c@nioz=18ya>ckj;-NF%i1NXfSt~k)!s#n2&4YEB;U41DabtNLD1E z9DASPBR7ACECpUIg=KzK_>rPO%{7TIB@~^56MzWn;&^K=#VNWgZ^6cI$6M}FmFUH{ z;mq*EKArP@$sham^Y`07U7gcX{4Gxs9Jw`n9AgY8oaxIuJ6cpq&L3K2W6>)^M|q!L z6mA|u{W#}Ek=CIwg0#z4(ounwo>kTORTTE&=1`bbu~|y#t@uM_+}t{@_*tVXKCQmQ z^cDJv9%PMBe7~f&kr|&<0SnEn#c&kXSbYa8ccHrk;}{2t>Ch#%LYFo>_KLhObcwl6 zJE!NOE<5vn`M*4yfH8eY{K&VRB)j~EiMPLzRZi+97qzN!r6oc{jWvm|6-8)gezCZn z_uE{GQ+sKeC2dzk4^uG&EAtIB-Tm$TyDj;ZHa3|GfXF#(_?6=RoQYG(IU5P5AqlOV zGqeaLXJ`;JFJedcaZ(O$>zmonfKje6jx9jarbg(bU(#OdqcDglp4K1HbfsR2Pe9Ra z+!VGNUESB{$ZA@QNb%}>^mO^sWN5~)Qep)34Ssj^Zu@aJL}z{> z&d2c#1Ls{YQp34SCE1f?0CA`pYdX*?wnCC<&pXTJj`9?W!bg(96mm$(Vof_Av7pD; zP6j2?Z51jy&qax4}JH2erf~h(bETD>O1Z1Ts{Gl1DiIUvOaXBhn_xzbIS*( wE!s<9BYWq6JMw@Lee^O^YOYCyVI@gCBY_=);DlasbNVm;4B+rkl**n+{eS*iceoixsd%Aws$x?c{HMO0Hn)!c zH_@uP(QL{#(b4?>_lp%691HW(L)JI60Xrua7uM1L=I90X`+i+SM;oRN{=#2Gv$5k8 z(ZT;S`v$<)OMV4u^@AZ`mEb(s))`KH*KX$BVjMVfEH!Q}_5ZDc?p0h0)?;_kzQ-!^ zmz%(mbG3U;&^~#1?%ATie#sTgzwWy@KmW%i%wJaod#7iCRh@d&&rJs7TBEP0#YF0- zd(wW$1g1~j80;n(3$~S;Q-As``Q;a2dzow!R0f;x2SaxTX|S3#6l}_8CP#e(R-b1C z%ljK!skn8-Ggtq-DIR_A-9mYq*ywYPe&)fep+*LO(Z6KDUuyi9a_&`vjT#fTqz?X< zXRqz=bMmQRtDQ$F72mO1FMd0$ep`U-`onU2M(sbyfxUgodVW(8`6IGH(<9( zeX!MSY2Up8?QhotoBdVE)vHo>KBxWrS;$W+f_19oV0k^d|3T=gPW%$l*XMWto#|_) z1v^_$Gku2CVDH6I+V?C5whxa}KVOsS+fz3en~}RSf1RoZST))Ydvh>1SRP+z-2vSj zd%tw_`KU5GX`kc~*xs>V)#@hLfBh@Ti6$`Nz<{5Op(cDD_d( znSOQ`uN@Jh}q)js=*1r~F{&RDRmeOaT73jF_Onwm8d-NExEzd<%Ow zGj&~j6xd|s_oQ=<1nb3o-~FGzqyDlC@-rnzg!XNC{FKAM>gfou%EA0i?&-8|I-2?2 z{|W5gx-V*1Z%ug`r2_RcG` zLsa8#V88nt+MDLIuM-=(ZAg35I}YuOA7c7aNx`PwHL&{TZQAF11a@z}L%q~9u&tho z>7Txb^2{CoE?Dm<0(KU@&-8~nvAlbhm0YV2?VIERn`~pj>TnL~d8ble67upT)br(` zz1a@7NvWH6w}Q>|Y|wRvGh{C>^ZWHyn7#m5`7gk_P7!jfH`G5ZMlP0-?Y4EFfpwc~ zU~_`)Jky{U^|0M%hnEA}1My*RE7bryAFbs558Hu`{RQlwt4HBe_{$Rf1wSYMVc6RthdrCQPAb_^q9AJ{*Nod-hY&YTjdee6uSdXQyw*MB|r=q<% z3bt93gLTPUV0pgw`{lg;ZSV1ZC0Q6=|65@7_I$7!a0Tg2;ia^18bxllf_ym<(~JC6 zt^YwcN$c?VDPlFT!F{o{MuFY&kC=YMX!50pDmk|?PXo3KFZf5`uz0jQ)oY%k8^|Vq$6OJCKq}6MsV=0gH50HY;P~g z0#=>oQ7`RKpWuN_;`hM1-{+u^>T{o7bgYlXW{*?q`-dPXS`q6PxJd&`<$G8E73(59J9?w*}Nc;Xnq3czD zg7t$AV6*xhxmQs51|X^oN#fDI2)|dm{ASVU>-G06qaODV*bZLF^i!9UUy@DI$zYY5=~br|K>%|$VmzqGmGt=vWVSaP! zLRZVjP*2;4>F$5B$Oke7H zJ#{_()+f>T&t1}q_Qel@Ra8eF@6i&lp4|*=>Q4gyTR)ZSN&QS?=z3alrvI!t`9yZG zncjiv4<-fMOr62%^H=Q4Ck)T$!7Z@8(;s@IKD09i(>~E(&{dA%!%@;~nPv_Ehk_V&#YFni#<7<`WBWSs{c^1z4MUv{T6`D zv==;H*6rY+EzraU&r#oE{iN%>rha<|^?b3R+dVtMdQr$N&V$|BtZz+{Jz$eKKI~2N zU%~&@&%1V$lZN&AZ$4PP6%Y3I)I+eJjp^0w`1oGEk*u%PsvFRC|HQCYH?M)c`w772 zU{cuY0?c1u&Pi^}_JLkqp5K4iUeH}uk(2QF+Oj+{i^KET^E1B=+xpw+bR zT@h^GTMo9%s?$E>daxJvz4eKGOkbc9bk*rH?Te62-$!86r7HDSPicRKY~Qec^Sjqz z{uPfyS8r9L{eTnXN!0D(gJ2uCChfCrBahZQ-ZUZ-sd-9|CJ zDcJ_Bm;4Id+1iDAUe@oy7$&*pGp7HrAMLZSJ)lw>^0XJ!=L`p{?P=JaxXiw}*_jor zW{qQhEpmeGs|n;&S;!SQ)?+K@1-o`8bmOu;W9Q8Q>)55JU-HOT+Jn_Ui(4y zD)RDCV4d?9@+Wg?UvvZ5v|R``vDbrjuO;LY)YZNJp@cz@OKE!1c8d8kgj9+hS&?VqweYO;jSbN?#Z=NicTYlZFC8bfGbb`Nx0 zBYeK!ZUDPI$3oZP`Pn?-^UlZivGyl1{ggjoZ%R%Cn+o^A&eJhqo0MZm>TTwa{#{UR zs{-NqX9>riDul=H^BC#n*pqCp$5kr!50N>FS()lb*9G3%2A}=0CRWBj~37j|Ft_zswb~KE4F38vRZEjwN@v3RcJVgU!gxfx zcCbG47xk&Xf^F$LU|Wm%>#9-Ue~++MRZ+Jp(J(7Hn>2q7xA_yg9u(?lLw<+H(>AS+o?CrMDDzr ze7+{wO#2CJon7RC^T1~QW!k5kP5q~5Cjb*<6!stG%&vB=<_W=-5wl6`(k6Ddk4mX&4{tgzu5q=`e+!~cKnL@9UDyh zNdv)=^1@tSg!6a5Z%jQbPn5rn`Mq}n<%_vRcI^|elakNZz48pK$DD+{TjcEmxc(%6 zfc>6n$uDn!?Y1;vmHH;wYyW`xZRPu|$CCA`*U0NaBJ!6w;I z^2>B!U7sw=kD%C$qa$UfKa#fLT(K=3xwo(K>*)F2*1_Muzl%JNO(k)jYVv8Y&7Par zz3n*l#bk9Pe9zJ)r2V9Q(9OKqU>kQg?KAw9Pe&gk4c|js^iT3Xyw4^Nb(483kC*ob z^;02#atUl6Y-axLPEzmi3-f>H2-vP)L4LN0oN*ag-CRKX$sw1W0@j_EK)0tR)4t-; z(0&-$WLQl7mm##DN_*vhLw-7+dXD}~|N9)UuKP7u?IoLcJA+N#8MJTFf%cJSF{CN& zZ~Q?0y(Z+hLVI1G_HFqcsr8zA)J)i$%_YFP6Loz)AGrzjpw9s|14F$;da_4dk-W@PlA`Eiu#o zZxz^F3GL%IBEO)nisfedgUSE%?y58e$%%{LcqVZXu&Q03$DflQYz|fft66!;%|E7I zjJlmkdz+EzgE1%S1453|6m0vH;_=oDqu%**=GW&j`Dsh)&xhrWz8|W`H{f6l0Id6y z?fY?gf4ldAZY#f`{oY>W@8Ut%#rlFxpZCb?hfz3LrLOZVroM>m-#x_q^7TV{fA3}LcX@nWKMue5vAwA~A>Sa|KH2!aJMDPAGP%^(wE*ivL#V&o5NxK+q<*9}_0^BS?#-HDdoU=Qg4?OnRR+7`?}7cLrO733 zGyQ1|Ru48aeFo}5y9I0?eoA{g60FM>CV$(OygeV-PH7TynlQg*V84Cp(0&8hITgOI zX%5i772kjN%6_nUPImI2A~$-&@?hlOV0D`9GF#?4c^KJ0avtopc@BHuxytlw*v?TN z**3Tj-Hmqvy6wewk9m79(;uL&67YWL^>=vu-`CTA@GYiKvJk8$lWoVrVBMeX3b$$> zuxl^DUiIevQdKU1O|mbU{xsVu%BxLQ|E)iQX`VRK!+OYTR+-~HIc9QvW5S7sHh9LW z)Be(^hq^@rfA*tHv`zb%ebt|`f%Ue8>^n@($+4j8*}!&l4)WSsV0R<+;JnFqKVp8F zhJ(Es`N4kA8DQr`L9ogfj`a^HM*BzXn?=rD#|iyDCYGf><#Wy}xBHAdi}Ui%$WmZa zv^sRvyeQah9@_8Z`KUTYpxXjjpsNH`$j--LufoqvAC;Z?wcP{uKF{8du0c|&%eCIREwM(3B|L?avgYaadvdoyr8SeFZ)eenP7(CJ|R%og(O zF<`GvKd^Is5bck*0_(D0kvHa|KC=zjaoz)~Z@y&uarAR>@-zbbiT)}TeLVkp1F-q> zJXpP32kgZ^PHy)F`T0q(GomI~7393N-B1neUpoq2`(?p8&1$ecQyOgYtpfWWk^S5Y z$m&z*>g|bOGpz{N?br&eXBPzf&0Mgbx)Ak^4Z+@%kHKEjl3<-T7ubB54eU;$?*5bv z?B}3v_uj<&U>|3Jy?^ou*nIXO)8AV`&Y6b#!|%avx};#|7X7;P@I+ueh3}hpJ2u#R zQycb9v-=HgaG#xy<-jWQJ+S+xBG^wx-T%E9*f#tJy7QFmrHumX!}(~x;xgD9ofWL> z{|R<`rv$qR&VqH(x4=%{Q($#93D|~Zjoa}Jzpu2fpt~3UWO?A;1e+2|QQo)-9+RhU z20KZU;QH+R9W0N^XXf>9Ye>GF4eZ8iOzxJ4di@?u|Ed7fM|A<4*nHkjwt-;(M-APd z{Wa4cu1M}Xocg&+U^9I*`A@#D!I&S|eBGM)_n8V-yV`-(a$b*Lx*OP8xtR7l2a{KE z?9g5wPWz8IwrHJEJF#HD(2T@F4%9e2W-Q-#jM-U z^rOSE?>xWLe&9W(?{NmKhGsrBbOCIQD@RaA1Y-y;#;FEu(9SZ_!UHn-E#{#pXCtnU&8exKdKdeesQs?&t?D*BfP z4WiFQ*SK5~_2zd0gg^P7>wCxX9;=}*`Q9fdo13vp>L87KVn1|$^mFK{8!$ zbpzO$&+k%wxEXA2@w?VTHcR-gK}to&HkJh-qNI)miBN4*K`vUInLT(hP&{ zouj{@Uu7WE&pZx$la2nk`U3NJI`xEZIvk@uss~uD{P8u{Sp1q^cJ$(Hv+m>qa5{OeZlTz4fe(~2m7%KlHVys z&X*tTF31UX4(Fsk=pAyWkHF6RcksSB+p~i0ZTefc>ig-CvS|)z1aN zs!)9LpzPEqzG+~C_sU-37`I#TC0H+b$$I6*6R=bG5ZEvDki2dmIPxufb;B|G3a^>p zy!p_bm5FgYTm2wdMe%&i&UH-RK0WnWZNOf)@P1}$4Yo@PLD$7g(EdgNu-Orx`qX@2 z?|x$Pp^us0yx3rqjn7XPO3CzjGDCMxu-tOfen^h}C(6N~9Sinn?_s&vK0DYg!g@pX zV*dKP2i-Zz^KtU81DjXXXn&FQhN)5pY(L8eUF|9XR>Lwd{ny37-lSw;cO%)k^b+N~ zSFteji+3BWdhvdEUAIy1mYexcnFY3K`F@%$?4x)ybMSbJ$IyNzug}vX$Zz;SA_%Pidatlc`{BYJg3bqhSC0 zI$%|MAJ|D=AFKu9il?j-dp;rB6w?Py&;^r<`-wkM8P!uRI?NPDkBORy)}(UG=Gq@69> zC(*8-XTx@mpOkHAopp5qygO^y#@B0x6+}BHO<)}Pt^Wt-8L@RLE4JVIa{fbo^bXi2 zk6lm)Y0Pu7YL$k(CIfYy8XP&c`)d}kJC6M!|Fs6|ika9Rd{B(`{nLZptChfN7yC=5 zZF#V5{5Ev6wifNny#@A?w*;Fn6H?#Ni+a7dU|ef(zIMq&K8Jp-pnJvs2CE1CXy2dD z&6KZAeKPw;c3w)b4ey!>y;ZGMo0ZsMheYRm*Gp#YxHa!B}Tx&}% zvG4!#3i8lj?_v65eW9xaJHbx9o?!Rb4sZ~k1@>-l1?#5OnO}HrLHrfiuA=T8c#nE) z<`=Zn!FtSZNbhdSNEYWG#OlRy!u#O7*oS9mH`IdvmS4-mJ#?b`Skdz=Eh2Xz_%|xm ze{9V=@A3JM?SZsTkN3eQL3{dw70gciM}5c@bJG68Tpp`mK60@YWS`>=Zu9T|!}egP z*D4Bo)$2FtW^^&I*?b4AVpjz_xe~#bOeyv^-K%ere{IP0Y*dH~QHF~Ajcczc!V6U@WptBFUC8x91juWC2~B)5#uddjK^p>UL(eH$k$>dum1!OoTk(9P!MVE5v4^2E7d|NaZ6Upo=(yL%(O)iMfoP;f1UQIF{Vt4G|sDPU_G6{2564fc1{qGVuwG}C|c>cjqtF8-4B-8uG; zyl(#kyMsQ3y?5s>>$}P9Pnnhpk)Mjq_PVW{9BeOFrhUfu$m42-9G}O}!1lUH!1Qju zM$m(CzR;fI8SbXsVAHQDbk(UY`Ai$I?N|%!e9#db%x{C$sGih6D+0Dx`+&VW)b)*i zv`_<_&`G{#+aEZy@VDZNZUeV}JM(Y}O5jy}90tJd63M z+S9;6IT;>*FWBEV4D2*MM*Awg$hp!Xe%>l8FlFq$^`l7JEb8-(@O>cqp_VWwm8jYF%&Qr8sQiu6RziYv3W|Oc#?)PK- zzIjy=y1Q{3bU!`E5A6I2VCQx==0AThSVzVSUJRwalKoFJdJ$N~W`EbqNOqgDKkK|Z zmFcJ7XZx#0N3h*_FKmxhWBTyh@Uxc$n>8F?u~R;#KJ*pr_1J=7Z>GZeIoa}n?d4ct zohUWa=ZMGaYn}wG6D0uqPj29Osd4O2>p1@dyLUN0r5oG_dnYr(-X6LG*4=nNygRGO z6W@pK-Jc1z+u8s37c^)3(;UC@cGaPNnfd!Ys(|J9o+KzYBK;?4(s#()*jkv&_s$#M ztHKuxpxkKif8~ZQz6+Xjry1J!CT#aQmr8(b{VmY#?t<(O{IQ9g!U5}I>%d-z55em6 zYOuK#n|lAnVCUn|UuyjVPzG@1UN|EXfsHp5x^8fVehSP$}+Fk4lVpOV51>b~BVE*DJ^Szp4UQ`HjKOR+jT-*D$cX&>Xt`WG?Ujv@gLX z+Z?bO#&XR5O1}%$u{-T6`P2`y+}0(ZgZ+3zsb{C3h*#=c=2xA5A(3xE$GQW1+mL!t zF7W*<$Z|dMew#Ucnf_K8=x(XrWL*X9f6RKto%Ag^G0Sb+cRG0m$C;d;W`aE%meVaq zQ1@J(Z~6XU{Z|vPv!Wl^x%~y$`(YH*&nQp(O7ySw*J-e6Hw?O+S^}&x)Bn{g$a-2A z?7{pa^>)cH|D7C{bFcP+?)zaopx~Fx?@4y#=l5s?Hm|aR^|Ln2FH;^Ke>AVhmdOux zMsU19&!Fx`mo?G##wzCT7vB%|MlwI|J?duP2RvTxv$W5|a?@!-e^!58SPp9X3#)Og zC)}j1nBPo}gPNVK!RidlY5P9!kN1@CukFs~;a=kVuUjpl{XeW%ybAMq{P}<5dr)U~ zf%U#i{61DJ1AF&>2isZn54P=&f%WRIncrlNTj<|;f86o=ncoUNPg&juLn5&welhB8 zeyjH46t>B(3`SZnV;i>jYW`ojZ3`~rd4#t1;Zh!_*L0>Wyb$bX-wIaWEC-t%r@_uS zmMePXIogld%=C*7)4mqRL)?u=z;^I9=uYfEX11^awn!=AUm zs()r4KXNZKl_z&+dq5W)3icW?Kfm-+ur9{q>D(K^&caaN7q-uy^L%ZMThPrrr*S+p zEiu{$D(Vc+Cv94=U+X0KAz7U{0oEzlp0lsQ`*SD*>}~Gd)CaRYqCR0cZ$HUFeK*-# zT@I`p^Zu)xRjEH@y{u|~LjCVwke|~eFL@>FVV#J&zh@D2e|BBy{v!{JcP)6${Lyom zK35~=pJy)E{=@c_t?&a__0CRx2J1cl39nCmznieAN-cbe;yaCs(c3y+G$|(&RDSh>@lC$4zgZzlFz&U zH0F2s0`&*H9$Vu8c@6JJ;O7BWQM`V)&3dNKIg{xhZy*<6z~gl?V1Fs?13w3_dCqo^ zcfT?1x6OdPcc&ZJb_?4LO}bJ~I|90C8NQ#-SQhyG7BIiCY;aw+ADyj3cs_dvL-#5% zy`A5M+=lHK-(i2olnC1~jcZchLN?bcfc>RpJM$B;p33`gZWSPZ$o%!?bYL}%&)56m zEWhs@d_KDPa`HFf^WU+a{8890dhsLJ#17km*QbK53Ga83g=A6Q1xs7SeH!+Y-P#;O z^!q(z864@`?B2z7%VzywxheZSR`iQv^qWM#O7^=v(JzzzHY56Vvfn5Bg+}xnWxp~; zzw`Sstbb3`=W}Q^E3BXEfrItczRs1>-L`y=-sz2C_4p&&f3OQ|XQl?bx%Ps+ zjO@pIBlm!VI3PS1cfd}tTjB+uW4j$-Rp$nuThA?E`#Z~VHDNQ@?-E6Q73alFRoa`; zKQq6&k@OrNQr9oT-Wj=)`gqnOHWTOB)R7(3H?4)P{$30APOk<#E2n{dpZS?moHuY@ zErM>eIOjWT ztp;Gzs~qyPd%BayRUrR39_&@D#pA_Z33l>_^A)T3zN;tnAJyrL;(M@pSk{=V?59V{ z9yPTS^$WB&-58H#M$|+8ras#p#;ZYoIT7}z1X(|4xo%tVe4M^(m|vapuy-zT9Kmib z0ru~by^8t4woE+KdtO2M8=CTQSTCv^)W4#=DarXvX9U|Z-i?gVO}nsOte7&)Zyk>B z%}4=un_nb%qyMLA@tiy{8SMw<#_`;Zq5o$_*7M%TS9qV*^2*S4-&iP~;U6({xBXu}lY}0N6n_Bmn-^=-6XUh}v?nzAF z@DW&jJ^<`bcna2ud(nOx?cG#)$vwjP?6FMm=DNlF_DrPSxC8c@XQjUK zHrTn80qmdSd~UFQ7TE24nfb-fM1B7m=69wx^?c{S+H?i0Gt`}dgK6LYAoZrapZ4k@ zuy>$3?Z>hHFr~QerJp-2?@sdkypyay{Pd}LyeRrTsO8V_e4U*v51rvJz+SO)$lpeB zT~BZ3MRMA6v`>CDWWFEXOdssJTbTYP**P%{Z02zO+{@SttRFka)FE?o++BanWk#@2kas%mAmVD6l)+^+-1;`V_`u3lsVAGHH zM=9ES1zEr9!PTLAleZ#$FkcCF6R%7W!VC6coa-CDBXb+s9y%~q^Q=}~yj#DQO`pa)c z=10P@gveNc3H!V@y3ZFq&t59}gXPc9w*>8D_aN(iJCFV6h<}0IMcvlOiF!b_r0(T< z!+N;%YNU4(J|#BF9-`jKj!r8ZnL|$9b$62a@ANavaHC4#$!9-No~9 zbA5>S$ZUB*&X(a^9^3b4^U5<;~ZCYvXuh=JJu79PqV`X91? zBKt40f8&V$PmKPN>_7GVZ~rPr|4a1GV)Wlc|IUd1pX?vT=s$}7r6c;EvVW>X|20Pc zR`h?3=pW1evz*seV&2yg^TKl8Sk5cUd1pBbPpp_YxXyY!vVP5aw*P~AhW1a`pVF!3k|T9X z=$jnFKUVn9O8;6b{BLFblOm{-BJ=o>HrfBp&9hAkpV{bo?EmctE!wLlHf^1if8o6S zrK{NfZGMQ?F*$7CR$K$Nuc_M<8^PuQbz7+$c@XE1ywn}Ry7OA*w{ajj5&Z;A$qr=U zS0LxXl$a-z^JsFOEpjhRI1gt<`!z=UR>s2I`Xx=m z_J{4Zlw%g*7|y?A9??Fs(fc!03jU&hL2#c6eWLC5#T?hzIG+8uFb^|-4cPCy5W3YH z*pItSKUIBxHCQE|%W;fLvuOXw0|(kd+1NInfAJT59XI|4v+WC5U|e0 zI8ODO0Xz35Q-9o>_A);)j^!?)->@39o9*AV^b@wPEm)sz$^0Ju2KH_@1?zKM7f82a zdfSilJ;54$(9MLmaeOuqjX7CTPg>n?yh6$o2Wzs`GgHhC}ynaNNy)M^;gd zdHiWJq3bivnSYK;g_z3-?|ol?b7dE`o&AXc{vVf_WgI9 z(8L%=495w>aYi`~`R_Lyj#J8U%oyXGVjR?yYlE6`=c$Krhw2;7>j&%PF#Xhv(Czy@$-hz8mm86b zb6mx3-h}-3QP?{pxE88g`ykkqB%6wiTXFwp+?2n^LU+GPgY;(acJli7!0JoR<9l6S zBR;_9W8D%_9b<_h<*r8llNio9oUQW58_6dem?zO{Onxo)@BOXi38mX zIs|)LiEHaR0}ha9?WMo=gk!uPe;fuo1NgkmTE_92dVJpgoCWm%zI&ba-!2Awzw>=j zwMT+&*4xnin)DwxS@?d~%7dW$OX)`v%nvZXoPWXIS@{Y1=ndxob1JauatW-PzGgXk zn(vFZ>l!(Vx|`%WxeU_>@gn5qp^s12?O;=w<3uL?D6n__DUaWzIrZ;jv3;7LJ@uJ! z!NL0o)>~tPy*o9*&Qgv`xtmH-Zy%0xnbPFLsbL@aw)J89;kvCqf$n9d|COgJGQSqo zgSC0V?j!1M^I7Cy(jh;m39rW;kPU2hK4SV8nZdeXX52q-YgQh=M-{M)3pFBcRK}HB z5qBCRE>*;>%D7hN1+OQF2g3X4h`3l8H)};)t&F>sak(;X*Dsd=*K5PLUN1)6@5j(1 zaltZf*b{NZo{T#damg{_mPK51jJRhJ7cJwa9T8V8>EUnN`@bwv)AORI;Y|7El03d^Y= zZIDbqOUrU)#Ax!__rR(@{XR{#w`squ3Uohfa_4LGgdrGdyC)VrJay>t}-k(?x zP|5WIw~ylar!59QZj*To&%Z+f`gz}&NUl{BtjA6R8@DPs=S;9}T@h^O{Xo5bL8fms zf!yFj@}E<{!TOQx5HxU$;(iGvw-ObGKNB}T}ECKuE+V^ z&rJX7Gv;r9Vfvbt!M5)j+CQ%Y);TxOzFWBdXEnZ0s!j#kZ=tRSaXnAlZ5{1@2-kBg zM%LrQ<9S<{|KgI&|5$juk)MK9_tntt+Wh1Nzk$^mJ|A0gKRFlI1J!Adkn3i_$PYxDXjPBI8O#+=+}!@xmCMNZg8yYtbU^MaIQM z;%FjqGZBu&)yTLTCE{|-3HtM@Y8-b}N5LKsTS%0Q-I0gLR(z)T^`wd#S5} zZIVzA)7xE5pxYW@+{n`UA*X}AiTwrGB=`udi&dlkPj2RysXW+gpPBlclC&S4jl8`m zSS>CI_SzHx2Ywo0XFwkExRzj9f4>{_zrC;>5Qz~8_QJ!xh@>^|9HC#sS3yM@{$xH8 zTQ@w8JP$3-Q;X{ed?#?8|6ZrK5Ar_w;y%jzET4lC&nd=p6wg`9_dvWS@;%b>JrnPt zd{5nKYg)v&#fX0s@o~P0pOf)*k#Xoq{9WW-h|B?KInFM|;f)xlm*e}RANtj|dMbpxO~jXkhlZ@})R*`v%L``KX}MQ*Zc^ci%&7VXWuj4QYGBlScs=*r>oZ1wcCf8-)RC)WGqjLn#Tvy!xL z*$C`AWx-zi24FjsY?@W3{pzgH^>3BH=ABGTf220;%UtL4F2i~!@I)c+q3)(y1=g$T z!CozzL;WMxW9k`W#PsY?KlUwj+qN!`x1&v%Ukz{&SIqqUs^Gw%5NxKE1qc3{;zj30~01 zPx^1Ir2kjMPeJ-ISP_ry$#`uM&#gtgw~Pmu@!~R`T*jNrcyuG;)nz=pjCWTe9zI6A zyojfl@%CE80uoHVM=g-nz=W`p@iSuPm!*Te;p&xGlGth%|exTcz zCz!r5=R-}sV_>(42VEUL#QdV4W$+C3oIOlGl78k^#LGpV{lD>aBHm8Mlv81Z}} z-cQB@8WArj;|XQFp^QgVB3@DY3rc@N>2E0gYElR7%kJTK5!v&^%;z3TI?<}SHn@j& z;@rYIdJm33?_TiIJd1FAG+x}knh?Dm%w@l-&NJ&DD?|nslTiPf>3+hTP~J^%Pt?BiJJdY_E@?p8O2hw42Q1 z6+X`N`^SNG!F{xkexA|yyNIQIQrg>$o5AXCXQq#{j(WB(v`@O0>7(+1RTaJ;dIw`W zZN{Ie*LsWTkJDZiWXy>zvXS}EKFvDsi{0R0&nec41CB8LYsN|jdlu3DX%XnA(4Vxo zj6t(oLcJ{OO!p|+t??)77}ek+?eCo>e;TIWu@`JMlGV+VU}qlfy^-g^wlrC7zX{f{ z_`Fr8d*n`k@O&$UzP`0C^LWh;Gkv$~h=@1p@ThO%{kIwK3Sa18A`Gso$sI}qqd9V!Sk)F!(#LQ?9R&O4{-cID$gem!$ z=X;($XL?b{)mT2Nx1Leo#IXW%nYwvZi}|g1%KU0p2HQL@XrCqY#rim2JsW)2ku@N6 zN=5FR+j+9nJD!&L--E#)EB=usm88>S6s9>`}+` zD_Fkh>5a(Zcxi&VE=Q!Udo%&_Ymqp3KjT!kE27s>kM?C~8T^GmId^K-#pB#vR3^-2 z+C|}9>;wnwXMB#l%mf8iQ7_0vqu_I+GlVe$JLse1rC@q{@Gx}ykZTTj-DZ<(TtWI^ z&la%Cd4c)mU~HK#a29O;;o6Pffg@mDs5|VP${Wdf82hIG{)zV0J2Jm6i^0x^oN*$)}aE086=~cedVC(YuHqCjkcYYR+SNb=wo)g;l+DQAj%+K$! z`9JIo3Vr5^hWFzfee86)r95AsK40#5<`=B-jPx*_2}}r1MUFe&1zU^ZWUrHp_~7J^8&vkxhbc$*KXSYorgNx|;#xmJ>?+vS=?q;x`x@+Q=?%6e2ZHtCZ@}(FruPaD2Rj3IK=(3pt)gHJ zY^Gm14tk`#vEAtl?cdFS^2d#obt~!1p;}QlZR@hUsz(mye8JAjp~x>78({hM3(rqg z`=0s5>k3_cL|+eeu_M^dUjyCS%Gd<&27O(ecdA0yakwwMIa7+9xXu5kuZQ#nafGjk z^d)hnuZi$QafGjm^ktF0E?WA+2wxdlAEXWD>Tibiir2ge_w9)IcZU9y*w-VvUil$X zs|5cFUrQr=F{Q7j6~3HW`g#gqQ0XfweMzOSsS>`Z(pS~b*oD5TpE1VRw&NPSw$>=V zhn0I$Pp}khlX8t+bLSXXKOG2NZ94}x=LXY$_wUr7jUneqg7-)lpHBWHFWBapNiLd) z+>O4@YE>I@{a>J)oeRO<@0-b8|0KWQo-X$NLU`{?vvbUEL1}Oh%NW`Z1p7Dcf%S`_ zVDHo=a^m`6xAs-0Z`cB?S5h}_W3cM@Cv-KY71++WO#6JpY5(T}3`#v5d1p!@B^ z{3p^U&8)czU3*+3)m**>HWzumruRQ!yMXrImIutQ4%f~%CtgtBGoR-dMcwon!Sge3 zsOMYA^E(rV?{c1faeGPlFYd2V};2t>kr@J`E}4!#guN4kZR!_1-bZhd zA3f#qdXd$bxXiC-BIcKe`J2oMX+J3$bla8Zqdod4dM|iAI&&=OdIPV=e)b;ilZN?k zpbw;48|J?>J#>{Iyq@8?z-HWgIG#G16YTFHo1}$k@9=u{{=8tPa(Mj*OEP_l)I9(C zWobW@dj_d7S!kc1tk;D3JxTu`dow)`SU+e4dwV!5&!=Dmu-?Z#==AeeJ;QWxr($?7Qg67WWT%HwSq$NX}04?KNtFzqjMk3F-i zCs++D5!!Pv4gH%22k$@auW*mOV67dnep-R{t44sGg=NWSCeeO>Y4W}av|q(N`PA3k zn?vU!+v`)I+alrlP5TM#zb?e%H$TMu7V~<{?KR|j<*4@w)9Dt^@18>w{JQU0`Pl z)9XzusDIdq={xLX`bb??gL`VJ<)L2uB6Rz0W9I*J9QYjDc07MGxH^51%kcQBc6PAd zR*m+**P}j}*Qd+ZroOK-kAJ-a^`hbZ*1I!nDgt=l5F}cT> zBlaNEVvjPphnd{tOs**}*PNGY()(h~dS9+-FV?)5YvNn6X1-igUx_vM<(m9*&3?J2 zzc1GOH|H2j^Y5MjV$T4%r-0mZK<-H(+hgg1cHOP8UFR>}*~A7-Hk+^Rf8Uh}T4QYd zhp=52EYuzS(@#^v-pt=oLI-TpX94T;K3IM5KJ|=`$w$aRd}7IHd#_YR=ypL~u#-Op zSpBBK?#;K!bF$L@d=lnY{RQ%~cc|1?#HKz~;g#usXuJKowX^y|D}3{>uF^ZKf9BVEt6)SFRQH!&|`q z1lp@bE1BO%?P&k^FU)U!C-S8*UdQXf^h3EHrT;_!kY6(YUVUhv;vP8g3kB;3=@?&> zbQsu-O2c@fER(6*>|lTN4`i<_*qiHt)zr_aPnbo0e+_Uj1_d?^T2k-+BlUNhft`B` zz;^j4uvxQ&{CF`qh|gjAgDb#x@FJ$)L^kIZlGAUb{n`0ob?;Z&_X+L0Y^NS;G4q>u z0<7Me2e$eQIC4Ga;2%sskLj&*mFW{Pz0Glv`usIK{^eU>Rc1Ze{zdyUzwmgQ?@;eZ z-45kGcRIx;+Sk3#{9cCXpI-x;avP!B8>g7x%I#pa@(Jzx>}CGuAF!%&l-xBL%d=vC z(EdzqmVehSkW;h(t6_J@PkVvA^LNR!r;_Ks1e=#T!RE>{uwBmb(v*KfuDl((v-L6U zHy@&X?AKsb_7qqpPr&kd70Y*jbRw{Q^c1?CM^*zqMEPwiB%^&3miK<&q~y=5QSZb0 z#Gb6n@_yvI%x}*ZV6%y=A5;PB6ltNGc6Gq2Ogh>(Y(e`hX}~&*AwOsRq-L)N+des& zzRwM?9-Eixf4xO+m5+Mc!lh7OG%rN`dIhjb^9fkht_aq53xl<-4>tR$o55Ykh09aF z^)uL-isV7Zz$yoIo9qGD|2fphrzjnLeBHPlkEaw^tt|t#Lq8_xt3d8voc8G|gH1fL zcYwP3yC8JCxf1OivZ_*p_75vFzb|Wnb-i-T?`}2fT}zP*)TF+tB-pHJ2UcG<1lz1_ zX(Iey|MSfDr!6RPAPQs^N6&U z)C>n~)@`MIp1joWZvp$?m!RHtE!al4r-Jl$bjS@$ft|Q@p}Ujf(SGKc#x~lndlwwv zjNc9RuGa;7cf#_yLp`u;-=q)X@*{q=&I!gm=uIW_M;}}H+c=MPauMTeYDND~{_Muq z^=nLgGku)5I;>|Wgnw)K01z5i{e z{=qk38?}x4L&i6#(nV2(Y=99UQrKcXVN} z9?s+I#ns5$`@mkM_>6qCJJ=>G3%1pHJ;7KqITP=X$`!5?Kd2Scw`xcI)z@IXzXn*n zp{}cS0_$UyY2TT1nl@fl+IMNr^xswloBCfey;F($j(SW#r##cwZcF>C)YYOcU{k(0 z^$)w#K3#sMFF6{l-pUO&eWy@AniFjQ=nS?M$f_9q%*=~i)F;iM{j5yPFZ$gH-V^&W z9l8Ec^1*~)lZ>p>CIScRSu_2r*Y%>`FFhtMIH+gHV;}JOroIXG+LP_e8{lAFS=ieo ze}Mg-X~BBTNw8bwZLpK_5c$e8zCXA4uDkXL^N+my@15ZL^ECVx#(zd#T}1kSzm?Nx z!NGnr)T>+o2kRt)U3-ao@3zdZzYlh+_M!dcTVUI9FxU(!5- z+jkp+&9s@!e_adeg@#ZUu_CKm}goIB7}nOScN{zqaeZ=6N4-^_kQ=g#OdJ!u4q1 z@Otz}&b8$|~T37-S$lOTN-q)&tNd5}I4 zR`^Uvp9<-7A$>BW&xZ8rkUk&(zWbq1h@2yo@%WyI*EcerU&i~3^#GJuFF?ul1mt=H zVm$)6UV#?t8ECQIfm{zku9qO!Q;_Q|Xt5rHT(3c{=itX!@8JO6r(nNXe&1rf2)Ukw z73)pN^(f?e6>>cbE7rU4<$4%my$rdYMvV0~#CjZZy$-pahg|PNt_Kohy%4dUh+J<( zi}gsfT(3l~XCl@+k?Wzz^-|<|DssIQE7oI?>$S-BT;zH$ay=NiUW_N!lhI9$64;qPfcgRYWa&w@z-r$g)KixSyU*#P z<-INdw(nCnbrXQ~hv#7LUVP2*t=DJC_3ndJ1^T(G{uelYHH+`R*JCo+J4p7|eg`%K z_aeO?X8`q+WVcO6u*&!=bXBl5*v+*WY)Wyx8mCXVo=jYq_FvLR%zaW4?6+P7duK%% za#@z=?(~ApFYavU-k73HKWjSq9_N1CqV%uRb8|5LOV$tme`?sNHOT=$lc{-9wF``_0ahS2m!1d$QA#?C-b*-T#L1 zJo@vyV7(-a?@9RtEZavJgEr3Hu$}eqnzvyrTqIV_MDL*z-OfrM{6&5uZcN6N$+$Bm z;?iW?nh|krO2oa%xHu!?<|60%Z(LpM4ty?=xVso}d2H82;`WS;>l1N*GA>ZY4aSHo zlyQe*{osG^b-2E;Tz^>ZM|Zx(Jog`JG9%~jn$D>i*+V~ICZw`!*wX+Iu&vq3oX{UP;wm%u}+2->uAVzHsm@S za-9yjj)z?5L#_jˬtRrH@IwNu&5-rv#(PAAFxz0(9bx_1QDO#+fBG*}w>#!)X zPK%6Rlksga;@?DkoR;x(BEHUw_&XV&C*${wi0{)f{!hdQ%J@Mo;tSQD8Z0lv_(K_= zDB~BEjBk|jk0L%&$@obTUn%1+WqhWL-&7*L(--ldzK9Q%@uM=nG)DZXh)JWN@0u3-vdMkhjM&%Bh<)F*+!s#l8z=Xbll#tDu`ivL`_|1E!}daCUpukyo!l2s z?wcp~)w5#Xy%_uQiGBOzzJAiDUHZIBpLivF=56R>AMvS=aKz_c`s7QWed*J$gwKDB zm;ezoAY%#~5py785@gJRjA@WD4>Be~#!SfZjTqw}Vtho7pJ*|@BFA51jL(Si8#%tC z!||ZV_>cON<3p-d4vyz+=lGdQ`y4S1X4;o{A9Wk9Yip|20jti8yH#)1rEa;-uU*y% zY}%G*OvPZ1*O{!0g|xfa{?*6(P!HD!QQN*H{~Wfr;~(Jh&#^sj^WGrG?#|<{dXMM3 ztuxqG{s+3c!FHrQ{1aF=W_w+Qv6nV$bJ`#NhW7vP{Ol*(Z%Up1ocX6b#@M5$Rlw%m z6^tdSl8anA2iPphK>Mi|3+kX5W;UguK7p}gdQ~E@9#M>Xmju*HeG0a1)HA-WAKkpOQOUr1+cWYfmkLB5Pv5-{YDoV4L(QImHfgw#Upr&jzNS!sFRV+sIR|QIESEtZqbsgYi9;E$t z+N+geesd1fKJj{{ud)lQ?#%+5!aJD%#j(t<{x9U6T*pqQUr62*iKUwZw%=uC`W>Ue z>TCh9oaZuP9!$=YDKU>G=h>{7hf{K%PR`?rc|JK0Xv93Bk@JXRo>8{<-w)O|$QSk- zRMgCR(eF+q&N&jtY^n$GOVRy?%)wvybFWW>t=sx6-|N*=z`?%WU~l_$u=kStyhZX3 z{K%l|v_JeuH*09Ge}dkYy1G#W&a1ZEyHrleL~J2#%Nc*3s#-N813GFQJ*-7$8#97YQy!#_1!S0 zv^HbOBG1YTW6otvx{O)(_cY@9USCu&`h4AEgTdaUfw=$bqhVm%@hd)$5o5u+8P`$K z#m3P7z*s)d0(^e<;25xcKb&B`ClW&$SzFtNdzAgVX6uRUpW;0m5}Z)vC-&=-`+3Rz zzEl)rpw#CXIbSe~F-fL;X0Z8wa6=p9?F`ajdpV4WN)WEI{*-KAegWN0Fc$Wc-5k#YE`AdOl$P++?udmoZx2=~>k4)T90*_e%@b!zGto0o|$lF4#-Ho}4X; z@68ah-E#u$i2c;$erulCk4^5^Ciiob`@PBi;N*UBaz8mO_M3~bAD!5*&Wio)g%_`}N8F{G1s3{rz`8K)GL_+)vOI`whzd2<3i-O6+GS_dE2( zeu#3vL|5#m=*#^U<$jD}zeY#w=NMzZN3kDdjQt|Tev*#ZZ&L0@X~lk(az9JC-=*9S z)5`ra<$juCzfDK($0_#fl>2!`%A&}ApK>1n|NFNaMVA-B`eOWE|4ah5Dc;6>u6r>N z^)Xq%CR=>4|3Lw;_a-hlSg#)J-+#gKVC}>(J@*ea6X$}REf1iZ&C9|1!DE&OOMYeg zgxv2_4ZBGDuc@oGDLJ3rjr&8o8}pD0a(_=Vx&qi{I*$C@D_pl$)fKvvocrAb zs_!?}k$EUuB zF`?$#U&!C|YYp9BdI78xwFRqV`@uFXb(MJsc~BGPcWWouNzNEtUFZbZ|Go~>*WL%# zrUvc190jXArNRD_sZ4+36R>?a1N?8@6dm6moWG1gl`*O^hE>M6x-te<#K_7RT3^K2 z${1W3qbp;09TDRzV}NChu#6#=F~%|mS&10s7%|Ku##xCNXh+0I%NS}aVyyoYgZ=*i D^@9lZ diff --git a/notebooks/weighted.shx b/notebooks/weighted.shx deleted file mode 100644 index 82ebeaac1fda052229f6a7caafd6dd68a323929e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 356 zcmaiwzbnLH9LHbZ@0~kcN*S(0$&Wf$x;herI$x1nEOd%GI*VBb^9=?WjFJrU50DH- zqtQZE+hvdplF92Sqw-l^&-;15-=Cfy7|rqbT(?uu@#{U-HtswoFTLd?Fn75cbZfqm z1pVJk7RM{%KT!t*U Date: Thu, 5 Dec 2024 16:59:08 -0800 Subject: [PATCH 20/32] Refactoring atkinson --- inequality/atkinson.py | 46 ++++++++++++++++++++++++++---------------- 1 file changed, 29 insertions(+), 17 deletions(-) diff --git a/inequality/atkinson.py b/inequality/atkinson.py index 5c0802ab..ce49d60f 100644 --- a/inequality/atkinson.py +++ b/inequality/atkinson.py @@ -1,3 +1,4 @@ + import numpy as np __all__ = ["Atkinson", "atkinson"] @@ -41,24 +42,29 @@ def atkinson(y, epsilon): >>> incomes = np.array([10, 20, 30, 40, 50]) >>> float(round(atkinson(incomes, 0.5), 5)) 0.06315 - >>> float(round(atkinson(incomes, 1),5)) + >>> float(round(atkinson(incomes, 1), 5)) 0.13161 """ y = np.asarray(y) + if np.any(y <= 0): + raise ValueError("All values in 'y' must be positive.") + if epsilon < 0: + raise ValueError("'epsilon' must be non-negative.") + + mean_y = y.mean() if epsilon == 1: geom_mean = np.exp(np.mean(np.log(y))) - return 1 - geom_mean / y.mean() + return 1 - geom_mean / mean_y else: ye = y ** (1 - epsilon) - ye_bar = ye.mean() - ye_bar = ye_bar ** (1 / (1 - epsilon)) - return 1 - ye_bar / y.mean() + ye_bar = ye.mean() ** (1 / (1 - epsilon)) + return 1 - ye_bar / mean_y class Atkinson: """A class to calculate and store the Atkinson index and the equally - distributed equivalent(EDE). + distributed equivalent (EDE). The Atkinson index is a measure of economic inequality that takes into account the social aversion to inequality. The equally @@ -86,27 +92,33 @@ class Atkinson: A: float The calculated Atkinson index. EDE: float - The equally distributed equivalent(EDE) of the income or + The equally distributed equivalent (EDE) of the income or wealth distribution. Example ------- - >> > incomes = np.array([10, 20, 30, 40, 50]) - >> > atkinson = Atkinson(incomes, 0.5) - >> > float(round(atkinson.A, 5)) + >>> incomes = np.array([10, 20, 30, 40, 50]) + >>> atkinson = Atkinson(incomes, 0.5) + >>> float(round(atkinson.A, 5)) 0.06315 - >> > float(round(atkinson.EDE, 5)) + >>> float(round(atkinson.EDE, 5)) 28.1054 - >> > atkinson = Atkinson(incomes, 1) - >> > float(round(atkinson.A, 5)) + >>> atkinson = Atkinson(incomes, 1) + >>> float(round(atkinson.A, 5)) 0.13161 - >> > float(round(atkinson.EDE, 5)) + >>> float(round(atkinson.EDE, 5)) 26.05171 """ def __init__(self, y, epsilon): - self.y = np.asarray(y) + y = np.asarray(y) + if np.any(y <= 0): + raise ValueError("All values in 'y' must be positive.") + if epsilon < 0: + raise ValueError("'epsilon' must be non-negative.") + + self.y = y self.epsilon = epsilon - self.A = atkinson(y, epsilon) - self.EDE = y.mean() * (1 - self.A) + self.A = atkinson(self.y, self.epsilon) + self.EDE = self.y.mean() * (1 - self.A) From 58f2d97a24ad2a19142b316c4be52f5b91d3ed9f Mon Sep 17 00:00:00 2001 From: Sergio Rey Date: Sat, 28 Dec 2024 10:49:46 -0800 Subject: [PATCH 21/32] REF: add default title for schutz plot --- inequality/gini.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/inequality/gini.py b/inequality/gini.py index be1af085..51eb596c 100644 --- a/inequality/gini.py +++ b/inequality/gini.py @@ -108,6 +108,12 @@ class Gini_Spatial: # noqa N801 p_z_sim : float (If ``permuations > 0``) pseudo :math:`p`-value based on standard normal approximation of permutation based values. + polarization: float + Spatial polarization index with an expected value of 1. + polarization_p_sim: float + (If ``permutations >0``) pseudo :mapth:`p`-value for polarization index. + polarization_sim: float + (If ``permutations >0``) polarization values under the null from permutations. Examples -------- From 4fee3759f7b569793f736ca097f6a5d393c1b030 Mon Sep 17 00:00:00 2001 From: Sergio Rey Date: Sat, 28 Dec 2024 10:51:33 -0800 Subject: [PATCH 22/32] ENH: add Gini polarization index --- docs/user-guide/viz/schutz.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/user-guide/viz/schutz.ipynb b/docs/user-guide/viz/schutz.ipynb index cb519cc2..1d813ebd 100644 --- a/docs/user-guide/viz/schutz.ipynb +++ b/docs/user-guide/viz/schutz.ipynb @@ -1029,7 +1029,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.10.16" } }, "nbformat": 4, From 524a8fcf69dd535a000f7f9355f01ddc61f6a14d Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 29 Dec 2024 10:37:36 -0800 Subject: [PATCH 23/32] DOC: new gini documentation/nb --- docs/user-guide/measure/gini.ipynb | 1439 ++++++++++------------------ 1 file changed, 497 insertions(+), 942 deletions(-) diff --git a/docs/user-guide/measure/gini.ipynb b/docs/user-guide/measure/gini.ipynb index db60fb21..f734a896 100644 --- a/docs/user-guide/measure/gini.ipynb +++ b/docs/user-guide/measure/gini.ipynb @@ -4,51 +4,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Demonstrating the Gini Coefficient:\n", - "## Spatial Inequality in Mexico: 1940-2000\n", + "# Gini-Based Measures of Spatial Inequality and Polarization\n", "\n", - "1. Imports & Input Data\n", - "2. Classic Gini Coefficient\n", - "3. Spatial Gini Coefficient\n", "\n", - "-------------------------\n", + "This notebook explores the measurement of spatial inequality and polarization using the Gini coefficient, with a particular focus on Mexican state-level income data between 1940 and 2000. `pysal-inequality` extends the classic Gini coefficient, which quantifies income inequality, to account for spatial relationships among neighboring regions. By leveraging spatial weights matrices, we distinguish between inequality contributions from neighboring areas versus distant areas, enabling a deeper understanding of spatial economic disparities.\n", "\n", - "### 1. Imports & Input Data" + "The analysis begins with an overview of the data, which includes decennial per capita incomes of Mexican states, followed by the calculation of the classic Gini coefficient to establish baseline inequality levels. We then extend the analysis to the spatial Gini coefficient, incorporating spatial relationships to reveal localized inequality patterns. The notebook culminates in the Gini-based spatial polarization index, which highlights the extent to which the inequality has a spatial structure.\n", + "\n", + "\n", + "\n", + "\n", + "## Imports & Input Data\n" ] }, { "cell_type": "code", - "execution_count": 69, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:00:59.142457Z", - "start_time": "2023-01-17T02:00:59.104306Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The watermark extension is already loaded. To reload it, use:\n", - " %reload_ext watermark\n", - "Last updated: 2024-12-02T11:43:47.151240-08:00\n", - "\n", - "Python implementation: CPython\n", - "Python version : 3.10.15\n", - "IPython version : 8.30.0\n", - "\n", - "Compiler : GCC 11.2.0\n", - "OS : Linux\n", - "Release : 6.1.0-22-amd64\n", - "Machine : x86_64\n", - "Processor : \n", - "CPU cores : 20\n", - "Architecture: 64bit\n", - "\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "%config InlineBackend.figure_format = \"retina\"\n", "%load_ext watermark\n", @@ -57,433 +30,212 @@ }, { "cell_type": "code", - "execution_count": 70, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.756177Z", - "start_time": "2023-01-17T02:00:59.145113Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "import geopandas\n", "import inequality\n", "import libpysal\n", "import matplotlib.pyplot as plt\n", - "import numpy" + "import numpy\n", + "import seaborn as sns" ] }, { "cell_type": "code", - "execution_count": 71, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.770545Z", - "start_time": "2023-01-17T02:01:01.761777Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Watermark: 2.5.0\n", - "\n", - "pandas : 2.2.3\n", - "geopandas : 1.0.1\n", - "IPython : 8.30.0\n", - "numpy : 2.1.2\n", - "inequality: 0.1.dev217+g3354455.d20241010\n", - "libpysal : 4.12.1\n", - "matplotlib: 3.9.2\n", - "scipy : 1.14.1\n", - "\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "%watermark -w\n", "%watermark -iv" ] }, { - "cell_type": "code", - "execution_count": 72, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.776633Z", - "start_time": "2023-01-17T02:01:01.772340Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mexico\n", - "======\n", - "\n", - "Decennial per capita incomes of Mexican states 1940-2000\n", - "--------------------------------------------------------\n", - "\n", - "* mexico.csv: attribute data. (n=32, k=13)\n", - "* mexico.gal: spatial weights in GAL format.\n", - "* mexicojoin.shp: Polygon shapefile. (n=32)\n", - "\n", - "Data used in Rey, S.J. and M.L. Sastre Gutierrez. (2010) \"Interregional inequality dynamics in Mexico.\" Spatial Economic Analysis, 5: 277-298.\n", - "\n" - ] - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "libpysal.examples.explain(\"mexico\")" + "To illustrate `pysal-inequality` we utilize a built-in data set on gross domestic product for the 32 Mexican states measured each decade from 1940 through 2000:" ] }, { "cell_type": "code", - "execution_count": 73, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:01.962407Z", - "start_time": "2023-01-17T02:01:01.779047Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", - "gdf = geopandas.read_file(pth)" + "libpysal.examples.explain(\"mexico\")" ] }, { "cell_type": "code", - "execution_count": 74, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.103640Z", - "start_time": "2023-01-17T02:01:01.964971Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 316, - "width": 515 - } - }, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "ax = gdf.plot(edgecolor='grey')\n", - "ax.set_axis_off()" + "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", + "gdf = geopandas.read_file(pth)" ] }, { "cell_type": "code", - "execution_count": 75, + "execution_count": null, "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.138110Z", - "start_time": "2023-01-17T02:01:02.106331Z" - }, "scrolled": true }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
POLY_IDAREACODENAMEPERIMETERACRESHECTARESPCGDP1940PCGDP1950PCGDP1960...GR9000LPCGDP40LPCGDP50LPCGDP60LPCGDP70LPCGDP80LPCGDP90LPCGDP00TESTgeometry
017.252751e+10MX02Baja California Norte2040312.3851.792187e+077252751.37622361.020977.017865.0...0.054.354.324.254.404.474.434.481.0MULTIPOLYGON (((-113.13972 29.01778, -113.2405...
127.225988e+10MX03Baja California Sur2912880.7721.785573e+077225987.7699573.016013.016707.0...0.003.984.204.224.394.464.414.422.0MULTIPOLYGON (((-111.20612 25.80278, -111.2302...
232.731957e+10MX18Nayarit1034770.3416.750785e+062731956.8594836.07515.07621.0...-0.053.683.883.884.044.134.114.063.0MULTIPOLYGON (((-106.62108 21.56531, -106.6475...
347.961008e+10MX14Jalisco2324727.4361.967200e+077961008.2855309.08232.09953.0...0.033.733.924.004.214.324.304.334.0POLYGON ((-101.5249 21.85664, -101.5883 21.772...
455.467030e+09MX01Aguascalientes313895.5301.350927e+06546702.98510384.06234.08714.0...0.134.023.793.944.214.324.324.445.0POLYGON ((-101.8462 22.01176, -101.9653 21.883...
\n", - "

5 rows × 35 columns

\n", - "
" - ], - "text/plain": [ - " POLY_ID AREA CODE NAME PERIMETER \\\n", - "0 1 7.252751e+10 MX02 Baja California Norte 2040312.385 \n", - "1 2 7.225988e+10 MX03 Baja California Sur 2912880.772 \n", - "2 3 2.731957e+10 MX18 Nayarit 1034770.341 \n", - "3 4 7.961008e+10 MX14 Jalisco 2324727.436 \n", - "4 5 5.467030e+09 MX01 Aguascalientes 313895.530 \n", - "\n", - " ACRES HECTARES PCGDP1940 PCGDP1950 PCGDP1960 ... GR9000 \\\n", - "0 1.792187e+07 7252751.376 22361.0 20977.0 17865.0 ... 0.05 \n", - "1 1.785573e+07 7225987.769 9573.0 16013.0 16707.0 ... 0.00 \n", - "2 6.750785e+06 2731956.859 4836.0 7515.0 7621.0 ... -0.05 \n", - "3 1.967200e+07 7961008.285 5309.0 8232.0 9953.0 ... 0.03 \n", - "4 1.350927e+06 546702.985 10384.0 6234.0 8714.0 ... 0.13 \n", - "\n", - " LPCGDP40 LPCGDP50 LPCGDP60 LPCGDP70 LPCGDP80 LPCGDP90 LPCGDP00 TEST \\\n", - "0 4.35 4.32 4.25 4.40 4.47 4.43 4.48 1.0 \n", - "1 3.98 4.20 4.22 4.39 4.46 4.41 4.42 2.0 \n", - "2 3.68 3.88 3.88 4.04 4.13 4.11 4.06 3.0 \n", - "3 3.73 3.92 4.00 4.21 4.32 4.30 4.33 4.0 \n", - "4 4.02 3.79 3.94 4.21 4.32 4.32 4.44 5.0 \n", - "\n", - " geometry \n", - "0 MULTIPOLYGON (((-113.13972 29.01778, -113.2405... \n", - "1 MULTIPOLYGON (((-111.20612 25.80278, -111.2302... \n", - "2 MULTIPOLYGON (((-106.62108 21.56531, -106.6475... \n", - "3 POLYGON ((-101.5249 21.85664, -101.5883 21.772... \n", - "4 POLYGON ((-101.8462 22.01176, -101.9653 21.883... \n", - "\n", - "[5 rows x 35 columns]" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "gdf.head()" ] }, { "cell_type": "code", - "execution_count": 76, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.975365Z", - "start_time": "2023-01-17T02:01:02.141021Z" - }, - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 337, - "width": 515 - } - }, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "ax = gdf.plot(column=\"PCGDP1940\", k=5, scheme=\"Quantiles\", legend=True)\n", - "ax.set_axis_off()\n", - "ax.set_title(\"PC GDP 1940\");\n", - "# plt.savefig(\"1940.png\")" + "import mapclassify\n", + "import libpysal as lps\n", + "import geopandas as gpd\n", + "\n", + "pth = lps.examples.get_path(\"mexicojoin.shp\")\n", + "gdf = gpd.read_file(pth)\n", + "\n", + "# we will use greedy from mapclassify\n", + "# states to ensure contiguous states are of a different color\n", + "sgdf = gdf.sort_values(by='NAME')\n", + "sgdf.reset_index(inplace=True)\n", + "sgdf['label'] = range(1, 33)\n", + "sgdf['greedy'] = mapclassify.greedy(sgdf)\n", + "\n", + "\n", + "font_size = 9\n", + "outside = [9, 29]\n", + "oc = [(-103, 17.5), (-95, 22.5)]\n", + "oe = [(-102.55, 17.49),(-95.5, 22.1)] \n", + "oinfo = zip(outside, oc)\n", + "\n", + "\n", + "from shapely.geometry import LineString\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "sgdf['centroid'] = sgdf.centroid\n", + "ax = sgdf.plot(\n", + " figsize=(8, 12),\n", + " column=\"greedy\",\n", + " categorical=True,\n", + " cmap=\"Set3\",\n", + " #legend=True,\n", + " edgecolor=\"w\",\n", + ")\n", + "\n", + "\n", + "table = []\n", + "for idx, row in sgdf.iterrows():\n", + " centroid = row['centroid']\n", + " table.append(f'{idx+1:2d} {row[\"NAME\"]}')\n", + " if idx+1 not in outside:\n", + " ax.text(centroid.x, centroid.y, str(idx+1), ha='center',\n", + " va='center', fontsize=font_size, color='black')\n", + "\n", + "\n", + "i = 0\n", + "for out in oinfo:\n", + " idx, coords = out\n", + " ax.text(coords[0], coords[1], str(idx), ha='center',\n", + " va='center', fontsize=font_size, color='black')\n", + " start_point = coords\n", + " end_point = sgdf.centroid[idx-1]\n", + "\n", + " \n", + " start_point = oe[i]\n", + " line = LineString([start_point, end_point])\n", + " \n", + " \n", + " line_gdf = gpd.GeoSeries([line])\n", + " \n", + " \n", + " line_gdf.plot(ax=ax, color='red', linewidth=2)\n", + " i+=1\n", + "\n", + "for i, label in enumerate(table):\n", + " if i < 16:\n", + " ax.text(-120, 20-i*1, label, ha='left',\n", + " va='center', fontsize=font_size, color='black');\n", + " else:\n", + " ax.text(-110, 20-(i-16)*1, label, ha='left',\n", + " va='center', fontsize=font_size, color='black');\n", + "ax.set_axis_off()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "------------------------------------------------\n", + "We begin with two views of the Mexican state income distribution. On the left we have a choropleth map using\n", + "a quintile classification to depict the *spatial distribution* of incomes. \n", + "To the map's right we have a kernel density estimate (KDE) of the *attribute distribution*.\n", "\n", - "### 2. Classic Gini Coefficient\n", + "The map and KDE together indicate that economic development was\n", + "unevenly distributed across Mexico in 1940, with a majority of states\n", + "having relatively low per capita GDP and a small number of outliers\n", + "with much higher values. `pysal-inequality` implements a variety of indices to explore the inequality from distributional and spatial lenses." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(8, 4)) # Two subplots in one row\n", "\n", - "The Gini coefficient can be expressed as the relative mean absolute difference in incomes between pairs of observations:\n", - "$$G = \\frac{\\sum_i \\sum_j \\left| x_i - x_j \\right |}{2\\bar{x}n^2}$$\n", - "where $x_i$ is the per capita income of area $i$, $\\bar{x}$ is the mean of the area per capita incomes, and $n$ is the number of areas.\n", + "# Left column: Choropleth map\n", + "ax_map = gdf.plot(column=\"PCGDP1940\", k=5, scheme=\"Quantiles\", legend=True,\n", + " legend_kwds={'fmt': \"{:.0f}\"}, ax=axes[0])\n", + "ax_map.set_axis_off()\n", + "ax_map.set_title(\"PC GDP 1940\")\n", + "\n", + "# Right column: Kernel density plot\n", + "sns.kdeplot(data=gdf['PCGDP1940'], ax=axes[1], fill=True, bw_adjust=0.5)\n", + "axes[1].set_title(\"Kernel Density: PC GDP 1940\")\n", + "axes[1].set_xlabel(\"Per Capita GDP\")\n", + "axes[1].set_ylabel(\"Density\")\n", "\n", - "The numerator, $\\sum_i \\sum_j \\left | x_i - x_j \\right |$ is a measure of inequality in the data set. The Gini normalizes this measure relative to the mean income and the number of pairwise comparisons. As a result of the normalization, the Gini coefficient is bounded between 0 (perfect equality) and 1 (maximum inequality)." + "# Adjust layout for better spacing\n", + "plt.tight_layout()\n", + "\n", + "# Show the plots\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ + "## Classic Gini Coefficient\n", + "\n", + "The Gini coefficient can be expressed as the relative mean absolute difference in incomes between pairs of observations:\n", + "$$G = \\frac{\\sum_i \\sum_j \\left| x_i - x_j \\right |}{2\\bar{x}n^2}$$\n", + "where $x_i$ is the per capita income of area $i$, $\\bar{x}$ is the mean of the area per capita incomes, and $n$ is the number of areas.\n", + "\n", + "The numerator, $\\sum_i \\sum_j \\left | x_i - x_j \\right |$ is a measure of inequality in the data set. The Gini normalizes this measure relative to the mean income and the number of pairwise comparisons. As a result of the normalization, the Gini coefficient is bounded between 0 (perfect equality) and 1 (maximum inequality).\n", + "\n", "Focusing on 1940, the Gini coefficient for Mexican state per capita income is:" ] }, { "cell_type": "code", - "execution_count": 77, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:02.985182Z", "start_time": "2023-01-17T02:01:02.978350Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.3537237117345285)" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "gini_1940 = inequality.gini.Gini(gdf[\"PCGDP1940\"])\n", "gini_1940.g" @@ -492,479 +244,337 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:02.993505Z", - "start_time": "2023-01-17T02:01:02.988524Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "range(1940, 2010, 10)" - ] - }, - "execution_count": 78, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "decades = range(1940, 2010, 10)\n", - "decades" + "There are a number of possible interpretations of this figure. Using the equation above, the mean relative absolute deviation between all pairs of Mexican states represents 35 percent of the mean income that year.\n", + "\n", + "A second interpretation is a graphical one:" ] }, { "cell_type": "code", - "execution_count": 79, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.010083Z", - "start_time": "2023-01-17T02:01:02.996515Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", - "import pandas as pd\n", - "ginis_df = pd.DataFrame(data=ginis, columns=['Gini'], index = list(decades))" + "from inequality.schutz import Schutz\n", + "s = Schutz(gdf, 'PCGDP1940')\n", + "s.plot()" ] }, { - "cell_type": "code", - "execution_count": 80, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 413, - "width": 556 - } - }, - "output_type": "display_data" - } - ], "source": [ - "ginis_df.plot();" + "The Gini coefficient of 0.35 represents the percentage of the area below the line of perfect inequality that lies above the Lorenz Curve. \n", + "\n", + "Thus, as the Gini coefficient increases in value, inequality is increasing, as is the area of the lens formed by the diagonal and the Lorenz curve." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "Interpretation XXX\n" + "inequality.gini.Gini(gdf['PCGDP2000']).g" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "Spatial invariance" + "s = Schutz(gdf, 'PCGDP2000')\n", + "s.plot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "--------------------------------------\n", - "\n", - "### 3. Spatial Gini Coefficient\n", - "\n", - "To introduce the spatial dimension into the analysis of income inequality, the spatial Gini makes use of a decomposition of the numerator of the Gini:\n", + "In comparing the distribution from 1940 to that in 2000, we see that overall inequality has declined. The lower value of the Gini for 2000 as well as the smaller area of the inequality lens in the second plot demonstrate the decline.\n", "\n", - "$$ \\sum_i \\sum_j \\left | x_i - x_j \\right | = \\sum_i \\sum_j \\gamma_{i,j} \\left | x_i - x_j \\right | + \\sum_i \\sum_j(1-\\gamma_{i,j}) \\left | x_i - x_j \\right |$$\n", - "\n", - "where $\\gamma_{i,j}$ is a binary indicator taking on a value of 1 if areas $i$ and $j$ are considered spatial neighbors, and 0 otherwise. \n", - "The first term in the decomposition is the contribution to overall inequality due to inequality between pairs of spatial neighbors, while the second term is the contribution due to inequality between pairs of \"distant\" observations.\n", - "\n", - "The relative contribution of these two inequality components will be a function of two factors:\n", - "- the number of neighboring (distant) pairs\n", - "- the inequality between each set of pairs\n", - "\n" + "We can plot the time series of Gini values by decade to see the long term trend of a decline between these two terminal decades, with the steepest drop in inequality occuring in the first two periods of the sample." ] }, { "cell_type": "code", - "execution_count": 81, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.023820Z", - "start_time": "2023-01-17T02:01:03.017957Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "inequality.gini.Gini_Spatial" - ] - }, - "execution_count": 81, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "inequality.gini.Gini_Spatial" + "decades = range(1940, 2010, 10)\n", + "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", + "import pandas as pd\n", + "ginis_df = pd.DataFrame(data=ginis, columns=['Gini'], index = list(decades))\n", + "ginis_df.plot();" ] }, { - "cell_type": "code", - "execution_count": 82, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_891467/40166334.py:1: FutureWarning: `use_index` defaults to False but will default to True in future. Set True/False directly to control this behavior and silence this warning\n", - " wq = libpysal.weights.Queen.from_dataframe(gdf)\n" - ] - } - ], "source": [ - "wq = libpysal.weights.Queen.from_dataframe(gdf)" + "## Spatial Invariance of the Gini Coefficient\n", + "\n", + "The Gini coefficient measures the inequality in the distribution as reflected in the average pairwise difference, normalized to the sample mean.\n", + "\n", + "Although often used to measure inequality in geographical distributions, the geographical configuration of the observations is not actually taken into consideration in the classic Gini. In other words, the Gini coefficient is a *spatially invariant* measure of inequality.\n", + "This means that the Gini coefficient is not sensitive to the spatial distribution of the attribute values.\n", + "\n", + "To see this, we can randomly permute the values from the 1940 map and contrast the two spatial distributions. On the left is the choropleth map for the observed 1940 spatial distribution of state income values, and on the right we have the permuted values. Below the two figures are the kernel densities for the attribute distributions associated with each of the maps. The two densities are identical despite the two maps being markedly different.\n", + "\n", + "We also see that the Gini index takes on the same value for each of the spatial distributions.\n" ] }, { "cell_type": "code", - "execution_count": 83, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.234210Z", - "start_time": "2023-01-17T02:01:03.204552Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.01)" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "numpy.random.seed(12345)\n", - "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], wq)\n", - "gs.p_sim" + "gdf['PCGDP1940r'] = numpy.random.permutation(gdf.PCGDP1940)" ] }, { "cell_type": "code", - "execution_count": 84, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(4735906.0)" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "gs.wcg" + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import geopandas as gpd\n", + "\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(12, 10))\n", + "\n", + "gdf.plot(column='PCGDP1940', ax=axes[0, 0], legend=True, scheme='quantiles',k=4,cmap='viridis',\n", + " legend_kwds={\n", + " \"fmt\": \"{:.0f}\"}\n", + " )\n", + "axes[0, 0].set_title('PCGDP1940')\n", + "axes[0,0].axis('off')\n", + "\n", + "gdf.plot(column='PCGDP1940r', ax=axes[0, 1], legend=True, scheme='quantiles', k=4, cmap='viridis',\n", + " legend_kwds={\n", + " \"fmt\": \"{:.0f}\"}\n", + " )\n", + "axes[0, 1].set_title('PCGDP1940r')\n", + "axes[0,1].axis('off')\n", + "\n", + "\n", + "sns.kdeplot(gdf['PCGDP1940'], ax=axes[1, 0], fill=True, color='blue')\n", + "axes[1, 0].set_title('Kernel Density of PCGDP1940')\n", + "\n", + "sns.kdeplot(gdf['PCGDP1940r'], ax=axes[1, 1], fill=True, color='orange')\n", + "axes[1, 1].set_title('Kernel Density of PCGDP1940r')\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 85, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "13.4765625" - ] - }, - "execution_count": 85, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "wq.pct_nonzero" + "inequality.gini.Gini(gdf['PCGDP1940']).g == inequality.gini.Gini(gdf['PCGDP1940r']).g" ] }, { - "cell_type": "code", - "execution_count": 86, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 546, - "width": 846 - } - }, - "output_type": "display_data" - } - ], "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from scipy.stats import gaussian_kde\n", + "## Spatial Gini Coefficient\n", "\n", - "# Data array\n", - "data = gs.wcgp\n", + "To introduce the spatial dimension into the analysis of income inequality, the spatial Gini makes use of a decomposition of the numerator of the Gini:\n", "\n", - "obs = gs.wcg\n", + "$$ \\sum_i \\sum_j \\left | x_i - x_j \\right | = \\sum_i \\sum_j \\gamma_{i,j} \\left | x_i - x_j \\right | + \\sum_i \\sum_j(1-\\gamma_{i,j}) \\left | x_i - x_j \\right |$$\n", "\n", - "# Kernel Density Estimation\n", - "kde = gaussian_kde(data)\n", - "maxd = max(max(data), obs)\n", - "x_range = np.linspace(min(data), maxd, 1000)\n", - "kde_values = kde(x_range)\n", + "where $\\gamma_{i,j}$ is a binary indicator taking on a value of 1 if areas $i$ and $j$ are considered spatial neighbors, and 0 otherwise. \n", + "The first term in the decomposition is the contribution to overall inequality due to inequality between pairs of spatial neighbors, while the second term is the contribution due to inequality between pairs of \"distant\" observations.\n", + "In what follows, we note that \n", + "the numerator of the Gini is the sum of the absolute deviations (SAD).\n", "\n", - "# Plot\n", - "plt.figure(figsize=(10, 6))\n", - "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", - "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs}')\n", - "plt.title(\"Kernel Density Plot with Vertical Line\")\n", - "plt.xlabel(\"Values\")\n", - "plt.ylabel(\"Density\")\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()\n" + "The relative contribution of these two inequality components to the SAD will be a function of two factors:\n", + "\n", + "- the relative number of neighboring (distant) pairs\n", + "- the inequality within each set of pairs\n", + "\n", + "\n", + "\n", + "\n", + "`pysal-inequality` originally had a single Gini-based measure of spatial inequality based on the work of Rey and Smith (2013). \n", + "This compared the sum of the observed absolute deviations of the distant pairs against what would be expected were incomes randomly distributed in space. \n", + "Inference on this index relies on random permutations of the observed values to simulate the null hypothesis of spatially random incomes.\n", + "\n", + "To implement the spatial Gini, a definition of neighboring pairs is required. For this, we can use a Queen contiguity rule where two states are considered neighbors if their borders touch:" ] }, { "cell_type": "code", - "execution_count": 87, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(4510351.818181818)" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "gs.wcgp.mean()" + "wq = libpysal.weights.Queen.from_dataframe(gdf)" ] }, { "cell_type": "code", - "execution_count": 88, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.029897Z", - "start_time": "2023-01-17T02:01:03.026482Z" + "end_time": "2023-01-17T02:01:03.234210Z", + "start_time": "2023-01-17T02:01:03.204552Z" } }, "outputs": [], "source": [ - "regimes = gdf[\"HANSON98\"]" + "numpy.random.seed(12345)\n", + "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], wq)" ] }, { - "cell_type": "code", - "execution_count": 89, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.038550Z", - "start_time": "2023-01-17T02:01:03.032955Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "wb = libpysal.weights.block_weights(regimes, silence_warnings=True)\n", - "wb" + "The sum of the absolute differences between non-neighbor pairs is stored in the `gc.wcg` attribute:" ] }, { "cell_type": "code", - "execution_count": 90, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.201808Z", - "start_time": "2023-01-17T02:01:03.041647Z" + "end_time": "2023-01-17T02:01:03.234210Z", + "start_time": "2023-01-17T02:01:03.204552Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 337, - "width": 515 - } - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "ax = gdf.plot(column=\"HANSON98\", categorical=True)\n", - "ax.set_title(\"Regions\")\n", - "ax.set_axis_off()\n", - "# plt.savefig(\"regions.png\")" + "gs.wcg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whether this value is large or not, is a question of inference.\n", + "A pseudo p-value based on random permutations is stored in the `gs.p_sim` attribute:" ] }, { "cell_type": "code", - "execution_count": 91, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2023-01-17T02:01:03.234210Z", "start_time": "2023-01-17T02:01:03.204552Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(0.01)" - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "numpy.random.seed(12345)\n", - "gs = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], wb)\n", "gs.p_sim" ] }, { - "cell_type": "code", - "execution_count": 92, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "20.1171875" - ] - }, - "execution_count": 92, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "wb.pct_nonzero" + "The `gs.p_sim` value of 0.01 indicates that none of the 99 random permutations of incomes in space generated a sum of the pairwise differences for the distant pairs that was as large as what we observed in the actual pattern.\n", + "\n", + "Repeating this analysis for the same year, but with the random spatial distribution of the attribute values:" ] }, { "cell_type": "code", - "execution_count": 93, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(4353856.0)" - ] - }, - "execution_count": 93, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "gs.wcg" + "gsr = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940r\"], wq)\n", + "gsr.wcg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "we see that the differences between the \"distant\" pairs has declined relative to what we saw for the observed distribution.\n", + "Moreover, the spatial gini index for the random distribution is no longer statistically significant:" ] }, { "cell_type": "code", - "execution_count": 94, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(4156997.4545454546)" - ] - }, - "execution_count": 94, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "gs.wcgp.mean()" + "gsr.p_sim" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gini Spatial Polarization Index\n", + "\n", + "Using the decomposition of the SAD into the two components, we can draw inspiration from the spatial polarization literature where Zhang and Kanbur (2001) have suggested that an index of polarization defined as a ratio of inequality between regions over inequality within regions. Adapting this to our Gini decomposition, one such Gini-Based Spatial Polarization Index could be:\n", + "$$\n", + "GP = \\frac{ \\sum_i \\sum_j(1-\\gamma_{i,j}) \\left | x_i - x_j \\right |} {\\sum_i \\sum_j \\gamma_{i,j} \\left | x_i - x_j \\right | } $$\n", + "\n", + "\n", + "However, simply decomposing the SAD into that due to the neighboring pairs and that due to the distant pairs will place more weight on the distant pairs component.\n", + "This is because they will generally outnumber the neighboring pairs.\n", + "\n", + "Thus, a polarization index formed as the ratio of the two components would be difficult to interpret and therefore potentially misleading.\n", + "Instead,\n", + "the polarization should take the relative size of the two pair sets into account:\n", + "\n", + "\n", + "\n", + "$n_{\\text{pairs}} = n(n-1)/2$\n", + "\n", + "$n_{\\text{pairs}} = n_{\\text{neighbor pairs}} + n_{\\text{distant pairs}}$\n", + "\n", + "Under the null, the average difference between two observations should be the same, whether the pair of observations are neighbors or not. That means that, under the null:\n", + "\n", + "$E[GP] = \\frac{n_{\\text{distant pairs}}} {n_{\\text{neighbor pairs}}}$\n", + "\n", + "We can use this to normalize and define the Gini Spatial Polarization index as:\n", + "$$\n", + "GP/E[GP] = \\left( \\frac{ \\sum_i \\sum_j(1-\\gamma_{i,j}) \\left | x_i - x_j \\right |} {\\sum_i \\sum_j \\gamma_{i,j} \\left | x_i - x_j \\right | } \\right ) / \\left ( \\frac{n_{\\text{distant pairs}}} {n_{\\text{neighbor pairs}}} \\right )\n", + "$$\n", + "\n", + "We can view this index in two ways. First, the Gini Polarization is expressed relative to its expected value. In cases where this exceeds 1, the differences due to distant pairs is larger than that due to neighboring pairs under the expectation of no difference.\n", + "\n", + "The second view of the Gini Polarization index is as a ratio of the average pairwise difference for the distant pairs over the average pairwise difference for the neighboring pairs." ] }, { "cell_type": "code", - "execution_count": 95, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 546, - "width": 846 - } - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ + "gs.polarization_sim.mean()\n", + "\n", + "gs.polarization_sim.max()\n", + "gs.polarization_sim.max()\n", + "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from scipy.stats import gaussian_kde\n", "\n", "# Data array\n", - "data = gs.wcgp\n", + "data = gs.polarization_sim\n", "\n", - "obs = gs.wcg\n", + "obs = gs.polarization\n", "\n", "# Kernel Density Estimation\n", "kde = gaussian_kde(data)\n", @@ -975,269 +585,214 @@ "# Plot\n", "plt.figure(figsize=(10, 6))\n", "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", - "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs}')\n", - "plt.title(\"Kernel Density Plot with Vertical Line\")\n", + "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs:.2f}')\n", + "plt.title(\"Gini Spatial Polarization Index 1940\")\n", "plt.xlabel(\"Values\")\n", "plt.ylabel(\"Density\")\n", "plt.legend()\n", "plt.grid(True)\n", - "plt.show()\n" + "plt.show()\n", + "\n", + "\n", + "gs.polarization_p_sim" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As the block weights matrix is more dense than the Queen weights matrix, there are more neighbor pairs in the block scheme than under the contiguity scheme. Conversely, there are fewer (more) distant pairs under the block (contiguity) scheme.\n", + "The Gini Polarization index of 1.52 means that the average pairwise difference between observations that are distant is 52 percent larger than the average pairwise difference for neighboring observations.\n", + "The kernel density of the spatial polarization indices from the 99 random permutations of the observed income values for 1940 suggests that the observed index value is significantly different from what would be expected under the null of a spatially random income distribution. In fact, none of the synthetic distributions generated spatial polarization values as large as the observed value.\n", "\n", - "Under the null, there is no difference in the average inequality between a pair of observations that are neighbors, and the average inequality for pairs that are not neighbors. As such, the expected level of \"distant\" inequality will be larger for the contiguity scheme relative to the block scheme." + "If we repeat this for the random permutation for 1940 that we used above, the spatial polarization index for the \"observed\" spatial distribution takes on the value of 0.92.\n", + "And, based on the pseudo p-value, this index is not a significant departure from the null of spatially random incomes for 1940." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "### Gini polarization\n", - "$$\n", - "GP = \\frac{ \\sum_i \\sum_j(1-\\gamma_{i,j}) \\left | x_i - x_j \\right |} {\\sum_i \\sum_j \\gamma_{i,j} \\left | x_i - x_j \\right | } $$\n" + "gsr.polarization" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "The polarization should be related to the relative size of the two sets.\n", + "gsr.polarization_sim.mean()\n", "\n", - "$n_{\\text{pairs}} = n(n-1)/2$\n", + "gsr.polarization_sim.max()\n", + "gsr.polarization_sim.max()\n", "\n", - "$n_{\\text{pairs}} = n_{\\text{neighbor pairs}} + n_{\\text{distant pairs}}$\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import gaussian_kde\n", "\n", - "$E[GP] = \\frac{n_{\\text{distant pairs}}} {n_{\\text{neighbor pairs}}}$\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.388274Z", - "start_time": "2023-01-17T02:01:03.237277Z" - } - }, - "outputs": [], - "source": [ - "gs_all = [\n", - " inequality.gini.Gini_Spatial(gdf[\"PCGDP%s\" % decade], w) for decade in decades\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.396504Z", - "start_time": "2023-01-17T02:01:03.391373Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[np.float64(0.04),\n", - " np.float64(0.01),\n", - " np.float64(0.01),\n", - " np.float64(0.01),\n", - " np.float64(0.02),\n", - " np.float64(0.01),\n", - " np.float64(0.01)]" - ] - }, - "execution_count": 98, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "p_values = [gs.p_sim for gs in gs_all]\n", - "p_values" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.404200Z", - "start_time": "2023-01-17T02:01:03.399458Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.2940179879590452,\n", - " 0.24885041274552472,\n", - " 0.21715641601961586,\n", - " 0.2212882581200239,\n", - " 0.20702733316567423,\n", - " 0.21270360014540865,\n", - " 0.2190953550725723]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "wgs = [gs.wcg_share for gs in gs_all]\n", - "wgs" + "# Data array\n", + "data = gsr.polarization_sim\n", + "\n", + "obs = gsr.polarization\n", + "\n", + "# Kernel Density Estimation\n", + "kde = gaussian_kde(data)\n", + "maxd = max(max(data), obs)\n", + "x_range = np.linspace(min(data), maxd, 1000)\n", + "kde_values = kde(x_range)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", + "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs:.2f}')\n", + "plt.title(\"Gini Spatial Polarization Index 1940 (Random)\")\n", + "\n", + "plt.xlabel(\"Values\")\n", + "plt.ylabel(\"Density\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "\n", + "gsr.polarization_p_sim" ] }, { - "cell_type": "code", - "execution_count": 99, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.404200Z", - "start_time": "2023-01-17T02:01:03.399458Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[np.float64(2.401152449690573),\n", - " np.float64(3.0184783660479737),\n", - " np.float64(3.604975613106773),\n", - " np.float64(3.518992595881942),\n", - " np.float64(3.8302800635496137),\n", - " np.float64(3.7013778766150596),\n", - " np.float64(3.564222731553409)]" - ] - }, - "execution_count": 99, - "metadata": {}, - "output_type": "execute_result" - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "wgp = [(1-gs.wcg_share)/gs.wcg_share for gs in gs_all]\n", - "wgp" + "### Alternative neighbor definitions\n", + "The spatial decomposition used in both the spatial Gini and the Gini\n", + "spatial polarization index can accommodate different definitions of\n", + "neighboring pairs. To illustrate this, we utilize a regional partition\n", + "scheme used by Hanson (1996) to study the effects of the North\n", + "American Free Trade Agreement. This assigns the states into five\n", + "exhaustive and mutually exclusive regions portrayed below. Using this\n", + "partition we can defined neighbor pairs based on regional membership.\n", + "That is, two states belonging to the same region constitute a\n", + "neighboring pair, while two states belonging to different regions are\n", + "defined as a distant pair." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.412352Z", - "start_time": "2023-01-17T02:01:03.407034Z" + "end_time": "2023-01-17T02:01:03.029897Z", + "start_time": "2023-01-17T02:01:03.026482Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.7059820120409548,\n", - " 0.7511495872544753,\n", - " 0.7828435839803841,\n", - " 0.778711741879976,\n", - " 0.7929726668343258,\n", - " 0.7872963998545913,\n", - " 0.7809046449274277]" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "bgs = [1 - wg for wg in wgs]\n", - "bgs" + "regimes = gdf[\"HANSON98\"]\n", + "\n", + "wb = libpysal.weights.block_weights(regimes, silence_warnings=True)\n", + "wb\n", + "\n", + "ax = gdf.plot(column=\"HANSON98\", categorical=True)\n", + "ax.set_title(\"Regions\")\n", + "ax.set_axis_off()\n", + "\n", + "numpy.random.seed(12345)\n", + "gsh = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940\"], wb)\n", + "gsh.p_sim\n", + "\n", + "\n", + "\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import gaussian_kde\n", + "\n", + "# Data array\n", + "data = gsh.polarization_sim\n", + "\n", + "obs = gsh.polarization\n", + "\n", + "# Kernel Density Estimation\n", + "kde = gaussian_kde(data)\n", + "maxd = max(max(data), obs)\n", + "x_range = np.linspace(min(data), maxd, 1000)\n", + "kde_values = kde(x_range)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", + "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs}')\n", + "plt.title(\"Gini Spatial Polarization 1940 (Hanson)\")\n", + "plt.xlabel(\"Values\")\n", + "plt.ylabel(\"Density\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.419153Z", - "start_time": "2023-01-17T02:01:03.414765Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1940, 1950, 1960, 1970, 1980, 1990, 2000])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "years = numpy.array(decades)\n", - "years" + "The Gini Spatial Polarization index takes on a value of 1.29 for the\n", + "Hanson partition, with an associated p-value of 0.01. Note that the\n", + "shape of the index distribution under the null is markedly different\n", + "from that based on the Queen contiguity structure. In both cases, the\n", + "observed index values are significant, however it is clear that the\n", + "spatial structure of the particular neighbor graph needs to be taken\n", + "into account to ensure meaningful inference.\n", + "\n", + "Finally, we repeat the analysis using the Hanson partition, but this time for the random spatial distribution of incomes in 1940.\n", + "As was the case for the Queen definition of neighbors, the polarization index is no longer significant for this synthetic distribution.\n" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": { "ExecuteTime": { - "end_time": "2023-01-17T02:01:03.733573Z", - "start_time": "2023-01-17T02:01:03.421484Z" + "end_time": "2023-01-17T02:01:03.029897Z", + "start_time": "2023-01-17T02:01:03.026482Z" } }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 469, - "width": 629 - } - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "fig, ax1 = plt.subplots()\n", - "t = years\n", - "s1 = ginis\n", - "ax1.plot(t, s1, \"b-\")\n", - "ax1.set_xlabel(\"Year\")\n", - "# Make the y-axis label, ticks and tick labels match the line color.\n", - "ax1.set_ylabel(\"Gini\", color=\"b\")\n", - "ax1.tick_params(\"y\", colors=\"b\")\n", - "\n", - "ax2 = ax1.twinx()\n", - "s2 = bgs\n", - "ax2.plot(t, s2, \"r-.\")\n", - "ax2.set_ylabel(\"Spatial Inequality Share\", color=\"r\")\n", - "ax2.tick_params(\"y\", colors=\"r\")\n", - "\n", - "fig.tight_layout()\n", - "\n", - "# plt.savefig(\"share.png\")" + "# Random Incomes\n", + "\n", + "gshr = inequality.gini.Gini_Spatial(gdf[\"PCGDP1940r\"], wb)\n", + "gshr.p_sim\n", + "data = gshr.polarization_sim\n", + "\n", + "obs = gshr.polarization\n", + "\n", + "# Kernel Density Estimation\n", + "kde = gaussian_kde(data)\n", + "maxd = max(max(data), obs)\n", + "x_range = np.linspace(min(data), maxd, 1000)\n", + "kde_values = kde(x_range)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x_range, kde_values, label='Kernel Density')\n", + "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs:.2f}')\n", + "plt.title(\"Gini Spatial Polarization 1940 (Hanson Random)\")\n", + "\n", + "plt.xlabel(\"Values\")\n", + "plt.ylabel(\"Density\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "-----------------------" + "## References\n", + "\n", + "- Hanson, Gordon H. U.S.-Mexico Integration and Regional Economies. Cambridge: National Bureau of Economic Research, 1996.\n", + "- Rey, Sergio J., and Richard J Smith. “A Spatial Decomposition of the Gini Coefficient.” Letters in Spatial and Resource Sciences 6 (2013): 55–70.\n", + "- Zhang, Xiaobo, and Ravi Kanbur. “What Difference Do Polarisation Measures Make?: An Application to China.” Journal of Development Studies 37 (2001): 85–98." ] } ], @@ -1257,7 +812,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.15" + "version": "3.10.16" } }, "nbformat": 4, From b26b37f5dce1b03ed17d88580c74385b75fa7bf3 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 29 Dec 2024 10:38:25 -0800 Subject: [PATCH 24/32] ENH: Gini spatial polarization index --- inequality/gini.py | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/inequality/gini.py b/inequality/gini.py index 51eb596c..4c67a11e 100644 --- a/inequality/gini.py +++ b/inequality/gini.py @@ -156,9 +156,14 @@ def __init__(self, x, w, permutations=99): self.g = g n = len(x) den = x.mean() * 2 * n**2 - d = g * den - wg = self._calc(x, w) - wcg = d - wg + d = g * den # sum of absolute devations SAD + wg = self._calc(x, w) # sum of absolute deviations for neighbor pairs + wcg = d - wg # sum of absolution deviations for distant pairs + n_pairs = n * (n-1) / 2 + n_n_pairs = w.s0 / 2 + n_d_pairs = n_pairs - n_n_pairs + polarization = (wcg / wg) * (n_n_pairs / n_d_pairs) + self.polarization = polarization self.g = g self.wcg = wcg self.wg = wg @@ -167,11 +172,15 @@ def __init__(self, x, w, permutations=99): self.wcg_share = wcg / den if permutations: + _scale = n_n_pairs / n_d_pairs ids = numpy.arange(n) wcgp = numpy.zeros((permutations,)) + polarization_sim = numpy.zeros((permutations,)) for perm in range(permutations): numpy.random.shuffle(ids) wcgp[perm] = d - self._calc(x[ids], w) + polar = (wcgp[perm] / (d - wcgp[perm])) + polarization_sim[perm] = polar * _scale above = wcgp >= self.wcg larger = above.sum() if (permutations - larger) < larger: @@ -182,6 +191,10 @@ def __init__(self, x, w, permutations=99): self.s_wcg = wcgp.std() self.z_wcg = (self.wcg - self.e_wcg) / self.s_wcg self.p_z_sim = 1.0 - norm.cdf(self.z_wcg) + self.polarization_sim = polarization_sim + # polarization is a directional concept, upper tail only + larger = (polarization_sim >= polarization).sum() + self.polarization_p_sim = (larger + 1) / (permutations + 1) def _calc(self, x, w): sad_sum = 0.0 From 9a8ac09090db1f20a6e35bb989004b868162beb7 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 29 Dec 2024 10:39:08 -0800 Subject: [PATCH 25/32] REF: provide meaningful default title in schutz --- inequality/schutz.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/inequality/schutz.py b/inequality/schutz.py index 7288b712..55b4534b 100644 --- a/inequality/schutz.py +++ b/inequality/schutz.py @@ -150,6 +150,7 @@ def plot( xlabel="Cumulative Share of the Population", ylabel="Cumulative Share of Income", grid=True, + title=None, ): """ Plot the Lorenz curve, the line of perfect equality, and the @@ -191,7 +192,9 @@ def plot( # Add labels and title plt.xlabel(xlabel) plt.ylabel(ylabel) - plt.title("Lorenz Curve with Line of Perfect Equality and Schutz Line") + if title is None: + title = self.column_name + plt.title(title) plt.legend() plt.grid(grid) plt.show() From ed1ae4471902d9cb59bf4060b30fa4b08e9fb978 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 29 Dec 2024 11:00:44 -0800 Subject: [PATCH 26/32] fix wolfson docstring example --- inequality/wolfson.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/inequality/wolfson.py b/inequality/wolfson.py index ad0d4366..4eb659dd 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -46,6 +46,8 @@ def lorenz_curve(data, column=None): >>> income = [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] >>> population, income_share = lorenz_curve(income) >>> print(population, income_share) + [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ] [0. 0.03868472 0.08704062 0.13926499 0.19729207 0.26499033 + 0.35203095 0.46808511 0.6131528 0.76789168 1. ] """ sorted_y = np.sort(data) cumulative_y = np.cumsum(sorted_y) @@ -93,6 +95,7 @@ def wolfson(data, column=None): Example ------- + >>> import pandas as pd >>> income_distribution = [20000, 25000, 27000, 30000, 35000, 45000, 60000, ... 75000, 80000, 120000] >>> wolfson_index = wolfson(income_distribution) From 43f55f0c43c7850d5090b4349a297e5fb14db919 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 29 Dec 2024 11:06:10 -0800 Subject: [PATCH 27/32] ruff fixes --- conftest.py | 1 + inequality/__init__.py | 33 +++++++++++++++++++++++++-------- inequality/theil.py | 3 ++- inequality/utils.py | 6 ++++-- inequality/wolfson.py | 2 +- 5 files changed, 33 insertions(+), 12 deletions(-) diff --git a/conftest.py b/conftest.py index 7918697f..f06c1245 100644 --- a/conftest.py +++ b/conftest.py @@ -4,6 +4,7 @@ import pytest + def warning_depr(x): return pytest.warns( FutureWarning, match=f"{x} is deprecated and will be removed on 2025-01-01." diff --git a/inequality/__init__.py b/inequality/__init__.py index 484e1592..ffe034cb 100644 --- a/inequality/__init__.py +++ b/inequality/__init__.py @@ -9,14 +9,31 @@ from importlib.metadata import PackageNotFoundError, version from . import atkinson, gini, schutz, theil, wolfson -from ._indices import (abundance, ellison_glaeser_egg, ellison_glaeser_egg_pop, - fractionalization_gs, gini_gi, gini_gi_m, gini_gig, - herfindahl_hd, hoover_hi, isolation_ii, isolation_isg, - margalev_md, maurel_sedillot_msg, - maurel_sedillot_msg_pop, menhinick_mi, - modified_segregation_msg, polarization, segregation_gsg, - shannon_se, similarity_w_wd, simpson_sd, simpson_so, - theil_th) +from ._indices import ( + abundance, + ellison_glaeser_egg, + ellison_glaeser_egg_pop, + fractionalization_gs, + gini_gi, + gini_gi_m, + gini_gig, + herfindahl_hd, + hoover_hi, + isolation_ii, + isolation_isg, + margalev_md, + maurel_sedillot_msg, + maurel_sedillot_msg_pop, + menhinick_mi, + modified_segregation_msg, + polarization, + segregation_gsg, + shannon_se, + similarity_w_wd, + simpson_sd, + simpson_so, + theil_th, +) with contextlib.suppress(PackageNotFoundError): __version__ = version("inequality") diff --git a/inequality/theil.py b/inequality/theil.py index de51f9ae..11be0b13 100644 --- a/inequality/theil.py +++ b/inequality/theil.py @@ -4,9 +4,10 @@ __author__ = "Sergio J. Rey " +import warnings + import numpy as np import pandas as pd -import warnings __all__ = ["Theil", "TheilD", "TheilDSim"] diff --git a/inequality/utils.py b/inequality/utils.py index c7d20f55..d38bedcc 100644 --- a/inequality/utils.py +++ b/inequality/utils.py @@ -1,6 +1,8 @@ +from functools import wraps + import numpy as np import pandas as pd -from functools import wraps + def consistent_input(func): @wraps(func) @@ -17,7 +19,7 @@ def wrapper(data, *args, column=None, **kwargs): raise TypeError("Input should be a sequence, numpy array, or pandas DataFrame.") return func(data, *args, **kwargs) - + return wrapper # Example function using the decorator diff --git a/inequality/wolfson.py b/inequality/wolfson.py index 4eb659dd..0fe1afcf 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -74,7 +74,7 @@ def wolfson(data, column=None): W = (2D_{50} - G)\\frac{\\mu}{m} Where :math:`D_{50} =0.5 - L(0.5)`, :math:`L(0.5)` is the value of the - Lorenz curve at the median, :math:`G` is the Gini index, :math:`\mu` + Lorenz curve at the median, :math:`G` is the Gini index, :math:`\\mu` is the mean, and :math:`m` is the median. See: :cite:`wolfson1994WhenInequalities`. From d1748438b24d7ba6c1c5176d05b6483743499a02 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 29 Dec 2024 11:13:52 -0800 Subject: [PATCH 28/32] ruff --- conftest.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/conftest.py b/conftest.py index f06c1245..94596dac 100644 --- a/conftest.py +++ b/conftest.py @@ -7,21 +7,25 @@ def warning_depr(x): return pytest.warns( - FutureWarning, match=f"{x} is deprecated and will be removed on 2025-01-01." + FutureWarning, + match=f"{x} is deprecated and will be removed on 2025-01-01." ) + def warning_invalid(x): - return pytest.warns(RuntimeWarning, match=f"invalid value encountered in {x}") + return pytest.warns(RuntimeWarning, + match=f"invalid value encountered in {x}") + -warning_div_zero = pytest.warns(RuntimeWarning, match="divide by zero encountered") +warning_div_zero = pytest.warns(RuntimeWarning, + match="divide by zero encountered") -def pytest_configure(config): +def pytest_configure(): pytest.warning_depr = warning_depr pytest.warning_invalid = warning_invalid pytest.warning_div_zero = warning_div_zero def pytest_ignore_collect(collection_path): - return True if str(collection_path).endswith("_indices.py") else False - + return bool(str(collection_path).endswith("_indices.py")) From aff0c2736bf899abcc94c1787d77839b03b76b21 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 29 Dec 2024 11:57:11 -0800 Subject: [PATCH 29/32] Ruff --- docs/conf.py | 4 +- docs/user-guide/measure/gini.ipynb | 162 ++++++++++++++++---------- docs/user-guide/measure/theil.ipynb | 20 ++-- docs/user-guide/measure/wolfson.ipynb | 43 +++---- docs/user-guide/viz/pengram.ipynb | 45 ++++--- docs/user-guide/viz/schutz.ipynb | 21 ++-- inequality/__init__.py | 1 - inequality/atkinson.py | 1 - inequality/gini.py | 8 +- inequality/tests/test_interface.py | 80 +++++++++---- inequality/tests/test_wolfson.py | 10 +- inequality/theil.py | 26 +++-- inequality/utils.py | 16 ++- inequality/wolfson.py | 48 ++++---- 14 files changed, 293 insertions(+), 192 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index ddac4fa8..9bab3f7c 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -106,8 +106,8 @@ # (Optional) PySAL favicon html_favicon = "_static/images/pysal_favicon.ico" -html_logo = '_static/images/pysal_logo.png' -icon_links_label = 'inequality' +html_logo = "_static/images/pysal_logo.png" +icon_links_label = "inequality" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the diff --git a/docs/user-guide/measure/gini.ipynb b/docs/user-guide/measure/gini.ipynb index f734a896..497213c6 100644 --- a/docs/user-guide/measure/gini.ipynb +++ b/docs/user-guide/measure/gini.ipynb @@ -104,16 +104,16 @@ "\n", "# we will use greedy from mapclassify\n", "# states to ensure contiguous states are of a different color\n", - "sgdf = gdf.sort_values(by='NAME')\n", + "sgdf = gdf.sort_values(by=\"NAME\")\n", "sgdf.reset_index(inplace=True)\n", - "sgdf['label'] = range(1, 33)\n", - "sgdf['greedy'] = mapclassify.greedy(sgdf)\n", + "sgdf[\"label\"] = range(1, 33)\n", + "sgdf[\"greedy\"] = mapclassify.greedy(sgdf)\n", "\n", "\n", "font_size = 9\n", "outside = [9, 29]\n", "oc = [(-103, 17.5), (-95, 22.5)]\n", - "oe = [(-102.55, 17.49),(-95.5, 22.1)] \n", + "oe = [(-102.55, 17.49), (-95.5, 22.1)]\n", "oinfo = zip(outside, oc)\n", "\n", "\n", @@ -121,52 +121,78 @@ "\n", "\n", "import matplotlib.pyplot as plt\n", - "sgdf['centroid'] = sgdf.centroid\n", + "\n", + "sgdf[\"centroid\"] = sgdf.centroid\n", "ax = sgdf.plot(\n", " figsize=(8, 12),\n", " column=\"greedy\",\n", " categorical=True,\n", " cmap=\"Set3\",\n", - " #legend=True,\n", + " # legend=True,\n", " edgecolor=\"w\",\n", ")\n", "\n", "\n", "table = []\n", "for idx, row in sgdf.iterrows():\n", - " centroid = row['centroid']\n", + " centroid = row[\"centroid\"]\n", " table.append(f'{idx+1:2d} {row[\"NAME\"]}')\n", - " if idx+1 not in outside:\n", - " ax.text(centroid.x, centroid.y, str(idx+1), ha='center',\n", - " va='center', fontsize=font_size, color='black')\n", + " if idx + 1 not in outside:\n", + " ax.text(\n", + " centroid.x,\n", + " centroid.y,\n", + " str(idx + 1),\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " fontsize=font_size,\n", + " color=\"black\",\n", + " )\n", "\n", "\n", "i = 0\n", "for out in oinfo:\n", " idx, coords = out\n", - " ax.text(coords[0], coords[1], str(idx), ha='center',\n", - " va='center', fontsize=font_size, color='black')\n", + " ax.text(\n", + " coords[0],\n", + " coords[1],\n", + " str(idx),\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " fontsize=font_size,\n", + " color=\"black\",\n", + " )\n", " start_point = coords\n", - " end_point = sgdf.centroid[idx-1]\n", + " end_point = sgdf.centroid[idx - 1]\n", "\n", - " \n", " start_point = oe[i]\n", " line = LineString([start_point, end_point])\n", - " \n", - " \n", + "\n", " line_gdf = gpd.GeoSeries([line])\n", - " \n", - " \n", - " line_gdf.plot(ax=ax, color='red', linewidth=2)\n", - " i+=1\n", + "\n", + " line_gdf.plot(ax=ax, color=\"red\", linewidth=2)\n", + " i += 1\n", "\n", "for i, label in enumerate(table):\n", " if i < 16:\n", - " ax.text(-120, 20-i*1, label, ha='left',\n", - " va='center', fontsize=font_size, color='black');\n", + " ax.text(\n", + " -120,\n", + " 20 - i * 1,\n", + " label,\n", + " ha=\"left\",\n", + " va=\"center\",\n", + " fontsize=font_size,\n", + " color=\"black\",\n", + " )\n", " else:\n", - " ax.text(-110, 20-(i-16)*1, label, ha='left',\n", - " va='center', fontsize=font_size, color='black');\n", + " ax.text(\n", + " -110,\n", + " 20 - (i - 16) * 1,\n", + " label,\n", + " ha=\"left\",\n", + " va=\"center\",\n", + " fontsize=font_size,\n", + " color=\"black\",\n", + " )\n", "ax.set_axis_off()" ] }, @@ -193,13 +219,19 @@ "fig, axes = plt.subplots(1, 2, figsize=(8, 4)) # Two subplots in one row\n", "\n", "# Left column: Choropleth map\n", - "ax_map = gdf.plot(column=\"PCGDP1940\", k=5, scheme=\"Quantiles\", legend=True,\n", - " legend_kwds={'fmt': \"{:.0f}\"}, ax=axes[0])\n", + "ax_map = gdf.plot(\n", + " column=\"PCGDP1940\",\n", + " k=5,\n", + " scheme=\"Quantiles\",\n", + " legend=True,\n", + " legend_kwds={\"fmt\": \"{:.0f}\"},\n", + " ax=axes[0],\n", + ")\n", "ax_map.set_axis_off()\n", "ax_map.set_title(\"PC GDP 1940\")\n", "\n", "# Right column: Kernel density plot\n", - "sns.kdeplot(data=gdf['PCGDP1940'], ax=axes[1], fill=True, bw_adjust=0.5)\n", + "sns.kdeplot(data=gdf[\"PCGDP1940\"], ax=axes[1], fill=True, bw_adjust=0.5)\n", "axes[1].set_title(\"Kernel Density: PC GDP 1940\")\n", "axes[1].set_xlabel(\"Per Capita GDP\")\n", "axes[1].set_ylabel(\"Density\")\n", @@ -257,7 +289,8 @@ "outputs": [], "source": [ "from inequality.schutz import Schutz\n", - "s = Schutz(gdf, 'PCGDP1940')\n", + "\n", + "s = Schutz(gdf, \"PCGDP1940\")\n", "s.plot()" ] }, @@ -276,7 +309,7 @@ "metadata": {}, "outputs": [], "source": [ - "inequality.gini.Gini(gdf['PCGDP2000']).g" + "inequality.gini.Gini(gdf[\"PCGDP2000\"]).g" ] }, { @@ -285,7 +318,7 @@ "metadata": {}, "outputs": [], "source": [ - "s = Schutz(gdf, 'PCGDP2000')\n", + "s = Schutz(gdf, \"PCGDP2000\")\n", "s.plot()" ] }, @@ -307,7 +340,8 @@ "decades = range(1940, 2010, 10)\n", "ginis = [inequality.gini.Gini(gdf[\"PCGDP%s\" % decade]).g for decade in decades]\n", "import pandas as pd\n", - "ginis_df = pd.DataFrame(data=ginis, columns=['Gini'], index = list(decades))\n", + "\n", + "ginis_df = pd.DataFrame(data=ginis, columns=[\"Gini\"], index=list(decades))\n", "ginis_df.plot();" ] }, @@ -334,7 +368,7 @@ "outputs": [], "source": [ "numpy.random.seed(12345)\n", - "gdf['PCGDP1940r'] = numpy.random.permutation(gdf.PCGDP1940)" + "gdf[\"PCGDP1940r\"] = numpy.random.permutation(gdf.PCGDP1940)" ] }, { @@ -350,26 +384,36 @@ "\n", "fig, axes = plt.subplots(2, 2, figsize=(12, 10))\n", "\n", - "gdf.plot(column='PCGDP1940', ax=axes[0, 0], legend=True, scheme='quantiles',k=4,cmap='viridis',\n", - " legend_kwds={\n", - " \"fmt\": \"{:.0f}\"}\n", - " )\n", - "axes[0, 0].set_title('PCGDP1940')\n", - "axes[0,0].axis('off')\n", - "\n", - "gdf.plot(column='PCGDP1940r', ax=axes[0, 1], legend=True, scheme='quantiles', k=4, cmap='viridis',\n", - " legend_kwds={\n", - " \"fmt\": \"{:.0f}\"}\n", - " )\n", - "axes[0, 1].set_title('PCGDP1940r')\n", - "axes[0,1].axis('off')\n", + "gdf.plot(\n", + " column=\"PCGDP1940\",\n", + " ax=axes[0, 0],\n", + " legend=True,\n", + " scheme=\"quantiles\",\n", + " k=4,\n", + " cmap=\"viridis\",\n", + " legend_kwds={\"fmt\": \"{:.0f}\"},\n", + ")\n", + "axes[0, 0].set_title(\"PCGDP1940\")\n", + "axes[0, 0].axis(\"off\")\n", + "\n", + "gdf.plot(\n", + " column=\"PCGDP1940r\",\n", + " ax=axes[0, 1],\n", + " legend=True,\n", + " scheme=\"quantiles\",\n", + " k=4,\n", + " cmap=\"viridis\",\n", + " legend_kwds={\"fmt\": \"{:.0f}\"},\n", + ")\n", + "axes[0, 1].set_title(\"PCGDP1940r\")\n", + "axes[0, 1].axis(\"off\")\n", "\n", "\n", - "sns.kdeplot(gdf['PCGDP1940'], ax=axes[1, 0], fill=True, color='blue')\n", - "axes[1, 0].set_title('Kernel Density of PCGDP1940')\n", + "sns.kdeplot(gdf[\"PCGDP1940\"], ax=axes[1, 0], fill=True, color=\"blue\")\n", + "axes[1, 0].set_title(\"Kernel Density of PCGDP1940\")\n", "\n", - "sns.kdeplot(gdf['PCGDP1940r'], ax=axes[1, 1], fill=True, color='orange')\n", - "axes[1, 1].set_title('Kernel Density of PCGDP1940r')\n", + "sns.kdeplot(gdf[\"PCGDP1940r\"], ax=axes[1, 1], fill=True, color=\"orange\")\n", + "axes[1, 1].set_title(\"Kernel Density of PCGDP1940r\")\n", "\n", "plt.tight_layout()\n", "\n", @@ -382,7 +426,7 @@ "metadata": {}, "outputs": [], "source": [ - "inequality.gini.Gini(gdf['PCGDP1940']).g == inequality.gini.Gini(gdf['PCGDP1940r']).g" + "inequality.gini.Gini(gdf[\"PCGDP1940\"]).g == inequality.gini.Gini(gdf[\"PCGDP1940r\"]).g" ] }, { @@ -584,8 +628,8 @@ "\n", "# Plot\n", "plt.figure(figsize=(10, 6))\n", - "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", - "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs:.2f}')\n", + "plt.plot(x_range, kde_values, label=\"Kernel Density Estimate\")\n", + "plt.axvline(x=obs, color=\"red\", linestyle=\"--\", label=f\"Value = {obs:.2f}\")\n", "plt.title(\"Gini Spatial Polarization Index 1940\")\n", "plt.xlabel(\"Values\")\n", "plt.ylabel(\"Density\")\n", @@ -645,8 +689,8 @@ "\n", "# Plot\n", "plt.figure(figsize=(10, 6))\n", - "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", - "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs:.2f}')\n", + "plt.plot(x_range, kde_values, label=\"Kernel Density Estimate\")\n", + "plt.axvline(x=obs, color=\"red\", linestyle=\"--\", label=f\"Value = {obs:.2f}\")\n", "plt.title(\"Gini Spatial Polarization Index 1940 (Random)\")\n", "\n", "plt.xlabel(\"Values\")\n", @@ -701,8 +745,6 @@ "gsh.p_sim\n", "\n", "\n", - "\n", - "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from scipy.stats import gaussian_kde\n", @@ -720,8 +762,8 @@ "\n", "# Plot\n", "plt.figure(figsize=(10, 6))\n", - "plt.plot(x_range, kde_values, label='Kernel Density Estimate')\n", - "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs}')\n", + "plt.plot(x_range, kde_values, label=\"Kernel Density Estimate\")\n", + "plt.axvline(x=obs, color=\"red\", linestyle=\"--\", label=f\"Value = {obs}\")\n", "plt.title(\"Gini Spatial Polarization 1940 (Hanson)\")\n", "plt.xlabel(\"Values\")\n", "plt.ylabel(\"Density\")\n", @@ -773,8 +815,8 @@ "\n", "# Plot\n", "plt.figure(figsize=(10, 6))\n", - "plt.plot(x_range, kde_values, label='Kernel Density')\n", - "plt.axvline(x=obs, color='red', linestyle='--', label=f'Value = {obs:.2f}')\n", + "plt.plot(x_range, kde_values, label=\"Kernel Density\")\n", + "plt.axvline(x=obs, color=\"red\", linestyle=\"--\", label=f\"Value = {obs:.2f}\")\n", "plt.title(\"Gini Spatial Polarization 1940 (Hanson Random)\")\n", "\n", "plt.xlabel(\"Values\")\n", diff --git a/docs/user-guide/measure/theil.ipynb b/docs/user-guide/measure/theil.ipynb index 5045a33a..73ae0bf0 100644 --- a/docs/user-guide/measure/theil.ipynb +++ b/docs/user-guide/measure/theil.ipynb @@ -178,7 +178,7 @@ } ], "source": [ - "ax = gdf.plot(edgecolor='grey')\n", + "ax = gdf.plot(edgecolor=\"grey\")\n", "ax.set_axis_off()" ] }, @@ -432,8 +432,9 @@ } ], "source": [ - "ax = gdf.plot(column=\"PCGDP1960\", k=5, scheme=\"Quantiles\", \n", - " edgecolor='grey',legend=True)\n", + "ax = gdf.plot(\n", + " column=\"PCGDP1960\", k=5, scheme=\"Quantiles\", edgecolor=\"grey\", legend=True\n", + ")\n", "ax.set_axis_off()\n", "ax.set_title(\"PC GDP 1960\");\n", "# plt.savefig(\"1940.png\")" @@ -549,8 +550,7 @@ } ], "source": [ - "ax = gdf.plot(column=\"HANSON98\", categorical=True,\n", - " edgecolor='grey')\n", + "ax = gdf.plot(column=\"HANSON98\", categorical=True, edgecolor=\"grey\")\n", "ax.set_title(\"Regions\")\n", "ax.set_axis_off()\n", "# plt.savefig(\"regions.png\")" @@ -568,7 +568,7 @@ "outputs": [], "source": [ "numpy.random.seed(12345)\n", - "ts = inequality.theil.TheilD(gdf['PCGDP1960'], regimes)" + "ts = inequality.theil.TheilD(gdf[\"PCGDP1960\"], regimes)" ] }, { @@ -689,6 +689,7 @@ "outputs": [], "source": [ "import numpy as np\n", + "\n", "np.random.seed(10)" ] }, @@ -698,7 +699,7 @@ "metadata": {}, "outputs": [], "source": [ - "ts = inequality.theil.TheilDSim(gdf['PCGDP1960'], regimes, permutations=999)" + "ts = inequality.theil.TheilDSim(gdf[\"PCGDP1960\"], regimes, permutations=999)" ] }, { @@ -760,11 +761,12 @@ ], "source": [ "import matplotlib.pyplot as plt\n", + "\n", "kdeplot = sbn.kdeplot(ts.bg, fill=False, legend=False)\n", "x_vals = kdeplot.lines[0].get_xdata()\n", "y_vals = kdeplot.lines[0].get_ydata()\n", - "plt.fill_between(x_vals, y_vals, where=(x_vals > ts.bg[0]), color='red')\n", - "plt.xlabel('Between Regions Inequality 1960');" + "plt.fill_between(x_vals, y_vals, where=(x_vals > ts.bg[0]), color=\"red\")\n", + "plt.xlabel(\"Between Regions Inequality 1960\");" ] }, { diff --git a/docs/user-guide/measure/wolfson.ipynb b/docs/user-guide/measure/wolfson.ipynb index 885d66bd..d7c29f58 100644 --- a/docs/user-guide/measure/wolfson.ipynb +++ b/docs/user-guide/measure/wolfson.ipynb @@ -30,7 +30,7 @@ "metadata": {}, "outputs": [], "source": [ - "from inequality.wolfson import wolfson\n" + "from inequality.wolfson import wolfson" ] }, { @@ -61,31 +61,33 @@ "income_low_polarization = np.random.normal(loc=50000, scale=15000, size=10000)\n", "\n", "# Distribution 2: High polarization (bimodal distribution)\n", - "income_high_polarization = np.concatenate([\n", - " np.random.normal(loc=30000, scale=5000, size=5000),\n", - " np.random.normal(loc=70000, scale=5000, size=5000)\n", - "])\n", + "income_high_polarization = np.concatenate(\n", + " [\n", + " np.random.normal(loc=30000, scale=5000, size=5000),\n", + " np.random.normal(loc=70000, scale=5000, size=5000),\n", + " ]\n", + ")\n", "\n", "# Plotting the distributions\n", "plt.figure(figsize=(12, 6))\n", "\n", "# Plot for low polarization\n", "plt.subplot(1, 2, 1)\n", - "plt.hist(income_low_polarization, bins=50, color='blue', alpha=0.7)\n", - "plt.title('Low Polarization Income Distribution')\n", - "plt.xlabel('Income')\n", - "plt.ylabel('Frequency')\n", + "plt.hist(income_low_polarization, bins=50, color=\"blue\", alpha=0.7)\n", + "plt.title(\"Low Polarization Income Distribution\")\n", + "plt.xlabel(\"Income\")\n", + "plt.ylabel(\"Frequency\")\n", "\n", "# Plot for high polarization\n", "plt.subplot(1, 2, 2)\n", - "plt.hist(income_high_polarization, bins=50, color='red', alpha=0.7)\n", - "plt.title('High Polarization Income Distribution')\n", - "plt.xlabel('Income')\n", - "plt.ylabel('Frequency')\n", + "plt.hist(income_high_polarization, bins=50, color=\"red\", alpha=0.7)\n", + "plt.title(\"High Polarization Income Distribution\")\n", + "plt.xlabel(\"Income\")\n", + "plt.ylabel(\"Frequency\")\n", "\n", "# Show plots\n", "plt.tight_layout()\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -139,6 +141,7 @@ "source": [ "import libpysal\n", "import geopandas\n", + "\n", "pth = libpysal.examples.get_path(\"mexicojoin.shp\")\n", "gdf = geopandas.read_file(pth)" ] @@ -161,7 +164,7 @@ } ], "source": [ - "gdf.plot(column='PCGDP1960', legend=True);" + "gdf.plot(column=\"PCGDP1960\", legend=True);" ] }, { @@ -237,7 +240,7 @@ } ], "source": [ - "gdf.plot(column='PCGDP2000', legend=True);" + "gdf.plot(column=\"PCGDP2000\", legend=True);" ] }, { @@ -313,7 +316,7 @@ "metadata": {}, "outputs": [], "source": [ - "import pandas " + "import pandas" ] }, { @@ -323,7 +326,7 @@ "metadata": {}, "outputs": [], "source": [ - "ts = pandas.DataFrame(data=years, columns=['year'])" + "ts = pandas.DataFrame(data=years, columns=[\"year\"])" ] }, { @@ -333,8 +336,8 @@ "metadata": {}, "outputs": [], "source": [ - "ts['wolfson'] = w\n", - "ts = ts.set_index('year')" + "ts[\"wolfson\"] = w\n", + "ts = ts.set_index(\"year\")" ] }, { diff --git a/docs/user-guide/viz/pengram.ipynb b/docs/user-guide/viz/pengram.ipynb index 42b8b611..f2bc6cd6 100644 --- a/docs/user-guide/viz/pengram.ipynb +++ b/docs/user-guide/viz/pengram.ipynb @@ -38,7 +38,7 @@ "metadata": {}, "outputs": [], "source": [ - "gdf = gpd.read_file('weighted.shp')" + "gdf = gpd.read_file(\"weighted.shp\")" ] }, { @@ -297,10 +297,10 @@ "metadata": {}, "outputs": [], "source": [ - "col='PCGDP2000'\n", - "weight='p'\n", - "name='NAME'\n", - "figsize=(16,9)" + "col = \"PCGDP2000\"\n", + "weight = \"p\"\n", + "name = \"NAME\"\n", + "figsize = (16, 9)" ] }, { @@ -321,7 +321,7 @@ } ], "source": [ - "p = pen(gdf,col, name)" + "p = pen(gdf, col, name)" ] }, { @@ -358,7 +358,7 @@ } ], "source": [ - "p = pen(gdf,col, name, xticks=False)" + "p = pen(gdf, col, name, xticks=False)" ] }, { @@ -481,7 +481,7 @@ } ], "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left');" + "pengram(gdf, col, name, figsize=figsize, leg_pos=\"lower left\");" ] }, { @@ -502,7 +502,7 @@ } ], "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks');" + "pengram(gdf, col, name, figsize=figsize, leg_pos=\"lower left\", scheme=\"FisherJenks\");" ] }, { @@ -523,7 +523,9 @@ } ], "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks',k=3);" + "pengram(\n", + " gdf, col, name, figsize=figsize, leg_pos=\"lower left\", scheme=\"FisherJenks\", k=3\n", + ");" ] }, { @@ -555,8 +557,16 @@ } ], "source": [ - "pengram(gdf, col, name, figsize=figsize, leg_pos='lower left', scheme='FisherJenks',k=3,\n", - " query=['Chiapas', 'Campeche']);" + "pengram(\n", + " gdf,\n", + " col,\n", + " name,\n", + " figsize=figsize,\n", + " leg_pos=\"lower left\",\n", + " scheme=\"FisherJenks\",\n", + " k=3,\n", + " query=[\"Chiapas\", \"Campeche\"],\n", + ");" ] }, { @@ -599,13 +609,14 @@ "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", - "fig, axes = plt.subplots(2, 2, figsize=(10, 8), gridspec_kw={'height_ratios': [1, 1]})\n", - "ax0, ax1, ax2, ax3 = axes[0,0], axes[0,1], axes[1,0], axes[1,1]\n", "\n", - "sns.kdeplot(data=gdf, x='PCGDP2000', ax=ax0)\n", - "gdf.plot('PCGDP2000', ax=ax1)\n", + "fig, axes = plt.subplots(2, 2, figsize=(10, 8), gridspec_kw={\"height_ratios\": [1, 1]})\n", + "ax0, ax1, ax2, ax3 = axes[0, 0], axes[0, 1], axes[1, 0], axes[1, 1]\n", + "\n", + "sns.kdeplot(data=gdf, x=\"PCGDP2000\", ax=ax0)\n", + "gdf.plot(\"PCGDP2000\", ax=ax1)\n", "pen(gdf, col, name, ax=ax2)\n", - "pengram(gdf, col, name, xticks=False, legend=False, ax=ax3);\n" + "pengram(gdf, col, name, xticks=False, legend=False, ax=ax3);" ] }, { diff --git a/docs/user-guide/viz/schutz.ipynb b/docs/user-guide/viz/schutz.ipynb index 1d813ebd..e42f663c 100644 --- a/docs/user-guide/viz/schutz.ipynb +++ b/docs/user-guide/viz/schutz.ipynb @@ -53,7 +53,7 @@ "metadata": {}, "outputs": [], "source": [ - "df = pd.DataFrame(data=np.array([1000, 2000, 1500, 3000, 2500]), columns=['GDP'])" + "df = pd.DataFrame(data=np.array([1000, 2000, 1500, 3000, 2500]), columns=[\"GDP\"])" ] }, { @@ -63,7 +63,7 @@ "metadata": {}, "outputs": [], "source": [ - "s = Schutz(df, 'GDP')" + "s = Schutz(df, \"GDP\")" ] }, { @@ -286,7 +286,7 @@ "metadata": {}, "outputs": [], "source": [ - "y = np.array([20,50,80,100,100,100,100,120, 150,180])" + "y = np.array([20, 50, 80, 100, 100, 100, 100, 120, 150, 180])" ] }, { @@ -296,7 +296,7 @@ "metadata": {}, "outputs": [], "source": [ - "df = pd.DataFrame(data=y, columns=['GDP'])" + "df = pd.DataFrame(data=y, columns=[\"GDP\"])" ] }, { @@ -306,7 +306,7 @@ "metadata": {}, "outputs": [], "source": [ - "s = Schutz(df, 'GDP')" + "s = Schutz(df, \"GDP\")" ] }, { @@ -595,7 +595,8 @@ "outputs": [], "source": [ "import geopandas as gpd\n", - "gdf = gpd.read_file('weighted.shp')\n" + "\n", + "gdf = gpd.read_file(\"weighted.shp\")" ] }, { @@ -857,7 +858,7 @@ "metadata": {}, "outputs": [], "source": [ - "s1960 = Schutz(gdf, 'PCGDP1960')" + "s1960 = Schutz(gdf, \"PCGDP1960\")" ] }, { @@ -878,7 +879,7 @@ } ], "source": [ - "s1960.plot(xlabel='State Percentile Rank 1960')" + "s1960.plot(xlabel=\"State Percentile Rank 1960\")" ] }, { @@ -888,7 +889,7 @@ "metadata": {}, "outputs": [], "source": [ - "s2000= Schutz(gdf, 'PCGDP2000')" + "s2000 = Schutz(gdf, \"PCGDP2000\")" ] }, { @@ -909,7 +910,7 @@ } ], "source": [ - "s2000.plot(xlabel= 'State Percentile Rank 2000')" + "s2000.plot(xlabel=\"State Percentile Rank 2000\")" ] }, { diff --git a/inequality/__init__.py b/inequality/__init__.py index ffe034cb..662e40a0 100644 --- a/inequality/__init__.py +++ b/inequality/__init__.py @@ -4,7 +4,6 @@ """ - import contextlib from importlib.metadata import PackageNotFoundError, version diff --git a/inequality/atkinson.py b/inequality/atkinson.py index ce49d60f..e4230317 100644 --- a/inequality/atkinson.py +++ b/inequality/atkinson.py @@ -1,4 +1,3 @@ - import numpy as np __all__ = ["Atkinson", "atkinson"] diff --git a/inequality/gini.py b/inequality/gini.py index 4c67a11e..bb27df5c 100644 --- a/inequality/gini.py +++ b/inequality/gini.py @@ -156,10 +156,10 @@ def __init__(self, x, w, permutations=99): self.g = g n = len(x) den = x.mean() * 2 * n**2 - d = g * den # sum of absolute devations SAD + d = g * den # sum of absolute devations SAD wg = self._calc(x, w) # sum of absolute deviations for neighbor pairs - wcg = d - wg # sum of absolution deviations for distant pairs - n_pairs = n * (n-1) / 2 + wcg = d - wg # sum of absolution deviations for distant pairs + n_pairs = n * (n - 1) / 2 n_n_pairs = w.s0 / 2 n_d_pairs = n_pairs - n_n_pairs polarization = (wcg / wg) * (n_n_pairs / n_d_pairs) @@ -179,7 +179,7 @@ def __init__(self, x, w, permutations=99): for perm in range(permutations): numpy.random.shuffle(ids) wcgp[perm] = d - self._calc(x[ids], w) - polar = (wcgp[perm] / (d - wcgp[perm])) + polar = wcgp[perm] / (d - wcgp[perm]) polarization_sim[perm] = polar * _scale above = wcgp >= self.wcg larger = above.sum() diff --git a/inequality/tests/test_interface.py b/inequality/tests/test_interface.py index cd7150f3..87731e14 100644 --- a/inequality/tests/test_interface.py +++ b/inequality/tests/test_interface.py @@ -5,73 +5,113 @@ def test_lorenz_curve_with_array(): - income = np.array([20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000]) + income = np.array( + [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] + ) population, cumulative_income = lorenz_curve(income) - + # Check that both returned arrays have the correct length (n+1) assert len(population) == len(income) + 1 assert len(cumulative_income) == len(income) + 1 - + # Ensure that the Lorenz curve starts at zero assert cumulative_income[0] == 0.0 assert population[0] == 0.0 + def test_lorenz_curve_with_list(): income = [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] population, cumulative_income = lorenz_curve(income) - + # Check that both returned arrays have the correct length (n+1) assert len(population) == len(income) + 1 assert len(cumulative_income) == len(income) + 1 - + # Ensure that the Lorenz curve starts at zero assert cumulative_income[0] == 0.0 assert population[0] == 0.0 + def test_lorenz_curve_with_dataframe(): - df = pd.DataFrame({'income': [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000]}) - population, cumulative_income = lorenz_curve(df, column='income') - + df = pd.DataFrame( + { + "income": [ + 20000, + 25000, + 27000, + 30000, + 35000, + 45000, + 60000, + 75000, + 80000, + 120000, + ] + } + ) + population, cumulative_income = lorenz_curve(df, column="income") + # Check that both returned arrays have the correct length (n+1) - assert len(population) == len(df['income']) + 1 - assert len(cumulative_income) == len(df['income']) + 1 - + assert len(population) == len(df["income"]) + 1 + assert len(cumulative_income) == len(df["income"]) + 1 + # Ensure that the Lorenz curve starts at zero assert cumulative_income[0] == 0.0 assert population[0] == 0.0 + def test_wolfson_with_array(): - income = np.array([20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000]) + income = np.array( + [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] + ) wolfson_index = wolfson(income) - + # Compare the result to an expected value (based on the example) assert np.isclose(wolfson_index, 0.2013, atol=1e-4) + def test_wolfson_with_list(): income = [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] wolfson_index = wolfson(income) - + # Compare the result to an expected value (based on the example) assert np.isclose(wolfson_index, 0.2013, atol=1e-4) + def test_wolfson_with_dataframe(): - df = pd.DataFrame({'income': [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000]}) - wolfson_index = wolfson(df, column='income') - + df = pd.DataFrame( + { + "income": [ + 20000, + 25000, + 27000, + 30000, + 35000, + 45000, + 60000, + 75000, + 80000, + 120000, + ] + } + ) + wolfson_index = wolfson(df, column="income") + # Compare the result to an expected value (based on the example) assert np.isclose(wolfson_index, 0.2013, atol=1e-4) + def test_wolfson_with_small_dataset(): income = [6, 6, 8, 8, 10, 10, 12, 12] wolfson_index = wolfson(income) - + # Compare the result to an expected value (based on the example) assert np.isclose(wolfson_index, 0.0833, atol=1e-4) + def test_wolfson_with_even_distribution(): income = [2, 4, 6, 8, 10, 12, 14, 16] wolfson_index = wolfson(income) - + # Compare the result to an expected value (based on the example) assert np.isclose(wolfson_index, 0.1528, atol=1e-4) - diff --git a/inequality/tests/test_wolfson.py b/inequality/tests/test_wolfson.py index b5194057..99fd3ab8 100644 --- a/inequality/tests/test_wolfson.py +++ b/inequality/tests/test_wolfson.py @@ -8,11 +8,11 @@ def test_lorenz_curve(): population, cumulative_income = lorenz_curve(income) # Expected cumulative income values (calculated manually) - expected_cumulative_income = np.array( - [0, 0.06666667, 0.2, 0.4, 0.66666667, 1]) + expected_cumulative_income = np.array([0, 0.06666667, 0.2, 0.4, 0.66666667, 1]) np.testing.assert_almost_equal( - cumulative_income, expected_cumulative_income, decimal=6) + cumulative_income, expected_cumulative_income, decimal=6 + ) # Should include start and end points (0 and 1) assert len(population) == 6 @@ -20,9 +20,9 @@ def test_lorenz_curve(): def test_wolfson(): income = [6, 6, 8, 8, 10, 10, 12, 12] wolfson_idx = wolfson(income) - expected_wolfson_idx = 1/12 + expected_wolfson_idx = 1 / 12 assert np.isclose(wolfson_idx, expected_wolfson_idx, atol=0.01) income = [2, 4, 6, 8, 10, 12, 14, 16] wolfson_idx = wolfson(income) - expected_wolfson_idx = 11/72 + expected_wolfson_idx = 11 / 72 assert np.isclose(wolfson_idx, expected_wolfson_idx, atol=0.01) diff --git a/inequality/theil.py b/inequality/theil.py index 11be0b13..b4bb6048 100644 --- a/inequality/theil.py +++ b/inequality/theil.py @@ -54,7 +54,7 @@ def __init__(self, y, column=None): "The nxT input format is deprecated. In future versions, " "please provide nx1 sequences or a DataFrame with a single column.", DeprecationWarning, - stacklevel=2 + stacklevel=2, ) # Old API behavior n = y.shape[0] @@ -64,7 +64,7 @@ def __init__(self, y, column=None): if column is None: raise ValueError("For DataFrame input, `column` must be specified.") y = y[column].values - elif isinstance(y, (list, np.ndarray)): + elif isinstance(y, list | np.ndarray): y = np.asarray(y) else: raise TypeError("Input must be an array, list, or DataFrame.") @@ -118,33 +118,33 @@ def __init__(self, y, partition, column=None, partition_col=None): "The nxT input format is deprecated. In future versions, " "please provide nx1 sequences or a DataFrame with a single column.", DeprecationWarning, - stacklevel=2 + stacklevel=2, ) - n = y.shape[0] else: # New API: Handle sequence or DataFrame if isinstance(y, pd.DataFrame): if column is None: raise ValueError("For DataFrame input, `column` must be specified.") y = y[column].values - elif isinstance(y, (list, np.ndarray)): + elif isinstance(y, list | np.ndarray): y = np.asarray(y) else: raise TypeError("Input must be an array, list, or DataFrame.") - n = len(y) # Handle partition similarly if isinstance(partition, pd.DataFrame): if partition_col is None: - raise ValueError("For DataFrame input, `partition_col` must be specified.") + raise ValueError( + "For DataFrame input, `partition_col` must be specified." + ) partition = partition[partition_col].values - elif isinstance(partition, (list, np.ndarray)): + elif isinstance(partition, list | np.ndarray): partition = np.asarray(partition) else: raise TypeError("Partition must be an array, list, or DataFrame.") groups = np.unique(partition) - T = Theil(y).T + t = Theil(y).T ytot = y.sum(axis=0) # Group totals @@ -159,11 +159,13 @@ def __init__(self, y, partition, column=None, partition_col=None): ng.shape = (ng.size,) # ensure ng is 1-d # Between group inequality sg = sg + (sg == 0) # handle case when a partition has 0 for sum - bg = np.multiply(sg, np.log(np.dot(np.diag(len(y) * 1.0 / ng), sg))).sum(axis=0) + bg = np.multiply(sg, + np.log(np.dot(np.diag(len(y) * 1.0 / ng), + sg))).sum(axis=0) - self.T = T + self.T = t self.bg = bg - self.wg = T - bg + self.wg = t - bg class TheilDSim: diff --git a/inequality/utils.py b/inequality/utils.py index d38bedcc..988766f9 100644 --- a/inequality/utils.py +++ b/inequality/utils.py @@ -10,26 +10,32 @@ def wrapper(data, *args, column=None, **kwargs): # If input is a DataFrame, extract the specified column if isinstance(data, pd.DataFrame): if column is None: - raise ValueError("For DataFrame input, 'column' argument must be provided.") + raise ValueError( + "For DataFrame input, 'column' argument must be provided." + ) data = data[column].values # If input is a series, numpy array, or list, no transformation needed - elif isinstance(data, (pd.Series, np.ndarray, list)): + elif isinstance(data, pd.Series | np.ndarray | list): data = np.asarray(data) else: - raise TypeError("Input should be a sequence, numpy array, or pandas DataFrame.") + raise TypeError( + "Input should be a sequence, numpy array, or pandas DataFrame." + ) return func(data, *args, **kwargs) return wrapper + # Example function using the decorator @consistent_input def compute_mean(data): return np.mean(data) + # Usage -df = pd.DataFrame({'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8]}) -print(compute_mean(df, column='a')) # Output: 2.5 +df = pd.DataFrame({"a": [1, 2, 3, 4], "b": [5, 6, 7, 8]}) +print(compute_mean(df, column="a")) # Output: 2.5 arr = np.array([1, 2, 3, 4]) print(compute_mean(arr)) # Output: 2.5 diff --git a/inequality/wolfson.py b/inequality/wolfson.py index 0fe1afcf..da0779a1 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -7,6 +7,7 @@ Author: Serge Rey """ + import numpy as np from .gini import Gini @@ -16,38 +17,34 @@ @consistent_input -def lorenz_curve(data, column=None): +def lorenz_curve(data): """ Calculate the Lorenz curve for a given distribution. This function takes an income or wealth distribution as input. The input can be a sequence, a NumPy array, or a Pandas DataFrame. If a DataFrame - is provided, the `column` parameter must be used to specify which column + is provided, the `column` parameter must be used to specify which column contains the income or wealth values. Parameters ---------- - data : array-like, numpy array, or pandas.DataFrame - A sequence, NumPy array, or DataFrame representing the income or + data : array-like or array + A sequence or NumPy array representing the income or wealth distribution. - column : str, optional - The column name to be used when `data` is a pandas DataFrame. Required - if `data` is a DataFrame. Returns ------- tuple - Two numpy arrays: the first represents the cumulative share of the - population, and the second represents the cumulative share of + Two numpy arrays: the first represents the cumulative share of the + population, and the second represents the cumulative share of the income/wealth. Example ------- >>> income = [20000, 25000, 27000, 30000, 35000, 45000, 60000, 75000, 80000, 120000] >>> population, income_share = lorenz_curve(income) - >>> print(population, income_share) - [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ] [0. 0.03868472 0.08704062 0.13926499 0.19729207 0.26499033 - 0.35203095 0.46808511 0.6131528 0.76789168 1. ] + >>> print(population[:2], income_share[:2]) + [0. 0.1] [0. 0.03868472] """ sorted_y = np.sort(data) cumulative_y = np.cumsum(sorted_y) @@ -56,36 +53,35 @@ def lorenz_curve(data, column=None): cumulative_population = np.linspace(0, 1, len(data) + 1) return cumulative_population, cumulative_y + @consistent_input -def wolfson(data, column=None): +def wolfson(data): """ Calculate the Wolfson Bipolarization Index for a given income distribution. - This function takes an income distribution and calculates the Wolfson - Bipolarization Index. The input can be a sequence, a NumPy array, or a - Pandas DataFrame. If a DataFrame is provided, the `column` parameter must + This function takes an income distribution and calculates the Wolfson + Bipolarization Index. The input can be a sequence, a NumPy array, or a + Pandas DataFrame. If a DataFrame is provided, the `column` parameter must be used to specify which column contains the income values. - The Wolfson index is constructed from the polarization curve, which is + The Wolfson index is constructed from the polarization curve, which is a rotation and rescaling of the Lorenz curve by the median income: .. math:: W = (2D_{50} - G)\\frac{\\mu}{m} - Where :math:`D_{50} =0.5 - L(0.5)`, :math:`L(0.5)` is the value of the - Lorenz curve at the median, :math:`G` is the Gini index, :math:`\\mu` + Where :math:`D_{50} =0.5 - L(0.5)`, :math:`L(0.5)` is the value of the + Lorenz curve at the median, :math:`G` is the Gini index, :math:`\\mu` is the mean, and :math:`m` is the median. See: :cite:`wolfson1994WhenInequalities`. Parameters ---------- - data : array-like, numpy array, or pandas.DataFrame - A sequence, NumPy array, or DataFrame representing the income distribution. - column : str, optional - The column name to be used when `data` is a pandas DataFrame. Required - if `data` is a DataFrame. + data : array-like or array + A sequence or NumPy array representing the income or + wealth distribution. Returns ------- @@ -110,8 +106,8 @@ def wolfson(data, column=None): y = np.array(data) y_med = np.median(y) ordinate, lc = lorenz_curve(y) - l50 = np.interp(.5, ordinate, lc) - d50 = .5 - l50 + l50 = np.interp(0.5, ordinate, lc) + d50 = 0.5 - l50 rat = y.mean() / y_med g = Gini(y).g w = (2 * d50 - g) * rat From 1e5f6a7bf0803b03329fc071600f3d815878a328 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sun, 29 Dec 2024 20:00:19 +0000 Subject: [PATCH 30/32] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- inequality/theil.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/inequality/theil.py b/inequality/theil.py index b4bb6048..44933dbd 100644 --- a/inequality/theil.py +++ b/inequality/theil.py @@ -159,9 +159,7 @@ def __init__(self, y, partition, column=None, partition_col=None): ng.shape = (ng.size,) # ensure ng is 1-d # Between group inequality sg = sg + (sg == 0) # handle case when a partition has 0 for sum - bg = np.multiply(sg, - np.log(np.dot(np.diag(len(y) * 1.0 / ng), - sg))).sum(axis=0) + bg = np.multiply(sg, np.log(np.dot(np.diag(len(y) * 1.0 / ng), sg))).sum(axis=0) self.T = t self.bg = bg From 3658e0bd9f5c7972c41cb59c0a6eb255c137dc90 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sun, 29 Dec 2024 12:13:15 -0800 Subject: [PATCH 31/32] DOC: update wolfson docstring for args --- inequality/wolfson.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/inequality/wolfson.py b/inequality/wolfson.py index da0779a1..f4a29936 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -60,10 +60,7 @@ def wolfson(data): Calculate the Wolfson Bipolarization Index for a given income distribution. This function takes an income distribution and calculates the Wolfson - Bipolarization Index. The input can be a sequence, a NumPy array, or a - Pandas DataFrame. If a DataFrame is provided, the `column` parameter must - be used to specify which column contains the income values. - + Bipolarization Index. The input can be a sequence or a NumPy array. The Wolfson index is constructed from the polarization curve, which is a rotation and rescaling of the Lorenz curve by the median income: From cdc94709aed4d509800819ad283d005975b1ede2 Mon Sep 17 00:00:00 2001 From: Sergio Rey Date: Fri, 3 Jan 2025 08:50:16 -0800 Subject: [PATCH 32/32] Update inequality/wolfson.py Co-authored-by: James Gaboardi --- inequality/wolfson.py | 1 - 1 file changed, 1 deletion(-) diff --git a/inequality/wolfson.py b/inequality/wolfson.py index f4a29936..5e147779 100644 --- a/inequality/wolfson.py +++ b/inequality/wolfson.py @@ -85,7 +85,6 @@ def wolfson(data): float The Wolfson Bipolarization Index value. - Example ------- >>> import pandas as pd