diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index b40708fe2..37bf73ff5 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -4,9 +4,15 @@ on: push: branches: - master + paths-ignore: + - ".github/workflows/documentation.yml" + - "Documentation/**" pull_request: branches: - master + paths-ignore: + - ".github/workflows/documentation.yml" + - "Documentation/**" jobs: build: @@ -24,10 +30,11 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install -r requirements.txt + pip install -r requirements/base.txt - name: Generate coverage report run: | pip install pytest pytest-cov + NUMBA_DISABLE_JIT=1 pytest --cov=./ --cov-report=xml - name: upload coverage report uses: codecov/codecov-action@v3 diff --git a/.github/workflows/documentation.yml b/.github/workflows/documentation.yml new file mode 100644 index 000000000..c91d80118 --- /dev/null +++ b/.github/workflows/documentation.yml @@ -0,0 +1,74 @@ +name: Documentation + +# Run on all pushes and pull requests, and on demand +on: + push: + pull_request: + workflow_dispatch: + +# Limit workflow permissions +permissions: + contents: read + +# Limit simultaneous workflow runs +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} + cancel-in-progress: true + +env: + FORCE_COLOR: "1" + +jobs: + render: + name: Render + runs-on: ubuntu-latest + permissions: + contents: write + + steps: + - uses: actions/checkout@v3 + + - name: Set up Python 3.9 + uses: actions/setup-python@v4 + with: + python-version: "3.9" # Numba doesn't support Python 3.11 [2023-05] + cache: 'pip' + cache-dependency-path: | + requirements/base.txt + requirements/dev.txt + + - name: Install Pandoc + run: sudo apt-get install --yes pandoc + + - name: Update pip + run: python -m pip install --upgrade pip + + - name: Install HARK + run: python -m pip install .[dev] + + - name: Run Sphinx + run: > + sphinx-build + -M html Documentation HARK-docs + -T + + - name: Set up git for deployment + run: | + git config user.name "${{ github.actor }}" + git config user.email "${{ github.actor }}@users.noreply.github.com" + git config --local --unset-all http.https://github.com/.extraheader + + - name: Commit all rendered HTML files + run: | + git switch --orphan gh-pages + git add --all HARK-docs/html + git commit -qm "Documentation from @ ${{ github.repository }}@${{ github.sha }}" + + - name: Deploy to GitHub Pages + # Only deploy to Pages on pushes to HEAD + if: (github.repository_owner == 'Econ-ARK') && (github.event_name == 'push') && (github.ref_name == 'master') + run: > + git push + --force + https://x-access-token:${{ github.token }}@github.com/${{ github.repository }} + `git subtree split --prefix HARK-docs/html gh-pages`:refs/heads/gh-pages diff --git a/.github/workflows/examples.yml b/.github/workflows/examples.yml index 7f68c123f..4c3204092 100644 --- a/.github/workflows/examples.yml +++ b/.github/workflows/examples.yml @@ -4,9 +4,15 @@ on: push: branches: - master + paths-ignore: + - ".github/workflows/documentation.yml" + - "Documentation/**" pull_request: branches: - master + paths-ignore: + - ".github/workflows/documentation.yml" + - "Documentation/**" schedule: - cron: 0 0 * * * diff --git a/.github/workflows/hark.yml b/.github/workflows/hark.yml index 7e35445d1..eca382a58 100644 --- a/.github/workflows/hark.yml +++ b/.github/workflows/hark.yml @@ -4,9 +4,15 @@ on: push: branches: - master + paths-ignore: + - ".github/workflows/documentation.yml" + - "Documentation/**" pull_request: branches: - master + paths-ignore: + - ".github/workflows/documentation.yml" + - "Documentation/**" jobs: build: diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 4496cafb2..79a3470c7 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -2,7 +2,7 @@ exclude: Documentation/example_notebooks/ repos: - repo: https://github.com/mwouts/jupytext - rev: v1.14.4 + rev: v1.14.5 hooks: - id: jupytext args: @@ -11,13 +11,13 @@ repos: files: ^examples/.*\.ipynb$ - repo: https://github.com/psf/black - rev: 23.1.0 + rev: 23.3.0 hooks: - id: black exclude: ^examples/ - repo: https://github.com/asottile/pyupgrade - rev: v3.3.1 + rev: v3.4.0 hooks: - id: pyupgrade args: ["--py38-plus"] @@ -30,7 +30,7 @@ repos: exclude: ^examples/ - repo: https://github.com/pycqa/isort - rev: 5.11.5 + rev: 5.12.0 hooks: - id: isort name: isort (python) @@ -38,7 +38,7 @@ repos: exclude: ^examples/ - repo: https://github.com/pre-commit/mirrors-prettier - rev: v3.0.0-alpha.4 + rev: v3.0.0-alpha.9-for-vscode hooks: - id: prettier exclude: ^examples/ diff --git a/Documentation/CHANGELOG.md b/Documentation/CHANGELOG.md index 65ccd00ee..e4e57967c 100644 --- a/Documentation/CHANGELOG.md +++ b/Documentation/CHANGELOG.md @@ -14,8 +14,13 @@ Release Date: TBD ### Major Changes +- Adds `HARK.core.AgentPopulation` class to represent a population of agents with ex-ante heterogeneous parametrizations as distributions. [#1237](https://github.com/econ-ark/HARK/pull/1237) + ### Minor Changes + - Adds option `sim_common_Rrisky` to control whether risky-asset models draw common or idiosyncratic returns in simulation. [#1250](https://github.com/econ-ark/HARK/pull/1250),[#1253](https://github.com/econ-ark/HARK/pull/1253) +- Addresses [#1255](https://github.com/econ-ark/HARK/issues/1255). Makes age-varying stochastic returns possible and draws from their discretized version. [#1262](https://github.com/econ-ark/HARK/pull/1262) +- Fixes bug in the metric that compares dictionaries with the same keys. [#1260](https://github.com/econ-ark/HARK/pull/1260) ### 0.13.0 diff --git a/Documentation/_static/theme_overrides.css b/Documentation/_static/theme_overrides.css deleted file mode 100644 index 55152d099..000000000 --- a/Documentation/_static/theme_overrides.css +++ /dev/null @@ -1,3 +0,0 @@ -.wy-nav-content { - max-width: 1400px !important; -} diff --git a/Documentation/conf.py b/Documentation/conf.py index 4bfc69ec1..27af3addd 100644 --- a/Documentation/conf.py +++ b/Documentation/conf.py @@ -1,298 +1,61 @@ -# -# HARK documentation build configuration file, created by -# sphinx-quickstart on Sat Jun 4 15:22:52 2016. -# -# This file is execfile()d with the current directory set to its -# containing dir. -# -# Note that not all possible configuration values are present in this # autogenerated file. -# -# All configuration values have a default; values that are commented out -# serve to show the default. - -import os -import sys - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -path = os.path.abspath("..") -sys.path.insert(0, path) -print(f"Inserting {path}") - - -# -- General configuration ------------------------------------------------ - -# If your documentation needs a minimal Sphinx version, state it here. -# needs_sphinx = '1.0' +# Project information +project = "HARK" +copyright = "2020, Econ-ARK team" +author = "Econ-ARK team" +version = release = "latest" -# Add any Sphinx extension module names here, as strings. They can be -# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom -# ones. +# General configuration extensions = [ "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.coverage", "sphinx.ext.doctest", + "sphinx.ext.githubpages", + "sphinx.ext.imgconverter", "sphinx.ext.intersphinx", - "sphinx.ext.todo", - "sphinx.ext.coverage", "sphinx.ext.mathjax", - "sphinx.ext.autosummary", - "sphinx.ext.imgconverter", "sphinx.ext.napoleon", + "sphinx.ext.todo", "nbsphinx", "recommonmark", ] -# This is currently not working -nbsphinx_execute = "never" - -# Extend theme width -html_css_files = ["theme_overrides.css"] - -autodoc_default_flags = ["members"] # must add outside ']' bracket -autosummary_generate = True - -# Add any paths that contain templates here, relative to this directory. -templates_path = ["_templates"] - -# The suffix(es) of source filenames. -# You can specify multiple suffix as a list of string: -source_suffix = [".rst", ".md"] -# source_suffix = '.rst' +exclude_patterns = [ + "_build", + "Thumbs.db", + ".DS_Store", +] -# The encoding of source files. -# source_encoding = 'utf-8-sig' +language = "en" -# The master toctree document. master_doc = "index" -# General information about the project. -project = "HARK" -copyright = "2020, Econ-ARK team" -author = "Econ-ARK team" - -# The version info for the project you're documenting, acts as replacement for -# |version| and |release|, also used in various other places throughout the -# built documents. -# -# The short X.Y version. -version = "latest" -# The full version, including alpha/beta/rc tags. -release = "latest" - -# The language for content autogenerated by Sphinx. Refer to documentation -# for a list of supported languages. -# -# This is also used if you do content translation via gettext catalogs. -# Usually you set "language" from the command line for these cases. -language = None - -# There are two options for replacing |today|: either, you set today to some -# non-false value, then it is used: -# today = '' -# Else, today_fmt is used as the format for a strftime call. -# today_fmt = '%B %d, %Y' - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -# This patterns also effect to html_static_path and html_extra_path -exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] +# Synchronise with Sphinx requirement in 'requirements/dev.txt' +needs_sphinx = "6.1" -# The reST default role (used for this markup: `text`) to use for all -# documents. -# default_role = None - -# If true, '()' will be appended to :func: etc. cross-reference text. -# add_function_parentheses = True - -# If true, the current module name will be prepended to all description -# unit titles (such as .. function::). -# add_module_names = True - -# If true, sectionauthor and moduleauthor directives will be shown in the -# output. They are ignored by default. -# show_authors = False - -# The name of the Pygments (syntax highlighting) style to use. pygments_style = "sphinx" -# A list of ignored prefixes for module index sorting. -# modindex_common_prefix = [] - -# If true, keep warnings as "system message" paragraphs in the built documents. -# keep_warnings = False - -# If true, `todo` and `todoList` produce output, else they produce nothing. -todo_include_todos = True - - -# -- Options for HTML output ---------------------------------------------- - -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -html_theme = "sphinx_rtd_theme" # 'pydata_sphinx_theme' 'alabaster' - -# 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 -# documentation. -# html_theme_options = {} - -# Add any paths that contain custom themes here, relative to this directory. -# html_theme_path = [] - -# The name for this set of Sphinx documents. -# " v documentation" by default. -# html_title = u'HARK v0.9' - -# A shorter title for the navigation bar. Default is the same as html_title. -# html_short_title = None - -# The name of an image file (relative to this directory) to place at the top -# of the sidebar. -# html_logo = None - -# The name of an image file (relative to this directory) to use as a favicon of -# the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 -# pixels large. -# html_favicon = None - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ["_static"] - -# Add any extra paths that contain custom files (such as robots.txt or -# .htaccess) here, relative to this directory. These files are copied -# directly to the root of the documentation. -# html_extra_path = [] - -# If not None, a 'Last updated on:' timestamp is inserted at every page -# bottom, using the given strftime format. -# The empty string is equivalent to '%b %d, %Y'. -# html_last_updated_fmt = None - -# If true, SmartyPants will be used to convert quotes and dashes to -# typographically correct entities. -# html_use_smartypants = True - -# Custom sidebar templates, maps document names to template names. -# html_sidebars = {} - -# Additional templates that should be rendered to pages, maps page names to -# template names. -# html_additional_pages = {} - -# If false, no module index is generated. -# html_domain_indices = True - -# If false, no index is generated. -# html_use_index = True - -# If true, the index is split into individual pages for each letter. -# html_split_index = False - -# If true, links to the reST sources are added to the pages. -# html_show_sourcelink = True - -# If true, "Created using Sphinx" is shown in the HTML footer. Default is True. -# html_show_sphinx = True - -# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. -# html_show_copyright = True - -# If true, an OpenSearch description file will be output, and all pages will -# contain a tag referring to it. The value of this option must be the -# base URL from which the finished HTML is served. -# html_use_opensearch = '' - -# This is the file name suffix for HTML files (e.g. ".xhtml"). -# html_file_suffix = None - -# Language to be used for generating the HTML full-text search index. -# Sphinx supports the following languages: -# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja' -# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh' -# html_search_language = 'en' - -# A dictionary with options for the search language support, empty by default. -# 'ja' uses this config value. -# 'zh' user can custom change `jieba` dictionary path. -# html_search_options = {'type': 'default'} - -# The name of a javascript file (relative to the configuration directory) that -# implements a search results scorer. If empty, the default will be used. -# html_search_scorer = 'scorer.js' - -# Output file base name for HTML help builder. -# htmlhelp_basename = 'HARKdoc' - -# -- Options for LaTeX output --------------------------------------------- - -latex_elements = { - # The paper size ('letterpaper' or 'a4paper'). - #'papersize': 'letterpaper', - # The font size ('10pt', '11pt' or '12pt'). - #'pointsize': '10pt', - # Additional stuff for the LaTeX preamble. - #'preamble': '', - # Latex figure (float) alignment - #'figure_align': 'htbp', -} - -# Grouping the document tree into LaTeX files. List of tuples -# (source start file, target name, title, -# author, documentclass [howto, manual, or own class]). -latex_documents = [ - (master_doc, "HARK.tex", "HARK Documentation", "TEMP", "manual"), +source_suffix = [ + ".rst", + ".md", ] -# The name of an image file (relative to this directory) to place at the top of -# the title page. -# latex_logo = None - -# For "manual" documents, if this is true, then toplevel headings are parts, -# not chapters. -# latex_use_parts = False - -# If true, show page references after internal links. -# latex_show_pagerefs = False - -# If true, show URL addresses after external links. -# latex_show_urls = False +# HTML writer configuration +html_theme = "pydata_sphinx_theme" -# Documents to append as an appendix to all manuals. -# latex_appendices = [] - -# If false, no module index is generated. -# latex_domain_indices = True - - -# -- Options for manual page output --------------------------------------- - -# One entry per manual page. List of tuples -# (source start file, name, description, authors, manual section). -man_pages = [(master_doc, "hark", "HARK Documentation", [author], 1)] - -# If true, show URL addresses after external links. -# man_show_urls = False +# Use Econ-ARK URL to host the website +html_baseurl = "https://docs.econ-ark.org" +# sphinx.ext.intersphinx configuration +intersphinx_mapping = { + "python": ("https://docs.python.org/3/", None), +} -# -- Options for Texinfo output ------------------------------------------- +# sphinx.ext.autodoc configuration +autodoc_default_flags = ["members"] # must add outside ']' bracket -# Grouping the document tree into Texinfo files. List of tuples -# (source start file, target name, title, author, -# dir menu entry, description, category) -texinfo_documents = [ - ( - master_doc, - "HARK", - "HARK Documentation", - author, - "HARK", - "One line description of project.", - "Miscellaneous", - ), -] +# sphinx.ext.autosummary configuration +autosummary_generate = True -# Example configuration for intersphinx: refer to the Python standard library. -intersphinx_mapping = {"https://docs.python.org/": None} +# nbsphinx configuration +nbsphinx_execute = "never" # This is currently not working diff --git a/Documentation/contributing/Installation_instruction.md b/Documentation/contributing/Installation_instruction.md index 530694b10..ff300108a 100644 --- a/Documentation/contributing/Installation_instruction.md +++ b/Documentation/contributing/Installation_instruction.md @@ -215,5 +215,3 @@ If for some reason you want to switch back to the PyPI version: pip uninstall econ-ark pip install econ-ark (options) ``` - ---- diff --git a/Documentation/reference/tools/numba.rst b/Documentation/reference/tools/numba_tools.rst similarity index 60% rename from Documentation/reference/tools/numba.rst rename to Documentation/reference/tools/numba_tools.rst index 89a4ff603..d7f67e8cf 100644 --- a/Documentation/reference/tools/numba.rst +++ b/Documentation/reference/tools/numba_tools.rst @@ -1,7 +1,7 @@ -Numba +Numba Tools ------------- -.. automodule:: HARK.numba +.. automodule:: HARK.numba_tools :members: :undoc-members: :show-inheritance: diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index e120a8f8e..89a4f9ae0 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -1908,18 +1908,12 @@ def __init__(self, agents=None, tolerance=0.0001, act_T=1200, **kwds): "TranShkAggNow", "KtoLnow", ] + params["reap_vars"] = ["aLvl", "pLvl"] + params["track_vars"] = ["MaggNow", "AaggNow"] + params["dyn_vars"] = ["AFunc"] params.update(kwds) - Market.__init__( - self, - agents=agents, - reap_vars=["aLvl", "pLvl"], - track_vars=["MaggNow", "AaggNow"], - dyn_vars=["AFunc"], - tolerance=tolerance, - act_T=act_T, - **params - ) + Market.__init__(self, agents=agents, tolerance=tolerance, act_T=act_T, **params) self.update() # Use previously hardcoded values for AFunc updating if not passed diff --git a/HARK/ConsumptionSaving/ConsBequestModel.py b/HARK/ConsumptionSaving/ConsBequestModel.py new file mode 100644 index 000000000..d64c3b5d4 --- /dev/null +++ b/HARK/ConsumptionSaving/ConsBequestModel.py @@ -0,0 +1,300 @@ +""" +Classes to solve consumption-saving models with a bequest motive and +idiosyncratic shocks to income and wealth. All models here assume +separable CRRA utility of consumption and Stone-Geary utility of +savings with geometric discounting of the continuation value and +shocks to income that have transitory and/or permanent components. + +It currently solves 2 types of models: + 1) A standard lifecycle model with a terminal and/or accidental bequest motive. + 3) A portfolio choice model with a terminal and/or accidental bequest motive. +""" + +import numpy as np + +from HARK.ConsumptionSaving.ConsIndShockModel import ( + ConsIndShockSolver, + IndShockConsumerType, + init_idiosyncratic_shocks, + init_lifecycle, +) +from HARK.ConsumptionSaving.ConsPortfolioModel import ( + ConsPortfolioSolver, + PortfolioConsumerType, + PortfolioSolution, + init_portfolio, +) +from HARK.core import make_one_period_oo_solver +from HARK.interpolation import ( + ConstantFunction, + IdentityFunction, + LinearInterp, + MargMargValueFuncCRRA, + MargValueFuncCRRA, + ValueFuncCRRA, +) +from HARK.rewards import UtilityFuncCRRA, UtilityFuncStoneGeary + + +class BequestWarmGlowConsumerType(IndShockConsumerType): + time_vary_ = IndShockConsumerType.time_vary_ + [ + "BeqCRRA", + "BeqFac", + "BeqShift", + ] + + def __init__(self, **kwds): + params = init_wealth_in_utility.copy() + params.update(kwds) + + super().__init__(**params) + + self.solve_one_period = make_one_period_oo_solver(BequestWarmGlowConsumerSolver) + + def update(self): + super().update() + self.update_parameters() + + def update_parameters(self): + if isinstance(self.BeqCRRA, (int, float)): + self.BeqCRRA = [self.BeqCRRA] * self.T_cycle + elif len(self.BeqCRRA) == 1: + self.BeqCRRA *= self.T_cycle + elif len(self.BeqCRRA) != self.T_cycle: + raise ValueError( + "Bequest CRRA parameter must be a single value or a list of length T_cycle" + ) + + if isinstance(self.BeqFac, (int, float)): + self.BeqFac = [self.BeqFac] * self.T_cycle + elif len(self.BeqFac) == 1: + self.BeqFac *= self.T_cycle + elif len(self.BeqFac) != self.T_cycle: + raise ValueError( + "Bequest relative value parameter must be a single value or a list of length T_cycle" + ) + + if isinstance(self.BeqShift, (int, float)): + self.BeqShift = [self.BeqShift] * self.T_cycle + elif len(self.BeqShift) == 1: + self.BeqShift *= self.T_cycle + elif len(self.BeqShift) != self.T_cycle: + raise ValueError( + "Bequest Stone-Geary parameter must be a single value or a list of length T_cycle" + ) + + def update_solution_terminal(self): + if self.TermBeqFac == 0.0: # No terminal bequest + super().update_solution_terminal() + else: + utility = UtilityFuncCRRA(self.CRRA) + + warm_glow = UtilityFuncStoneGeary( + self.TermBeqCRRA, factor=self.TermBeqFac, shifter=self.TermBeqShift + ) + + aNrmGrid = ( + np.append(0.0, self.aXtraGrid) + if self.TermBeqShift != 0.0 + else self.aXtraGrid + ) + cNrmGrid = utility.derinv(warm_glow.der(aNrmGrid)) + vGrid = utility(cNrmGrid) + warm_glow(aNrmGrid) + cNrmGridW0 = np.append(0.0, cNrmGrid) + mNrmGridW0 = np.append(0.0, aNrmGrid + cNrmGrid) + vNvrsGridW0 = np.append(0.0, utility.inv(vGrid)) + + cFunc_term = LinearInterp(mNrmGridW0, cNrmGridW0) + vNvrsFunc_term = LinearInterp(mNrmGridW0, vNvrsGridW0) + vFunc_term = ValueFuncCRRA(vNvrsFunc_term, self.CRRA) + vPfunc_term = MargValueFuncCRRA(cFunc_term, self.CRRA) + vPPfunc_term = MargMargValueFuncCRRA(cFunc_term, self.CRRA) + + self.solution_terminal.cFunc = cFunc_term + self.solution_terminal.vFunc = vFunc_term + self.solution_terminal.vPfunc = vPfunc_term + self.solution_terminal.vPPfunc = vPPfunc_term + self.solution_terminal.mNrmMin = 0.0 + + +class BequestWarmGlowPortfolioType(PortfolioConsumerType, BequestWarmGlowConsumerType): + def __init__(self, **kwds): + params = init_portfolio_bequest.copy() + params.update(kwds) + + self.IndepDstnBool = True + + super().__init__(**params) + + self.solve_one_period = make_one_period_oo_solver( + BequestWarmGlowPortfolioSolver + ) + + def update(self): + PortfolioConsumerType.update(self) + self.update_parameters() + + def update_solution_terminal(self): + BequestWarmGlowConsumerType.update_solution_terminal(self) + + # Consume all market resources: c_T = m_T + cFuncAdj_terminal = self.solution_terminal.cFunc + cFuncFxd_terminal = lambda m, s: self.solution_terminal.cFunc(m) + + # Risky share is irrelevant-- no end-of-period assets; set to zero + ShareFuncAdj_terminal = ConstantFunction(0.0) + ShareFuncFxd_terminal = IdentityFunction(i_dim=1, n_dims=2) + + # Value function is simply utility from consuming market resources + vFuncAdj_terminal = self.solution_terminal.vFunc + vFuncFxd_terminal = lambda m, s: self.solution_terminal.vFunc(m) + + # Marginal value of market resources is marg utility at the consumption function + vPfuncAdj_terminal = self.solution_terminal.vPfunc + dvdmFuncFxd_terminal = lambda m, s: self.solution_terminal.vPfunc(m) + # No future, no marg value of Share + dvdsFuncFxd_terminal = ConstantFunction(0.0) + + # Construct the terminal period solution + self.solution_terminal = PortfolioSolution( + cFuncAdj=cFuncAdj_terminal, + ShareFuncAdj=ShareFuncAdj_terminal, + vFuncAdj=vFuncAdj_terminal, + vPfuncAdj=vPfuncAdj_terminal, + cFuncFxd=cFuncFxd_terminal, + ShareFuncFxd=ShareFuncFxd_terminal, + vFuncFxd=vFuncFxd_terminal, + dvdmFuncFxd=dvdmFuncFxd_terminal, + dvdsFuncFxd=dvdsFuncFxd_terminal, + ) + + +class BequestWarmGlowConsumerSolver(ConsIndShockSolver): + def __init__( + self, + solution_next, + IncShkDstn, + LivPrb, + DiscFac, + CRRA, + Rfree, + PermGroFac, + BoroCnstArt, + aXtraGrid, + BeqCRRA, + BeqFac, + BeqShift, + ): + self.BeqCRRA = BeqCRRA + self.BeqFac = BeqFac + self.BeqShift = BeqShift + vFuncBool = False + CubicBool = False + + super().__init__( + solution_next, + IncShkDstn, + LivPrb, + DiscFac, + CRRA, + Rfree, + PermGroFac, + BoroCnstArt, + aXtraGrid, + vFuncBool, + CubicBool, + ) + + def def_utility_funcs(self): + super().def_utility_funcs() + + BeqFacEff = (1.0 - self.LivPrb) * self.BeqFac + + self.warm_glow = UtilityFuncStoneGeary(self.BeqCRRA, BeqFacEff, self.BeqShift) + + def calc_EndOfPrdvP(self): + EndofPrdvP = super().calc_EndOfPrdvP() + + return EndofPrdvP + self.warm_glow.der(self.aNrmNow) + + +class BequestWarmGlowPortfolioSolver(ConsPortfolioSolver): + def __init__( + self, + solution_next, + ShockDstn, + IncShkDstn, + RiskyDstn, + LivPrb, + DiscFac, + CRRA, + Rfree, + PermGroFac, + BoroCnstArt, + aXtraGrid, + ShareGrid, + AdjustPrb, + ShareLimit, + BeqCRRA, + BeqFac, + BeqShift, + ): + self.BeqCRRA = BeqCRRA + self.BeqFac = BeqFac + self.BeqShift = BeqShift + vFuncBool = False + DiscreteShareBool = False + IndepDstnBool = True + + super().__init__( + solution_next, + ShockDstn, + IncShkDstn, + RiskyDstn, + LivPrb, + DiscFac, + CRRA, + Rfree, + PermGroFac, + BoroCnstArt, + aXtraGrid, + ShareGrid, + vFuncBool, + AdjustPrb, + DiscreteShareBool, + ShareLimit, + IndepDstnBool, + ) + + def def_utility_funcs(self): + super().def_utility_funcs() + + self.warm_glow = UtilityFuncStoneGeary(self.BeqCRRA, self.BeqFac, self.BeqShift) + + def calc_EndOfPrdvP(self): + super().calc_EndOfPrdvP() + + self.EndofPrddvda = self.EndOfPrddvda + self.warm_glow.der(self.aNrm_tiled) + self.EndOfPrddvdaNvrs = self.uPinv(self.EndOfPrddvda) + + +init_wealth_in_utility = init_idiosyncratic_shocks.copy() +init_wealth_in_utility["BeqCRRA"] = init_idiosyncratic_shocks["CRRA"] +init_wealth_in_utility["BeqFac"] = 1.0 +init_wealth_in_utility["BeqShift"] = 0.0 +init_wealth_in_utility["TermBeqCRRA"] = init_idiosyncratic_shocks["CRRA"] +init_wealth_in_utility["TermBeqFac"] = 0.0 # ignore bequest motive in terminal period +init_wealth_in_utility["TermBeqShift"] = 0.0 + +init_warm_glow = init_lifecycle.copy() +init_warm_glow["TermBeqCRRA"] = init_lifecycle["CRRA"] +init_warm_glow["TermBeqFac"] = 1.0 +init_warm_glow["TermBeqShift"] = 0.0 + +init_accidental_bequest = init_warm_glow.copy() +init_accidental_bequest["BeqFac"] = 1.0 # Value of bequest relative to consumption +init_accidental_bequest["BeqShift"] = 0.0 # Shifts the utility function +init_accidental_bequest["BeqCRRA"] = init_lifecycle["CRRA"] + +init_portfolio_bequest = init_accidental_bequest.copy() +init_portfolio_bequest.update(init_portfolio) diff --git a/HARK/ConsumptionSaving/ConsPortfolioModel.py b/HARK/ConsumptionSaving/ConsPortfolioModel.py index d70ec73a2..731f603de 100644 --- a/HARK/ConsumptionSaving/ConsPortfolioModel.py +++ b/HARK/ConsumptionSaving/ConsPortfolioModel.py @@ -652,42 +652,42 @@ def optimize_share(self): Optimization of Share on continuous interval [0,1] """ - # For values of aNrm at which the agent wants to put more than 100% into risky asset, constrain them FOC_s = self.EndOfPrddvds - # Initialize to putting everything in safe asset - self.Share_now = np.zeros_like(self.aNrmGrid) - self.cNrmAdj_now = np.zeros_like(self.aNrmGrid) + + # For each value of aNrm, find the value of Share such that FOC-Share == 0. + crossing = np.logical_and(FOC_s[:, 1:] <= 0.0, FOC_s[:, :-1] >= 0.0) + share_idx = np.argmax(crossing, axis=1) + a_idx = np.arange(self.aNrmCount) + bot_s = self.ShareGrid[share_idx] + top_s = self.ShareGrid[share_idx + 1] + bot_f = FOC_s[a_idx, share_idx] + top_f = FOC_s[a_idx, share_idx + 1] + bot_c = self.EndOfPrddvdaNvrs[a_idx, share_idx] + top_c = self.EndOfPrddvdaNvrs[a_idx, share_idx + 1] + alpha = 1.0 - top_f / (top_f - bot_f) + + self.Share_now = (1.0 - alpha) * bot_s + alpha * top_s + self.cNrmAdj_now = (1.0 - alpha) * bot_c + alpha * top_c + # If agent wants to put more than 100% into risky asset, he is constrained constrained_top = FOC_s[:, -1] > 0.0 # Likewise if he wants to put less than 0% into risky asset constrained_bot = FOC_s[:, 0] < 0.0 + + # For values of aNrm at which the agent wants to put + # more than 100% into risky asset, constrain them self.Share_now[constrained_top] = 1.0 + self.Share_now[constrained_bot] = 0.0 + + # Get consumption when share-constrained + self.cNrmAdj_now[constrained_top] = self.EndOfPrddvdaNvrs[constrained_top, -1] + self.cNrmAdj_now[constrained_bot] = self.EndOfPrddvdaNvrs[constrained_bot, 0] + if not self.zero_bound: # aNrm=0, so there's no way to "optimize" the portfolio self.Share_now[0] = 1.0 # Consumption when aNrm=0 does not depend on Share self.cNrmAdj_now[0] = self.EndOfPrddvdaNvrs[0, -1] - # Mark as constrained so that there is no attempt at optimization - constrained_top[0] = True - - # Get consumption when share-constrained - self.cNrmAdj_now[constrained_top] = self.EndOfPrddvdaNvrs[constrained_top, -1] - self.cNrmAdj_now[constrained_bot] = self.EndOfPrddvdaNvrs[constrained_bot, 0] - # For each value of aNrm, find the value of Share such that FOC-Share == 0. - # This loop can probably be eliminated, but it's such a small step that it won't speed things up much. - crossing = np.logical_and(FOC_s[:, 1:] <= 0.0, FOC_s[:, :-1] >= 0.0) - for j in range(self.aNrmCount): - if not (constrained_top[j] or constrained_bot[j]): - idx = np.argwhere(crossing[j, :])[0][0] - bot_s = self.ShareGrid[idx] - top_s = self.ShareGrid[idx + 1] - bot_f = FOC_s[j, idx] - top_f = FOC_s[j, idx + 1] - bot_c = self.EndOfPrddvdaNvrs[j, idx] - top_c = self.EndOfPrddvdaNvrs[j, idx + 1] - alpha = 1.0 - top_f / (top_f - bot_f) - self.Share_now[j] = (1.0 - alpha) * bot_s + alpha * top_s - self.cNrmAdj_now[j] = (1.0 - alpha) * bot_c + alpha * top_c def make_basic_solution(self): """ diff --git a/HARK/ConsumptionSaving/ConsRiskyAssetModel.py b/HARK/ConsumptionSaving/ConsRiskyAssetModel.py index dfdf5582a..9eab85cf8 100644 --- a/HARK/ConsumptionSaving/ConsRiskyAssetModel.py +++ b/HARK/ConsumptionSaving/ConsRiskyAssetModel.py @@ -86,7 +86,7 @@ def pre_solve(self): def update(self): IndShockConsumerType.update(self) - self.update_AdjustPrb() + self.update_AdjustDstn() self.update_RiskyDstn() self.update_ShockDstn() @@ -123,8 +123,8 @@ def update_RiskyDstn(self): else: self.add_to_time_inv("RiskyAvg", "RiskyStd") - # Generate a discrete approximation to the risky return distribution if the - # agent has age-varying beliefs about the risky asset + # Generate a discrete approximation to the risky return distribution + # if its parameters are time-varying if "RiskyAvg" in self.time_vary: self.RiskyDstn = IndexDistribution( Lognormal.from_mean_std, @@ -134,8 +134,8 @@ def update_RiskyDstn(self): self.add_to_time_vary("RiskyDstn") - # Generate a discrete approximation to the risky return distribution if the - # agent does *not* have age-varying beliefs about the risky asset (base case) + # Generate a discrete approximation to the risky return distribution if + # its parameters are constant else: self.RiskyDstn = Lognormal.from_mean_std( self.RiskyAvg, self.RiskyStd @@ -193,7 +193,7 @@ def update_ShockDstn(self): self.IndepDstnBool = True self.add_to_time_inv("IndepDstnBool") - def update_AdjustPrb(self): + def update_AdjustDstn(self): """ Checks and updates the exogenous probability of the agent being allowed to rebalance his portfolio/contribution scheme. It can be time varying. @@ -209,12 +209,20 @@ def update_AdjustPrb(self): """ if type(self.AdjustPrb) is list and (len(self.AdjustPrb) == self.T_cycle): self.add_to_time_vary("AdjustPrb") + + self.AdjustDstn = IndexDistribution( + Bernoulli, {"p": self.AdjustPrb}, seed=self.RNG.integers(0, 2**31 - 1) + ) + elif type(self.AdjustPrb) is list: raise AttributeError( "If AdjustPrb is time-varying, it must have length of T_cycle!" ) else: self.add_to_time_inv("AdjustPrb") + self.AdjustDstn = Bernoulli( + p=self.AdjustPrb, seed=self.RNG.integers(0, 2**31 - 1) + ) def update_ShareLimit(self): """ @@ -305,9 +313,7 @@ def get_Rfree(self): def get_Risky(self): """ - Sets the attribute Risky as a single draw from a lognormal distribution. - Uses the attributes RiskyAvgTrue and RiskyStdTrue if RiskyAvg is time-varying, - else just uses the single values from RiskyAvg and RiskyStd. + Draws a new risky return factor. Parameters ---------- @@ -317,22 +323,26 @@ def get_Risky(self): ------- None """ + + # How we draw the shocks depends on whether their distribution is time-varying if "RiskyDstn" in self.time_vary: - RiskyAvg = self.RiskyAvgTrue - RiskyStd = self.RiskyStdTrue - else: - RiskyAvg = self.RiskyAvg - RiskyStd = self.RiskyStd - - # Draw either a common economy-wide return, or one for each agent - if self.sim_common_Rrisky: - self.shocks["Risky"] = Lognormal.from_mean_std( - RiskyAvg, RiskyStd, seed=self.RNG.integers(0, 2**31 - 1) - ).draw(1) + if self.sim_common_Rrisky: + raise AttributeError( + "If sim_common_Rrisky is True, RiskyDstn cannot be time-varying!" + ) + + else: + # Make use of the IndexDistribution.draw() method + self.shocks["Risky"] = self.RiskyDstn.draw( + np.maximum(self.t_cycle - 1,0) if self.cycles == 1 else self.t_cycle + ) + else: - self.shocks["Risky"] = Lognormal.from_mean_std( - RiskyAvg, RiskyStd, seed=self.RNG.integers(0, 2**31 - 1) - ).draw(self.AgentCount) + # Draw either a common economy-wide return, or one for each agent + if self.sim_common_Rrisky: + self.shocks["Risky"] = self.RiskyDstn.draw(1) + else: + self.shocks["Risky"] = self.RiskyDstn.draw(self.AgentCount) def get_Adjust(self): """ @@ -348,9 +358,12 @@ def get_Adjust(self): ------- None """ - self.shocks["Adjust"] = IndexDistribution( - Bernoulli, {"p": self.AdjustPrb}, seed=self.RNG.integers(0, 2**31 - 1) - ).draw(self.t_cycle) + if "AdjustPrb" in self.time_vary: + self.shocks["Adjust"] = self.AdjustDstn.draw( + np.maximum(self.t_cycle - 1,0) if self.cycles == 1 else self.t_cycle + ) + else: + self.shocks["Adjust"] = self.AdjustDstn.draw(self.AgentCount) def initialize_sim(self): """ diff --git a/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py b/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py index 3cc8bb80e..96b047a60 100644 --- a/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py +++ b/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py @@ -255,3 +255,52 @@ def test_simulation(self): == self.pcct.history["Risky"][:, 0][:, np.newaxis] ) ) + + +class test_time_varying_Risky_and_Adj(unittest.TestCase): + def setUp(self): + # Create a parameter dictionary for a three period problem + self.params = cpm.init_portfolio.copy() + # Update time varying parameters + self.params.update( + { + "cycles": 1, + "T_cycle": 3, + "T_age": 3, + "Rfree": 1.0, + "RiskyAvg": [1.01, 1.02, 1.03], + "RiskyStd": [0.0, 0.0, 0.0], + "RiskyCount": 1, + "AdjustPrb": [0.0, 1.0, 0.0], + "PermGroFac": [1.0, 1.0, 1.0], + "LivPrb": [0.5, 0.5, 0.5], + "PermShkStd": [0.0, 0.0, 0.0], + "TranShkStd": [0.0, 0.0, 0.0], + "T_sim": 50, + "sim_common_Rrisky": False, + "AgentCount": 10, + } + ) + + # Create and solve agent + self.agent = cpm.PortfolioConsumerType(**self.params) + self.agent.solve() + + def test_draws(self): + # Simulate the agent + self.agent.track_vars = ["t_age", "t_cycle", "Adjust", "Risky"] + self.agent.initialize_sim() + self.agent.simulate() + + # Check that returns and adjustment draws are correct + Rrisky_draws = self.agent.history["Risky"] + Adjust_draws = self.agent.history["Adjust"] + # t_age is increased before being recorded + t_age = self.agent.history["t_age"] - 1 + + # Check that the draws are correct + self.assertTrue(np.all(Rrisky_draws[t_age == 1] == 1.01)) + self.assertTrue(np.all(Rrisky_draws[t_age == 2] == 1.02)) + # Adjust + self.assertTrue(np.all(Adjust_draws[t_age == 1] == 0)) + self.assertTrue(np.all(Adjust_draws[t_age == 2] == 1)) diff --git a/HARK/core.py b/HARK/core.py index 7fb680f86..3149ebf0d 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -8,12 +8,21 @@ """ import sys from copy import copy, deepcopy +from dataclasses import dataclass, field from time import time +from typing import Any, Dict, List, NewType, Optional, Union from warnings import warn import numpy as np - -from HARK.distribution import IndexDistribution, TimeVaryingDiscreteDistribution +import pandas as pd +from xarray import DataArray + +from HARK.distribution import ( + Distribution, + IndexDistribution, + TimeVaryingDiscreteDistribution, + combine_indep_dstns, +) from HARK.parallel import multi_thread_commands, multi_thread_commands_fake from HARK.utilities import NullFunc, get_arg_names @@ -1109,8 +1118,8 @@ def __init__( super().__init__() self.agents = agents if agents is not None else list() # NOQA - reap_vars = reap_vars if reap_vars is not None else list() # NOQA - self.reap_state = {var: [] for var in reap_vars} + self.reap_vars = reap_vars if reap_vars is not None else list() # NOQA + self.reap_state = {var: [] for var in self.reap_vars} self.sow_vars = sow_vars if sow_vars is not None else list() # NOQA # dictionaries for tracking initial and current values @@ -1427,3 +1436,262 @@ def distribute_params(agent, param_name, param_count, distribution): agent_set[j].assign_parameters(**{param_name: param_dist.atoms[0, j]}) return agent_set + + +Parameters = NewType("ParameterDict", dict) + + +@dataclass +class AgentPopulation: + """ + A class for representing a population of ex-ante heterogeneous agents. + """ + + agent_type: AgentType # type of agent in the population + parameters: Parameters # dictionary of parameters + seed: int = 0 # random seed + time_var: List[str] = field(init=False) + time_inv: List[str] = field(init=False) + distributed_params: List[str] = field(init=False) + agent_type_count: Optional[int] = field(init=False) + term_age: Optional[int] = field(init=False) + continuous_distributions: Dict[str, Distribution] = field(init=False) + discrete_distributions: Dict[str, Distribution] = field(init=False) + population_parameters: List[Dict[str, Union[List[float], float]]] = field( + init=False + ) + agents: List[AgentType] = field(init=False) + agent_database: pd.DataFrame = field(init=False) + solution: List[Any] = field(init=False) + + def __post_init__(self): + """ + Initialize the population of agents, determine distributed parameters, + and infer `agent_type_count` and `term_age`. + """ + # create a dummy agent and obtain its time-varying + # and time-invariant attributes + dummy_agent = self.agent_type() + self.time_var = dummy_agent.time_vary + self.time_inv = dummy_agent.time_inv + + # create list of distributed parameters + # these are parameters that differ across agents + self.distributed_params = [ + key + for key, param in self.parameters.items() + if (isinstance(param, list) and isinstance(param[0], list)) + or isinstance(param, Distribution) + or (isinstance(param, DataArray) and param.dims[0] == "agent") + ] + + self.__infer_counts__() + + def __infer_counts__(self): + """ + Infer `agent_type_count` and `term_age` from the parameters. + If parameters include a `Distribution` type, a list of lists, + or a `DataArray` with `agent` as the first dimension, then + the AgentPopulation contains ex-ante heterogenous agents. + """ + + # infer agent_type_count from distributed parameters + agent_type_count = 1 + for key in self.distributed_params: + param = self.parameters[key] + if isinstance(param, Distribution): + agent_type_count = None + warn( + "Cannot infer agent_type_count from a Distribution. " + "Please provide approximation parameters." + ) + break + elif isinstance(param, list): + agent_type_count = max(agent_type_count, len(param)) + elif isinstance(param, DataArray) and param.dims[0] == "agent": + agent_type_count = max(agent_type_count, param.shape[0]) + + self.agent_type_count = agent_type_count + + # infer term_age from all parameters + term_age = 1 + for param in self.parameters.values(): + if isinstance(param, Distribution): + term_age = None + warn( + "Cannot infer term_age from a Distribution. " + "Please provide approximation parameters." + ) + break + elif isinstance(param, list) and isinstance(param[0], list): + term_age = max(term_age, len(param[0])) + elif isinstance(param, DataArray) and param.dims[-1] == "age": + term_age = max(term_age, param.shape[-1]) + + self.term_age = term_age + + def approx_distributions(self, approx_params: dict): + """ + Approximate continuous distributions with discrete ones. If the initial + parameters include a `Distribution` type, then the AgentPopulation is + not ready to solve, and stands for an abstract population. To solve the + AgentPopulation, we need discretization parameters for each continuous + distribution. This method approximates the continuous distributions with + discrete ones, and updates the parameters dictionary. + """ + self.continuous_distributions = {} + self.discrete_distributions = {} + + for key, points in approx_params.items(): + param = self.parameters[key] + if key in self.distributed_params and isinstance(param, Distribution): + self.continuous_distributions[key] = param + self.discrete_distributions[key] = param.discretize(points) + else: + raise ValueError( + f"Warning: parameter {key} is not a Distribution found " + f"in agent type {self.agent_type}" + ) + + if len(self.discrete_distributions) > 1: + joint_dist = combine_indep_dstns(*self.discrete_distributions.values()) + else: + joint_dist = list(self.discrete_distributions.values())[0] + + for i, key in enumerate(self.discrete_distributions): + self.parameters[key] = DataArray(joint_dist.atoms[i], dims=("agent")) + + self.__infer_counts__() + + def __parse_parameters__(self) -> None: + """ + Creates distributed dictionaries of parameters for each ex-ante + heterogeneous agent in the parameterized population. The parameters + are stored in a list of dictionaries, where each dictionary contains + the parameters for one agent. Expands parameters that vary over time + to a list of length `term_age`. + """ + + population_parameters = [] # container for dictionaries of each agent subgroup + for agent in range(self.agent_type_count): + agent_parameters = {} + for key, param in self.parameters.items(): + if key in self.time_var: + # parameters that vary over time have to be repeated + if isinstance(param, (int, float)): + parameter_per_t = [param] * self.term_age + elif isinstance(param, list): + if isinstance(param[0], list): + parameter_per_t = param[agent] + else: + parameter_per_t = param + elif isinstance(param, DataArray): + if param.dims[0] == "agent": + if param.dims[-1] == "age": + parameter_per_t = param[agent].item() + else: + parameter_per_t = param.item() + elif param.dims[0] == "age": + parameter_per_t = param.item() + + agent_parameters[key] = parameter_per_t + + elif key in self.time_inv: + if isinstance(param, (int, float)): + agent_parameters[key] = param + elif isinstance(param, list): + if isinstance(param[0], list): + agent_parameters[key] = param[agent] + else: + agent_parameters[key] = param + elif isinstance(param, DataArray) and param.dims[0] == "agent": + agent_parameters[key] = param[agent].item() + + else: + if isinstance(param, (int, float)): + agent_parameters[key] = param # assume time inv + elif isinstance(param, list): + if isinstance(param[0], list): + agent_parameters[key] = param[agent] # assume agent vary + else: + agent_parameters[key] = param # assume time vary + elif isinstance(param, DataArray): + if param.dims[0] == "agent": + if param.dims[-1] == "age": + agent_parameters[key] = param[ + agent + ].item() # assume agent vary + else: + agent_parameters[key] = param.item() # assume time vary + elif param.dims[0] == "age": + agent_parameters[key] = param.item() # assume time vary + + population_parameters.append(agent_parameters) + + self.population_parameters = population_parameters + + def create_distributed_agents(self): + """ + Parses the parameters dictionary and creates a list of agents with the + appropriate parameters. Also sets the seed for each agent. + """ + + self.__parse_parameters__() + + rng = np.random.default_rng(self.seed) + + self.agents = [ + self.agent_type(seed=rng.integers(0, 2**31 - 1), **agent_dict) + for agent_dict in self.population_parameters + ] + + def create_database(self): + """ + Optionally creates a pandas DataFrame with the parameters for each agent. + """ + database = pd.DataFrame(self.population_parameters) + database["agents"] = self.agents + + self.agent_database = database + + def solve(self): + """ + Solves each agent of the population serially. + """ + + # see Market class for an example of how to solve distributed agents in parallel + + for agent in self.agents: + agent.solve() + + def unpack_solutions(self): + """ + Unpacks the solutions of each agent into an attribute of the population. + """ + self.solution = [agent.solution for agent in self.agents] + + def initialize_sim(self): + """ + Initializes the simulation for each agent. + """ + for agent in self.agents: + agent.initialize_sim() + + def simulate(self): + """ + Simulates each agent of the population serially. + """ + for agent in self.agents: + agent.simulate() + + def __iter__(self): + """ + Allows for iteration over the agents in the population. + """ + return iter(self.agents) + + def __getitem__(self, idx): + """ + Allows for indexing into the population. + """ + return self.agents[idx] diff --git a/HARK/interpolation.py b/HARK/interpolation.py index 36f2fd638..9896f2696 100644 --- a/HARK/interpolation.py +++ b/HARK/interpolation.py @@ -1230,7 +1230,7 @@ def __init__( _check_grid_dimensions(1, self.y_list, self.x_list) _check_grid_dimensions(1, self.dydx_list, self.x_list) - self.n = len(x_list) + self.n = self.x_list.size self._chs = CubicHermiteSpline( self.x_list, self.y_list, self.dydx_list, extrapolate=None @@ -1239,21 +1239,21 @@ def __init__( # Define lower extrapolation as linear function (or just NaN) if lower_extrap: - temp = np.array([y_list[0], dydx_list[0], 0, 0]) + temp = np.array([self.y_list[0], self.dydx_list[0], 0, 0]) else: temp = np.array([np.nan, np.nan, np.nan, np.nan]) self.coeffs = np.vstack((temp, self.coeffs)) - x1 = x_list[self.n - 1] - y1 = y_list[self.n - 1] + x1 = self.x_list[self.n - 1] + y1 = self.y_list[self.n - 1] # Calculate extrapolation coefficients as a decay toward limiting function y = mx+b if slope_limit is None and intercept_limit is None: - slope_limit = dydx_list[-1] - intercept_limit = y_list[-1] - slope_limit * x_list[-1] + slope_limit = self.dydx_list[-1] + intercept_limit = self.y_list[-1] - slope_limit * self.x_list[-1] gap = slope_limit * x1 + intercept_limit - y1 - slope = slope_limit - dydx_list[self.n - 1] + slope = slope_limit - self.dydx_list[self.n - 1] if (gap != 0) and (slope <= 0): temp = np.array([intercept_limit, slope_limit, gap, slope / gap]) elif slope > 0: diff --git a/HARK/mat_methods.py b/HARK/mat_methods.py new file mode 100644 index 000000000..abe2cb4fd --- /dev/null +++ b/HARK/mat_methods.py @@ -0,0 +1,256 @@ +import numpy as np +from numba import njit +from typing import List + + +@njit +def ravel_index(ind_mat: np.ndarray, dims: np.ndarray) -> np.ndarray: + """ + This function takes a matrix of indices, and a vector of dimensions, and + returns a vector of corresponding flattened indices + """ + # Initialize indices + r_ind = np.zeros(ind_mat.shape[1:], dtype=np.int64) + # Find index multipliers + cdims = np.concatenate((np.cumprod(dims[1:][::-1])[::-1], np.array([1]))) + for i, cdim in enumerate(cdims): + r_ind += ind_mat[i] * cdim + + return r_ind + + +@njit +def multidim_get_lower_index( + points: np.ndarray, grids: List[np.ndarray], dims: np.ndarray +) -> np.ndarray: + """ + Get the lower index for each point in a multidimensional grid. + + Parameters + ---------- + points : np.ndarray + The points for which to find the lower index. + grids : List[np.ndarray] + The grids for each dimension. + dims : np.ndarray + The dimensions of the grids. + + Returns + ------- + np.ndarray + The indices of the lower grid point for each point in each dimension. + """ + inds = np.empty_like(points, dtype=np.int64) + for i, grid in enumerate(grids): + inds[:, i] = np.minimum( + np.searchsorted(grid, points[:, i], side="right") - 1, dims[i] - 2 + ) + + return inds + + +@njit +def fwd_and_bwd_diffs( + points: np.ndarray, grids: List[np.ndarray], inds: np.ndarray +) -> np.ndarray: + """ + Computes backward and forward differences for each point in points for each grid in grids. + + Parameters + ---------- + points : np.ndarray + The points for which to compute the differences. + grids : List[np.ndarray] + The grids for each dimension. + inds : np.ndarray + The indices of the lower grid point for each point in each dimension. + + Returns + ------- + np.ndarray + A (2, ndim, npoints) matrix in which [:,i,:] is the backward and forward difference for the ith dimension. + """ + # Preallocate + diffs = np.empty((2, points.shape[1], points.shape[0])) + + for i, grid in enumerate(grids): + # Backward + diffs[0, i, :] = points[:, i] - grid[inds[i, :]] + # Forward + diffs[1, i, :] = grid[inds[i, :] + 1] - points[:, i] + + return diffs + + +@njit +def sum_weights( + weights: np.ndarray, dims: np.ndarray, add_inds: np.ndarray +) -> np.ndarray: + """ + Sums the weights that correspond to each point in the grid. + + Parameters + ---------- + weights : np.ndarray + The weights to be summed. + dims : np.ndarray + The dimensions of the grid. + add_inds : np.ndarray + The indices of the points in the grid to which the weights correspond. + + Returns + ------- + np.ndarray + The sum of the weights for each point in the grid (flattened). + """ + # Initialize arary to hold weights. + distr = np.zeros(np.prod(dims), dtype=np.float64) + + # Add weights point by point + for i in range(weights.shape[1]): + distr[add_inds[:, i]] += weights[:, i] + + return distr + + +@njit +def denominators(inds: np.ndarray, grids: List[np.ndarray]) -> np.ndarray: + """ + This function computes the denominators of the interpolation weights, + which are the areas of the hypercubes of the grid that contain the points. + + Parameters + ---------- + inds : np.ndarray + The indices of the lower grid point for each point in each dimension. + grids : List[np.ndarray] + The grids for each dimension. + + Returns + ------- + np.ndarray + The denominators of the interpolation weights. + """ + denoms = np.ones(inds.shape[1], dtype=np.float64) + for i, g in enumerate(grids): + d = np.diff(g) + denoms *= d[inds[i, :]] + return denoms + + +@njit +def get_combinations(ndim: int) -> np.ndarray: + """ + Produces an array with all the 2**ndim possible combinations of 0s and 1s. + This is used later to generate all the possible combinations of backward and forward differences. + + Parameters + ---------- + ndim : int + The number of dimensions. + + Returns + ------- + np.ndarray + An array with all the 2**ndim possible combinations of 0s and 1s. + """ + bits = np.zeros((2**ndim, ndim), dtype=np.int64) + for i in range(ndim): + col = (ndim - 1) - i + for j in range(2**ndim): + bits[j, col] = (j >> i) & 1 + return bits + + +@njit +def numerators( + diffs: np.ndarray, comb_inds: np.ndarray, ndims: int, npoints: int +) -> np.ndarray: + """ + Finds the numerators of the interpolation weights, which are the areas of the hypercubes + formed by the points and the grid points that contain them. + + Parameters + ---------- + diffs : np.ndarray + A (2, ndim, npoints) that contains the forward and backward differences of point coordinates. + and the grid points that contain them along every dimension. + comb_inds : np.ndarray + An array with all the 2**ndim possible combinations of 0s and 1s (fwd and bwd differences). + ndims : int + The number of dimensions. + npoints : int + The number of points. + + Returns + ------- + np.ndarray + The numerators of the interpolation weights. + """ + numers = np.ones((2**ndims, npoints), dtype=np.float64) + for i in range(2**ndims): + for d, j in enumerate(comb_inds[i]): + numers[i, :] *= diffs[j, d, :] + + return numers + + +@njit +def mass_to_grid( + points: np.ndarray, mass: np.ndarray, grids: List[np.ndarray] +) -> np.ndarray: + """ + Distributes the mass of a set of R^n points to a rectangular R^n grid, + following the 'lottery' method. + + Parameters + ---------- + points : np.ndarray + shape = (#points, #dims) The points to be distributed. + mass : np.ndarray + shape = (#points) The mass of each point. + grids : List[np.ndarray] + The grids for each dimension. + + Returns + ------- + np.ndarray + The mass of each point in the grid. (flattened). + """ + dims = np.array([len(g) for g in grids]) + ndims = len(grids) + npoints = points.shape[0] + + # Trim points to maximum and minimum of grids + grid_inf_lims = np.expand_dims(np.array([x[0] for x in grids]), 0) + grid_sup_lims = np.expand_dims(np.array([x[-1] for x in grids]), 0) + points = np.clip(points, grid_inf_lims, grid_sup_lims) + + # Find lower indices along every dimension + inds = multidim_get_lower_index(points, grids, dims).T + + # Forward and backward differences + diffs = fwd_and_bwd_diffs(points, grids, inds) + + # Matrix with combinations of forward and backward differencess + comb_inds = get_combinations(len(grids)) + + # Find denominators + numers = numerators(diffs, comb_inds, ndims, npoints) + denoms = denominators(inds, grids) + + # Multiply the ndim differences to find areas + fact = mass / denoms + + # Weights add up to 1 + weights = numers * np.expand_dims(fact, 0) + + # A (ndim, 2**ndim, npoints) matrix in which [:,:,n] nth row has + # the indices where we should add weights[:,n] + add_inds = np.expand_dims(inds, axis=1) + (1 - np.expand_dims(comb_inds.T, -1)) + + # Make indices unidimensional (to not do *inds in multidim matrices with numba) + add_inds = ravel_index(add_inds, dims) + distr = sum_weights(weights, dims, add_inds) + + return distr diff --git a/HARK/metric.py b/HARK/metric.py index d1151058e..3c434d782 100644 --- a/HARK/metric.py +++ b/HARK/metric.py @@ -29,7 +29,7 @@ def distance_dicts(dict_a, dict_b): len_b = len(dict_b) if len_a == len_b: - if set(dict_a.keys()) == set(dict_b.keys()): + if set(dict_a.keys()) != set(dict_b.keys()): warn("Dictionaries with keys that do not match are being compared.") return 1000.0 return np.max( diff --git a/HARK/rewards.py b/HARK/rewards.py index fac0bbf97..f766138bc 100644 --- a/HARK/rewards.py +++ b/HARK/rewards.py @@ -233,7 +233,7 @@ def CRRAutilityP_invP(uP, rho): return (-1.0 / rho) * uP ** (-1.0 / rho - 1.0) -def StoneGearyCRRAutility(c, rho, shifter): +def StoneGearyCRRAutility(c, rho, shifter, factor=1.0): """ Evaluates Stone-Geary version of a constant relative risk aversion (CRRA) utility of consumption c with given risk aversion parameter rho and @@ -263,12 +263,12 @@ def StoneGearyCRRAutility(c, rho, shifter): if np.isscalar(c): c = np.asarray(c) if rho == 1: - return np.log(shifter + c) + return factor * np.log(shifter + c) - return (shifter + c) ** (1.0 - rho) / (1.0 - rho) + return factor * (shifter + c) ** (1.0 - rho) / (1.0 - rho) -def StoneGearyCRRAutilityP(c, rho, shifter): +def StoneGearyCRRAutilityP(c, rho, shifter, factor=1.0): """ Marginal utility of Stone-Geary version of a constant relative risk aversion (CRRA) utility of consumption c wiht given risk aversion parameter rho and @@ -291,10 +291,10 @@ def StoneGearyCRRAutilityP(c, rho, shifter): if np.isscalar(c): c = np.asarray(c) - return (shifter + c) ** (-rho) + return factor * (shifter + c) ** (-rho) -def StoneGearyCRRAutilityPP(c, rho, shifter): +def StoneGearyCRRAutilityPP(c, rho, shifter, factor=1.0): """ Marginal marginal utility of Stone-Geary version of a CRRA utilty function with risk aversion parameter rho and Stone-Geary intercept parameter shifter @@ -316,7 +316,35 @@ def StoneGearyCRRAutilityPP(c, rho, shifter): if np.isscalar(c): c = np.asarray(c) - return (-rho) * (shifter + c) ** (-rho - 1) + return factor * (-rho) * (shifter + c) ** (-rho - 1) + + +def StoneGearyCRRAutility_inv(u, rho, shifter, factor=1.0): + if np.isscalar(u): + u = np.asarray(u) + + return (u * (1.0 - rho) / factor) ** (1.0 / (1.0 - rho)) - shifter + + +def StoneGearyCRRAutilityP_inv(uP, rho, shifter, factor=1.0): + if np.isscalar(uP): + uP = np.asarray(uP) + + return (uP / factor) ** (-1.0 / rho) - shifter + + +def StoneGearyCRRAutility_invP(u, rho, shifter, factor=1.0): + if np.isscalar(u): + u = np.asarray(u) + + return (1.0 / (1.0 - rho)) * (u * (1.0 - rho) / factor) ** (1.0 / (1.0 - rho) - 1.0) + + +def StoneGearyCRRAutilityP_invP(uP, rho, shifter, factor=1.0): + if np.isscalar(uP): + uP = np.asarray(uP) + + return (-1.0 / rho) * (uP / factor) ** (-1.0 / rho - 1.0) def CARAutility(c, alpha): @@ -808,6 +836,39 @@ def derinv(self, u, order=(1, 0)): return self.inverse(u, order) +class UtilityFuncStoneGeary(UtilityFuncCRRA): + def __init__(self, CRRA, factor=1.0, shifter=0.0): + self.CRRA = CRRA + self.factor = factor + self.shifter = shifter + + def __call__(self, c, order=0): + if order == 0: + return StoneGearyCRRAutility(c, self.CRRA, self.shifter, self.factor) + else: # order >= 1 + return self.derivative(c, order) + + def derivative(self, c, order=1): + if order == 1: + return StoneGearyCRRAutilityP(c, self.CRRA, self.shifter, self.factor) + elif order == 2: + return StoneGearyCRRAutilityPP(c, self.CRRA, self.shifter, self.factor) + else: + raise ValueError(f"Derivative of order {order} not supported") + + def inverse(self, u, order=(0, 0)): + if order == (0, 0): + return StoneGearyCRRAutility_inv(u, self.CRRA, self.shifter, self.factor) + elif order == (1, 0): + return StoneGearyCRRAutilityP_inv(u, self.CRRA, self.shifter, self.factor) + elif order == (0, 1): + return StoneGearyCRRAutility_invP(u, self.CRRA, self.shifter, self.factor) + elif order == (1, 1): + return StoneGearyCRRAutilityP_invP(u, self.CRRA, self.shifter, self.factor) + else: + raise ValueError(f"Inverse of order {order} not supported") + + class UtilityFuncCobbDouglas(UtilityFunction): """ A class for representing a Cobb-Douglas utility function. diff --git a/HARK/tests/test_core.py b/HARK/tests/test_core.py index 58846ed02..6b61a80f8 100644 --- a/HARK/tests/test_core.py +++ b/HARK/tests/test_core.py @@ -5,7 +5,11 @@ import numpy as np -from HARK.core import AgentType, distribute_params +from HARK.ConsumptionSaving.ConsIndShockModel import ( + IndShockConsumerType, + init_idiosyncratic_shocks, +) +from HARK.core import AgentPopulation, AgentType, distribute_params from HARK.distribution import Uniform from HARK.metric import MetricObject, distance_metric @@ -18,6 +22,9 @@ def setUp(self): self.obj_a = MetricObject() self.obj_b = MetricObject() self.obj_c = MetricObject() + self.dict_a = {"a": 1, "b": 2} + self.dict_b = {"a": 3, "b": 4} + self.dict_c = {"a": 5, "f": 6} def test_list(self): # same length @@ -42,6 +49,12 @@ def test_array(self): distance_metric(np.array(self.list_b), np.array(self.list_b)), 0.0 ) + def test_dict(self): + # Same keys (max of diffs across keys) + self.assertEqual(distance_metric(self.dict_a, self.dict_b), 2.0) + # Different keys + self.assertEqual(distance_metric(self.dict_a, self.dict_c), 1000.0) + def test_hark_object_distance(self): self.obj_a.distance_criteria = ["var_1", "var_2", "var_3"] self.obj_b.distance_criteria = ["var_1", "var_2", "var_3"] @@ -126,3 +139,32 @@ def test_distribute_params(self): ) ) self.assertEqual(self.agents[0].parameters["AgentCount"], 1) + + +class test_agent_population(unittest.TestCase): + def setUp(self): + params = init_idiosyncratic_shocks.copy() + params["CRRA"] = Uniform(2.0, 10) + params["DiscFac"] = Uniform(0.9, 0.99) + + self.agent_pop = AgentPopulation(IndShockConsumerType, params) + + def test_distributed_params(self): + self.assertTrue("CRRA" in self.agent_pop.distributed_params) + self.assertTrue("DiscFac" in self.agent_pop.distributed_params) + + def test_approx_agents(self): + self.agent_pop.approx_distributions({"CRRA": 3, "DiscFac": 4}) + + self.assertTrue("CRRA" in self.agent_pop.continuous_distributions) + self.assertTrue("DiscFac" in self.agent_pop.continuous_distributions) + self.assertTrue("CRRA" in self.agent_pop.discrete_distributions) + self.assertTrue("DiscFac" in self.agent_pop.discrete_distributions) + + self.assertEqual(self.agent_pop.agent_type_count, 12) + + def test_create_agents(self): + self.agent_pop.approx_distributions({"CRRA": 3, "DiscFac": 4}) + self.agent_pop.create_distributed_agents() + + self.assertEqual(len(self.agent_pop.agents), 12) diff --git a/HARK/tests/test_mat_methods.py b/HARK/tests/test_mat_methods.py new file mode 100644 index 000000000..7e5b84374 --- /dev/null +++ b/HARK/tests/test_mat_methods.py @@ -0,0 +1,87 @@ +import unittest +import numpy as np +from HARK.utilities import jump_to_grid_1D, jump_to_grid_2D +from HARK.mat_methods import mass_to_grid + + +# Compare general mass_to_grid with jump_to_grid_1D +class TestMassToGrid1D(unittest.TestCase): + def setUp(self): + n_grid = 30 + n_points = 1000 + + # Create 1d grid + self.grid = np.linspace(0, 10.0, n_grid) + # Simulate 1d points from a normal distribution + # large variance to ensure some points are outside the grid + self.points = np.random.normal(5, 20, n_points) + # Create weights + self.weights = np.random.uniform(0, 1, n_points) + + def test_compare_jump_to_grid_1d(self): + # Compare mass_to_grid with jump_to_grid_1D + res1 = mass_to_grid(self.points[..., np.newaxis], self.weights, (self.grid,)) + res2 = jump_to_grid_1D(self.points, self.weights, self.grid) + + # Compare results + self.assertTrue(np.allclose(res1, res2)) + + +# Compare general mass_to_grid with jump_to_grid_2D +class TestMassToGrid2D(unittest.TestCase): + def setUp(self): + n_grid = 30 + n_points = 1000 + + # Create 2d grid + self.x_grid = np.linspace(0.0, 10, n_grid) + self.y_grid = np.linspace(0.0, 10, n_grid) + + # Simulate 2d points from a normal distribution + # large variance to ensure some points are outside the grid + mean = np.array([3, 4]) + vcov = np.array([[10.0, -0.5], [-0.5, 3.0]]) + self.points = np.random.multivariate_normal(mean, vcov, n_points) + self.weights = np.repeat(1.3, n_points) + + def test_compare_jump_to_grid_2d(self): + # Compare mass_to_grid with jump_to_grid_2D + res1 = mass_to_grid(self.points, self.weights, (self.x_grid, self.y_grid)) + res2 = jump_to_grid_2D( + self.points[:, 0], self.points[:, 1], self.weights, self.x_grid, self.y_grid + ) + + # Compare results + self.assertTrue(np.allclose(res1, res2)) + + +class Test3DMassToGrid(unittest.TestCase): + def test_simple_3d(self): + # 3d grid of 2 points in each dimension + x_grid = np.array([0.0, 1.0]) + y_grid = np.array([0.0, 1.0]) + z_grid = np.array([0.0, 1.0]) + + # Some points + my_points = np.array( + [ + [0.5, 0.5, 0.5], + [3.0, 3.0, 3.0], + ] + ) + mass = np.array([1.0, 1.0]) + + # Compare results + grid_mass = mass_to_grid(my_points, mass, (x_grid, y_grid, z_grid)) + + grid_mass = grid_mass.reshape((2, 2, 2)) + + # Check the mass on the 8 points + self.assertTrue(grid_mass[0, 0, 0] == 1 / 8) + self.assertTrue(grid_mass[0, 0, 1] == 1 / 8) + self.assertTrue(grid_mass[0, 1, 0] == 1 / 8) + self.assertTrue(grid_mass[0, 1, 1] == 1 / 8) + self.assertTrue(grid_mass[1, 0, 0] == 1 / 8) + self.assertTrue(grid_mass[1, 0, 1] == 1 / 8) + self.assertTrue(grid_mass[1, 1, 0] == 1 / 8) + self.assertTrue(grid_mass[1, 1, 1] == (1 / 8 + 1.0)) diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index 36fe6d79b..000000000 --- a/MANIFEST.in +++ /dev/null @@ -1,19 +0,0 @@ -# Include the README, CHANGES, and CONTRIBUTING files -include *.md - -# Include the license file -include LICENSE - -# include everything in the root -include requirements.txt -include setup.py -include MANIFEST.in -include setup.cfg - -# include data files -recursive-include HARK/datasets/data *.txt -recursive-include HARK/datasets *.csv - -# except build files -global-exclude *.pyc -global-exclude *.*~ diff --git a/environment.yml b/environment.yml deleted file mode 100644 index 3d3a0f4d9..000000000 --- a/environment.yml +++ /dev/null @@ -1,19 +0,0 @@ -name: hark-dev -channels: - - conda-forge - - defaults -dependencies: - - estimagic - - interpolation>=2.2.3 - - joblib>=1.2 - - jupyterlab>=3.6 - - jupytext>=1.14 - - matplotlib>=3.6 - - networkx>=3 - - numba>=0.56 - - numpy>=1.23 - - pandas>=1.5 - - quantecon - - scipy>=1.10 - - seaborn>=0.12 - - xarray>=2023 diff --git a/examples/Calibration/Income_calibrations.ipynb b/examples/Calibration/Income_calibrations.ipynb new file mode 100644 index 000000000..e1ef6d5f2 --- /dev/null +++ b/examples/Calibration/Income_calibrations.ipynb @@ -0,0 +1,178 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1cf57cc2", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:28:08.411520Z", + "iopub.status.busy": "2023-03-16T17:28:08.410520Z", + "iopub.status.idle": "2023-03-16T17:28:09.968079Z", + "shell.execute_reply": "2023-03-16T17:28:09.967574Z" + } + }, + "outputs": [], + "source": [ + "\"\"\"\n", + "Created on Sun Jan 3 10:50:02 2021\n", + "\n", + "@author: Mateo\n", + "\"\"\"\n", + "\n", + "from HARK.Calibration.Income.IncomeTools import (\n", + " parse_income_spec,\n", + " find_profile,\n", + " Cagetti_income,\n", + " CGM_income,\n", + ")\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# What year to use as the base monetary year?\n", + "# (pick 1992 as it is used by both of the papers we are comparing)\n", + "adjust_infl_to = 1992" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8a2b66ca", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:28:09.970087Z", + "iopub.status.busy": "2023-03-16T17:28:09.970087Z", + "iopub.status.idle": "2023-03-16T17:28:10.154905Z", + "shell.execute_reply": "2023-03-16T17:28:10.154905Z" + }, + "title": "Cocco, Gomes, Maenhout (2005) calibration" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "age_min = 21\n", + "age_max = 100\n", + "\n", + "ages = np.arange(age_min, age_max + 1)\n", + "\n", + "plt.figure()\n", + "for spec in CGM_income.items():\n", + " label = spec[0]\n", + "\n", + " params = parse_income_spec(\n", + " age_min=age_min, age_max=age_max, adjust_infl_to=adjust_infl_to, **spec[1]\n", + " )\n", + " MeanY = find_profile(params[\"PermGroFac\"], params[\"P0\"])\n", + "\n", + " plt.plot(ages, MeanY, label=label)\n", + "\n", + "plt.title(\n", + " \"Mean paths of permanent income calibrations in\\n\"\n", + " + \"Cocco, Gomes & Maenhout (2005)\"\n", + ")\n", + "plt.xlabel(\"Age\")\n", + "plt.ylabel(\n", + " \"Mean Permanent Income,\\n\" + \"Thousands of {} U.S. dollars\".format(adjust_infl_to)\n", + ")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "934dda85", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:28:10.157911Z", + "iopub.status.busy": "2023-03-16T17:28:10.157407Z", + "iopub.status.idle": "2023-03-16T17:28:10.312173Z", + "shell.execute_reply": "2023-03-16T17:28:10.312173Z" + }, + "title": "Cagetti (2003) calibration" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "age_min = 25\n", + "age_max = 91\n", + "# Cagetti has a year trend in his specification, so we have to say on what\n", + "# year agents enter the model.\n", + "start_year = 1980\n", + "\n", + "ages = np.arange(age_min, age_max + 1)\n", + "\n", + "plt.figure()\n", + "for spec in Cagetti_income.items():\n", + " label = spec[0]\n", + "\n", + " params = parse_income_spec(\n", + " age_min=age_min,\n", + " age_max=age_max,\n", + " adjust_infl_to=adjust_infl_to,\n", + " start_year=start_year,\n", + " **spec[1]\n", + " )\n", + " MeanY = find_profile(params[\"PermGroFac\"], params[\"P0\"])\n", + "\n", + " plt.plot(ages, MeanY, label=label)\n", + "\n", + "plt.title(\"Mean paths of permanent income calibrations in\\n\" + \"Cagetti (2003)\")\n", + "plt.xlabel(\"Age\")\n", + "plt.ylabel(\n", + " \"Mean Permanent Income,\\n\" + \"Thousands of {} U.S. dollars\".format(adjust_infl_to)\n", + ")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "title,-all", + "encoding": "# -*- coding: utf-8 -*-", + "formats": "ipynb,py:percent" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/Calibration/Income_calibrations.py b/examples/Calibration/Income_calibrations.py index 6c90b698c..34ab06b9f 100644 --- a/examples/Calibration/Income_calibrations.py +++ b/examples/Calibration/Income_calibrations.py @@ -1,4 +1,21 @@ # -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# cell_metadata_filter: title,-all +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.14.5 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% """ Created on Sun Jan 3 10:50:02 2021 @@ -27,7 +44,6 @@ plt.figure() for spec in CGM_income.items(): - label = spec[0] params = parse_income_spec( @@ -60,7 +76,6 @@ plt.figure() for spec in Cagetti_income.items(): - label = spec[0] params = parse_income_spec( diff --git a/examples/Calibration/Life_Cycle_example.ipynb b/examples/Calibration/Life_Cycle_example.ipynb index 3da13f460..f208b69f3 100644 --- a/examples/Calibration/Life_Cycle_example.ipynb +++ b/examples/Calibration/Life_Cycle_example.ipynb @@ -6,10 +6,10 @@ "id": "19c5f531", "metadata": { "execution": { - "iopub.execute_input": "2023-02-07T00:33:16.266083Z", - "iopub.status.busy": "2023-02-07T00:33:16.266083Z", - "iopub.status.idle": "2023-02-07T00:33:17.980038Z", - "shell.execute_reply": "2023-02-07T00:33:17.979037Z" + "iopub.execute_input": "2023-03-20T20:26:25.537828Z", + "iopub.status.busy": "2023-03-20T20:26:25.537828Z", + "iopub.status.idle": "2023-03-20T20:26:27.373377Z", + "shell.execute_reply": "2023-03-20T20:26:27.373377Z" } }, "outputs": [], @@ -29,7 +29,8 @@ "from HARK.datasets.SCF.WealthIncomeDist.SCFDistTools import income_wealth_dists_from_scf\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", - "from copy import copy" + "from copy import copy\n", + "from HARK.utilities import plot_funcs" ] }, { @@ -38,10 +39,10 @@ "id": "8a2d828c", "metadata": { "execution": { - "iopub.execute_input": "2023-02-07T00:33:17.982547Z", - "iopub.status.busy": "2023-02-07T00:33:17.981542Z", - "iopub.status.idle": "2023-02-07T00:33:18.025698Z", - "shell.execute_reply": "2023-02-07T00:33:18.025698Z" + "iopub.execute_input": "2023-03-20T20:26:27.377400Z", + "iopub.status.busy": "2023-03-20T20:26:27.376394Z", + "iopub.status.idle": "2023-03-20T20:26:27.436705Z", + "shell.execute_reply": "2023-03-20T20:26:27.436462Z" }, "title": "Alter calibration" }, @@ -90,10 +91,10 @@ "id": "fbfff075", "metadata": { "execution": { - "iopub.execute_input": "2023-02-07T00:33:18.029215Z", - "iopub.status.busy": "2023-02-07T00:33:18.029215Z", - "iopub.status.idle": "2023-02-07T00:33:18.445386Z", - "shell.execute_reply": "2023-02-07T00:33:18.445386Z" + "iopub.execute_input": "2023-03-20T20:26:27.440705Z", + "iopub.status.busy": "2023-03-20T20:26:27.440705Z", + "iopub.status.idle": "2023-03-20T20:26:27.845883Z", + "shell.execute_reply": "2023-03-20T20:26:27.845883Z" }, "title": "Create and solve agent" }, @@ -106,13 +107,51 @@ { "cell_type": "code", "execution_count": 4, + "id": "17ba6fbf", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T20:26:27.848786Z", + "iopub.status.busy": "2023-03-20T20:26:27.848786Z", + "iopub.status.idle": "2023-03-20T20:26:28.129778Z", + "shell.execute_reply": "2023-03-20T20:26:28.129778Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Agent.unpack(\"cFunc\")\n", + "# Plot the consumption functions\n", + "print(\"Consumption functions\")\n", + "plot_funcs(Agent.cFunc, 0, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "id": "a16b7032", "metadata": { "execution": { - "iopub.execute_input": "2023-02-07T00:33:18.447889Z", - "iopub.status.busy": "2023-02-07T00:33:18.447889Z", - "iopub.status.idle": "2023-02-07T00:33:20.468930Z", - "shell.execute_reply": "2023-02-07T00:33:20.468930Z" + "iopub.execute_input": "2023-03-20T20:26:28.132779Z", + "iopub.status.busy": "2023-03-20T20:26:28.132779Z", + "iopub.status.idle": "2023-03-20T20:26:30.219758Z", + "shell.execute_reply": "2023-03-20T20:26:30.219758Z" }, "title": "Simulation" }, @@ -181,7 +220,7 @@ " 9.46119676, 17.64418495]])}" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -201,14 +240,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "7c7979ec", "metadata": { "execution": { - "iopub.execute_input": "2023-02-07T00:33:20.471440Z", - "iopub.status.busy": "2023-02-07T00:33:20.471440Z", - "iopub.status.idle": "2023-02-07T00:33:20.484486Z", - "shell.execute_reply": "2023-02-07T00:33:20.484486Z" + "iopub.execute_input": "2023-03-20T20:26:30.221759Z", + "iopub.status.busy": "2023-03-20T20:26:30.221759Z", + "iopub.status.idle": "2023-03-20T20:26:30.235789Z", + "shell.execute_reply": "2023-03-20T20:26:30.235284Z" }, "title": "Extract and format simulation results" }, @@ -228,21 +267,21 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "1d8269db", "metadata": { "execution": { - "iopub.execute_input": "2023-02-07T00:33:20.486485Z", - "iopub.status.busy": "2023-02-07T00:33:20.486485Z", - "iopub.status.idle": "2023-02-07T00:33:20.748839Z", - "shell.execute_reply": "2023-02-07T00:33:20.748839Z" + "iopub.execute_input": "2023-03-20T20:26:30.237800Z", + "iopub.status.busy": "2023-03-20T20:26:30.237800Z", + "iopub.status.idle": "2023-03-20T20:26:30.433688Z", + "shell.execute_reply": "2023-03-20T20:26:30.433688Z" }, "title": "Plots" }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/examples/Calibration/Life_Cycle_example.py b/examples/Calibration/Life_Cycle_example.py index 729417108..d0dc93130 100644 --- a/examples/Calibration/Life_Cycle_example.py +++ b/examples/Calibration/Life_Cycle_example.py @@ -6,7 +6,7 @@ # extension: .py # format_name: percent # format_version: '1.3' -# jupytext_version: 1.14.4 +# jupytext_version: 1.14.5 # kernelspec: # display_name: Python 3 (ipykernel) # language: python @@ -30,6 +30,7 @@ import matplotlib.pyplot as plt import pandas as pd from copy import copy +from HARK.utilities import plot_funcs # %% Alter calibration birth_age = 25 @@ -72,6 +73,12 @@ Agent = IndShockConsumerType(**params) Agent.solve() +# %% +Agent.unpack("cFunc") +# Plot the consumption functions +print("Consumption functions") +plot_funcs(Agent.cFunc, 0, 5) + # %% Simulation # Number of agents and periods in the simulation. Agent.AgentCount = 500 diff --git a/examples/Calibration/SCF_distributions.ipynb b/examples/Calibration/SCF_distributions.ipynb new file mode 100644 index 000000000..be0c9457f --- /dev/null +++ b/examples/Calibration/SCF_distributions.ipynb @@ -0,0 +1,138 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6ed24ac4", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:28:21.782036Z", + "iopub.status.busy": "2023-03-16T17:28:21.782036Z", + "iopub.status.idle": "2023-03-16T17:28:23.389921Z", + "shell.execute_reply": "2023-03-16T17:28:23.389921Z" + } + }, + "outputs": [], + "source": [ + "\"\"\"\n", + "Created on Mon Jan 18 13:57:50 2021\n", + "\n", + "@author: Mateo\n", + "\"\"\"\n", + "\n", + "from HARK.datasets.SCF.WealthIncomeDist.SCFDistTools import income_wealth_dists_from_scf\n", + "import seaborn as sns\n", + "from itertools import product, starmap\n", + "import pandas as pd\n", + "\n", + "# List the education levels and years\n", + "educ_lvls = [\"NoHS\", \"HS\", \"College\"]\n", + "years = list(range(1995, 2022, 3))\n", + "\n", + "age = 25\n", + "base_year = 1992" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "126e70de", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:28:23.392923Z", + "iopub.status.busy": "2023-03-16T17:28:23.391921Z", + "iopub.status.idle": "2023-03-16T17:28:23.562887Z", + "shell.execute_reply": "2023-03-16T17:28:23.562887Z" + }, + "title": "Get the distribution of aNrm and pLvl at each year x education" + }, + "outputs": [], + "source": [ + "params = list(product([base_year], [age], educ_lvls, years))\n", + "base_year, age, education, year = list(zip(*params))\n", + "\n", + "frame = pd.DataFrame(\n", + " {\"base_year\": base_year, \"age\": age, \"education\": education, \"wave\": year}\n", + ")\n", + "\n", + "results = list(starmap(income_wealth_dists_from_scf, params))\n", + "frame = pd.concat([frame, pd.DataFrame(results)], axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f9a37ca2", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:28:23.565891Z", + "iopub.status.busy": "2023-03-16T17:28:23.565891Z", + "iopub.status.idle": "2023-03-16T17:28:24.670183Z", + "shell.execute_reply": "2023-03-16T17:28:24.670183Z" + }, + "title": "Plot time trends at different education levels." + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Formatting\n", + "frame = frame.melt(id_vars=[\"base_year\", \"age\", \"education\", \"wave\"])\n", + "aux = frame[\"variable\"].str.split(\"(Mean|Std)\", n=1, expand=True)\n", + "frame[\"variable\"] = aux[0]\n", + "frame[\"stat\"] = aux[1]\n", + "\n", + "# Plot\n", + "g = sns.FacetGrid(frame, col=\"stat\", row=\"variable\", hue=\"education\", sharey=True)\n", + "g.map(sns.scatterplot, \"wave\", \"value\", alpha=0.7)\n", + "g.add_legend()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "title,-all", + "encoding": "# -*- coding: utf-8 -*-", + "formats": "ipynb,py:percent" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/Calibration/SCF_distributions.py b/examples/Calibration/SCF_distributions.py index a14c82eeb..5fef14250 100644 --- a/examples/Calibration/SCF_distributions.py +++ b/examples/Calibration/SCF_distributions.py @@ -1,4 +1,21 @@ # -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# cell_metadata_filter: title,-all +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.14.5 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% """ Created on Mon Jan 18 13:57:50 2021 diff --git a/examples/Calibration/Sabelhaus_Song_var_profiles.ipynb b/examples/Calibration/Sabelhaus_Song_var_profiles.ipynb new file mode 100644 index 000000000..fc6a5f2a3 --- /dev/null +++ b/examples/Calibration/Sabelhaus_Song_var_profiles.ipynb @@ -0,0 +1,146 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f6d16a7c", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:28:18.171737Z", + "iopub.status.busy": "2023-03-16T17:28:18.171737Z", + "iopub.status.idle": "2023-03-16T17:28:19.738534Z", + "shell.execute_reply": "2023-03-16T17:28:19.738028Z" + } + }, + "outputs": [], + "source": [ + "\"\"\"\n", + "Created on Thu Jan 14 16:44:09 2021\n", + "\n", + "@author: Mateo\n", + "\n", + "This short script demonstrates how to use the module for computing\n", + "[1] Sabelhaus & Song (2010) age profiles of income volatility.\n", + "It does so by replicating the results from the original paper (Figure 6 in [1])\n", + "\n", + "[1] Sabelhaus, J., & Song, J. (2010). The great moderation in micro labor\n", + " earnings. Journal of Monetary Economics, 57(4), 391-403.\n", + "\n", + "\"\"\"\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from HARK.Calibration.Income.IncomeTools import sabelhaus_song_var_profile\n", + "import numpy as np\n", + "\n", + "# Set up ages and cohorts at which we will get the variances\n", + "age_min = 27\n", + "age_max = 54\n", + "cohorts = [1940, 1965, None]\n", + "\n", + "# Find volatility profiles using the module\n", + "variances = [\n", + " sabelhaus_song_var_profile(age_min=age_min, age_max=age_max, cohort=c)\n", + " for c in cohorts\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2a399fc2", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:28:19.740540Z", + "iopub.status.busy": "2023-03-16T17:28:19.740540Z", + "iopub.status.idle": "2023-03-16T17:28:20.033913Z", + "shell.execute_reply": "2023-03-16T17:28:20.033913Z" + }, + "title": "Plots" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACHqElEQVR4nOzdd3hT1R/H8XeSNt2L0QGUtuyyoQzLEJBRWTJkyN5QQFmCgIgKPxWR6WKILJlliwhIQTZlFcosu1BGSymjk67k/v6IRCsFKZSm4/t6njztvbm595so5MM5556jUhRFQQghhBAil1CbugAhhBBCiMyQ8CKEEEKIXEXCixBCCCFyFQkvQgghhMhVJLwIIYQQIleR8CKEEEKIXEXCixBCCCFyFQkvQgghhMhVzExdQFbR6/XcuXMHOzs7VCqVqcsRQgghxAtQFIW4uDiKFCmCWv1ibSp5JrzcuXMHd3d3U5chhBBCiJdw8+ZNihUr9kLH5pnwYmdnBxjevL29vYmrEUIIIcSLiI2Nxd3d3fg9/iLyTHh50lVkb28v4UUIIYTIZTIz5OOlBuzOmTMHLy8vLC0t8fHxYf/+/c88NiIigq5du1K2bFnUajUjRox47rlXr16NSqWibdu2L1OaEEIIIfK4TIeXgIAARowYwYQJEzh58iT169enefPmhIeHZ3h8cnIyhQsXZsKECVSpUuW5575x4wajR4+mfv36mS1LCCGEEPlEpsPLzJkz6devH/3798fb25vZs2fj7u7O3LlzMzze09OTb7/9lp49e+Lg4PDM8+p0Orp168akSZMoUaJEZssSQgghRD6RqTEvKSkpBAcHM27cuHT7mzVrxqFDh16pkMmTJ1O4cGH69ev33G6oJ5KTk0lOTjZux8bGvtL1hRDieRRFIS0tDZ1OZ+pShMhVNBoNZmZmWTqNSabCS3R0NDqdDhcXl3T7XVxciIyMfOkiDh48yMKFCwkJCXnh10yZMoVJkya99DWFEOJFpaSkEBERQWJioqlLESJXsra2xs3NDa1WmyXne6m7jf6dnhRFeelEFRcXR/fu3VmwYAGFChV64deNHz+eUaNGGbef3GolhBBZSa/XExYWhkajoUiRImi1WpkIU4gXpCgKKSkp3Lt3j7CwMEqXLv3CE9E9T6bCS6FChdBoNE+1skRFRT3VGvOirl69yvXr12ndurVxn16vNxRnZsbFixcpWbLkU6+zsLDAwsLipa4phBAvKiUlBb1ej7u7O9bW1qYuR4hcx8rKCnNzc27cuEFKSgqWlpavfM5MxR+tVouPjw+BgYHp9gcGBlKnTp2XKqBcuXKcOXOGkJAQ4+Odd96hUaNGhISESGuKECJHyIp/LQqRX2X1n59MdxuNGjWKHj16UKNGDXx9ffnpp58IDw/H398fMHTn3L59m19++cX4midjWeLj47l37x4hISFotVrKly+PpaUlFStWTHcNR0dHgKf2CyGEEEJkOrx07tyZ+/fvM3nyZCIiIqhYsSJbt27Fw8MDMExK9+85X6pVq2b8PTg4mJUrV+Lh4cH169dfrXohhBBC5DsqRVEUUxeRFWJjY3FwcCAmJkaWBxBCZJmkpCTCwsKMs4oL8V/27NlDo0aNePjwobEnIb973p+jl/n+lk5cIYTIg1Qq1XMfvXv3Nml9w4cPx8fHBwsLC6pWrZrhMWvWrKFq1apYW1vj4eHBtGnTnnm+gwcPYmZmluG51q9fT/ny5bGwsKB8+fJs3Lgxi95F9tuzZw8qlYpHjx6ZuhSTyjMLM4qXk6rTk5isIyEljcSUNBKe/P7Xz4RknXF/YkoaekXBWmuGjYUm/U+tGdYWGsNPrQYbC8NzWo1abisVwgQiIiKMvwcEBPDpp59y8eJF4z4rK6t0x6empmJubp5t9SmKQt++fTly5AinT59+6vlt27bRrVs3vv/+e5o1a0ZoaCj9+/fHysqK999/P92xMTEx9OzZk8aNG3P37t10zwUFBdG5c2f+97//0a5dOzZu3EinTp04cOAAtWvXfq3vMaulpqaauoQcQ8JLHvUoMYWw6ATCohO4Hp3AtegEbj96TELyPwJJio6UNP1rrcNMrTKGmSc/ne0s8ShojUdBa4oXsMajoA3FnKww10hDoMgdFEXhcappZtq1Mte80D8IXF1djb87ODigUqmM+65fv46bmxsBAQHMmTOHw4cPM3fuXN555x3ef/999u/fz4MHDyhZsiQff/wxXbp0MZ6rYcOGVK5cGUtLS37++We0Wi3+/v58/vnnmXof3333HQD37t3LMLwsW7aMtm3bGm8GKVGiBGPHjmXq1KkMHTo03WcwaNAgunbtikajYdOmTenOM3v2bJo2bcr48eMBw00le/fuZfbs2axateqZ9R08eJCPP/6YY8eOYWFhQa1atVi9ejVOTk4kJyczZswYVq9eTWxsLDVq1GDWrFnUrFkz3TmCg4MZO3Ys58+fp2rVqixevJiyZcsan587dy7Tp0/n5s2beHl58cknn9CjRw/j8yqVirlz57Jt2zZ27txJhw4djDfDODk5AdCrVy+WLFnyXx93niPhJRdLSE7j+n1DQAm7l0DY/b/DysPEzCV0rUadYcuJoVVFg7WF4adKpSLxHy0ziSk6EpL/+vmP/UmphlCUpleITUojNintH1eLeer6GrWKIo6WeBSwoXhBazwKPAk3NngUtMbGQv5XFTnH41Qd5T/9wyTXPj/ZD2tt1vx5GDt2LDNmzGDx4sVYWFiQlJSEj48PY8eOxd7ent9//50ePXpQokSJdK0US5cuZdSoURw5coSgoCB69+5N3bp1adq0aZbUBYYlYP49r46VlRW3bt3ixo0beHp6ArB48WKuXr3K8uXL+eKLL546T1BQECNHjky3z8/Pj9mzZz/z2iEhITRu3Ji+ffvy3XffYWZmxu7du41LQ3z00UesX7+epUuX4uHhwTfffIOfnx9XrlyhQIECxvNMmDCBGTNmULhwYfz9/enbty8HDx4EYOPGjQwfPpzZs2fTpEkTtmzZQp8+fShWrBiNGjUynuOzzz5jypQpzJo1C41GQ5s2bXj33Xe5ePEi9vb2T7Wg5RfyjZALPEpMIfjGQ65ExXP9fgLX7iVw/X4Cd2OTn/s6V3tLvArZ4FnIhhKFbHAvYIW9pbkxiFhbmGGrNcNKq0FrlrWtHjq9Ygg5/ww3yWnEJ6dx59FjbtxP5MaDRMLvJ3LjQQJJqXpuPnjMzQeP4crT5ytkq8WjoM1focaGysUcqFbcEUfrrJlqWoj8aMSIEbRv3z7dvtGjRxt//+CDD9i+fTtr165NF14qV67MZ599BkDp0qX54Ycf2LVrV5aGFz8/P0aOHEnv3r1p1KgRV65cMQaOiIgIPD09uXz5MuPGjWP//v2YmWX8dRYZGZnpJW2++eYbatSowZw5c4z7KlSoAEBCQgJz585lyZIlNG/eHIAFCxYQGBjIwoULGTNmjPE1X375JQ0aNABg3LhxtGzZkqSkJCwtLZk+fTq9e/dmyJAhgGEaksOHDzN9+vR04aVr16707dvXuB0WFgaAs7Nzvh4MLOElB3qUmMKRsAccvnafw9cecCEylmfdE1bQRotnIRu8/vHwLGiDZyHrLPvX2cvQqFXYWZpjZ/nffeiKonAvLpnr9xO5cT+B8AeJ/wg3hlak6PgUouMNIe6fShS2oXpxJ8PDw5HSznZo1DLGRrxeVuYazk/2M9m1s0qNGjXSbet0Or7++msCAgK4ffu2cQFcGxubdMdVrlw53babmxtRUVFZVhfAgAEDuHr1Kq1atSI1NRV7e3uGDx/O559/jkajQafT0bVrVyZNmkSZMmWee67MLmkTEhJCx44dM3zu6tWrpKamUrduXeM+c3NzatWqRWhoaLpj//k5ubm5AYYZ6YsXL05oaCgDBw5Md3zdunX59ttv0+37938jYSDhJQd4lJjC0bAHHL5mCCyhGYSVUs62lHezN7aiPGlRcbDKvgF2r4tKpcLZ3hJne0tqeRV46vnYpFRDC81frTRXouIJCX/EtWhDK9S1ewmsC74FgK2FGVXcHYyBRlpnxOugUqlM+o+DrPLvUDJjxgxmzZrF7NmzqVSpEjY2NowYMYKUlJR0x/17YK9KpTIu65JVVCoVU6dO5auvviIyMpLChQuza9cuADw9PYmLi+P48eOcPHnSOIBXr9ejKApmZmbs2LGDt956C1dX10wvafO8rpgns4u8SCD65+f05Ll/fk4vco5//zcSBrn/T18uFJOYypGw+/8ZVt4oUYA3ShSktldBCtvl33Wc7C3NqVjUgYpFHdLtf5iQwsmbDzlx4xEnwh9y6uYj4pPTOHjlPgev3Dce96R1plpxR6oXd6KMi7TOCJGR/fv306ZNG7p37w4YvmgvX76Mt7e3yWrSaDQULVoUgFWrVuHr64uzszN6vZ4zZ86kO3bOnDn8+eefrFu3Di8vLwB8fX0JDAxMN+5lx44dz13SpnLlyuzatYtJkyY99VypUqXQarUcOHCArl27Aoa7gI4fP86IESNe+H15e3tz4MABevbsadx36NCh//ysn6zK/GT8TX4l4SUbxCalcuTak26g+5yPkLCSFZxstLxVzoW3yhn+BaXTK1yMjONE+ENOhD98butMteKONC7nTGNvF9wLyGJ7QoDhi3n9+vUcOnQIJycnZs6cSWRkZKbDS8+ePSlatChTpkx55jFXrlwhPj6eyMhIHj9+bFxGpnz58mi1WqKjo1m3bh0NGzYkKSmJxYsXs3btWvbu3QsY1sr59xIyzs7OTy05M3z4cN58802mTp1KmzZt+PXXX9m5cycHDhx4Zm3jx4+nUqVKDBkyBH9/f7RaLbt376Zjx44UKlSIwYMHM2bMGAoUKEDx4sX55ptvSExMpF+/fi/8GY0ZM4ZOnTpRvXp1GjduzG+//caGDRvYuXPnc1/n4eGBSqViy5YttGjRAisrK2xtbV/4unmFhJfXJDlNx+4L99h08jZ/XogiRZe+SbVkYRveKFHQEFZKFMDZTmbufFUatYryRewpX8Se7m8Ylqt4VuvM/svR7L8czee/naecqx1NvF1o7O1MlWKOqKVVRuRTEydOJCwsDD8/P6ytrRk4cCBt27YlJubpOwSfJzw8/D8X4uvfv78xiMDfy8iEhYUZ7yRaunQpo0ePRlEUfH192bNnD7Vq1cpULXXq1GH16tV88sknTJw4kZIlSxIQEPDcOV7KlCnDjh07+Pjjj6lVqxZWVlbUrl3beMv4119/jV6vp0ePHsTFxVGjRg3++OMP4+3LL6Jt27Z8++23TJs2jWHDhuHl5cXixYtp2LDhc19XtGhRJk2axLhx4+jTpw89e/bMl7dKy/IAWUivVzh2/QGbQm7z++mIdLcHexWywbdkQXwlrJjUk9aZA1fusTM0iuPXH6D/x5+AQrYWNC7nTJPyLtQrVQgrbdYNjhS5kywPIMSry+rlAaTlJQtcvhvHxpO3+TXkDrcfPTbud7W3pE21IrStWhRvN1lvKSf4Z+vMwDdL8jAhhT2Xoth5Poq9l+4RHZ9MwPGbBBy/iYWZmnqlCtGkvAuNyznjbC9fXEIIkRNIeHlJd2OT2Bxyh00htzl3J9a4387CjOaVXGlbrSi1vQrKwNAczslGS7tqxWhXrRgpaXqOhN1n5/m77AyN4vajx+y6EMWuC4ZbQKsUc6CxtwtNvF3wdrOTZQ+EEMJEpNsoE+KSUvnj3F02nbzNwavRxkG35hoVDcs607ZqURp7O2OZhfMwCNNQFIWLd+PYef4ugaFRnLr5KN3zRR2teLuiKx1rFKOcq7Sq5WXSbSTEq5Nuo2yWqtOz79I9NoXcIfB8pHHae4AaHk60rVaUlpXccLKRuUTyEpVKRTlXe8q52vP+W6WJik3izwtR7AyN4sCVe9x+9JiFB8JYeCCMSkUd6FijGO9UKSJzygghRDaQ8PIcer3CWzP2GKas/0uJwja0q1qUNlWLUryg3GKbXzjbW/JereK8V6s4Sak69l26x4YTt9l14S5nbsdw5nYMX2wJpWkFFzr6FKN+6cLSZSiEEK+JhJfnUKtV1PIsyOOUe7Su4ka7akWpVNRBxjrkc5bmGppVcKVZBVceJKSw6eRt1gbfIjQilt9PR/D76Qhc7S1pX70oHXyKUaJw/puDQQghXicZ8/IfHiWmYGthhpkmaxcuFHnP2dsxrAu+xaaQ2zz6x6reNTyc6FijGC0rF8FWVsfOdWTMixCvLqvHvEh4ESKLJafp2BUaxdrjN9l76Z5xHhkrcw3NK7nS0ced2l4FZDK8XELCixCvTgbsCpHDWZhpaFHJjRaV3Lgbm8SGE7dZG3yTa/cS2HDiNhtO3Ma9gBUdqrvzXi13XGT+GCHylD179tCoUSMePnyIo6OjqcvJk6QvRIjXyMXeksENS7JrVAPWD65Dl1ru2FqYcfPBY2btvES9qX/y4ZpTXIiM/e+TCZEJKpXquY/evXubtL7hw4fj4+ODhYUFVatWzfCYNWvWULVqVaytrfHw8GDatGlPHZOcnMyECRPw8PDAwsKCkiVLsmjRIuPzS5YsyfD9JyUlva639lrt2bMHlUrFo0ePTF2KSUnLixDZQKVS4ePhhI+HE5+2qsD2cxGsPBLOsesPWX/iFutP3KJ+6UIMqF+C+qULyaBw8coiIiKMvwcEBPDpp59y8eJF4z4rK6t0x6empmJubp5t9SmKQt++fTly5AinT59+6vlt27bRrVs3vv/+e5o1a0ZoaCj9+/fHysqK999/33hcp06duHv3LgsXLqRUqVJERUWRlpaW7lz29vbp3juQK7sAU1NT//ugfEJaXoTIZlZaDe2qFWOtfx02DqlDy0puqFWw/3I0PRcdpfm3+1kXfIuUNP1/n0yIZ3B1dTU+HBwMd0k+2U5KSsLR0ZE1a9bQsGFDLC0tWb58Offv36dLly4UK1YMa2trKlWqxKpVq9Kdt2HDhgwbNoyPPvqIAgUK4Orqyueff57p+r777juGDh1KiRIlMnx+2bJltG3bFn9/f0qUKEHLli0ZO3YsU6dO5clQze3bt7N37162bt1KkyZN8PT0pFatWtSpUyfduf753p88/svBgwdp0KAB1tbWODk54efnx8OHDwFDa8+wYcOMq1jXq1ePY8eOPXWO4OBgatSogbW1NXXq1HkqQM2dO5eSJUui1WopW7Ysy5Yte6ruefPm0aZNG2xsbOjfvz+NGjUCwMnJKUe0oJmKhBchTKhacSd+7FadvWMa0aeuJ9ZaDRci4xi99hT1pv7Jj7uvEJMo/9rKcRQFUhJM88jCeyzGjh3LsGHDCA0Nxc/Pj6SkJHx8fNiyZQtnz55l4MCB9OjRgyNHjqR73dKlS7GxseHIkSN88803TJ48mcDAwCyrCwwB4d+tI1ZWVty6dYsbN24AsHnzZmrUqME333xD0aJFKVOmDKNHj+bx48fpXhcfH4+HhwfFihWjVatWnDx58rnXDgkJoXHjxlSoUIGgoCAOHDhA69at0el0AHz00UesX7+epUuXcuLECUqVKoWfnx8PHjxId54JEyYwY8YMjh8/jpmZGX379jU+t3HjRoYPH86HH37I2bNnGTRoEH369GH37t3pzvHZZ5/Rpk0bzpw5w+TJk1m/fj0AFy9eJCIigm+//TYTn2reId1GQuQA7gWs+ax1BUY0LsPKo+EsORTG3dhkpv1xkR93X6FTDXf61vWSiRFzitRE+KqIaa798R3Q2mTJqUaMGEH79u3T7Rs9erTx9w8++IDt27ezdu1aateubdxfuXJlPvvsMwBKly7NDz/8wK5du2jatGmW1AXg5+fHyJEj6d27N40aNeLKlSvMnj0bMHSJeXp6cu3aNQ4cOIClpSUbN24kOjqaIUOG8ODBA+O4l3LlyrFkyRIqVapEbGws3377LXXr1uXUqVOULl06w2t/88031KhRgzlz5hj3VahQAYCEhATmzp3LkiVLaN68OQALFiwgMDCQhQsXMmbMGONrvvzySxo0aADAuHHjaNmyJUlJSVhaWjJ9+nR69+7NkCFDABg1ahSHDx9m+vTpxtYVgK5du6YLPWFhYQA4Ozvn68HA0vIiRA7iYG3O4IYl2f/RW8zsVAVvN3sSU3QsOXSdhtN3M3h5MCfCH5q6TJFH1KhRI922Tqfjyy+/pHLlyhQsWBBbW1t27NhBeHh4uuMqV66cbtvNzY2oqKgsrW3AgAG8//77tGrVCq1WyxtvvMF7770HgEZjWD9Or9ejUqlYsWIFtWrVokWLFsycOZMlS5YYW1/eeOMNunfvTpUqVahfvz5r1qyhTJkyfP/998+89pOWl4xcvXqV1NRU6tata9xnbm5OrVq1CA0NTXfsPz8nNzc3AOPnFBoamu4cAHXr1n3qHP/+byQMpOVFiBxIa6amffVitKtWlINX7rNg/zX2XrrHtrORbDsbiY+HEwPql6BpeRdZhsAUzK0NLSCmunYWsbFJ34IzY8YMZs2axezZs6lUqRI2NjaMGDGClJSU9CX8a2CvSqVCr8/aMVoqlYqpU6fy1VdfERkZSeHChdm1axcAnp6egCEQFC1aFAcHB+PrvL29URSFW7duZdiyolarqVmzJpcvX37mtf89mPmfnoy3+fegekVRntr3z8/pyXP//Jxe5Bz//m8kDKTlRYgcTKVSUa90IZb2rcUfI96ko08xtBo1wTce4r88mMYz9rA++BY6fZ6YazL3UKkMXTemeLzGO9H2799PmzZtjC0VJUqUeO6XfHbQaDQULVoUrVbLqlWr8PX1xdnZGTC0VNy5c4f4+Hjj8ZcuXUKtVlOsWLEMz6coCiEhIcaWkIxUrlzZGJT+rVSpUmi1Wg4cOGDcl5qayvHjx/H29n7h9+Xt7Z3uHACHDh36z3NotYbFX5+Mv8mvJLwIkUuUdbVjWscqHBjXiPcblcLBypzr9xP5cO0pms3ay++nI9BLiBGvoFSpUgQGBnLo0CFCQ0MZNGgQkZGRmT5Pz549GT9+/HOPuXLlCiEhIURGRvL48WNCQkIICQkxtvJER0czb948Lly4QEhICMOHD2ft2rXGcS9gGA9SsGBB+vTpw/nz59m3bx9jxoyhb9++xtaTSZMm8ccff3Dt2jVCQkLo168fISEh+Pv7P7O28ePHc+zYMYYMGcLp06e5cOECc+fOJTo6GhsbGwYPHsyYMWPYvn0758+fZ8CAASQmJtKvX78X/ozGjBnDkiVLmDdvHpcvX2bmzJls2LAh3ZijjHh4eKBSqdiyZQv37t1LF9zyEwkvQuQyznaWjPYrS9D4txjXvByO1uZcvZfA0JUnaPX9AXaF3iWPrPohstnEiROpXr06fn5+NGzYEFdXV9q2bZvp84SHh6ebZyYj/fv3p1q1asyfP59Lly5RrVo1qlWrxp07f3fHLV26lBo1alC3bl3OnTvHnj17qFWrlvF5W1tbAgMDefToETVq1KBbt260bt2a7777znjMo0ePGDhwIN7e3jRr1ozbt2+zb9++dOf5tzJlyrBjxw5OnTpFrVq18PX15ddff8XMzDDS4uuvv+bdd9+lR48eVK9enStXrvDHH3/g5OT0wp9R27Zt+fbbb5k2bRoVKlRg/vz5LF68mIYNGz73dUWLFmXSpEmMGzcOFxeXdHPe5CeytpEQuVxsUiqLDoTx8/4w4pMNk3NVK+7I6GZlqVOyoEx494pkbSMhXl1Wr20kLS9C5HL2luaMaFKG/R81wr9BSSzN1ZwMf0S3n4/QZcFhjl9/8N8nEUKIXETCixB5hJONlnHNy7Hvo0b0ruOJVqPm8LUHdJgXRO/FRzlzK8bUJQohRJaQ8CJEHuNsZ8nn71Rgz5iGdKlVHDO1ij0X79H6hwP4LwvmYmScqUsUQohXIuFFiDyqiKMVU9pXYteHDWhfrSgqFWw/F8nb3+5j+OqThEUnmLpEIYR4KRJehMjjPAraMLNzVXaMeJOWldxQFPg15A5NZu5l7LrT3HqYaOoShRAiUyS8CJFPlHax48du1dnyQT0al3NGp1cIOH6Tt2bsZcaOiySmpJm6RCGEeCESXoTIZyoWdWBh75psGFIH3xIFSUnT8/2fV3hr+l5+Dbktc8QIIXI8CS9C5FPVizuxckBt5vfwwb2AFZGxSQxfHUKHeUGcvvXI1OUJIcQzSXgRIh9TqVT4VXAlcGQDxviVxVqrIfjGQ9r8eJAxa08RFZdk6hKFEOIpEl6EEFiaaxjaqBR/ftiQ9tWKoiiwNvgWb03fy/y9V0lOy9+LwAmR23l6eqZbFyq3k/AihDBydbBkZueqbBhShyrujsQnpzFl2wX8Zu1j53lZMyk3UalUz3307t3b1CXmeUuWLMHR0dHUZbx2pghGZtl6NSFErlC9uBMbB9dhw8nbTN1+gev3E+n/y3HeLFOYT1t5U8rZztQliv/wz4URAwIC+PTTT7l48aJx35NVl59ITU3F3Nw82+ozlZSUFLRaranLyBNM+VlKy4sQIkNqtYoOPsXYPboh/g1KotWo2XfpHn6z9zPpt3PEJKaaukTxHK6ursaHg4MDKpXKuJ2UlISjoyNr1qyhYcOGWFpasnz5cu7fv0+XLl0oVqwY1tbWVKpUiVWrVqU7b8OGDRk2bBgfffQRBQoUwNXVlc8//zxTtel0Ovr164eXlxdWVlaULVuWb7/9Nt0xaWlpDBs2DEdHRwoWLMjYsWPp1atXulWu4+Li6NatGzY2Nri5uTFr1iwaNmzIiBEjjMd4enryxRdf0Lt3bxwcHBgwYAAAhw4d4s0338TKygp3d3eGDRtGQsLfEzdGRETQsmVLrKys8PLyYuXKlU+1MMycOZNKlSphY2ODu7s7Q4YMIT4+HoA9e/bQp08fYmJijK1dTz6nlJQUPvroI4oWLYqNjQ21a9dmz549z/3MnqyO7eLigqWlJRUrVmTLli3G59evX0+FChWwsLDA09OTGTNmPHWOxMRE+vbti52dHcWLF+enn35K9/yZM2d46623sLKyomDBggwcOND4fgB69+5N27ZtmTJlCkWKFKFMmTI0bNiQGzduMHLkSOP7zBZKHhETE6MASkxMjKlLESJPCrsXr/RfekzxGLtF8Ri7Rak2eYey/PB1JU2nN3Vpr9Xjx4+V8+fPK48fPzbu0+v1SkJKgkkeen3mP+/FixcrDg4Oxu2wsDAFUDw9PZX169cr165dU27fvq3cunVLmTZtmnLy5Enl6tWrynfffadoNBrl8OHDxtc2aNBAsbe3Vz7//HPl0qVLytKlSxWVSqXs2LHjhetJSUlRPv30U+Xo0aPKtWvXlOXLlyvW1tZKQECA8ZgvvvhCKVCggLJhwwYlNDRU8ff3V+zt7ZU2bdoYj+nfv7/i4eGh7Ny5Uzlz5ozSrl07xc7OThk+fLjxGA8PD8Xe3l6ZNm2acvnyZeXy5cvK6dOnFVtbW2XWrFnKpUuXlIMHDyrVqlVTevfubXxdkyZNlKpVqyqHDx9WgoODlQYNGihWVlbKrFmzjMfMmjVL+fPPP5Vr164pu3btUsqWLasMHjxYURRFSU5OVmbPnq3Y29srERERSkREhBIXF6coiqJ07dpVqVOnjrJv3z7lypUryrRp0xQLCwvl0qVLGX5eOp1OeeONN5QKFSooO3bsUK5evar89ttvytatWxVFUZTjx48rarVamTx5snLx4kVl8eLFipWVlbJ48eJ0n0OBAgWUH3/8Ubl8+bIyZcoURa1WK6GhoYqiKEpCQoJSpEgRpX379sqZM2eUXbt2KV5eXkqvXr2M5+jVq5dia2ur9OjRQzl79qxy5swZ5f79+0qxYsWUyZMnG99nRjL6c/TEy3x/qxQlb3Riv8yS2kKIzNt/+R6TfzvP5SjDv8i83eyZ3KYCNT0LmLiy1yMpKYmwsDC8vLywtLQEIDE1kdora5ukniNdj2Btbp2p1yxZsoQRI0bw6NEjAK5fv46XlxezZ89m+PDhz31ty5Yt8fb2Zvr06YCh5UWn07F//37jMbVq1eKtt97i66+/ztyb+YehQ4dy9+5d1q1bBxhajkaPHs3o0aMBQ2tNiRIlqFatGps2bSIuLo6CBQuycuVKOnToAEBMTAxFihRhwIABxhYST09PqlWrxsaNG43X6tmzJ1ZWVsyfP9+478CBAzRo0ICEhASuX7+Ot7c3x44do0aNGgBcuXKF0qVLM2vWrHQtO/+0du1aBg8eTHR0NPD05w5w9epVSpcuza1btyhSpIhxf5MmTahVqxZfffXVU+fdsWMHzZs3JzQ0lDJlyjz1fLdu3bh37x47duww7vvoo4/4/fffOXfunPFzqF+/PsuWLQNAURRcXV2ZNGkS/v7+LFiwgLFjx3Lz5k1sbGwA2Lp1K61bt+bOnTu4uLjQu3dvtm/fTnh4eLruIk9PT0aMGPHMzwUy/nP0xMt8f8uYFyFEptQvXZitw+uz4vANZgZeIjQilo7zguhWuzhjm5fD3jLvj5vIK558MT+h0+n4+uuvCQgI4Pbt2yQnJ5OcnGz8MnuicuXK6bbd3NyIiorK1LXnzZvHzz//zI0bN3j8+DEpKSlUrVoVMISQu3fvUqtWLePxGo0GHx8f9Ho9ANeuXSM1NTXdMQ4ODpQtW/Y/32dwcDBXrlxhxYoVxn2KoqDX6wkLC+PSpUuYmZlRvXp14/OlSpXCyckp3Xl2797NV199xfnz54mNjSUtLY2kpCQSEhKe+syeOHHiBIqiPBVCkpOTKViwYIavCQkJoVixYhkGF4DQ0FDatGmTbl/dunWZPXs2Op0OjUYDpP/v9qQb8cl/t9DQUKpUqZKu7rp166LX67l48SIuLi4AVKpUKUeMGZLwIoTINHONmt51vXinalGmbrtAwPGbrDgSTuD5u0xuU4G3K7qZusTXysrMiiNdj5js2lnl31+wM2bMYNasWcyePds4lmPEiBGkpKSkO+7fA3tVKpUxVLyINWvWMHLkSGbMmIGvry92dnZMmzaNI0fSf6b/Hj/xz46CJ78/75gn/v0+9Xo9gwYNYtiwYU8dW7x48XQDm5917hs3btCiRQv8/f353//+R4ECBThw4AD9+vUjNfXZ48H0ej0ajYbg4GBjqHjC1tY2w9f8e3B1RnW9yOfwvP9uGZ3jn8c98axQlt0kvAghXloBGy1TO1SmbbWifLzxDGHRCfgvP0Gz8i5MblMRVwfL/z5JLqRSqTLddZMb7N+/nzZt2tC9e3fA8EV7+fJlvL29s/w6derUYciQIcZ9V69eNf7u4OCAi4sLR48epX79+oChVejkyZPG1pmSJUtibm7O0aNHcXd3BwzdD5cvX6ZBgwbPvX716tU5d+4cpUqVyvD5cuXKkZaWxsmTJ/Hx8QEM3Ub/7P45fvw4aWlpzJgxA7XacO/LmjVr0p1Hq9Wi06WfI6latWrodDqioqKM7+2/VK5cmVu3bnHp0qUMW1/Kly/PgQMH0u07dOgQZcqUeSogPUv58uVZunRpulajgwcPolarn9ni80RG7/N1k7uNhBCvzLdkQbYNr8/7jUphplax4/xdms7cy7LDN9Dr88SwunyhVKlSBAYGcujQIUJDQxk0aBCRkZGZPk/Pnj0ZP378c69z/Phx/vjjDy5dusTEiRM5duxYumM++OADpkyZwq+//srFixcZPnw4Dx8+NLYC2NnZ0atXL8aMGcPu3bs5d+4cffv2Ra1W/+cdL2PHjiUoKIihQ4cSEhLC5cuX2bx5Mx988AFgCC9NmjRh4MCBHD16lJMnTzJw4ECsrKyM5y5ZsiRpaWl8//33XLt2jWXLljFv3rx01/H09CQ+Pp5du3YRHR1NYmIiZcqUoVu3bvTs2ZMNGzYQFhbGsWPHmDp1Klu3bs2w3gYNGvDmm2/y7rvvEhgYSFhYGNu2bWP79u0AfPjhh+zatYv//e9/XLp0iaVLl/LDDz8Yxwu9iG7dumFpaUmvXr04e/Ysu3fv5oMPPqBHjx7GLqNn8fT0ZN++fdy+fds43ud1k/AihMgSluYaRvuVZcuwelR1dyQuOY2Jm87SaX4Ql+/Gmbo88QImTpxI9erV8fPzo2HDhri6uqa7NflFhYeHp5tn5t/8/f1p3749nTt3pnbt2ty/fz9dKwwYAkaXLl3o2bMnvr6+2Nra4ufnl26w58yZM/H19aVVq1Y0adKEunXr4u3t/dSA0H+rXLkye/fu5fLly9SvX59q1aoxceJE3Nz+7u785ZdfcHFx4c0336Rdu3YMGDAAOzs747mrVq3KzJkzmTp1KhUrVmTFihVMmTIl3XXq1KmDv78/nTt3pnDhwnzzzTcALF68mJ49e/Lhhx9StmxZ3nnnHY4cOWJsQcrI+vXrqVmzJl26dKF8+fJ89NFHxtaO6tWrs2bNGlavXk3FihX59NNPmTx5cqYmIrS2tuaPP/7gwYMH1KxZkw4dOtC4cWN++OGH/3zt5MmTuX79OiVLlqRw4cIvfM1XIXcbCSGynE6v8EvQdab9cZHEFB3mGhVDGpZiSKOSWJi9WDN2TvG8uyRE9tHr9Xh7e9OpUyf+97//ZXhMQkICRYsWZcaMGfTr1y9Lr3/r1i3c3d3ZuXMnjRs3ztJz5wdyt5EQIsfTqFX0qetFswquTNx0lj8vRPHtrsv8fiaCKe0r5dnbqkXWuXHjBjt27KBBgwYkJyfzww8/EBYWRteuXY3HnDx5kgsXLlCrVi1iYmKYPHkywFN33ryMP//8k/j4eCpVqkRERAQfffQRnp6evPnmm698bvHqpNtICPHaFHW0YmGvGvzQtRqFbC24EhVPx3lBTNh4htgkmaFXPJtarWbJkiXUrFmTunXrcubMGXbu3PnU4OHp06dTpUoVmjRpQkJCAvv376dQoUKvfP3U1FQ+/vhjKlSoQLt27ShcuDB79uzJF0so5AbSbSSEyBYxial8tTWUgOM3AXC2s8gVt1VLt5EQry6ru42k5UUIkS0crM2Z2qEyqwa8gVchG6LikvFffoKBvxwnMibJ1OUJIXIRCS9CiGz15LbqoY1Kprutes2xmxlOrCWEEP/2UuFlzpw5xqYfHx+fdGtc/FtERARdu3albNmyqNXqDNc+WLBgAfXr18fJyQknJyeaNGnC0aNHX6Y0IUQuYGmuYYxfOX77oB5V/rqt+qP1pxm4LJjo+GRTl5chCVZCvLys/vOT6fASEBDAiBEjmDBhAidPnqR+/fo0b96c8PDwDI9PTk6mcOHCTJgwgSpVqmR4zJ49e+jSpQu7d+8mKCiI4sWL06xZM27fvp3Z8oQQuYi3mz0bBtdh7NvlMNeoCDx/F79Z+9hxLvMTo70uTwZoJiYmmrgSIXKvJ39+smrAc6YH7NauXZvq1aszd+5c4z5vb2/atm371AQ9/9awYUOqVq1qXO3zWXQ6HU5OTvzwww/07NnzheqSAbtC5G7n78Qyak0IFyINE9p18CnGZ63LY5cDFnqMiIjg0aNHODs7Y21t/Z8zuAohDBRFITExkaioKBwdHdNNBPjEa5/nJSUlheDgYMaNG5duf7NmzTh06FBmTvVciYmJpKamUqDAs+eCeLLa6ROxsbFZdn0hRPYrX8SeX9+vy6zAy8zfd5V1wbcIunqf6R2r4Fsy49V2s4urqytApldOFkIYODo6Gv8cZYVMhZfo6Gh0Ot1T6xy4uLi81PoXzzJu3DiKFi1KkyZNnnnMlClTmDRpUpZdUwhhehZmGsY1L0djb2dGrQnh5oPHdFlwmH71vBjjVxZLc9PMzqtSqXBzc8PZ2fm5KwYLIZ5mbm7+wgtEvqiXmmE3o6W3s6oZ9ZtvvmHVqlXs2bPnuXMqjB8/nlGjRhm3Y2Njn7suhBAi96jpWYBtw9/ky9/Ps+roTRYeCGPfpXvM6lyVikUdTFaXRqPJ8r+EhRCZl6nwUqhQITQazVOtLFFRUf+56uSLmD59Ol999RU7d+6kcuXKzz3WwsICCwuLV76myD6P0x5zJ/4OcSlxJKYl8jjt8d+P1Mfpt5/zSNYlY6GxwMrMKt3D0szyqX3Pethr7XGzdcPG3MbUH4t4BlsLM6a0r0zT8i58tO4Ml6PiafvjQYY3Ls3ghiUx08hMD0LkV5kKL1qtFh8fHwIDA2nXrp1xf2Bg4CuvJTFt2jS++OIL/vjjD2rUqPFK5xKmoVf03Eu8x634W9yKu/X3z79+j36cPUulZ4aDhQNFbIpQxLYIbjZuFLUtipvtXz9t3LDX2svgTBN7q5wLO0Y6MWHjGbadjWRG4CV2XYhiZqcqlChsa+ryhBAmkOluo1GjRtGjRw9q1KiBr68vP/30E+Hh4fj7+wOG7pzbt2/zyy+/GF8TEhICQHx8PPfu3SMkJAStVkv58uUBQ1fRxIkTWblyJZ6ensaWHVtbW2xt5S+nnCQhNSHDYHIr7hZ34u+Qok957uvtzO1wtHT8z5YRa3Pr9K0qGkuszA2/W2gsSNYlp2uxSdIlGVtmElP/btVJ0iVl2KrzKPkRsSmxxCTHEJMcQ+iD0AzrtTW3NYQZG0OoeRJ0itgWwdPeE1ut/P+ZHQrYaJnTrTqbQm7z6a/nCLn5iBbf7WdCC2+6v+EhAVOIfOal1jaaM2cO33zzDREREVSsWJFZs2YZV9rs3bs3169fZ8+ePX9fJIO/WDw8PLh+/ToAnp6e3Lhx46ljPvvsMz7//PMXqklulc56afo0Lj+8TMi9EE5GneRU1CnuJNx57ms0Kg1uNm4UsytmeNgWS/e7g4Xpxiv8W3xKPHcS7hARH8Ht+NtEJPz1Mz6COwl3eJD04D/P4WnviXdBbyoUrED5guUpV6Acdlq7bKg+/7rz6DFj1p3i4JX7ANQvXYhpHarg6iDrDgmRG73M97cszCiMYlNiORV1ipB7IZyKOsXp6NM8Tnv81HEOFg5/h5J/hRNXG1fM1C81DjzHeZz22Bhk7sT/9fjr99vxt5/ZDeZh70H5AuUpX9DwKFewHPZa+X8yK+n1Cr8EXWfKtgskp+mxtzTji3aVeKdKEVOXJoTIJAkvEl5emKIo3Ii9Qci9EEKiQjh17xRXHl156jhbc1uqFK5CVeeqVHWuincB7xzVemJKD5IecP7++XSPiISIDI91t3M3hpnyBcvL55hFrkTF8+GaEE7digGgo08xJrWpgLU2bwRoIfIDCS8SXp4pVZfK6ejThESFGFtWHiY/fOo4D3uPv8NK4aqUdCyJWiV3dbyoh0kPnwo0z+pqc7dzp4ZLDXyL+PKG2xs4WTplc7V5Q6pOz/d/XuGHPy+jV6CUsy0/dK1GOVf5e0CI3EDCi4SXdJJ1yQTdCSLwRiC7b+4mLiUu3fNatZaKhSpSxbkKVQtXpUrhKhS0Mu1MpnnRw6SHhN4P5fyDvwPN7fj063apUFGuQDl8i/jiW8SXas7VsNDIVACZcfjafYavPsnd2GQszNR82ro8XWsVl8G8QuRwEl4kvPA47TEHbx9kx40d7Lu1j4TUBONzBSwL4OPiQ5XCVajmXA3vAt6Ya0y/bkx+9CjpEWeiz3A44jBBEUFcfng53fOWGkt8XHyMrTJlnMrIl/ALuB+fzOi1p9h98R4ALSu58VX7SjhYyf/nQuRUEl7yaXhJTE1k36197LixgwO3D6QbZOts7UxTj6Y09WhK1cJV0ahldtCcKPpxNEF3ggyPiKCnBgMXsirEG25vGFpm3HwpbF3YRJXmfHq9wqKDYUzdfoFUnUIxJyt+6Fqdqu6Opi5NCJEBCS/5KLzEpcSx5+YeAm8EcujOIZJ1fy9SWdS2KE2KN6GpZ1MqFaokY1ZyGUVRuPLoijHIHI88TpIuKd0xpRxL4VvEl7pF6lLLtZa0oGXg1M1HvL/qBDcfPMZMreKjt8vSv14J1GppwRIiJ5HwksfDS0xyDH+G/0ngjUCCIoJI06cZnytuV9zQwuLZlPIFyksXQx6SokshJCqEoAhDy8z5++dR+PuPrb3WnsbFG+Pn6Uctt1qYqyXIPBGblMr4DWf4/bThLrCGZQszo2MVCtrKeCIhcgoJL3kwvOj0Ovbc3MOaS2s4GnGUNOXvwFLSoSRNPZvSpHgTGRORjzxKesSRyCME3Qli76296bqYHC0cjUGmpmvNPDPnzqtQFIVVR28y6bdzJKfpcbazYPZ7ValTspCpSxNCIOElT4WXmOQYNlzewOoLq9PdalvWqaxxDEsJxxJZd0FdGqQmQMqTRzwkx//9+5P9ih60NqC1/evnv3//a9tMm3W1iWfS6XWciDrBH9f/IPBGYLpZgZ0snGji0YS3Pd/Gx8Un3493uhAZy/srT3IlKh6VCj54qzTD3iolCzwKYWISXvJAeLny8AorL6zkt6u/Gcc5OFo40rFMR9qUaoOHvceLnUivh9jbcP8KPLgK969CzM1/BJInoeSv7bSk/z5nZqjNwcI242Bj5wpOXlDA6++fWlnd+VWl6dMIvhvMH9f/YOeNnenm8SloWdAYZKo5V8u3QSYxJY1Jm88TcPwmALW8CvDte1Vxc7AycWVC5F8SXnJpeNHpdey7tY8VF1ZwJOKIcX9Zp7J08+5Gc6/mWJplsG6LokDCPUNAuX/FEFDuX4EH1wyPlwkkKs1focPu6dChtQGVClIS07fG/LN15h8DhzPFxjl9mPnnT5tChuuKF5amT+No5FF2XN/BzvCdxCTHGJ8rbFWYph5N8fP0o6pz1Xw5oPvXkNt8vOEMCSk6nKzNmd6xCo29XUxdlhD5koSXXBZeYlNi2Xh5I6surDJOWqZWqWlcvDFdy3XFx8XHMI5FlwZ3z8C9S3+1ojwJKlfhXxPPpaM2M3z5FywJBUuBowdYOqQPJBa26cOJRvtqQUGXmnGoMXZFxUHMLXgYBg/CDD8fPz3TbzpaOyjg+XegKVACilQD5wqgkTEd/yVVn8qRiCNsD9vOn+F/Epf69/8zztbONPdszrtl3sXLwcuEVWa/69EJvL/qBGdvxwLQr54XY98uh9Ys/4U5IUxJwksuCS/XYq6xMnQlm69uNs7JYq+1p0OZDnQu25kiVs4QcQqu74frByA8yPDFnyEVOLobwkmBv0JKwZKGh0Px3PHl/vjh30HG+PO64Wfs7We/ztwGilaHYjXBvZbhp40MwnyeVF0qQRFB/HH9D/4M/5P41L//v6rhUoOOZTrSxKMJWk3+GLOUnKbj620XWHzwOgBV3B2Z2606RRylG0mI7CLhJQeHF72i58DtA6wIXcGhO4eM+0s5lqJb2S60tC6G1c1jhrByI+jpFhVLB3CpBAVLpA8qTp5gnkGXUl6RmgSPbqQPN9EX4fYJSI59+vgCJaBYLXCvafjpXD53BDgTSNYlc+D2ATZe3sj+2/vRK3rAMMbqnZLv8G6ZdynhkIWDwnOwwPN3Gb32FDGPUylgo+X7LtWoW0qCsBDZQcJLDgwvKboU1l9ez/LzywmPCwcM69g0KlyNbuau1Lx7FVX44YzDikc98KwHXvUNXSRqac420uvg3kW4dRRuHjP8jL709HFPtc7UAhtZv+nfIhMi2Xh5I+svr+du4l3j/houNehQpgNNPJrk+bWWbj5IxH95MOfuxKJWwWi/sgxuUFKmIBDiNZPwkoPCi17Rsy1sG9+f/N44nsVOreVdxZbOkdcplvgo/Qv+GVY864FLBcind4S8tMcP4VbwX4HmKNwOfnbrTHFfKOMHJd8CC7vsrzWH0ul1HLh9gHWX1rHv9j5ja4yDhQPvlHyHDmU65OnWmKRUHRM3nWVt8C0A/Cq4MK1jFewtZeI/IV4XCS85ILwoikLQnSBmBc/iwsMLABTW6Rnw8BFt4hOwfvJxWzqAR91/hJWKElaymrF15tjfLTTRF9Mfo9GCZ30o29zwcChmmlpzoMiESDZe2ciGyxuITIg07vdx8aFDmQ409WiaJ1tjFEVh9bGbfPbrOVJ0erwK2TCvuw9lXSXkCvE6SHgxcXg5F32OWUe+4kj0aQBs9Xr6PYqlW2wcVlp78JSwYnJPWmeu7YaLWw23lP+TayUo2wLKvA1uVaWrDkNrzME7B1l7aS37bmXQGlO6Q9ZOmJhDnLr5iMHLg7kTk4SVuYapHSrzTpUipi5LiDxHwouJwkt4ZAjfH5rM9rjLAJgrCl1i4xiQkIpj2VZQuRN4NZSBozmNokD0ZUOIubQdbh4xzCD8hJ2boWupbAvwehPM5Q6UyIRINl3ZxPrL69O1xtR2q02fCn2oU6ROnhoj8iAhhWGrTnLgimEJhr51vRjfohzmMiuvEFlGwkt2hpeURKLPrmH+2YWs0z8kTaVCpSi0TkhkqH1FilTpbvjSs7B9/bWIrJFwHy7vMISZq3+mvz3d3BpKNIKybxtaZWydTVdnDvCkNWbdpXXsu7UPnaIDoIxTGXpX6M3bXm/nmQUidXqFGTsuMmfPVQBqejrxY9fqONvn4bv8hMhGEl5ed3jR6yBsLwmnVrL09h6W2Frw+K9uhfo6c4aXaE/ZGgPz/RdbnpCWbJhn5+I2uLgdYm/940kVFPWB8m2gcmewy98zs96Jv8Oy88tYf3m9cd4iF2sXepTvwbul38VWmzcC/I5zkXy45hRxyWkUtrNgTrfq1PQsYOqyhMj1JLy8jvCiKIYJ406vIfXsOtaqEpjv5MADjWG8SiVtAUZWH0HNsu2y7poiZ1EUiDxj6Fq6uBXunPz7OZUGSjeDat2gtF++XpAyJjmGtZfWsiJ0hXGla1tzWzqW6Ug372642OT+kHftXjz+y4O5dDceM7WKj1t406euZ57qKhMiu0l4yerwotfDgoboI07xh4013zk5cMvc0BTuaeXCsFof0cSjqfzFld/ERsDF3+HUasOdTE9YFzS0xFTtBq4VTVefiaXoUthybQtLzi0hLCYMADO1GS28WtC7Qm9KO5U2cYWvJjEljXHrz7D5lGG199ZVivB1+0rYWMiYNiFehoSX19Dycmh1e2bHnSdUawgthSwLMrjqENqVbpdn+vTFK7h3EUJWGIJM/N+Tu+FWBap2h0odwDp/di3oFT37bu1j8dnFnIg6Ydxfr2g9+lToQ03Xmrk2+CuKwpJD1/ny91DS9AplXGyZ192HEoXzRheZENlJwksWh5cUXQrN1zUjKuk+NuY29K3Yl+7e3bE2t86S84s8RJcGV3fByeWGcTL6VMN+jdYwcLtad8OEePn09vjT906z5NwSdoXvMt5qXb5gefpU6EMTjyaYqXNnq8Wx6w8YsuIE9+KSsbUwY3rHKrxd0dXUZQmRq0h4eQ0tL79d/Y3z988zsPJAnCydsuy8Ig9LuA9n1kLIcsNYmSfs3KDKe4YWmUKlTFefCd2MvcnS80vZdGUTybpkAIraFjUO7rU0y3138ETFJvH+ypMcvf4AgPcblWJU0zKo1bmzVUmI7CbhJQfMsCtEOhGnDd1Kp9fA4wd/73evbRgbU/HdfHk7/YOkB6y+sJpVF1bxKPkRAIWsCtG/Un86lOmQ62buTdXpmbL1AosOGsb4NC3vwqzOVbGVcTBC/CcJLxJeRE6Vlmy4W+nkCrgS+PdkeJaOUKMv1B4Edvmvu+Fx2mM2X9nMorOLuJNgGADrYu3CwMoDaVeqHeaa3DWubH3wLcZvPENKmp4yLrb83LMmxQtKN7MQzyPhRcKLyA3iIg0DfE8s/Xt5ArW5YSZm36GGRTnzmVRdKhuvbGT+6flEJUYBUMSmCIOqDKJ1yda5anD8yfCHDFoWTFRcMo7W5szpVp06JQuZuiwhciwJLxJeRG6i1xkG9wb9AOFBf+8v+RbU+cAwo28uvRvnZSXrkll3aR0/n/nZOFeMu507/lX8aeHVItcM7I2MSWLgsuOcvhWDRq3i89bl6eHraeqyhMiRJLxIeBG51a3jcOh7CN38d5eSS0VDS0zFDvlu8ruktCQCLgaw6OwiHiQZxgp52nsyuMpg/Dz90OSCu7aSUnWMXX+aX0MM3WHdahfns9YV0JrJukhC/JOEFwkvIrd7eB0Oz4UTyyA1wbDP1tUwJqZGH7DKX3e8JaYmsurCKhafW0xMcgwApRxLMbjKYJp4NEGtytlBQFEU5u29xjd/XEBRoJZXAeZ2q05B29w1IFmI10nCi4QXkVc8fgjBS+DIfIiLMOwzt4HqPeCNweDkacrqsl18SjwrL6xkybklxKXEAVDWqSxDqg6hkXujHD/Z3a7QuwxfHUJ8chpFHa34uVcNvN3k7ykhQMKLhBeR96SlwNn1hnExd88a9qnU4N0afD8A95qmrS+bxabEsvz8cpadX0Z8qmHV7/IFyzO06lDqF62fo0PM5btx9P/lODfuJ2Kt1TCzUxXeruhm6rKEMDkJLxJeRF6lKHBtj2FczNVdf+93fwMajoMSDfPV4N6Y5BiWnlvK8tDlxpWsqxSuwugao6nqXNW0xT3Ho8QUhq48wcEr9wEY2aQMH7xVSia0E/mahBcJLyI/uHsegn6EM2tAl2LY51kf3voEir9h2tqy2YOkByw5u4RVF1aRpEsCoKlHU0ZWH4m7vbuJq8tYmk7PF7+HsuTQdQBaVHJlescqWGtzx51UQmQ1CS8SXkR+EhcJB2bD8YV/h5hSTQwhpkg1k5aW3e4l3uPHkB/ZeGUjekWPmdqMruW6MrDyQBwsHExdXoYCjoXzyaazpOoUvN3sWdDTh2JOMqGdyH8kvEh4EflRzC3YN82wKKQ+zbCvXCtoNAFcypu2tmx26eElZh6fycE7BwGw19rjX8Wf98q+lyNn6z1+/QH+y4OJjk+hoI2WeT18qOmZP1chF/mXhBcJLyI/e3AN9kyF0wGAAqgMayc1+hgKljR1ddnq4O2DTD8+nSuPrgBQ3K44I31G0rh44xw3qPf2o8cMWHqc8xGxmGtUTG5TkS61ipu6LCGyjYQXCS9CQNQF2DMFzm8ybKs0ULULNBgLjvnnS1Gn17HxykZ+OPkD95MMA2SrO1dndI3RVCpcycTVpZeYksaYtaf5/Yzhtvj+9bwY38IbjQzkFfmAhBcJL0L8LeIU7P7KsCAkGNZP8ukN9T8E+/xzi25CagKLzy5m6bmlxkG9zb2aM6L6CIrYFjFxdX9TFIXvdl1h1s5LgGFl6m/fqyoDeUWeJ+FFwosQT7t5DHZ/YbjVGsDMEmr2h3ojwSb/LBgYmRDJ9ye/57erv6GgoFVr6V6+O/0r9cdOa2fq8ox+DbnNmHWnSUnTU7GoPQt71cTF3tLUZQnx2kh4kfAixLOF7Yc//wc3jxi2tbaG2Xp93wcrR5OWlp1C74cy/fh0jkYeBcDJwonBVQfToUyHHLN6dfCNBwz4JZgHCSm4OViysFdNyheRv9dE3iThRcKLEM+nKHBlpyHERJwy7LNyMtyZ5NMHNPmji0JRFPbd2seM4BmExYQBhoUfx9Qcw5vF3jRxdQY37ifQd8kxrt5LwEar4Yeu1WlUztnUZQmR5SS8SHgR4sUoClzYAn9+AfcuGPY5l4e3v4YSDUxbWzZK1aey/tJ65oTM4WHyQwAaujdkbM2xFLMrZuLqICYxlcErgjl09T5qFXzWugK96niauiwhspSEFwkvQmSOLg2CF8PuLw2LQYJh3aRmX+SrxR/jUuL46fRPLD+/nDQlDQuNBf0r9adPxT5YaEy7AnRKmp5PNp1hzfFbAPSu48nEVuXlTiSRZ0h4kfAixMtJfGC4vfrYQlB0oLGAOh8YBvVa2Jq6umxz9dFVvjrylXE8jLudO+Nrjad+sfomrUtRFObtvcbU7YZWsrfKOfNdl2rYWuSPbj6Rt0l4kfAixKu5ex62j4OwvYZtOzdoMgkqd8o3Cz8qisL269uZdmwa9x7fA+At97f4qNZHFLUtatLatp6JYGRACMlperzd7FnUuwZuDlYmrUmIVyXhRcKLEK9OUeDC77BjAjy8bthXrBY0/xqK+pi0tOyUkJrA3JC5LA9djk7RYamxZEDlAfSu0ButRmuyukJuPqL/0uNExyfjbGfBwl41qVQsZ67fJMSLkPAi4UWIrJOaBIfnwL7pkJpg2Fe1GzT+DOxcTFtbNrr88DJfHfmK43ePA4alBsbXHk+9ovVMVtOth4n0XXKMS3fjsTLX8O17VWlWwdVk9QjxKiS8SHgRIuvFRsCuSXBqlWFbawdvjjbMEWNm2sGs2UVRFLaGbWX68elEP44GoHHxxnxU8yOTzdIbm5TK0BUn2H85GpUKJrTwpl89rxy3dpMQ/0XCi4QXIV6fW8dh20dwO9iwXaAE+H0FZd7ON+Nh4lPimXtqLitCVxi7kgZWHkivCr1M0pWUptPz2eZzrDgSDkC32sWZ9E4FzDTqbK9FiJcl4UXCixCvl15vWLV652cQf9ewr+Rb8PZUKFzGtLVlo8sPL/PlkS8JvmsIch72Hnxc62PqFK2T7bUoisLCA2F8uTUURYE3yxTmx67VsLPMGbMFC/FfJLxIeBEieyTHwf4ZEPQj6FJAo4X6ow23VpuZbjBrdlIUhd/Dfmf6senGVaubejTlo5of4WqT/eNP/jgXyYjVITxO1VHWxY4lfWvKnUgiV5DwIuFFiOz14BpsGwuXdxi2C5eD1t9B8dqmrSsbxaXEMSdkDqsurEKn6LAxt2Fk9ZF0LNsRtSp7u2/O3Iqh39JjRMUl42pvyZK+NSnnKn8fipxNwouEFyGyn6LA2fWG+WES7gEqqNnPcFeSZf75s3jxwUUmH57M6XunAajmXI3PfT+nhGOJbK3j1sNEei8+xpWoeOwszJjf04c6JfPP6uEi95HwIuFFCNNJfAA7JkLIcsO2XRFoOR3KtTRtXdlIp9cRcDGAb098S2JaIuZqcwZWHki/iv0w12TfGJSYxFQG/HKco9cfYK5RMb1jFdpUNe0Ee0I8y8t8f79Um+acOXPw8vLC0tISHx8f9u/f/8xjIyIi6Nq1K2XLlkWtVjNixIgMj1u/fj3ly5fHwsKC8uXLs3HjxpcpTQhhKtYFoO2P0HMzOHlB3B1Y3RUCekBcpKmryxYatYau3l3Z1GYT9YvWJ1Wfyo8hP9JpSydCokKyrQ4Ha3N+6VeLlpXcSNUpDF8dwry9V8kj/1YVIvPhJSAggBEjRjBhwgROnjxJ/fr1ad68OeHh4Rken5ycTOHChZkwYQJVqlTJ8JigoCA6d+5Mjx49OHXqFD169KBTp04cOXIks+UJIUytRAMYEmQYvKvSQOhm+KEWHF9suFspH3CzdePHxj8ytf5UClgW4MqjK/Tc1pMpR6aQ8GTCv9fM0lzD912q0a+eFwBfb7vAZ5vPodNLgBG5X6a7jWrXrk316tWZO3eucZ+3tzdt27ZlypQpz31tw4YNqVq1KrNnz063v3PnzsTGxrJt2zbjvrfffhsnJydWrVr1QnVJt5EQOVDkGdg8DO6cMGwXrwOtv81Xt1U/SnrEtOPT2Hx1MwCuNq5MfGMibxZ7M9tq+Hn/NeOt1M3Ku/Bdl2pYmmuy7fpCPM9r7zZKSUkhODiYZs2apdvfrFkzDh06lJlTpRMUFPTUOf38/J57zuTkZGJjY9M9hBA5jGsl6L8T/KaAuQ2EH4J5dWHvN5CWYurqsoWjpSNf1vuS+U3nU9S2KJEJkQzdNZSP9n3E/cf3s6WG/vVL8EOX6mjN1Ow4f5euCw7zICF/fP4ib8pUeImOjkan0+Hikn5dExcXFyIjX75POzIyMtPnnDJlCg4ODsaHu7v7S19fCPEaqTXgOwSGHoZSTQ3zwuz+EubXh/D80zVcp0gdNryzgV7le6FWqdkWto02v7Zh89XN2TIWpWVlN5b3q42DlTknwh/RYe4hwu8nvvbrCvE6vNSA3X+vnaEoyiuvp5HZc44fP56YmBjj4+bNm690fSHEa+ZYHLqthXcXgnUhuHcBFvnB7x9CUv5oObU2t2Z0zdGsbLGSsk5liUmOYcKBCQwKHMStuFuv/fq1vAqwfrAvRR2tuBadQPu5Bzl969Frv64QWS1T4aVQoUJoNJqnWkSioqKeajnJDFdX10yf08LCAnt7+3QPIUQOp1JBpQ7w/jHDCtUocOxn+LE2XN5p6uqyTYVCFVjVahXDqw9Hq9YSFBFE+83tWXpuKWn6tNd67VLOdmwcUofybvZEx6fw3k+H2X0h6rVeU4islqnwotVq8fHxITAwMN3+wMBA6tR5+TU9fH19nzrnjh07XumcQogczLoAtJ0DPX/9+7bqFe/ClpGQkj1345iaudqc/pX6s6HNBmq61uRx2mOmH59O963dufzw8mu9trO9JWv8falfuhCJKTr6/3Kc1UczvmNUiJwo091Go0aN4ueff2bRokWEhoYycuRIwsPD8ff3BwzdOT179kz3mpCQEEJCQoiPj+fevXuEhIRw/vx54/PDhw9nx44dTJ06lQsXLjB16lR27tz5zDlhhBB5RImGMPgQ1Db8/cHxRTCvHtw8atKyspOHvQcLmy1kUp1J2Jnbce7+OTpv6czPZ35+ra0wthZmLOpdk3erF0OnVxi34QwzAy/JXDAiV3ipGXbnzJnDN998Q0REBBUrVmTWrFm8+abhtr/evXtz/fp19uzZ8/dFMhi74uHhwfXr143b69at45NPPuHatWuULFmSL7/8kvbt279wTXKrtBC53NXd8OtQiL0NKrVhnpgG4/LNQo8A9xLvMSloEntv7QWgcqHKfFHvC7wcvF7bNRVFYVbgJb778woAHX2K8VX7SphrsnddJpF/yfIAEl6EyN0eP4JtH8HpAMO2ayVo9xO4lDdpWdlJURR+vforU49OJT41HguNBcOqDaObdzc06tc3N8vKI+F8sukMegXeLFOYOd2qY2th9tquJ8QTEl4kvAiRN5zbZBj/8vgBaLTQ+FN4Y4jhtut8IjIhks8OfcahO4b5rqo7V+eLul/gbv/6poXYFXqX91ee5HGqjkpFHVjcpyaFbC1e2/WEAAkvEl6EyEvi7sLmD+DyH4Ztj7rQdi44eZi2rmykKArrLq9j+rHpJKYlYmVmxUifkXQu2xm16vV065y6+Yg+S47xICEFz4LWLOtXG/cC1q/lWkKAhBcJL0LkNYoCJ5bC9o8hNQG0dvD2FKjW3XDbdT5xO/42Ew9O5FjkMQBqu9ZmUt1JFLV9PStFX7sXT4+FR7n96DGF7SxY2qcW5YvI36vi9ZDwIuFFiLzpQRhsGgzhQYbtsi0MayTZOpu2rmykV/SsurCK2cGzSdIlYW1mzZiaY3i39LuvPEloRu7GJtFr0VEuRMZhZ2HGz71qULtEwSy/jhASXiS8CJF36XVw6HvD0gK6FMMsva2/Be9Wpq4sW4XHhvPJwU84GXUSgLpF6vJ5nc9xtXHN8mvFPE5lwNLjHL3+AK2Zmu+7VMOvQtZfR+RvEl4kvAiR90WehY2D4O5Zw3aVrtD8a7B0MG1d2Uin17E8dDnfnfiOFH0KduZ2jK01lndKvpPlrTBJqTo+WHWSwPN3Uavgy3aV6FKreJZeQ+RvEl4kvAiRP6Qlw54pcPBbUPTg4G6YsdfrTVNXlq2uxVzjkwOfcCb6DAANizXkszqfUciqUJZeJ02nZ8LGswQcN6wh92HTMrz/VqnX0l0l8h8JLxJehMhfwg8bWmEeXgdUUP9DaDgeNPlnfpI0fRpLzi3hx5AfSdOn4WDhwCe1P+Ftr7ez9DqKojBjxyV+2G2YzK6Xrwefta6AWi0BRrwaCS8SXoTIf5Lj4Y/xcOIXw7b7G9BhITgUM21d2ezSw0t8cuATQh+EAtCyREs+rv0x9tqs/ftwycEwPv/NsLxLq8puzOhUBQuz/DP/jsh6L/P9LfM/CyFyNwtbeOd76LAILOzh5mGYWxcubDV1ZdmqjFMZVrRcgX8Vf9QqNb9f+50OmztwPPJ4ll6nd10vvutSDXONii2nI+i35Djxya93JWwh/k1aXoQQeceDMFjXB+4Y7sShtj80nQxm+WuW2JCoEMbvH8+t+FuoUNG3Yl+GVh2KucY8y66x//I9Bi0LJjFFZuMVr0ZaXoQQ+VsBL+i7A3zfN2wfmQcLm8L9q6atK5tVda7KunfW0a5UOxQUFp5dSLet3bgWcy3LrlG/dGFWDXiDAjZaztyOocPcQ9x8kJhl5xfieaTlRQiRN136Azb6G9ZH0tpCq9lQuaOpq8p2O2/s5POgz4lJjsFSY8mHNT6kc9nOWXankMzGK16VtLwIIcQTZfxg8EHwqAcp8bChP/w6FFISTF1Ztmri0YQN72zA182XJF0SXx75kqG7hhL9ODpLzl+isC0bhtShnKsd9+KS6Tw/iCPX7mfJuYV4FgkvQoi8y74I9NoMDcaBSg0nl8NPjeDuOVNXlq2crZ2Z13Qe42qNQ6vWsv/2ft7d/C67w3dnyfld7C0JGORLLc8CxCWn0WPRUf44F5kl5xYiI9JtJITIH8L2w4YBEBcBZpaGBR59+uSrBR4Brjy8wtj9Y7n08BIAHcp0YEyNMVibv/rK0f+ejXdK+0p0rimz8Yrnk24jIYR4Fq/64H8ASjeDtCTYMhLW9obHj0xdWbYq5VSKVS1X0btCb1SoWHdpHZ22dOLMvTOvfG5Lcw1zu1Wncw139AqMXX+Gn/blr8HSIntIy4sQIn/R6+Hwj7Dzc9CngWNx6LAEivmYurJsdyTiCBMOTOBu4l00Kg2DqwymX6V+mKlfbYZiRVH4etsF5u8z3N00pGFJxviVleUERIak5UUIIf6LWg11PjDcUu3oAY/CYVEzOPidIdjkI7XdarP+nfX4efqhU3T8EPIDfbb34WbczVc6r0qlYnwLb8a+XQ6AOXuu8smms+j0eeLfyiIHkJYXIUT+lRQDm4fB+U2G7dJ+0H4+WDmZtKzspigKW65t4asjXxGfGo+1mTWfvPEJrUu2fuVzrzwSzoRNZ1AUw3ICMztVRWsm/24Wf5OWFyGEyAxLB+i4xDAHjJklXP4DfmoIEadNXFj2UqlUtC7ZmnXvrKO6c3US0xL5+MDHjN8/noTUV7u1vGvt4nz33t/LCQxcdpzHKbosqlzkVxJehBD5m0oFNfpAv7+6kR5eN8zKG7LK1JVlu6K2RVnkt4j3q76PWqVmy7UtdPqtE+eiX+3W8tZVirCgZw0szdXsuXiPHguPEPM4NYuqFvmRhBchhABwqwID90Cppoa7kTb5w5ZRkJZs6sqylUatYVCVQSx5ewluNm6Ex4XTfVt3lp5bil55+TFBDcs6s7xfbewszTh+4yHv/XSYe3H567MVWUfCixBCPGFdALqugYbjARUcXwiLW0DMbVNXlu2qOVdjbeu1NCnehDR9GtOPT2fIriGvNDNvDc8CBAz0pZCtBaERsXScJ+shiZcj4UUIIf5JrYaG4wwhxtIBbh+H+W/Ctb2mrizbOVg4MLPhTCa+MRELjQUHbx+kw+YOHLpz6KXPWb6IPev8fSnmZMX1+4l0nBfE5btxWVi1yA8kvAghREbKNIOBe8G1EiRGw7K2cGA25I0bNF+YSqWiU9lOrG65mlKOpbifdJ9BgYOYGTyTVP3LjVvxLGTDOv86lHa2JTI2iY7zgzh181HWFi7yNAkvQgjxLAW8DPPBVOkKih52fgZrekBSrKkry3ZPZubtVKYTAIvPLqbXtl4vPSeMq4Mlawb5UsXdkUeJqXRdcJhDV7NmsUiR90l4EUKI59FaQ9s50GoWqM0h9DdY0AiiQk1dWbazNLNkou9EZjaciZ3WjjPRZ+j0Wye2hW17qfM52WhZ0b82dUoWJCFFR+/Fx2RBR/FCJLwIIcR/UamgRl/oux3si8L9K7CgMZxdb+rKTKKpR1PWt15PNedqxKfG89G+j5h4cCKJqZkffGtrYcai3jXxq+BCSpqewcuDWRd86zVULfISCS9CCPGiitUwjIPxehNSE2BdX9j+Mejy35wlbrZuLPJbxKDKg1ChYtOVTXTe0pkLDy5k+lyW5hp+7FqdDj7F0Csweu0pFh4Iew1Vi7xCwosQQmSGbWHovhHqjjBsH/4Rlr4DcXdNWpYpmKnNeL/a+yz0W4iztTPXY6/T9feurAhdQWZXnjHTqPnm3cr0q+cFwP+2nGfmjouZPo/IHyS8CCFEZmnMoOkk6LQMtHYQfshwO/WNIFNXZhI1XWuyrvU6GhZrSKo+la+Pfs2wP4fxKOlRps6jVqv4pKU3o5uVAeC7P68wect59LKgo/gXCS9CCPGyyr8DA3dD4XIQHwlLW8HRBfnudmoAJ0snvnvrO8bVGoe52pw9t/bQ4bcOhESFZOo8KpWK998qzeQ2FQBYfPA64zaclhWpRToSXoQQ4lUUKg39d0GF9qBPg62jYctISEsxdWXZTqVS0c27GytbrsTD3oO7iXfpvb03i88uzvTSAj19PZnRsQpqFaw5fothq06SkvbyyxOIvEXCixBCvCoLW+iwCJp8DqggeLFhUruE/DlvSbkC5QhoFUBzr+boFB0zg2fywZ8fZLob6V2fYvzYtTrmGhW/nzGsSJ2UKitSCwkvQgiRNVQqqDcSuqw2jIO5cRB+agSRZ01dmUnYmNswtf5UPvX9FK1ay75b+16qG6l5JTd+7lXTuCJ1r0VHiUvKf3d3ifQkvAghRFYq+zb03wlOXhATDgubwfnNpq7KJFQqFR3LdGRly5V42nsau5EWnV2UqW6kBmUK80vf2thZmHEk7AHdfz7Cw4T81y0n/ibhRQghsppzORjwJ3g1MMwHs6YH7JkK+vw5ZqNsgbKsbrXa2I00K3gW7+96n4dJD1/4HLW8CrBywBs4WZtz6lYM7/10mKjYpNdYtcjJJLwIIcTrYF0Aum+A2v6G7T1fwbrekJJg0rJM5Uk30me+n6FVa9l/ez8df+vIyaiTL3yOSsUcWDPIF2c7Cy7ejaPT/CBuPcz8rL4i95PwIoQQr4vGDJpPhXe+N6yLdP5XWOgHj8JNXZlJqFQqOpTpkK4bqc/2PpnqRirtYsc6/zoUc7Li+v1EOs4L4tq9+NdcuchpJLwIIcTrVr0n9N4CNoXh7hnDQN4bh0xdlcm8ajdS8YLWrPX3pWRhGyJikug0P4jzd/LfSt/5mYQXIYTIDsXfgAG7wbUSJEYblhQIXmLqqkzmVbuR3BysCBjkS3k3e6LjU3jvpyBOhL/4GBqRu0l4EUKI7OLoDn3/gPJtQZ8Kvw2HrWPy5cKO8OrdSIVsLVg18A18PJyITUqj+89HOHQlf86tk99IeBFCiOyktYGOS6DRJ4btoz/B8vaQ+MCkZZnSk26kFl4tMt2N5GBlzrJ+tahXqhCJKTp6LznGzvP5b5HM/EbCixBCZDeVChqMgc7LwdwGwvbBgrcgKtTUlZmMjbkNX9f/ms99P8dCY2HsRnqRSe2stWb83KsGTcu7kJKmx395MJtP3Xn9RQuTkfAihBCm4t0a+geCY3F4GAY/N4WL20xdlcmoVCreLfMuK1qsSNeNtPz8cpT/WOzS0lzDnG7VaVO1CGl6heGrT7LqaP68qys/kPAihBCm5FIBBuwBj3qQEgerusCh7/PlytRPPOlG8vP0I01JY+qxqXy490PiU55/S7S5Rs2sTlXpWrs4igLjN5zh5/3XsqlqkZ0kvAghhKnZFISem8CnD6DAjk8MK1Pn04G8YOhGmvbmNMbVGoeZ2ozAG4G89/t7XHp46bmvU6tVfNm2IoPeLAHAF7+H8v2uy//ZciNyFwkvQgiRE2jModUs8PsK48rUKztBUoypKzMZlUpFN+9uLHl7Ca42rtyIvUG337vx65Vf//N145qXY1TTMgDMCLzEN39clACTh0h4EUKInEKlAt+h8N4KMLeGq38aZuR9eMPUlZlUlcJVWNNqDXWL1CVJl8QnBz/h80Ofk5T27LWNVCoVwxqX5pOW3gDM3XOVSb+dR6+XAJMXSHgRQoicplxL6LMN7NzgXij83BhuHTd1VSblZOnEnCZzGFp1KCpUrL+8nh7benAz9uZzX9e/fgm+aFsRgCWHrjNuw2l0EmByPQkvQgiRExWpCv13gUslSLgHS1rCuU2mrsqk1Co1/lX8md90Pk4WTlx4cIFOWzqx68au576u+xsezOhYBbUK1hy/xciAEFJ1+XOF77xCwosQQuRUDkWh7zYo7QdpSbC2F+yfma/vRALwLeLLmtZrqFq4KvGp8YzYM4Lpx6aTqn/2AOd3fYrxfZfqmKlVbD51hyErTpCcpsvGqkVWkvAihBA5mYUddFkFtf0N27smweYPIC3FtHWZmKuNK4veXkTP8j0BWHp+Kf3+6MfdhGfPrtuyshvze/igNVMTeP4u/Zce53GKBJjcSMKLEELkdGoNNJ8KzaeBSg0nl8GKd+Fx/l6I0FxtzpiaY5jVcBa25racjDpJpy2dOBxx+JmvaeztwuLeNbEy17D/cjS9Fh8lPjktG6sWWUHCixBC5Ba1B0KX1aC1NSwpsLAZPAgzdVUm18SjCQGtAijrVJYHSQ8YuGMg80/Nf+bijnVLFeKXfrWwszDjaNgDuv18hJjE/DunTm70UuFlzpw5eHl5YWlpiY+PD/v373/u8Xv37sXHxwdLS0tKlCjBvHnznjpm9uzZlC1bFisrK9zd3Rk5ciRJSc++DU4IIfKlMn7QdzvYF4XoS4Y7kcKPmLoqkytuX5zlLZbTvnR7FBR+CPmBIbuGPHNxx5qeBVgxoDaO1uacuvmI9xYcJjo+OZurFi8r0+ElICCAESNGMGHCBE6ePEn9+vVp3rw54eEZryERFhZGixYtqF+/PidPnuTjjz9m2LBhrF+/3njMihUrGDduHJ999hmhoaEsXLiQgIAAxo8f//LvTAgh8irXSjDgT3CrCon3YWlrOLPO1FWZnKWZJZPqTGJynclYaCw4ePsgnbd05mz02QyPr1zMkdUD36CQrQWhEbF0nh9EZIz8ozk3UCmZnHKwdu3aVK9enblz5xr3eXt707ZtW6ZMmfLU8WPHjmXz5s2Ehv69Wqq/vz+nTp0iKCgIgPfff5/Q0FB27fr7drcPP/yQo0eP/merzhOxsbE4ODgQExODvb19Zt6SEELkTikJsGEgXNhi2G70Cbw52jDZXT538cFFRu0ZRXhcOOZqc8bXHk+H0h1QZfDZXLsXT7efjxARk0TxAtas6F8b9wLWJqg6f3qZ7+9MtbykpKQQHBxMs2bN0u1v1qwZhw4dyvA1QUFBTx3v5+fH8ePHSU019DHWq1eP4OBgjh49CsC1a9fYunUrLVu2fGYtycnJxMbGpnsIIUS+orWBTr+A7/uG7d1fwEZ/SJPuj7IFyrKq1SoauTciVZ/K5KDJfHLwEx6nPX7q2BKFbVkzyJfiBawJf5BIp/lBXLv3/EUghWllKrxER0ej0+lwcXFJt9/FxYXIyMgMXxMZGZnh8WlpaURHRwPw3nvv8b///Y969ephbm5OyZIladSoEePGjXtmLVOmTMHBwcH4cHd3z8xbEUKIvEGtAb8vDesiqTRwejUsa5/v70QCsNfaM7vRbEZUH4FapWbz1c302JrxrLzuBaxZM8iXkoVtiIhJotP8w1yMjDNB1eJFvNSA3X83uymKkmFT3POO/+f+PXv28OWXXzJnzhxOnDjBhg0b2LJlC//73/+eec7x48cTExNjfNy8+fwpooUQIk+r0Re6rQULe7hxABa9DY/k70W1Sk2/Sv34qelPFLAswMWHF+m8pTN7bu556lhXB0sCBvlSztWO6PhkOv8UxJlb+XdhzJwsU+GlUKFCaDSap1pZoqKinmpdecLV1TXD483MzChYsCAAEydOpEePHvTv359KlSrRrl07vvrqK6ZMmYJen/GtbhYWFtjb26d7CCFEvlaq8V9rIhWBexdgYVOIPGPqqnKE2m61CWgVQOXClYlLjeODPz/guxPfodOnn6SukK0Fqwe+QRV3Rx4lptJ1wWGCbzwwUdXiWTIVXrRaLT4+PgQGBqbbHxgYSJ06dTJ8ja+v71PH79ixgxo1amBubg5AYmIianX6UjQaDYqiyBLmQgiRGa4VoX8gFPaGuAhY1Byu7jZ1VTmCq40rS/yW0LVcVwAWnFmA/05/HiSlDyeO1lqW96tFLa8CxCWn0WPhUQ5djTZFyeIZMt1tNGrUKH7++WcWLVpEaGgoI0eOJDw8HH9/w9TV48ePp2fPnsbj/f39uXHjBqNGjSI0NJRFixaxcOFCRo8ebTymdevWzJ07l9WrVxMWFkZgYCATJ07knXfeQaPRZMHbFEKIfMShmGEuGM/6kBIHKzrAqdWmripHMNcY7jz6uv7XWJlZcTjiMJ23dOb0vdPpjrOzNGdpn1rUL12IxBQdfRYfY8/FKBNVLf4t07dKg2GSum+++YaIiAgqVqzIrFmzePPNNwHo3bs3169fZ8+ePcbj9+7dy8iRIzl37hxFihRh7NixxrADkJaWxpdffsmyZcu4ffs2hQsXpnXr1nz55Zc4Ojq+UE1yq7QQQvxLWjJsGgxn/5pXq/GnUG+U3Er9l8sPLzNqzyiux17HTG3GuJrj6FS2U7pxmkmpOoauOMGuC1GYa1T80LU6fhVcTVh13vMy398vFV5yIgkvQgiRAb0edn4Gh74zbNfoa1gjSWNm2rpyiPiUeCYenMjO8J0AtC7Rmom+E7EyszIek5KmZ0TASbaeiUSjVjG7c1VaVyliqpLznNc+z4sQQohcRq2GZv+D5t8AKji+CAK6Gya4E9hqbZnZcCYf+nyIRqXht2u/0W1rN8Jj/541Xmum5rv3qtGuWlF0eoXhq0+yLviWCasWEl6EECI/qD0IOi8DM0u4tM2wpECCDEIFw7QdvSv2ZkGzBRS0LMjlh5fpvKUzf4b/aTzGTKNmRscqdKnljl6B0WtPsfzwDRNWnb9JeBFCiPzCuzX03AxWTnA72HAr9f2rpq4qx6jpWpM1rddQzbka8anxDN89nNnBs0nTpwGgVqv4ql0letfxBOCTTWdZeEBW9TYFCS9CCJGfFK8N/QLBsTg8uGYIMLeOm7qqHMPZ2pmFfgvp7t0dgIVnF6a7nVqlUvFZ6/IMalACgP9tOc+Pu6+YrN78SsKLEELkN4VKQ7+df69KvaQVXNxm6qpyDHO1OWNrjWXam9OwMrPiSMQROm/pzJl7hgn/VCoV494ux4gmpQGY9sdFZuy4KPOSZSMJL0IIkR/ZuUDv36FUE0h7DKu7GgbzCqO3vd5mVctVeNp7EpkQSa/tvVh7aa1xSZwRTcowrnk5AL7/8wpfbQ2VAJNNJLwIIUR+ZWELXVZDte6g6GHLSNg1GeQL2KikY0lWtVxF4+KNjatTf3roU5LSkgDwb1CSSe9UAGDB/jA+/fUcer18fq+bhBchhMjPNObwzg/QcLxhe/8Mw8R2aSmmrSsHsdXaMqvhLOPq1JuubKLntp7cjr8NQK86nnzdvhIqFSw7fIOx60+jkwDzWkl4EUKI/E6lgobjDCFGpYFTq2BVZ0iON3VlOYZKpaJfpX7MbzofJwsnQh+E0nlLZw7ePgjAe7WKM6tTVTRqFWuDbzEiIIRUXcYLC4tXJ+FFCCGEQfUe0DUAzG3g6p8yF0wG3nB7g4BWAVQsWJGY5BgG7xzM/FPz0St62lYryg9dqmGmVvHbqTu8v/IEyWm6/z6pyDQJL0IIIf5Wuin0+g2sCsCdE7DIDx7KZGz/5GbrxtLmS+lYpiMKCj+E/MCwP4cRmxJL80pu/NTTB62Zmj/O3WXQsmCSUiXAZDUJL0IIIdIr5gN9/wAHd7h/xRBg7p4zdVU5ilaj5VPfT5lcZzJatZa9t/by3pb3uPjgIm+Vc2FRr5pYmqvZc/EefZccIzElzdQl5ykSXoQQQjytcBnotwMKe0NcBCxuDjeCTF1VjtOudDuWtVhGEZsi3Iy7Sfet3dlybQv1ShdiaZ9a2Gg1HLp6n54LjxKXlGrqcvMMCS9CCCEyZl8E+m4D9zcgKQaWtYULW01dVY5TvmB5AloFULdIXZJ0SYzfP54pR6ZQ3cOe5f1rY29pxvEbD+n+8xEeJcpdXFlBwosQQohns3KCHhuhTHNIS4KAbnDiF1NXleM4WjryY+MfGVR5EAArL6yk7x99KVoolZUD3sDJ2pxTt2LosuAI9+OTTVxt7ifhRQghxPNpraHzcqj612R2mz8wzAcjk9mlo1FreL/a+3z/1vfYmdsRci+ETr91IklzmdUDfSlka0FoRCzv/XSYqNgkU5ebq0l4EUII8d80ZtDmB6g30rC9azJsHw96mcvk3xq6N2R1q9WUdirN/aT79N/Rn6MPNhEwsDau9pZcjoqn0/wg7jx6bOpScy0JL0IIIV6MSgVNPge/KYbtI3NhwwCZjTcDxe2Ls7z5clp4tUCn6Pjm2DfMD/0fv/SrSjEnK67fT6TT/CDC7yeautRcScKLEEKIzPEdAu0XgNoMzq6T2Xifwdrcmq/rf824WuMwU5mx7fo2xh7uz6xuRfEqZMOth4/pND+Iq/fks8ssCS9CCCEyr3In6BIA5tYyG+9zqFQqunl3Y6HfQgpZFeLKoysM29eb4a1TKO1sS2RsEp3nH+ZiZJypS81VJLwIIYR4OaWbyGy8L6i6S3XWtFpDdefqxKfGM/HwhzSte5JybrZExyfz3k9BnL0dY+oycw0JL0IIIV5esRoyG+8LKmxdmJ/9fqabdzcAll1YSNGyK6hYTMPDxFS6LDjMyfCHJq4yd5DwIoQQ4tXIbLwvzFxtzrha45hSfwqWGkuO3g0ixXUWlbziiEtKo/vPRzhy7b6py8zxJLwIIYR4dRnNxntxm6mryrFalWjF8hbLcbdzJyLhDhE20/EufYGEFB29Fh/lwGUZP/Q8El6EEEJkjX/Pxru6G5xeY+qqcqyyBcqyquUqGhRrQLIumVtmS/Aqt52ktBT6Lj3GnxfumrrEHEvCixBCiKyjtYbOy6ByZ1B0hnlgjvxk6qpyLAcLB7576zuGVB2CChXRqj24lVtEKg8ZtCyY7WcjTF1ijiThRQghRNbSmEPbeVDLsM4P28bA3m9kOYFnUKvUDK4ymB8b/4id1o54ruFU+kf0FlcYuvIkv4bcNnWJOY6EFyGEEFlPrYbmU6HheMP27i9lOYH/UL9YfQJaBVDWqSypxGLjsRC1415GBJxkzbGbpi4vR5HwIoQQ4vVQqaDhOHj7a8P2kbnw61DQpZm2rhzM3c6dZS2W0bpEaxT0WLpsxaLIKj7acIxfgq6burwcQ8KLEEKI1+uNwYZuJJUGTq2ENT0hVVZVfhYrMyu+rPclE2pPwExthrn9aay9fuSzbXv4ad9VU5eXI0h4EUII8fpV7QKdl4PGAi7+Dis6QLJMif8sKpWK98q9x2K/xThbOaOxiMLG8we+2b+Ob3deRsnn44ckvAghhMge5VpA9/WgtYPr+/9aD0kmZHueqs5VCWgdQA2XGqg0yVgVW86Pp77l6+3n83WAkfAihBAi+3jVh16b/1oP6aRhNt4YuZvmeQpZFWJBswX0Kt8LAItCe/klbALjfw3KtwFGwosQQojsVbQ69N0O9kUh+qJhPaT7MpbjeczUZoyuOZrpDaZjrrLEzOYqv0V/xOB1G9Hr81+AkfAihBAi+xUuawgwBUpCzE1DgIk4beqqcjw/Tz/WvrOagtpiqM1jOJAwmc6rZpKapjN1adlKwosQQgjTcCxuWJHatRIk3IMlrWRBxxdQ0rEkW95dSwWHeqhUOi6kLeHtlUOJTUo0dWnZRsKLEEII07EtDL1/h+J1IDkGlrWDSztMXVWOZ6u1ZVWbObQqNgBFURGlHKTp6o5ceXjD1KVlCwkvQgghTMvSwXAXUulmkPYYVneBM+tMXVWOp1KpmNJ4GB+Un4aSZkOiKpwOv3Yi8PpuU5f22kl4EUIIYXpaa3hvJVTsAPo0WN8fjv1s6qpyhUG1/JjquxglqTg6VSKj9gxn9vEf0Ct5dykGCS9CCCFyBo05tF8ANfsDCvz+IRyYZeqqcoWW5b35udlCiPEFlcLCc/Px3zGUmOQYU5f2Wkh4EUIIkXOo1dBiOtQfbdje+TnsmiwrUr+AN7xcWdl+Gqro91D0ZgRFHqDj5s6E3g81dWlZTsKLEEKInEWlgsYTockkw/b+GbDtI1mR+gVUKuZAQNcP0EYNR59SgIjE23Tf2oNfr/xq6tKylIQXIYQQOVO9EdByBqCCoz/B5vdlReoX4O1mz5o+HbCJ/pC0+LKk6JP55OAnTA6aTIouxdTlZQkJL0IIIXKumv2h3XzDitQhK2B9X0jLG1/Ar1MpZ1vWDmyMU5w/yfeagKJi7aW19NzWkzvxd0xd3iuT8CKEECJnq9IZOi0FjRbO/2q4lTol/0zI9rI8Ctqw1r8uRZR3SLzZG/TWnLt/jk5bOnHw9kFTl/dKJLwIIYTI+bxbQ5fVYGYFV3bC8nchKdbUVeV4RR2tWDPIlxI2PsRfex9VcjFikmMYvHMwc0/NzbW3U0t4EUIIkTuUagw9NoKFPYQfgl/egcQHpq4qx3O2tyRgkC8VnD2JDRsEsW+goDAnZA5Ddw3lUdIjU5eYaRJehBBC5B4evtDrN7AuCHdOwuIWEBdp6qpyvAI2WlYOeAOf4s7E3W6LPqoT5motB24foPOWzpy7f87UJWaKhBchhBC5S5Gq0Gcb2LnBvVBY9DbkkzV9XoW9pTm/9K1FnZIFSbhfncSwIRSyKMKdhDv02NqDdZfWoeSS+XQkvAghhMh9Cpc1BBhHD3gYZggw9y6Zuqocz8bCjEW9a/JWOWeSEl25dW4g5R18SdWnMiloEhMPTiQpLcnUZf4nCS9CCCFypwJe0Hc7FCoLcXdgcXOIOGXqqnI8S3MN87r70LKSG6mplhw/+g5NXfugVqn59eqvdN/anZuxN01d5nNJeBFCCJF72ReBPlvBtTIkRsOS1nDzqKmryvG0Zmq+fa8q71Yvhk6vYuOesrzn/gUFLAtw8eFFOm/pzJ6be0xd5jNJeBFCCJG72RSC3lvA/Q1IjoFf2sK1PaauKscz06iZ1qEyPd7wQFFg/h9q2rvMoErhKsSlxvHBnx/w7YlvSdPnvFmNJbwIIYTI/SwdoMcGKPkWpCbAio5wYaupq8rx1GoVk9tUYNCbJQCYtf0uNS0+ppt3NwB+PvMz/oH+3H9835RlPkXCixBCiLxBa2OYyK5cK9ClQEB3OL3W1FXleCqVinHNyzGySRkAZgWGoX7Qlqn1p2JlZsWRyCN02tKJkKgQ0xb6DxJehBBC5B1mFtBxKVR+DxQdbBgAwUtNXVWOp1KpGN6kNBNaeAMwZ89Vjp71YEXzlXg5eBGVGEWf7X0IvBFo4koNJLwIIYTIWzRm0HYu1OgLKPDbMDg8z9RV5QoD3izBl+0qolLBkkPXWfBnAsubr6SZRzMcLByoUriKqUsEXjK8zJkzBy8vLywtLfHx8WH//v3PPX7v3r34+PhgaWlJiRIlmDfv6f+JHj16xNChQ3Fzc8PS0hJvb2+2bpX+SiGEEC9BrYaWM8H3fcP29rGwf4Zpa8olutX2YEbHKqhVsOb4LSZsuMyUet+wutVqnK2dTV0e8BLhJSAggBEjRjBhwgROnjxJ/fr1ad68OeHh4RkeHxYWRosWLahfvz4nT57k448/ZtiwYaxfv954TEpKCk2bNuX69eusW7eOixcvsmDBAooWLfry70wIIUT+plJBsy+gwVjD9q7JsOt/kEtmkTWl9tWL8WPX6phrVPx26g5DVpzEUVvY1GUZqZRMzgVcu3Ztqlevzty5c437vL29adu2LVOmTHnq+LFjx7J582ZCQ0ON+/z9/Tl16hRBQUEAzJs3j2nTpnHhwgXMzc1f6o3Exsbi4OBATEwM9vb2L3UOIYQQedSB2bDzM8PvbwwBv68M4UY81+4LUfgvDyY5TU/90oX4qUcNrLSaLL3Gy3x/Z6rlJSUlheDgYJo1a5Zuf7NmzTh06FCGrwkKCnrqeD8/P44fP05qaioAmzdvxtfXl6FDh+Li4kLFihX56quv0Ol0z6wlOTmZ2NjYdA8hhBAiQ/VGQPNpht8Pz4EtI0CvN2VFuUKjcs4s7lMTa62G/Zej+e3UHVOXBGQyvERHR6PT6XBxcUm338XFhcjIjFf1jIyMzPD4tLQ0oqOjAbh27Rrr1q1Dp9OxdetWPvnkE2bMmMGXX375zFqmTJmCg4OD8eHu7p6ZtyKEECK/qT0Q2vwIKjUEL4FN/qDLeROw5TR1ShZiWb/aDG9cmo41ipm6HOAlB+yq/tXUpijKU/v+6/h/7tfr9Tg7O/PTTz/h4+PDe++9x4QJE9J1Tf3b+PHjiYmJMT5u3szZ6zAIIYTIAap1h/YLQKWB0wGwrjekpZi6qhzPx8OJkU3LPPe7PjuZZebgQoUKodFonmpliYqKeqp15QlXV9cMjzczM6NgwYIAuLm5YW5ujkbzdz+at7c3kZGRpKSkoNVqnzqvhYUFFhYWmSlfCCGEgEodwNwK1vaG0N9gdVfovMywT+QKmWp50Wq1+Pj4EBiYfpKawMBA6tSpk+FrfH19nzp+x44d1KhRwzg4t27duly5cgX9P/ofL126hJubW4bBRQghhHgl5VoaZuM1s4IrgYblBJLjTV2VeEGZ7jYaNWoUP//8M4sWLSI0NJSRI0cSHh6Ov78/YOjO6dmzp/F4f39/bty4wahRowgNDWXRokUsXLiQ0aNHG48ZPHgw9+/fZ/jw4Vy6dInff/+dr776iqFDh2bBWxRCCCEyUKoxdF8PWlu4vh+WtYPHj0xdlXgBmeo2AujcuTP3799n8uTJREREULFiRbZu3YqHhwcAERER6eZ88fLyYuvWrYwcOZIff/yRIkWK8N133/Huu+8aj3F3d2fHjh2MHDmSypUrU7RoUYYPH87YsWOz4C0KIYQQz+BZF3puhuXt4NZRWNoaemwCm4Kmrkw8R6bnecmpZJ4XIYQQLy3yDPzSFhKjobA39NwEdq6mripfeO3zvAghhBB5kmsl6LMV7NzgXigsbg6P5C7WnErCixBCCAFQuCz02QaOxeHBNUOAuX/V1FWJDEh4EUIIIZ4o4GUIMAVLQcxNWNwCoi6YuirxLxJehBBCiH9yKAa9t4JzeYiPhCUtIOK0qasS/yDhRQghhPg3Oxfo/Tu4VYXE+7C0FdwKNnVV4i8SXoQQQoiMWBeAnr9CsVqQFAO/tIEbQaauSiDhRQghhHg2K0fosRE860NKHCxvD9f2mLqqfE/CixBCCPE8FrbQdQ2UbAypibCiE1zaYeqq8jUJL0IIIcR/0VpDl1VQtiXokg2LOYb+Zuqq8i0JL0IIIcSLMLOATkuhQjvQp8KaXnBmnamrypckvAghhBAvSmMO7X+GKl1A0cH6/nBimamrynckvAghhBCZoTGDNnPApw+gwOb34egCU1eVr0h4EUIIITJLrYZWs6D2YMP21tFw6HvT1pSPSHgRQgghXoZKBW9PgXqjDNs7PoG934CimLaufEDCixBCCPGyVCpo8hk0+sSwvftL2DVZAsxrJuFFCCGEeFUNxkCzLwy/H5gJ28dLgHmNJLwIIYQQWaHOB9BiuuH3I3NhywjQ601aUl4l4UUIIYTIKrUGQJsfARUEL4Ffh4AuzdRV5TkSXoQQQoisVK07vPszqDRwahVs6A+6VFNXladIeBFCCCGyWqUO0HEJqM3h3EbDbLxpyaauKs+Q8CKEEEK8DuXfgfdWgsYCLv4Oq7pASqKpq8oTJLwIIYQQr0uZZtBtDZhbw9VdsLITJMebuqpcT8KLEEII8TqVaAjd14PWDq7vh+XtISnG1FXlahJehBBCiNfNow70/BUsHeDmEfilDSQ+MHVVuZaEFyGEECI7FPOBXlvAuiDcOQlLW0P8PVNXlStJeBFCCCGyi1tl6P072LrA3bOwpCXERpi6qlxHwosQQgiRnZy9ofdWsC8K0RdhcXN4dNPUVeUqEl6EEEKI7FaoFPTZCo7F4WEYLG4BD66ZuqpcQ8KLEEIIYQpOntBnOxQoCTHhhgBz75Kpq8oVJLwIIYQQpuJQFPpsg8LeEBcBS1rA3XOmrirHk/AihBBCmJKdi2EQr2slSLhnGMR7J8TUVeVoEl6EEEIIU7MpCL1+g6I+8PghLH0Hbh41dVU5loQXIYQQIiewcoIem6C4LyTHwLJ2cP2gqavKkSS8CCGEEDmFpb1hKQGvBpASD8vfhat/mrqqHEfCixBCCJGTaG2gawCUbgZpj2FlZ7i43dRV5SgSXoQQQoicxtwKOq+Acq1AlwIB3eDcJlNXlWNIeBFCCCFyIjMtdFwCFTuAPg3W9YFTAaauKkeQ8CKEEELkVBpzaP8TVO0Oih42DoLgJaauyuQkvAghhBA5mVoD73wPNQcACvw2HA7PM3VVJiXhRQghhMjp1GpoMQ3qfGDY3j4WDswybU0mJOFFCCGEyA1UKmj6P2gw1rC983PY/RUoiknLMgUJL0IIIURuoVJBo4+h8WeG7b1TIfDTfBdgJLwIIYQQuU39UfD2VMPvh76DrWNArzdtTdlIwosQQgiRG73hD61mAyo4tgB++wD0OlNXlS0kvAghhBC5VY0+0G4+qNRwcjlsGAi6VFNX9dpJeBFCCCFysyqdocNiUJvB2XWwtjekpZi6qtdKwosQQgiR21Voa1hOQKOFC1sMywmkPjZ1Va+NhBchhBAiLyj7tmFBRzMruLwDVnaClARTV/VaSHgRQggh8oqSb0H39aC1hbB9sKw9JMWauqosJ+FFCCGEyEs860LPX8HSAW4ehl/egcQHpq4qS0l4EUIIIfKaYjWg129gVQDunISlrSH+nqmryjISXoQQQoi8yK0K9NkKti5w9ywsaQGxd0xdVZaQ8CKEEELkVc7e0Gcb2BeD6Euw6G14eN3UVb0yCS9CCCFEXlawJPTdBk5e8OgGLGoO0ZdNXdUrkfAihBBC5HWOxQ0tMIXLQdwdWNwcIs+auqqXJuFFCCGEyA/s3aD37+BaGRLuwZKWcDvY1FW9lJcKL3PmzMHLywtLS0t8fHzYv3//c4/fu3cvPj4+WFpaUqJECebNm/fMY1evXo1KpaJt27YvU5oQQgghnsWmkOEupGK1IOkRLG0DNw6ZuqpMy3R4CQgIYMSIEUyYMIGTJ09Sv359mjdvTnh4eIbHh4WF0aJFC+rXr8/Jkyf5+OOPGTZsGOvXr3/q2Bs3bjB69Gjq16+f+XcihBBCiP9m5Qg9NoJnfUiJM0xkd/VPU1eVKSpFUZTMvKB27dpUr16duXPnGvd5e3vTtm1bpkyZ8tTxY8eOZfPmzYSGhhr3+fv7c+rUKYKCgoz7dDodDRo0oE+fPuzfv59Hjx6xadOmF64rNjYWBwcHYmJisLe3z8xbEkIIIfKf1MewpqdhKQGNFjougXIts72Ml/n+zlTLS0pKCsHBwTRr1izd/mbNmnHoUMbNTkFBQU8d7+fnx/Hjx0lN/XvZ7smTJ1O4cGH69euXmZKEEEII8TLMrQyLOXq/A7oUCOgBZ9aZuqoXkqnwEh0djU6nw8XFJd1+FxcXIiMjM3xNZGRkhsenpaURHR0NwMGDB1m4cCELFix44VqSk5OJjY1N9xBCCCFEJphpocNiqPweKDpY3x9OLDN1Vf/ppQbsqlSqdNuKojy177+Of7I/Li6O7t27s2DBAgoVKvTCNUyZMgUHBwfjw93dPRPvQAghhBAAaMyg7Vyo0RdQYPP7cGS+qat6LrPMHFyoUCE0Gs1TrSxRUVFPta484erqmuHxZmZmFCxYkHPnznH9+nVat25tfF6v1xuKMzPj4sWLlCxZ8qnzjh8/nlGjRhm3Y2NjJcAIIYQQL0OthpYzwdwagn6AbR9BSgLUH/XfrzWBTIUXrVaLj48PgYGBtGvXzrg/MDCQNm3aZPgaX19ffvvtt3T7duzYQY0aNTA3N6dcuXKcOXMm3fOffPIJcXFxfPvtt88MJBYWFlhYWGSmfCGEEEI8i0oFzb4ArS3s/Rp2TTIEmLc+MTyXg2QqvACMGjWKHj16UKNGDXx9ffnpp58IDw/H398fMLSI3L59m19++QUw3Fn0ww8/MGrUKAYMGEBQUBALFy5k1apVAFhaWlKxYsV013B0dAR4ar8QQgghXiOVChqNB601BH4K+6cbAszbU3JUgMl0eOncuTP3799n8uTJREREULFiRbZu3YqHhwcAERER6eZ88fLyYuvWrYwcOZIff/yRIkWK8N133/Huu+9m3bsQQgghRNapO9zQhbR1NByZC6kJ0Go2qDWmrgx4iXleciqZ50UIIYTIYiEr4dehoOihUkdoO88wwDcLvfZ5XoQQQgiRj1TtCh0WgdoMzqyFkznjNuqsjU9CCCGEyFsqtDN0IV34Har3MnU1gISX/7d3PyFN/3Ecx19TyaJ0RJSbKcP+GFjqIUHnxbLslxQIQZRE2KVLHYyEoCD0ECgdgiIookue7FCd+oMe0g4iqCEN6SC4wkgdReIINdDP7xD7/vKnzs2+v9/2Xc8HDGTfr/D2xWvz7fzqAADAagr/+nlLEvzaCAAAOArLCwAAcBSWFwAA4CgsLwAAwFFYXgAAgKOwvAAAAEdheQEAAI7C8gIAAByF5QUAADgKywsAAHAUlhcAAOAoLC8AAMBRWF4AAICjpMy7ShtjJEnT09MJngQAAMQq8n078n08FimzvITDYUlSfn5+gicBAADxCofDcrvdMZ3rMvGsOklsYWFBnz9/VlZWllwuV6LHSTrT09PKz8/X2NiYsrOzEz2O45GnfcjSXuRpH7K010p5GmMUDoeVm5urtLTYrmZJmVde0tLSlJeXl+gxkl52djYPQhuRp33I0l7kaR+ytNdyecb6iksEF+wCAABHYXkBAACOwvLyh8jMzFRzc7MyMzMTPUpKIE/7kKW9yNM+ZGkvO/NMmQt2AQDAn4FXXgAAgKOwvAAAAEdheQEAAI7C8gIAAByF5SXF3Lt3TyUlJdY/AfL7/Xr58qV13BijlpYW5ebmasOGDTpw4ICGh4cTOHHyWi3Lc+fOyeVyLbpVVFQkcGLnaG1tlcvl0qVLl6z76ObaLZcn/YxdS0vLkqw8Ho91nG7GbrUs7eoly0uKycvLU1tbmwYGBjQwMKDq6mrV1dVZD7SbN2/q1q1bunv3rvr7++XxeFRTU2O9NxT+sVqWknT06FGNj49btxcvXiRwYmfo7+/XgwcPVFJSsuh+urk2K+Up0c947N27d1FWgUDAOkY34xMtS8mmXhqkvM2bN5uHDx+ahYUF4/F4TFtbm3VsdnbWuN1uc//+/QRO6ByRLI0xpqGhwdTV1SV2IIcJh8Nm9+7dpqury1RVVZnGxkZjjKGba7RSnsbQz3g0Nzeb0tLSZY/RzfhEy9IY+3rJKy8pbH5+Xh0dHfr+/bv8fr+CwaAmJiZ05MgR65zMzExVVVWpt7c3gZMmv39nGdHd3a1t27apsLBQ58+fVygUSuCUye/ixYs6duyYDh8+vOh+urk2K+UZQT9jNzIyotzcXBUUFOj06dMaHR2VRDfXYqUsI+zoZcq8MSP+EQgE5Pf7NTs7q02bNunZs2cqKiqyHmg5OTmLzs/JydHHjx8TMWrSWylLSaqtrdXJkyfl8/kUDAZ1/fp1VVdXa3BwkP/IuYyOjg69fftW/f39S45NTExIopvxiJanRD/jUV5ervb2dhUWFmpyclI3btxQZWWlhoeH6WacomW5ZcsW23rJ8pKC9uzZo6GhIU1NTenJkydqaGhQT0+Pddzlci063xiz5D78tFKWRUVFOnXqlHXevn37VFZWJp/Pp+fPn+vEiRMJnDr5jI2NqbGxUZ2dnVq/fv2K59HN2MSSJ/2MXW1trfVxcXGx/H6/du7cqUePHlkXk9LN2ETL8vLly7b1kl8bpaB169Zp165dKisrU2trq0pLS3X79m3riu/ITxIRoVBoyU8V+GmlLJfj9Xrl8/k0MjLyP0+Z/AYHBxUKhbR//35lZGQoIyNDPT09unPnjjIyMqz+0c3YrJbn/Pz8ks+hn7HbuHGjiouLNTIywvPmb/o1y+WstZcsL38AY4zm5uZUUFAgj8ejrq4u69iPHz/U09OjysrKBE7oHJEsl/P161eNjY3J6/X+z1Mlv0OHDikQCGhoaMi6lZWV6cyZMxoaGtKOHTvoZhxWyzM9PX3J59DP2M3Nzen9+/fyer08b/6mX7Nczpp7+duX/CKpXL161bx588YEg0Hz7t07c+3aNZOWlmY6OzuNMca0tbUZt9ttnj59agKBgKmvrzder9dMT08nePLkEy3LcDhsmpqaTG9vrwkGg+b169fG7/eb7du3k2WM/v3XMXTz9/yaJ/2MT1NTk+nu7jajo6Omr6/PHD9+3GRlZZkPHz4YY+hmPKJlaWcvueYlxUxOTurs2bMaHx+X2+1WSUmJXr16pZqaGknSlStXNDMzowsXLujbt28qLy9XZ2ensrKyEjx58omW5czMjAKBgNrb2zU1NSWv16uDBw/q8ePHZLlGdNM+6enp9DMOnz59Un19vb58+aKtW7eqoqJCfX198vl8kuhmPKJlaefzpssYY/6jrwEAAMB2XPMCAAAcheUFAAA4CssLAABwFJYXAADgKCwvAADAUVheAACAo7C8AAAAR2F5AQAAjsLyAgAAHIXlBQAAOArLCwAAcBSWFwAA4Ch/A7YUiRsVZWriAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Plot transitory shock variances\n", + "plt.figure()\n", + "for i in range(len(cohorts)):\n", + " coh_label = \"aggregate\" if cohorts[i] is None else cohorts[i]\n", + " plt.plot(\n", + " variances[i][\"Age\"],\n", + " np.power(variances[i][\"TranShkStd\"], 2),\n", + " label=\"Tran. {} cohort\".format(coh_label),\n", + " )\n", + "\n", + "plt.legend()\n", + "\n", + "# Plot permanent shock variances\n", + "plt.figure()\n", + "for i in range(len(cohorts)):\n", + " coh_label = \"aggregate\" if cohorts[i] is None else cohorts[i]\n", + " plt.plot(\n", + " variances[i][\"Age\"],\n", + " np.power(variances[i][\"PermShkStd\"], 2),\n", + " label=\"Perm. {} cohort\".format(coh_label),\n", + " )\n", + "\n", + "plt.legend()" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "title,-all", + "encoding": "# -*- coding: utf-8 -*-", + "formats": "ipynb,py:percent" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/Calibration/Sabelhaus_Song_var_profiles.py b/examples/Calibration/Sabelhaus_Song_var_profiles.py index 0017be6c8..908048df8 100644 --- a/examples/Calibration/Sabelhaus_Song_var_profiles.py +++ b/examples/Calibration/Sabelhaus_Song_var_profiles.py @@ -1,4 +1,21 @@ # -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# cell_metadata_filter: title,-all +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.14.5 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% """ Created on Thu Jan 14 16:44:09 2021 @@ -33,11 +50,10 @@ # Plot transitory shock variances plt.figure() for i in range(len(cohorts)): - coh_label = "aggregate" if cohorts[i] is None else cohorts[i] plt.plot( variances[i]["Age"], - np.power(variances[i]["TranShkStd"],2), + np.power(variances[i]["TranShkStd"], 2), label="Tran. {} cohort".format(coh_label), ) @@ -46,11 +62,10 @@ # Plot permanent shock variances plt.figure() for i in range(len(cohorts)): - coh_label = "aggregate" if cohorts[i] is None else cohorts[i] plt.plot( variances[i]["Age"], - np.power(variances[i]["PermShkStd"],2), + np.power(variances[i]["PermShkStd"], 2), label="Perm. {} cohort".format(coh_label), ) diff --git a/examples/Calibration/US_SSA_life_tables.ipynb b/examples/Calibration/US_SSA_life_tables.ipynb new file mode 100644 index 000000000..2141425a7 --- /dev/null +++ b/examples/Calibration/US_SSA_life_tables.ipynb @@ -0,0 +1,235 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1c047f75", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:31:19.001577Z", + "iopub.status.busy": "2023-03-16T17:31:19.001577Z", + "iopub.status.idle": "2023-03-16T17:31:20.537804Z", + "shell.execute_reply": "2023-03-16T17:31:20.537804Z" + } + }, + "outputs": [], + "source": [ + "from HARK.datasets.life_tables.us_ssa.SSATools import (\n", + " parse_ssa_life_table,\n", + " get_ssa_life_tables,\n", + ")\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b56693d8", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:31:20.540750Z", + "iopub.status.busy": "2023-03-16T17:31:20.539751Z", + "iopub.status.idle": "2023-03-16T17:31:20.617418Z", + "shell.execute_reply": "2023-03-16T17:31:20.616912Z" + }, + "title": "Inspect lifetables" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "\n", + "tables = get_ssa_life_tables()\n", + "print(tables.head)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c1d658a7", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:31:20.618931Z", + "iopub.status.busy": "2023-03-16T17:31:20.618931Z", + "iopub.status.idle": "2023-03-16T17:31:20.632466Z", + "shell.execute_reply": "2023-03-16T17:31:20.632466Z" + }, + "title": "Survival probabilities from the SSA" + }, + "outputs": [], + "source": [ + "\n", + "# We will find 1-year survival probabilities from ages 21 to 100\n", + "min_age = 21\n", + "max_age = 100\n", + "ages = np.arange(min_age, max_age + 1)\n", + "\n", + "# In the years 1900 and 1950\n", + "years = [1900, 1950]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1922e95b", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:31:20.634469Z", + "iopub.status.busy": "2023-03-16T17:31:20.634469Z", + "iopub.status.idle": "2023-03-16T17:31:20.959159Z", + "shell.execute_reply": "2023-03-16T17:31:20.958863Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Longitudinal survival probabilities')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# First, the \"longitudinal method\", which gives us the probabilities\n", + "# experienced by agents born in \"year\" throughout their lived\n", + "plt.figure()\n", + "for cohort in years:\n", + " for s in [\"male\", \"female\"]:\n", + " fem = s == \"female\"\n", + " LivPrb = parse_ssa_life_table(\n", + " female=fem, cohort=cohort, min_age=min_age, max_age=max_age\n", + " )\n", + "\n", + " plt.plot(ages, LivPrb, label=s + \" born in \" + str(cohort))\n", + "\n", + "plt.legend()\n", + "plt.title(\"Longitudinal survival probabilities\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "84551443", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-16T17:31:20.961159Z", + "iopub.status.busy": "2023-03-16T17:31:20.961159Z", + "iopub.status.idle": "2023-03-16T17:31:21.239772Z", + "shell.execute_reply": "2023-03-16T17:31:21.239772Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Cross-sectional survival probabilities')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGxCAYAAACwbLZkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACl5klEQVR4nOzdd3wURf/A8c9ev/TeCCShh95RlCZNFBRFRZEqqIA+KlixIaigYsEGqIiI+hNUEBUQLEiT3nsvCSEhIb1e3d8fFw5iEkhCIJTv+3n2dbezs7MzlyP5Ojs7o6iqqiKEEEIIUUU0VV0BIYQQQlzfJBgRQgghRJWSYEQIIYQQVUqCESGEEEJUKQlGhBBCCFGlJBgRQgghRJWSYEQIIYQQVUqCESGEEEJUKQlGhBBCCFGlJBgR5bJjxw6GDh1KTEwMJpMJLy8vWrRowTvvvENaWlpVV++KtWbNGl577TUyMjKKHevUqROdOnW67HUqybFjx1AUhVmzZlV1VcrlctR7+fLlKIrC8uXLL9k1yutMu999991KK/NMO3/66acL5n3ttddQFKVIWknfZ0VReO2119z7e/bs4bXXXuPYsWPFyhwyZAjR0dEVqLm4mumqugLi6vHFF18watQo6tWrx7PPPkuDBg2w2Wxs2rSJ6dOns3btWn7++eeqruYVac2aNYwfP54hQ4bg5+dX5NjUqVOrplLXkPDwcNauXUutWrWquirXleHDh3PrrbdeMN/atWuJjIx07+/Zs4fx48fTqVOnYoHHK6+8wpNPPlnZVRVXOAlGRJmsXbuWkSNH0q1bNxYsWIDRaHQf69atG08//TRLliw5bxn5+fmYzeZLXdWrToMGDaq6ClccVVUpKCgo8/fFaDRyww03XOJaXR55eXl4eHhUdTXKJDIyskiQUZry/GwkoLw+yW0aUSYTJ05EURQ+//zzIoHIGQaDgTvuuMO9Hx0dTa9evZg/fz7NmzfHZDIxfvx4AHbt2sWdd96Jv78/JpOJZs2a8fXXXxcpz+l08sYbb1CvXj3MZjN+fn40adKEDz/80J0nJSWFRx55hOrVq2M0GgkODuamm27ir7/+umB7jhw5wv33309ERARGo5HQ0FC6dOnCtm3biuSbO3cuN954I56ennh5edGjRw+2bt1arLz169fTu3dvAgMDMZlM1KpVi6eeegpwdWU/++yzAMTExKAoSpHu/pK6tdPS0hg1ahTVqlXDYDBQs2ZNXnrpJSwWS5F8iqLw+OOP88033xAbG4uHhwdNmzZl4cKFRfIdOnSIoUOHUqdOHTw8PKhWrRq9e/dm586dF/ysSlKWn09p3e0lde2facf06dOJjY3FaDQyY8YMQkJCGDhwYLEyMjIyMJvNjBkzBih+m2bBggUoisLff/9d7Nxp06ahKAo7duwAYNOmTdx///1ER0djNpuJjo7mgQce4Pjx4xX6bGbNmoWiKPz5558MHTqUgIAAPD096d27N0eOHCmSt1OnTjRq1IiVK1fSrl07PDw8eOihhwCIi4tjwIABhISEYDQaiY2N5b333sPpdBa7ptPp5M0336RGjRqYTCZatWpVrO3l/Q4UFBQwZswYwsLCMJvNdOzYsdh3v6SfZUnOvU0za9Ys7r33XgA6d+7s/vdw5mdX0vdGVVWmTp1Ks2bNMJvN+Pv7c8899xT7PLdu3UqvXr3cn1lERAS33347J06cuGAdRdWSnhFxQQ6Hg2XLltGyZUuqV69e5vO2bNnC3r17efnll4mJicHT05P9+/fTrl07QkJC+OijjwgMDOTbb79lyJAhnDp1iueeew6Ad955h9dee42XX36ZDh06YLPZ2LdvX5ExFwMHDmTLli28+eab1K1bl4yMDLZs2UJqauoF63bbbbfhcDh45513qFGjBqdPn2bNmjVFyp84cSIvv/wyQ4cO5eWXX8ZqtTJ58mTat2/Phg0b3D0aS5cupXfv3sTGxvL+++9To0YNjh07xh9//AG4urLT0tL4+OOPmT9/PuHh4UDpPSIFBQV07tyZw4cPM378eJo0acKqVauYNGkS27ZtY9GiRUXyL1q0iI0bNzJhwgS8vLx45513uOuuu9i/fz81a9YE4OTJkwQGBvLWW28RHBxMWloaX3/9NW3btmXr1q3Uq1evbD/UQmX5+ZTXggULWLVqFa+++iphYWGEhIRw9OhRpk+fzqeffoqPj4877/fff09BQQFDhw4tsawzf5C++uorunTpUuTYrFmzaNGiBU2aNAFcgUy9evW4//77CQgIIDExkWnTptG6dWv27NlDUFBQhdozbNgwunXrxv/93/8RHx/Pyy+/TKdOndixY0eRW3WJiYkMGDCA5557jokTJ6LRaEhJSaFdu3ZYrVZef/11oqOjWbhwIc888wyHDx8udmvvk08+ISoqiilTpuB0OnnnnXfo2bMnK1as4MYbbwTK/x148cUXadGiBTNmzCAzM5PXXnuNTp06sXXrVvf3qiJuv/12Jk6cyIsvvsinn35KixYtgPP3iDz66KPMmjWLJ554grfffpu0tDQmTJhAu3bt2L59O6GhoeTm5tKtWzdiYmL49NNPCQ0NJSkpiX/++Yfs7OwK11dcJqoQF5CUlKQC6v3331/mc6KiolStVqvu37+/SPr999+vGo1GNS4urkh6z549VQ8PDzUjI0NVVVXt1auX2qxZs/New8vLS33qqafKXKczTp8+rQLqlClTSs0TFxen6nQ69X//+1+R9OzsbDUsLEy977773Gm1atVSa9Wqpebn55da3uTJk1VAPXr0aLFjHTt2VDt27Ojenz59ugqoP/zwQ5F8b7/9tgqof/zxhzsNUENDQ9WsrCx3WlJSkqrRaNRJkyaVWh+73a5arVa1Tp066ujRo93pR48eVQH1q6++KvVcVS3bz2fw4MFqVFRUsfRx48ap//3VA6i+vr5qWlpakfQdO3aogPr5558XSW/Tpo3asmXL89Z7zJgxqtlsdn+nVFVV9+zZowLqxx9/XGq97Xa7mpOTo3p6eqoffvihO/2ff/5RAfWff/45X7PVr776SgXUu+66q0j6v//+qwLqG2+84U7r2LGjCqh///13kbwvvPCCCqjr168vkj5y5EhVURT3v6sz7Y6IiCjy/cvKylIDAgLUrl27nredJX0HzrSzRYsWqtPpdKcfO3ZM1ev16vDhw91pJf0s//t9VlXXz3fcuHHu/R9//LHUz/K/35u1a9eqgPree+8VyRcfH6+azWb1ueeeU1VVVTdt2qQC6oIFC0pts7hyyW0acck0adKEunXrFklbtmwZXbp0KdbDMmTIEPLy8li7di0Abdq0Yfv27YwaNYqlS5eSlZVVrPw2bdowa9Ys3njjDdatW4fNZityXFVV7HZ7kQ0gICCAWrVqMXnyZN5//322bt1arOt76dKl2O12Bg0aVOR8k8lEx44d3bdYDhw4wOHDhxk2bBgmk+miPq9zPyNPT0/uueeeYp8RUKz7vXPnznh7e7v3Q0NDCQkJKXKbwW63M3HiRBo0aIDBYECn02EwGDh48CB79+4tdx3L8vMpr1tuuQV/f/8iaY0bN6Zly5Z89dVX7rS9e/eyYcMG9+2M0jz00EPk5+czd+5cd9pXX32F0Wikf//+7rScnByef/55ateujU6nQ6fT4eXlRW5uboU+mzMefPDBIvvt2rUjKiqKf/75p0i6v78/t9xyS5G0ZcuW0aBBA9q0aVMkfciQIaiqyrJly4qk33333UW+f97e3vTu3ZuVK1ficDiA8n8H+vfvX+QWTFRUFO3atStW/0tt4cKFKIrCgAEDivxbDAsLo2nTpu5/i7Vr18bf35/nn3+e6dOns2fPnstaT3FxJBgRFxQUFISHhwdHjx4t13lnbkecKzU1tcT0iIgI93GAsWPH8u6777Ju3Tp69uxJYGAgXbp0YdOmTe5z5s6dy+DBg5kxYwY33ngjAQEBDBo0iKSkJAC+/vpr9Hp9kQ1wjyXo0aMH77zzDi1atCA4OJgnnnjC3Z176tQpAFq3bl2sjLlz53L69GnANW4FKNMgvrJKTU0lLCys2L34kJAQdDpdsdtQgYGBxcowGo3k5+e798eMGcMrr7xCnz59+O2331i/fj0bN26kadOmRfKVVVl+PuVV0vcCXEHF2rVr2bdvH3A2oHjggQfOW17Dhg1p3bq1O5BxOBx8++233HnnnQQEBLjz9e/fn08++YThw4ezdOlSNmzYwMaNGwkODq7QZ3NGWFhYiWn//fldzL+TC13LarWSk5MDlP87UNb6X2qnTp1CVVVCQ0OL/Vtct26d+9+ir68vK1asoFmzZrz44os0bNiQiIgIxo0bV+w/VMSVR8aMiAvSarV06dKF33//nRMnTpT5D29JA9sCAwNJTEwsln7y5EkA9/15nU7HmDFjGDNmDBkZGfz111+8+OKL9OjRg/j4eDw8PAgKCmLKlClMmTKFuLg4fv31V1544QWSk5NZsmQJvXv3ZuPGjSXWLSoqii+//BJw9W788MMPvPbaa1itVqZPn+6ux08//URUVFSpbQwODgao1AFygYGBrF+/HlVVi3yGycnJ2O32Co1h+Pbbbxk0aBATJ04skn769OlijxqXRVl+PiaTqdiA2zPXLElpAyEfeOABxowZw6xZs3jzzTf55ptv6NOnT7FelJIMHTqUUaNGsXfvXo4cOUJiYmKRcSaZmZksXLiQcePG8cILL7jTLRbLRc+bcyYo/m9a7dq1i6RdzL+TC13LYDDg5eUFlP87UFqZJQW/l1JQUBCKorBq1aoSB8+fm9a4cWPmzJmDqqrs2LGDWbNmMWHCBMxmc5Gfr7jySM+IKJOxY8eiqioPP/wwVqu12HGbzcZvv/12wXK6dOnCsmXL3L9Uz5g9ezYeHh4lPgLo5+fHPffcw2OPPUZaWlqJEyXVqFGDxx9/nG7durFlyxbA9Qu9VatWRbaS1K1bl5dffpnGjRu7z+3Rowc6nY7Dhw8XK+PcsurWrUutWrWYOXNmiX94zzjzC7Ms/6XdpUsXcnJyWLBgQbHP6Mzx8lIUpdgv8kWLFpGQkFDusv6rtJ9PdHQ0ycnJ7l4mAKvVytKlS8tVvr+/P3369GH27NksXLiQpKSkC96iOeOBBx7AZDIxa9YsZs2aRbVq1ejevbv7uKIoqKpa7LOZMWOG+/ZGRX333XdF9tesWcPx48fLNMFdly5d2LNnj/v7eMbs2bNRFIXOnTsXSZ8/fz4FBQXu/ezsbH777Tfat2+PVqsFyv8d+P7771FV1b1//Phx1qxZUykT9JXn30OvXr1QVZWEhIQS/x02bty42DmKotC0aVM++OAD/Pz8in2O4sojPSOiTG688UamTZvGqFGjaNmyJSNHjqRhw4bYbDa2bt3K559/TqNGjejdu/d5yxk3bhwLFy6kc+fOvPrqqwQEBPDdd9+xaNEi3nnnHXx9fQHo3bs3jRo1olWrVgQHB3P8+HGmTJlCVFQUderUITMzk86dO9O/f3/q16+Pt7c3GzduZMmSJdx9993nrcOOHTt4/PHHuffee6lTpw4Gg4Fly5axY8cO9389RUdHM2HCBF566SWOHDnCrbfeir+/P6dOnWLDhg14enq6H1X+9NNP6d27NzfccAOjR4+mRo0axMXFsXTpUvcfpDO/MD/88EMGDx6MXq+nXr16RcZ6nDFo0CA+/fRTBg8ezLFjx2jcuDGrV69m4sSJ3HbbbXTt2rV8Pzxcv9BnzZpF/fr1adKkCZs3b2by5MkVvr10oZ8PQL9+/Xj11Ve5//77efbZZykoKOCjjz6q0B/5hx56iLlz5/L4448TGRlZ5s/Az8+Pu+66i1mzZpGRkcEzzzyDRnP2v8F8fHzo0KEDkydPJigoiOjoaFasWMGXX35ZoR6jc23atInhw4dz7733Eh8fz0svvUS1atUYNWrUBc8dPXo0s2fP5vbbb2fChAlERUWxaNEipk6dysiRI4uNxdJqtXTr1o0xY8bgdDp5++23ycrKcn9HofzfgeTkZO666y4efvhhMjMzGTduHCaTibFjx17U5wLQqFEjAD7//HO8vb0xmUzExMSU2Oty00038cgjjzB06FA2bdpEhw4d8PT0JDExkdWrV9O4cWNGjhzJwoULmTp1Kn369KFmzZqoqsr8+fPJyMigW7duF11ncYlV1chZcXXatm2bOnjwYLVGjRqqwWBQPT091ebNm6uvvvqqmpyc7M4XFRWl3n777SWWsXPnTrV3796qr6+vajAY1KZNmxZ7euO9995T27VrpwYFBakGg0GtUaOGOmzYMPXYsWOqqqpqQUGBOmLECLVJkyaqj4+Pajab1Xr16qnjxo1Tc3Nzz9uGU6dOqUOGDFHr16+venp6ql5eXmqTJk3UDz74QLXb7UXyLliwQO3cubPq4+OjGo1GNSoqSr3nnnvUv/76q0i+tWvXqj179lR9fX1Vo9Go1qpVq8gTCqqqqmPHjlUjIiJUjUZT5EmCkp4+SE1NVUeMGKGGh4erOp1OjYqKUseOHasWFBQUyQeojz32WLE2RkVFqYMHD3bvp6enq8OGDVNDQkJUDw8P9eabb1ZXrVpV7NplfZrmQj+fMxYvXqw2a9ZMNZvNas2aNdVPPvmk1KdpSmrHGQ6HQ61evboKqC+99FKx4+er9x9//KECKqAeOHCg2PETJ06offv2Vf39/VVvb2/11ltvVXft2lXsMyzv0zR//PGHOnDgQNXPz081m83qbbfdph48eLBI3o4dO6oNGzYssZzjx4+r/fv3VwMDA1W9Xq/Wq1dPnTx5supwOIq1++2331bHjx+vRkZGqgaDQW3evLm6dOnSIuWV9Ttwpp3ffPON+sQTT6jBwcGq0WhU27dvr27atKlImRV9mkZVVXXKlClqTEyMqtVqi/zsSnsKa+bMmWrbtm1VT09P1Ww2q7Vq1VIHDRrkrtO+ffvUBx54QK1Vq5ZqNptVX19ftU2bNuqsWbNK/HzFlUVR1XP64YQQQlyUWbNmMXToUDZu3FjqrUEhRFEyZkQIIYQQVUqCESGEEEJUKblNI4QQQogqJT0jQgghhKhSEowIIYQQokpJMCKEEEKIKnVVTHrmdDo5efIk3t7epU4ZLYQQQogri6qqZGdnExERUWTCwf+6KoKRkydPFlvlVQghhBBXh/j4+PPO+HxVBCNnpsyOj4/Hx8enimsjhBBCiLLIysqievXqJS59ca6rIhg5c2vGx8dHghEhhBDiKnOhIRYygFUIIYQQVUqCESGEEEJUKQlGhBBCCFGlJBgRQgghRJWSYEQIIYQQVUqCESGEEEJUKQlGhBBCCFGlJBgRQgghRJWSYEQIIYQQVarcwcjKlSvp3bs3ERERKIrCggULLnjOihUraNmyJSaTiZo1azJ9+vSK1FUIIYQQ16ByByO5ubk0bdqUTz75pEz5jx49ym233Ub79u3ZunUrL774Ik888QTz5s0rd2WFEEIIce0p99o0PXv2pGfPnmXOP336dGrUqMGUKVMAiI2NZdOmTbz77rv07du3vJcXQgghxDXmki+Ut3btWrp3714krUePHnz55ZfYbDb0en2xcywWCxaLxb2flZV1SeqW8fMCCvbsAQUURQOKAhqNa1+jAc7uoyhn8yjK2TyKUiSfoijgLkspvn/mHEVzdr/wfEVzppyi7935NBr3K4oGRasBjdaVV6t11VGrdaX955ii1bpeNRrQ6lzHC9MVrRZ0Otcxne6CCxoJIYQQlemSByNJSUmEhoYWSQsNDcVut3P69GnCw8OLnTNp0iTGjx9/qavGxl8+J3Ld0Ut+nauNqlFQNRrQalB1riCGwuAFnQ5Fd+bVtWl0ehSDAY1Oj0ZvQKs3oDUYUfT6wk13zntXXsVgKNw3oBj0KAZjYXphWQYDitGIYjCiMRld742uPBqTyfVeI+OvhRDiWnDJgxEovnSwqqolpp8xduxYxowZ497PysqievXqlV6vg439Wa85hsZVHder6npVVFeHyJn9c48X9oUUOaacc477/bn7ha9Fyjj3Wv85x5WuonEW7jvPHtcU7p8598z7YvvnpJ95r3W63mvV0j8XxamiOB1gd4DFdsHP0Vn46ijHZ18ZFL3eFZSYTGj++2oyFb4aUUzmc/bPvmo8zK5jZhMac+F7DzMaDw/XvtnDlUeCHiGEuKQueTASFhZGUlJSkbTk5GR0Oh2BgYElnmM0GjEajZe6atw2/E0yLBk4VAdO1eneVFXFietV5exfbVVViwRQiiskQVEUzvzP9X+laNqZ/Oe5/XHmWiqq633hvlN1utOcqtNdrzN1/m/dHaoDh9Nx9rjTgV21FzvmcDqw2S04HXZUmx2Hw4bTbsNhs+J02HHa7DjtVpx2O06HDafNhmq3o9pd+c7sY7fjtNuhcF/nAJ0TtA5X4KNznNlUdIX7ejvoHWeP6R2gK0zT21XXqwMMNtdxg/uYq2z3Z2azodpskJNzSQMhxWRyBSienq7XczdPz6KblydaLy80Xl5oPF2vWi9PNN7errTL8L0WQoirzSUPRm688UZ+++23Iml//PEHrVq1KnG8yOUUmplGREEaBg8/MPoUbt5g8CwcCyLKQ1VVbE4bFocFq8OKxWGhwFGAxW4p8j7fnk++PZ8CRwH59nxy7Pnk2/LJs+eRb88nz5ZHnj2PPFseubZccu25rldbLjgc6O2uAMVgdwUsZwIXg13FYAejrehxV9rZY0YbeDr1eDi0eNi1mOyKK92qorc60VrsaCw2lMIePLWgAEdBAY60tIv+jBS93hWYeHuh9fJG4+ON1scXrY/P2fe+Pmh9fdH6+qLx9UXr64fWzw+Np4eM5xFCXJPKHYzk5ORw6NAh9/7Ro0fZtm0bAQEB1KhRg7Fjx5KQkMDs2bMBGDFiBJ988gljxozh4YcfZu3atXz55Zd8//33ldeKCtozbyItM/8slu5Eg0UxYVMM2DVG7BoDdsWAQ2PAoehQFS1ORYsD16sTDSoKTjQ4UFDR4EQp3DSuTdHiQOM6prj2VUWHes57NDrQ6kFrQNHqUbR6NDoDGr0RncGITm9CbzCiM5gwGF2b0WjGaDJhMpkxmUwYjGaUwjLQ6F2DXS8TRVEwaA0YtIZLUr6qqq5gxZ5HtjWbHGsO2bZscm25ZFuzS9xOWbPIKtyyrdnk2/MLS3MWbqXchlI16O1gsoHJ6noNUj0JxosA1RN/pxl/hxFfhxFvuw4PmwazRcVocaIrsKHm5OLIzcGZk4szJwdnbi6oKqrNhiMtDUdaWmlXLp1O5wpS/PzO2Yru6/z9z+4Xvle02gp/5kIIcTmUOxjZtGkTnTt3du+fGdsxePBgZs2aRWJiInFxce7jMTExLF68mNGjR/Ppp58SERHBRx99dEU81puiBLLXWQMv8vFW8vAiH53iCh/Mah5mNe/sgIirlB0tdnQ4FC0ORY9T0Z3dNHpUTWFQpCkMhjQ60LpelcJ9Ret6r9G63mt0BjRaHRqtHq1Oh1ZncG16VwDlKkfvCqzOBFjutP8c0+hcgZM7b+H7MwGVe9+AojXgoffAQ+9BkDmoQp+H1WF1BSeWLDKtmWQUZJBpzSTTkkmGJcO1FWSQbkl3v6ZaMnCqTuLJA/IueA2NoiHIFESIRwghHrUI8Qgh1BxCuOJLqOpNkNOTAJsRJS8fZ3Y2jswsHFmZOLOycWQVvs/IxJFZuGVkoFqtYLfjSE3FkZpa9gYrClofH7QBAa7gxN8fXUAA2sAAdIFB6AID0AYEogsMQBccjMbXV3pfhBCXnaKeGU16BcvKysLX15fMzEx8fHwqrVyHUyXXaienwE52gZ2cAiu5uTlYctKx5eeg2i2otgJUewGqzYJiz0dxOlBwoFHtaFUHiupAozrQKq6+ES0qGkU90wfiOn6m30R1olEdgNM1QNRpRyksQ3HaUR02FKcNHHZwWlGcdjQOKzhtaJxWNE4bWqcNjWpD57ShVW3osaFT7RiwYcCORrnif5wXRVU0qBoDTp0RtEbQuTZFZ0KjN6HozYVpJtemN4Peo/DVfM6+h+t2nMELDOe+P+e18I+yU3WSackkrSCNtII0UvNTSS1IJTU/ldP5p91bSn4KaQVpONULR7AKCoHmQMI9w4nwiiDCM8L16hVBNa9qRHhFYNaZ3fmd+fk4MjLcwUmRLb3ovj0jHUdGJs7MzHJ/vorBgC4oCF1wMLqQYHTBIejCw9CHhaMPD0MfHo4uJASlim+xCiGuDmX9+31dByPXEpvDSZ7VgcVipcCSj6XAQoHVgqWgAJulAJvNgs1qwWazYrNasNttOKwWHA4bDrsNh93qGphqt+Fw2FEddtTCAMnpcIDThup0FAZKNnC60hSnHR2OIptecaDFgb5w/+x7O3rlnHxn0oql29GfeVUu9zM6LioKisELjF6u4MRUOKbI/eoLJj8w+4HZ3705TD6kahSS7Xkk56eQnJdMcl4yp/JOcSr3FIm5iSTlJmF1Wi9YhyBzEJFekUR6F25ekdTwqUF17+oEmgIv2IOh2u2u4CUtDXt6Oo60dBzpadjT0nCknnlNxV64lTl4URR0YWEYIiPRV6+OoXok+sjC16godP7+ZStHCHHNk2BEXBaqqmJ3qhTYHFjsTix2JwU2B1a7E2vhvsXuwGJzvbc6HO70s8ed7vznHrfYnFjtDlegZLPgtFtw2ApQ7Vachb1W2C1oHFaMig0jNkxYXa+KtfC9FZNixYwVMxbMSuErFjwUC54UYMaCp1KABwV4UoC2MnqXtAbwDAaPQNerZxB4hYBXGKpnCOkmTxK1ComqjZPWTBJzE0nISeBkzklO5pwk25Z93uI99Z7U8K5BDZ8a1PCuQZRPFNG+0UT7RONr9K1QlZ1WK46UFOwpKdgKX+2nkrEnJWJLTMKWmIg9Kcn1BNP5mu7nhyE6GkNMjOu1ZgymOnXQV68u41eEuM5IMCKuG06nisXuJM9qJ8/qoMDmIM96ZrOTa3WQa7GTa7GTc85rVuHtuewCG9kFdrLybWQVWFFs+XhRgKeSjycFeCv5eJPn2s68V/LwJRdfJRc/cvFTcvBVcvAnB7Ny4V6PIvSe4BMO3uHgEwE+EWR6BnLCYOSERuGEauFEQSrxOfHEZ8WTmJtY5JHz//I3+hPlE0WMbww1fWtS068mMb4xRHhGoNVcXDCgOp2uwbcJCVjjT2CLjyt8jccaH4/9P4/xn0sxmTDWqoWxbl2MdetiqlcXY/366AICLqpOQogrlwQjQlSQxe4gM99GVr6NzHwbGXmuLT3PevY130Z6rpX0PNdrWq4Vq8M1VsSEhUCyCFSyCFCyCCSbICWTYCWDYCWTEDIIVjIIUTLwUS48IBZwjXHxqQa+kVh9q3HCw584o4E4jcpxRx7HC05zLOs4p/JOlVqEUWsk2ieaWn61qONfh9p+tantV5sIrwg0SuU8deXMy8MaF4f16FGsx45hOXoU6+EjWA4dQj1niYdz6UJCMMbWx1Q/FlNsfYz16mGoUUN6UYS4BkgwIsRlpKoqeVYHablWUnOtpOVaSM2xuvdTc6yczrG4t9QcK3anigkLYUoaYUo6oaQRrqQRqqQTrqQRoZwmXEklWCnD2kwaHfhUI88vkuPeQRwzeXBMq3DYmc8RSxrHck5gc5Z8e8WsM1PbrzZ1/etS178u9QLqUde/Lt4G78r7fBwObPHxFBw4gOXgQSwHDmLZtw9rXByU8CtIMZkw1q6NsV5dTPXquXpTatdGG3jhsTJCiCuHBCNCXMGcTpXMfBspORaSsyyk5BSQnGUhOdu1ncosIDErn6TMAjQOV8ASoaQSqaRQTTlNBKlUU0673iunMVxgoK9DayTBvzqHfYM4bPbkoAYOO3I5UpCMzWkv8ZxqXtWo51+P2MBYGgQ2IDYglmCP4Er9HBw5uVgOHMCyfx8Fe/dRsG8flgMHUAsKSsyv9fXFULu263ZP7VoYarpedaGhEqQIcQWSYESIa4DTqZKaayUps4CEjHxOpOdxIt31Gp+WT3x6HvlWGyFkEKmkFG6niVRSqK4kU0NzmmpKCtpSJsyxA3EGEwf9wtnv7c8BvY79zjySbCX3xgSZg4gNcAUnjYMa0zCoYYXnfCmNuxdl/wEs+/dTcGA/lgMHscXHl9iLAqDx9MRQq5Y7SDHWqYOxXj3XY8gSpAhRZSQYEeI6oKquYOXY6VyOnM7l6OlcjqbkcuR0DsdO52F1ONHiIFxJcwUnSjLRShJ1dMnU1SUT7jyJ3ll8LEemRsMBg5593kHs9fJjrxaOOHJwljBwNtwznEZBjWgU1IgmQU1oGNSwyBwplcVZUOAah3LoMJbDh7AeOoTl8BHXrR57yb07Wl9fjPXru2/3mJs0wVCrlix+KMRlIsGIENc5u8PJ8bQ8Dp7K5sCpHA4m53AgKZvDKTnYnYUrZ+MklHRqahKpp02ktVcK9bWJhNviMFtSipSXrygcMOjZYzCw2zuAXUYjR7AUC090io66AXVpGtyUpsFNaRbSjAjPiEvWQ6FarVjj4s4GKYcPU3DgANajx8BR/PaVxtsbc5MmmJs1K9yaovWuvPExQoizJBgRQpSowObgUHIOe05msScxy/2aYynau+BDLrG6RNr7naaFKZGaxBOYdwR9XrI7T46isNdoYKfRwC6Tme1mM8klzNMS6hFKq7BWtAxtSavQVkT7RF/y2ydOiwXLoUNYztzu2bOH/F27UPPzi2bUaDA3bYpn+5vxuvlmTA0bypM8QlQSCUaEEGXmdKocS81lZ0ImO09ksjMhk90niwcoAKG6XLoGpnGDVxINNHGEW45gTj+AYstFBZK0WrabjGw3GthuNLLXaMT+n7gjwBRAq9BWtA1vS9vwttTwrnFZxnaodjuWAwfI27aN/G3byN+2Hds5a2mBa9I2z5tuwqtTJ7xv6YzG0/OS10uIa5UEI0KIi3JugLIrIZMdJ0oPUAxalY7BuXTySaKpPp4oyyG8Mvag5JwiX1HYYTSwyWRis8nIDqMRi6Zo4BHqEUrb8La0CWtD2/C2hHmGXa5mYjt5kpzVq8ld/S+5a9bgzMlxH1PMZrxvuQWfXrfjddNNKIZLsyK1ENcqCUaEEJXuTICy62QWuxMy3YFKVkHxAEWvVbghxE5Xv0Ra644Qnb8Hc8o2bJYsdhmNbDAb2WAysc1kxPafXpEonyh3YNImrA3+psuz3o1qs5G/Ywc5K1aStWRJkV4Tra8v3j164Nf3bkxNmshTOkKUgQQjQojLQlVVTqTnu27xnNOLkplffJI1P5OWW8NzuMUrjibqXkLStmBNP8w2o4ENZhPrTSZ2GQ04//OHvp5/PdqEt6FtWFtahrbEy+B1WdpVsGsXWQsXkrl4MY6U0+5jpgYN8O//AD63347GXPlPDglxrZBgRAhRZc4EKDtOZLL9RAZb49LZcSITi73ofCcGrYaOESp3+B+jpWYfYWmbyU3ZzWaTifVmI+vMJg7959aIVtHSMLAhbcLb0CasDc1DmmPSmS5texwO8jZsIHPBL2T9/juq1bX+kMbHB7+7+uB3//0YY2IuaR2EuBpJMCKEuKLYHE72JmaxNS6DLXHpbDiaRmJm0ZlWDToNnatruCfwOK3VXfieWktq2iE2mE1sMJnYYDYSr9cXPUdjoHlIc26IuIG2YW1pENjgohcEPB97ejqZ8+eT/v0cbCdOuNO9Oncm8OHheLRoccmuLcTVRoIRIcQVTVVVjqfmsfZIKuuOpLL2cCrJ2UUnYKvmZ+b2GIVe3vtpkLcZ3dHlJBakum/prDcbSdbpipzjbfCmbVhb2ke256aImwj1DL009Xc6yV29mvTv/o+clSvds8OamzcncPgwvDp3lsnVxHVPghEhxFVFVVUOp+Sy4kAKy/cns/5oGtZzbuuY9Bo61QnmvhpZ3Mh2zHHLUY+v4ajGyTqTifVmExvNZrL/86ROXf+63FztZtpXa0+zkGboNLr/XvqiWY4cJe2rr8hcsADV5horY4iJIXD4MHzvuAPlP705QlwvJBgRQlzV8q0O1h1JZfn+ZP7am0xCxtnJyvRahXa1grgj1ptbzfvwPPYXHFyKPTeF3UYD/5rNrPYws8toKDJDrJ/Rj87VO9M1qis3hN+AQVu5j+rakpNJ//Y70r//Hmd2tquu1aoROOJR/O68Ux4NFtcdCUaEENcMVVXZfTKLpbuT+H1XEoeSz84FYtBq6BIbwp1Nw7nFJx7DoaWw9zc4fYA0jYY1ZhOrPTz418uLjHMWDPTUe9IhsgPdorrRIbIDRq2x0urryMklY+5cUr/6Csdp11M4+ogIV1DSp48EJeK6IcGIEOKadSg5h6W7k/hlWwIHTp0NTHxMOm5vEsE9LavRwnwKZe9vsOdXOLUTO7DFZORPLx+W+fiQrJ599Nhb70336O7cXvN2Woa2RKNUzlgPZ34+GT/8wOkZM9yPBusiwgkaORK/u+5C0VX+LSMhriQSjAghrnmqqrI3MZtftiWwYFsCp7LODoCtE+JFv9bV6dsiEv+CeNg9H7bPhdSDOIGdRgN/+QWzxNuLJMfZW0DhnuHcXvN27qh1BzG+lfO4rrOgwBWUfPGFOygx1KxJyJjReHXpIhOoiWuWBCNCiOuKw6my/kgq87YksHhnIvk214q9Bq2GHo3CeKB1dW6sGYBycits/x52/QT56TiBzWYzCyPq8oeST47j7OPGbcLacF+9+7ilxi3oNRc/CNVZUED6nDmkTv8MR0YGAOZmzQh59hk8Wra86PKFuNJIMCKEuG5lFdj4ZdtJ5myIY/fJLHd67RAvBreLpm+LanhonHBwKWyaCYeXAVCgKKwIr8tvQRGsyjmKU3WNMQkyB3FX7bu4t+69hHuFX3T9HNnZpH75JWmzvkYtcAU/Xp07E/LsMxhr1rzo8oW4UkgwIoQQwK6ETL7fEMeCrQnkWl29JT4mHf1aV2fQjdFUD/CAlP2w/jNXj4ktD4BE7xDm1b2JeXnHOF2QCoBG0XBL9VsY3HAwzUKaXXTdbKeSOT11Khk//QQOB+h0BDzYn6DHHkMrv+vENUCCESGEOEd2gY2fNp/g6zXHOJbqCjg0CnRrEMqIjrVoXsMf8tNhyzew4XPIjAfA5h3OP03v4AdHKuuTNrjLax7SnMENB9O5eueLHvBqOXKU5HffJWeZq4dG6+9P8FNP4XdPXxTtpZtNVohLTYIRIYQogdOpsvxAMl/9e4xVB88ufndT7UAe61SbG2sFojjtsO07WDEZsgqnfPeJ5HCbIXxNJguPLsbmdD2NE+UTxaAGg+hTu89Fz1uSs2o1p956C+vhwwAY69cn7KUX8Wjd+qLKFaKqSDAihBAXcPBUNp+vPMLPWxOwO12/CptV9+OxzrXpUj8EjdMKW2bDqvcgO9F1UmBtUjq/wP9ZEph74Aeyra7JzUI8QhjeeDh317n7ouYsUW020r//npSPP3FPnOZ7552EPP8cuoCAi2uwEJeZBCNCCFFGCRn5fL7iMHM2xrtXFq4f5s0z3evRJTYExW6BzbNg1buQm+I6qXZXcru8wvz0nczaPYvkvGQAQswhDGs8jL51+15UUGJPSyNlyodk/PgjqCpaX19CnnsW37vvlkeBxVVDghEhhCinlGwLM/89yjdrj5NjsQPQMsqfZ3vU44aagVCQBSsnw7pp4LSBooU2D2NtP4b5J/5hxs4ZnMo7BbiCkocaP8S9de+9qNs3+du2kTjuNSz79wNgbtWS8Ndew1i79sU3WIhLTIIRIYSooIw8K9NXHGHWmqMU2Fw9Je3rBPFcj/o0jvSF1MPwxyuwf5HrBHMA9JiItdHd/HxoATN2zSApNwmAal7VeKzZY9xe8/YKD3RVbTbSZn9DyiefoObng15P0MPDCRoxQqaWF1c0CUaEEOIincoq4ONlB5mzId49pqR30whe6Fmfan5mOPwPLBkLKXtdJ9TuCr2mYPUOZcGhBUzfPp2UfNdtnXr+9XiyxZPcXO3mCt9msSUkkPT6G+QsXw6AsUEs1d5+G2OdOhfdViEuBQlGhBCikhxPzWXKXwdZsC0BVQWjTsOjHWsxomNNPLTAmo9g+VvgsIDBG7qNh5ZDyXda+G7vd8zcOZNsm2swaqvQVjzd6mkaBTWqUF1UVSV7yRKSXhuPIzMTxWAgePRoAgYPQtFUzpo6QlQWCUaEEKKS7UrIZMLCPWw4mgZAmI+JF3rW585mESinD8Ivj8GJwrlIom6GOz6CwFpkFGQwY+cMvt/3PVanFYA7a93JUy2fIsgcVKG62JKTSXzlFXJXrATAo3VrwidNwhBZ7eIbKkQlkWBECCEuAVVV+X1XEhMX7+VEumuBveY1/HijTyMahnm5Jkz7e4JrJledGXq8Aa2GgaKQmJPIx1s/5rcjvwHgqffk0SaPMiB2AHpt+de+UVWVjB9/5NRbb6Pm5aHx9CTs1VfwvfPOSm2zEBUlwYgQQlxCBTYHX64+yqf/HCLP6kCrURjRsSb/u6UOpuw4+PV/cGyVK3PtrnDHJ+DjWtdme8p23lr/FrtSdwGuidOea/0cHSI7VKgu1vh4Tr4wlvzNmwHwvesuwl55GY2Hx8U3VIiLIMGIEEJcBqeyCnjt1938vsv19EzNYE/eursJbaL8YMNn8Oc411gSsz/0+gAa3gWAU3Xy6+FfmbJ5CqmFa990rt6ZF9u+SJhnWLnroTocnP7sM05/8ik4nRhq1yLygw9kcKuoUhKMCCHEZbRkVxKv/LKLlGwLAANuqMHzt9bHO+sw/PwIJG53ZWx8H9w2Gcx+AORYc/h8x+d8s+cb7KodD50H/2v+Px6o/wBaTfnXpcndsIGTTz+DPSUFxWQi7OWX8O3bVyZKE1VCghEhhLjMMvNtTFq8lzkbXYvsRfiaePfeprSL9oGV77imlVed4FMN7vgYandxn3so/RDj145nW8o2ABoENmDcjeNoENig3PWwp6Zy8vkXyF29GgCf3r0Jf20cGk/Pi2+kEOUgwYgQQlSRNYdOM/bnnRwvXB142M0xPNujHqakzfDzo5B2xJWx5VDo/joYvQHXrZt5B+fxwaYPyLZlo1E0DIgdwOPNH8esM5erDqrTSeqML0n58ENwODDUqkXkRx9irFWrUtsqxPlIMCKEEFUoz2rnjUV7+b/1cQDUDfXig37NaBikg7/Gu8aTAPjVgDunQkx797mn80/zzoZ3+P3Y74BrgOsbN71Bs5Bm5a/Hli0kPDUae3IyiocH4RMm4Nvr9otunxBlIcGIEEJcAZbtO8VzP+3kdI4FvVZhTLd6PNKhJtrjq2DBY5DpClZo8yh0HQeGs7dSVp5Yyfi140nOS0ajaBjcYDCPNX+s3Avw2VNTSXj6GfLWrQPAv39/Ql54Ho1MJS8uMQlGhBDiCpGaY2Hs/J38sce1iF6bmADev68pkR4O+ONl14rAAH5RriduzhlLkmXN4u0Nb/Pr4V8BqOVbizdvfpOGQQ3LVQfV4SDl449Jne7qkTE1aULklA/QR0RcfAOFKIUEI0IIcQVRVZUfN59g/K+7ybU68DbpeKNPI+5sVg0O/gW/PQlZJ1yZm/SDHpPAM9B9/j9x/zB+7XhSC1LRKloebvIwjzZ5FJ1GV656ZC9fzsnnX8CZmYnWz4+I997F66abKrOpQrhJMCKEEFeg46m5jJ67jS1xGQD0aRbBhD6N8FEKYNkbsP4zQHWtBHzrJFdgUvhYbkZBBhPXT3SPJWkR0oK3O7xd7nlJrCcSSHjySQp27waNhuCnniLw4eHy+K+odBKMCCHEFcrucPLJP4f4eNkhHE6Van5mPujXjDYxAXBis2v21uTdrsw1O0PvKeAf7T5/8ZHFTFg3gVxbLn5GP968+c1yz97qtFhImjCBzHnzAfDu1pXwSZPQenlVUiuFkGBECCGueJuPpzN67jbi0vLQKDCyUy2e6loXPY7ClYDfds3eqjND5xfhhlGgdd2WicuK45kVz7A3bS8AgxoM4qkWT5VrjRtVVcn44UeS3ngDbDYMMTFEfvKxPP4rKo0EI0IIcRXIsdh57dfd/LTZNV6kSaQvU/o1o2awF6Qedo0lObPGTXhT6P0RRDQDwOqw8sHmD/h277cANApsxOSOk4n0jixXHfK3b+fEE09iP3UKjYcH4W9Nwqd790pro7h+STAihBBXkcU7Exk7fyeZ+TbMei2v9GrAA22qowBs/db11E1BBihauPEx6DQWDK6F8P6O+5tX/32VLGsWvkZf3unwDu0i2pXr+vbTp0kY8zR5GzYAEPS/xwkaNUrGkYiLIsGIEEJcZRIz83n6h+2sOexaOK9rbChv921MoJcRcpLh9+dht2uMB/7RrinlY1xjRRJzEhmzfAy7UnehUTQ82eJJhjYcWq5gQrXbOfX2O6R/8w0A3rfeSsTEN2X1X1FhEowIIcRVyOlU+XL1USYv3Y/V4STIy8gH/ZrSvk6wK8P+JbBoDGQluPZbPQRdx4PJB4vDwhvr3mDBoQUA9IjuwYR2E/DQly+YSP/xR5ImvA42G8YGsVT/9FP04eGV2EpxvZBgRAghrmJ7Tmbx5JytHEzOQVFgZMdajO5WF71WAwVZ8Nc42DTTldkn0vXETZ1uqKrKD/t/4K2Nb2F32qnjX4cPO31IdZ/q5bp+3qZNnHjiSRxpaWiDgoj8+CM8mjev/IaKa5oEI0IIcZUrsDmYsHCPe32bllH+fHh/MyL9C3s6jq6CXx+H9GOu/aYPuOYmMfuzNXkrY5aP4XT+abwN3rzb4V3aVSvfOBJbQgLxox7Dsn8/il5P+KRJsq6NKBcJRoQQ4hqxaEciL8zbQbbFjo9Jxzv3NOXWRoUTnVlzYdmbsG4qoLoW3rv3a6jWguS8ZEYvH82OlB1oFS3Ptn6W/vX7l2sciTM3l5MvvED2n38BEPLsswQ8VL6xKOL6JcGIEEJcQ+LT8nj8+61sj88AYPCNUbx0ewMMOk1hho0w/2FIPwpaA9z6FrR6CKvTxvi1491r29xT9x5ebPNi+eYjcTpJfvtt0r6eDUDA4EGEPP88ikZTqW0U1x4JRoQQ4hpjczh594/9fLbiCADNqvsx9cEWRPiZXRnyM+CXx2DfQtd+k37Q6wNUvQdf7/6a9ze/j4pKq9BWvN/pffxN/uW6furMr0h+5x0AvHveSsRbb6Exlm8FYXF9kWBECCGuUf/sS+apudvIzLcR4Gngo/ubc3OdINdBVYU1H8Nfr4HqgOBYuG82BNdl5YmVPLfyOXJtuVTzqsYnt3xCbf/a5bp25sJFnBw7Fmw2PFq3JvLTT9DK72VRirL+/ZY+NiGEuMp0rh/Cwv/dTMMIH9JyrQycuZ5Plh3E6VRdi+rd9AQMWQheYZCyF77oDIf/oUNkB77t+S2RXpEk5CQw4PcBrE5YXa5r+/a6nRpffI7Gy4u8jRs5/uAA7Ckpl6il4nohwYgQQlyFqgd4MG9kO/q1qo6qwrt/HGD47E1k5tlcGaLawYhVEN0erDnwf/3g4F/U9q/N97d/T6vQVuTacnn878eZu29uua7tecMNRH37DbrgYCwHD3J88BBsycmXoJXieiHBiBBCXKVMei1v39OEt/s2xqDTsGxfMndP+5f4tDxXBq8QGDAP6t3uWnBvzgNwYCl+Jj8+7/Y5d9S6A4fq4I31b/DOxndwOB1lv3b9+kR99y268HCsR44QN2gwtlOnLlFLxbVOghEhhLjK9Wtdg/kj2xHua+JwSi53T1vDroRM10GdEe6dBbG9wWGFOQ/CvkXotXreuOkNnmj+BADf7PmGp5Y/RZ4tr8zXNdSoQdQ3s9FHRGA9dozjgwZhS0q6BC0U1zoJRoQQ4hrQqJov80e1o36YNynZFvp9tpYVBwrHcugMcM9X0PAucNrgh0Gw5xcUReHhJg8zucNkDBoDy+OXM2TJEJLzyn7LxRAZSY3Zs9FHRmI7HsfxgYOwnTx5aRoprlkSjAghxDUi3NfMDyNupF2tQHKtDh6atZEfNsW7Dmr1cPcMaHwvOO3w41DYNQ+AW2Nu5cseXxJgCmBv2l4eXPwgRzKOlPm6hshqRM3+Gn316tji4zk+aDC2hIRL0URxjZJgRAghriE+Jj2zhrbhrubVcDhVnvtpBx/+dRBVVUGrg7s+c00brzpg/iNw7F8AmoU047vbviPaJ5qk3CQG/j6QbcnbynxdfUSE65ZNVA1sJ07IoFZRLhUKRqZOnUpMTAwmk4mWLVuyatWq8+b/9NNPiY2NxWw2U69ePWbPnl2hygohhLgwg07D+/c15bHOtQD44K8DvLN0v+ugRgt3fgoN7y7sIRkMmScAiPSO5Jue39AkuAlZ1iyG/zGcZXHLynxdfVgYUbO/cQck8Q8/giMrq9LbJ6495Q5G5s6dy1NPPcVLL73E1q1bad++PT179iQuLq7E/NOmTWPs2LG89tpr7N69m/Hjx/PYY4/x22+/XXTlhRBClExRFJ7tUZ8JdzYEYNryw3z6zyHXwTMBSWhjyE2BuQPBVgCAn8mPGd1n0DGyIxaHhdHLR/PjgR/LfF19aAg1vvwSbXAQlv37iR81CmdBQaW3T1xbyj0Da9u2bWnRogXTpk1zp8XGxtKnTx8mTZpULH+7du246aabmDx5sjvtqaeeYtOmTaxeXbbJdmQGViGEqLjPVx5m4uJ9AEy4syGDbox2HUg/Bp93gvx0aPagK0ApXADP7rTz+rrXmX9wPgCjmo5iRNMRZV4gr2D/fo4PGIgzOxuvW24h8qMPUXS6Sm6ZuNJdkhlYrVYrmzdvpnv37kXSu3fvzpo1a0o8x2KxYDKZiqSZzWY2bNiAzWYr9ZysrKwimxBCiIp5pEMtnrjFNe37q7/sZt5m120Z/KNdT9koGtj2HWz4wn2OTqPjtRtf49EmjwIwdftUJq6fiFN1lumapnr1qD5tKorRSM6yZSSOG8dVsPqIqCLlCkZOnz6Nw+EgNDS0SHpoaChJpTxb3qNHD2bMmMHmzZtRVZVNmzYxc+ZMbDYbp0+fLvGcSZMm4evr696qV69enmoKIYT4j9Hd6jKkXTQAz/60nSW7Cn9n1+oM3Sa43i8d6x7QCq5bPY83f5yX276MgsKc/XN49d9Xyzw5mkerVlT74H3QasmcN5+U9z+ozCaJa0iFBrD+t5tOVdVSu+5eeeUVevbsyQ033IBer+fOO+9kyJAhAGi12hLPGTt2LJmZme4tPj6+ItUUQghRSFEUXu3VgHtbRuJU4Ynvt7LyzDwkNz5+9pHfHwa5B7Se0a9+P968+U20ipZfDv/C86uex+YouWf7v7xvuYXwCeMBSP3iC9Jmf1Op7RLXhnIFI0FBQWi12mK9IMnJycV6S84wm83MnDmTvLw8jh07RlxcHNHR0Xh7exMUFFTiOUajER8fnyKbEEKIi6PRKLzVtwm3NQ7D6nAy4tvNHDiV7Ron0vsjCGsMeafhxyHgsBc5t3et3rzb8V10Gh1Ljy1l9PLRWByWMl3Xr29fgseMAeDUW2+Rs/rfC5whrjflCkYMBgMtW7bkzz//LJL+559/0q5du/Oeq9friYyMRKvVMmfOHHr16oVGI9OcCCHE5aTVKEzp15ybageSZ3Xw6DebySqwgcED+n0HRh84sRH+LX5LpWtUVz7q/BFGrZEVJ1bw2N+PlXn6+MCHh+N7993gdJIwZgyWo0cru2niKlbuaGDMmDHMmDGDmTNnsnfvXkaPHk1cXBwjRowAXLdYBg0a5M5/4MABvv32Ww4ePMiGDRu4//772bVrFxMnTqy8VgghhCgzg07Dxw+0oJqfmaOnc3n6h+04nSr4R8FthU8+Ln8LTm4rdm77yPZM6zoND50H6xPX8+ifj5Jry73gNRVFIey1cZibNcOZlcWJUY/hyM6u5JaJq1W5g5F+/foxZcoUJkyYQLNmzVi5ciWLFy8mKioKgMTExCJzjjgcDt577z2aNm1Kt27dKCgoYM2aNURHR1daI4QQQpRPgKeBqQ+2wKDV8OeeU0xbcdh1oEk/iL3DNX7k50fd84+cq3VYaz7v/jneBm+2pWzjsb8fI9+ef8FragwGIj/+CF1YGNajR0l4+mlUR9lXChbXrnLPM1IVZJ4RIYS4NOZsiOOF+TvRKPD1Q21oXycYclNh6g2Qmww3PAa3ltyTvfv0bob/MZwcWw7tItrx8S0fY9AaLnjN/N27Of7gANSCAgIeeojQ556t7GaJK8QlmWdECCHEteX+NjXo16q6+wmbE+l54BkId37iyrDuUzi6ssRzGwY1ZGrXqZh1ZtacXMMzK57B5rzwUzbmhg2JmOQKcNJmziRjwYLKao64SkkwIoQQ17nxdzakcTVf0vNsjPx2CwU2B9TtAS0GuzL8PBIKMks8t3lIcz665SMMGgP/xP/DS6teKtM8JD49exI0aiQASa+8Sv7OXZXWHnH1kWBECCGucya9lmkDWuDvoWdnQiYTFu5xHegx0TVLa9YJ+P2FUs+/IfwGPuj8ATpFx+/Hfmf82vFlmqk16PHH8erSBdVmI2H0aFlU7zomwYgQQggi/T346IHmKAr83/o4/t57CoxecNdnrunit/8f7FtU6vkdIjvwVoe30Cgafj70M+9sfOeC078rGg0Rkyaij4zEduIEiS+9LFPGX6ckGBFCCAFA+zrBDLspBoDn5+0kNccCNW6Adk+4Mix6BiylP47bI7oHr9/0OgDf7f2O7/Z+d8Fran18qPbBB6DXk/3nn6R/e+FzxLVHghEhhBBuz/SoR91QL07nWHjp512unopOL7hu12SfhH+Kr85+rjtq3cGYlq7ZVt/Z+A7L45df8Jrmxo0Ife45AE69846MH7kOSTAihBDCzaTX8v59zdBrFZbsTmL+lgTQm+G291wZ1k+DxO3nLWNIwyH0rdMXFZXnVj7H3tS9F7yu/4AH8e7WDWT8yHVJghEhhBBFNKrmy1Nd6wLw2q+7ScjIhzpdoeFdoDrht6fgPE/MKIrCSze8RNvwtuTb83l82eOcyj113msqikL4m2/I+JHrlAQjQgghinm0Q01a1PAj22LnmTPTxfeY5Fq75uQW2DTzvOfrNXre7/Q+NX1rkpyXzP+W/e+C69jI+JHrlwQjQgghitFpNbx/XzM8DFrWHkll5r9HwSccbnnFleHvCZCddN4yfAw+fNrlUwJMAexN28vzq56/4Bwk5saNCH3WNSPrqXfeoWDfvkppj7iySTAihBCiRNFBnrx0eywA7yzdz8FT2dB6GEQ0B0sWLBl7wTIivSP5sPOHGDQGlscv56OtH13wHP+BA/C65Raw2Tj53PM4rdaLbYq4wkkwIoQQolT929SgU71grHYnz/60Awca6DXFNffI7vlw6K8LltEspBlv3PwGADN3zbzgEzaKohD++gS0AQFYDhwg5cMPL74h4oomwYgQQohSKYrCpLsb42XUsS0+g9lrj0FEM2jzqCvDoqfBduEVe3vG9OTB2AcBeGn1SyTkJJw3vy4wkPDXJwCQNvMrcjdsuJhmiCucBCNCCCHOK9zXzAs96wMweel+12J6t7wE3hGQfgxWvVemcp5u+TSNgxqTZc3imeXPYHWc//aLd5cu+N7TF1SVky+8gCO79AnXxNVNghEhhBAX1L9NDVpH+5NndfDygl2oBi/o+Zbr4OopkHLggmXotXre7fguPgYfdqXu4r1NFw5iQl8Yiz4yEvvJRE69OfEiWyGuVBKMCCGEuCCNRmHS3U0waDUs35/Cr9tPQuwdUKc7OG2waAyUYV6QCK8IJrV3zeL6f/v+j6XHlp43v9bLk4h33gaNhswFC8ha+keltEdcWSQYEUIIUSa1Q7x4okttAMb/toe0PBvcNhl0Jji2Cnb8UKZyOkR2YFijYQCMWzOOY5nHzpvfo0ULAocPByBp3DhsyckVb4S4IkkwIoQQoswe6VCL+mHepOVaeX3hHteaNR1c84Lwx0uQn16mch5v/jgtQlqQa8vl6RVPU2AvOG/+4McfwxgbiyMjg6RXx8nsrNcYCUaEEEKUmUGn4a2+TdAo8PPWBJbvT3at6htUD3JTXJOhlYFOo2Nyx8kEmAI4kH6AKVumnDe/YjAQ8fZbKHo9OcuXk7VwUSW0RlwpJBgRQghRLs2q+zH0phgAXvp5F7kODfR633Vw01dwYlOZygnxCOHNm98E4Lu937H25Nrz5jfVrUvgyBEAnHrzTeypqRVsgbjSSDAihBCi3J7uXpdIfzMJGfl88OcBiL4ZmvYHVFj4FDjsZSrn5mo3069ePwBe/vdlMi2Z580fNHw4xnr1cGRkyNM11xAJRoQQQpSbh0HH630aATDz36PsSsiE7q+DyQ+SdsKGz8pc1piWY4jyiSI5L5k317953ryKwUD4G2+ARkPW4sVkL1t2Mc0QVwgJRoQQQlRI53oh9GoSjlOFsfN3YjcFQLfxroPL3oS0o2Uqx0PvwcSbJ6JVtPx+9Hd+P/r7efObGzci8KGhACSNew1HVtZFtUNUPQlGhBBCVNirvRvgY9KxMyGTr9ceh+aDILo92HLhl8fA6SxTOU2Cm/Bwk4cBeH3d65zKPXXe/EGPP44hKgp7SgrJkydfdDtE1ZJgRAghRIWFeJt4oadrZd/3/thPQpYF7vwEDF5w/F9YP73MZT3S5BEaBjYk25rNK/++glMtPZDRmEyEv+lafC/jx5/IXXv+wa/iyibBiBBCiItyf+vqtIpyTRU/7pddqH5RrvEjAH+Ph9MHy1SOXqNnUvtJmLQm1iau5ft93583v0erVvj3fwCAxFdexZmXd1HtEFVHghEhhBAXRaNRmHh3Y/Rahb/2JrN0dxK0HAq1bgF7Afw8osxP18T4xjC65WgAPtj8Acezjp83f/CYp9FFhGM7cYKUjz+56LaIqiHBiBBCiItWN9SbRzvUAmDcr7vJstjhjo/B6AMJm2DNR2Uu64H6D9A2vC0Wh4Vxa8ad93aN1suT8HHjAEibPZuC/fsvriGiSkgwIoQQolI8fkttogM9OJVl4d2l+8E3Enq+7Tq4fBKc2lOmchRF4bUbX8OsM7P51GZ+3P/jefN7deyId7du4HCQ9Np41DIOmhVXDglGhBBCVAqTXsubdzUG4Jt1x9kSlw5NH4C6PcFhhZ8fBYetTGVFekfyZIsnAXh/8/sk5iSeN3/oi2NRPDzI37qVzPnzL64h4rKTYEQIIUSlual2EHe3qIaqwovzd2JzqtD7QzD7Q9IO+Kfss6Y+UP8BmgU3I8+ex/h148+7OJ4+PJzg//0PgOTJ72JPL9uCfeLKIMGIEEKISvXy7Q3w99CzLymbGauOgnco3F64ds3q92Hvb2UqR6NoGH/TeAwaA/8m/MtvR85/XsDAAa6p4jMzSZ787sU2Q1xGEowIIYSoVAGeBl66vQEAH/59gLjUPGh0N9wwypXh5xGQUraBpjV9azKy2UgA3t7wNqfzT5eaV9HpCCsczJo5fz55mzdfRCvE5STBiBBCiErXt0U12tUKpMDm5KUFO123WLpNcM3Oas2BOf2h4PyL4p0xuOFgYgNiybJmMXH9+W/zeLRojt+99wC4BrPayjZGRVQtCUaEEEJUOkVRePOuxhh0GlYdPM2v20+CVg/3fAU+kZB6yNVDUoYnX/QaPRNumoBO0fHn8T/58/if580fPGYMWn9/LAcPkjZ7dmU1SVxCEowIIYS4JGKCPPlf59oATPhtDxl5VvAKhn7fgNYI+xfDyrKtK1M/oD5DG7kWx5u4fiJZ1tIXx9P5+xPy7LMApHzyKbbE8z+JI6qeBCNCCCEumUc71qJOiBepuVYmLd7nSqzWAnp94Hq/fCLsX1K2spo+SrRPNKfzT/PRlvNPouZ7Vx/MLVui5ueT/O57F9MEcRlIMCKEEOKSMeg0TLzbNffI3E3xrDuS6jrQ/EFo7Vqll/kPl2lAq1Fr5NUbXwXgh/0/sC15W6l5FUUh7KUXQVHIWrRIBrNe4SQYEUIIcUm1jg6gf9sagGvukQKbw3Wgx0SocSNYsuC7eyAn+cJlhbWmT+0+qKiMXzsem7P0AaqmBg3wu6dwMOubb6I6HBffGHFJSDAihBDiknv+1vqEeBs5cjqXj/4uXMVXZ4B+34J/DGTEwf/1A2vuBct6uuXT+Bv9OZRxiK93f33evMGjn0Lj7Y1lz14yZGbWK5YEI0IIIS45X7Oe1/s0AuCzlUfYc7JwAKpnEAyYB+YAOLkF5g0H5/l7MPxMfjzb2jVAdfr26cRnxZeaVxcQQPDjjwGQ8sEUHFmlD3wVVUeCESGEEJdFj4Zh9GwUhsOp8vy8HdgdhY/1BtaCB+acfcJmyVg4z9TvAL1q9nKv7Pv6utfPO1W8f//+GGrWxJGWxulPp1Zmk0QlkWBECCHEZTP+zob4mHTsTMhk5r9Hzx6o0Rbu/hxQYMNnsO78QYOiKLxywysYNAbWJq5l0dFFpefV6wkdOxaAtO++w3L4cGU0RVQiCUaEEEJcNiHeJl4unCr+/T8PcDz1nDEiDftA99dd75e+BHt+OW9ZUT5RPNr0UQAmb5xMpqX0GV292t+MV+fOYLdzatJb5+1JEZefBCNCCCEuq3tbRbqnih87f2fRwODGxwsf+VVh/iOQsOW8ZQ1tOJRavrVIK0hjypYp580b+vxzoNeTu3o1OcuXX3Q7ROWRYEQIIcRlpSgKk+5ujEmvYc3hVH7cdOLcg9DzbajTA+wFMOdByE4qtSy9Vu+ee2TegXlsT9leal5DdDSBgwcBkPzW27JuzRVEghEhhBCXXVSgJ2O61QXgjUV7SM4qOHtQo4W+MyCoHmSfdAUktoJSSoIWoS24s9adqKi8ue5N7E57qXkDR4xEGxiI9fhx0n/4odLaIy6OBCNCCCGqxEM3xdC4mi9ZBXbG/bq76EGTDzzwPZj8IGET/PbkeZ+wGdNqDD4GH/am7WXu/rml5tN6ebof9T396VQcOTmV0RRxkSQYEUIIUSV0Wg1v9W2MVqPw+64kluz6z+2YwFpw39egaGHHHFjzcallBZgCeLLFkwB8svUTUvJSSs3rd889GKKjcaSlkfrFjEppi7g4EowIIYSoMg0jfHm0Q00AXv1lF5n5/xnHUbMT3DrJ9f7PV+HAH6WW1bdOXxoHNSbHlsO7m94tNZ+i1xPyzNMApM2ahS2p9DEp4vKQYEQIIUSVeqJLHWoGeZKcbWHS4r3FM7R5BFoMBlSYN6zURfW0Gi0v3fASGkXD4qOLWZ+4vtRrenXpgrlFC1SLhZSPSu9xEZeHBCNCCCGqlEmv5a2+TQCYszGeNYdPF82gKHDbu1CjnWtRvR8GlTqgtWFgQ/rV6wfAG+vewOYo+YkZRVEIfc41pXzmzz9TsP/CqwaLS0eCESGEEFWuTUwAA25wrew7dv5O8q3/WZ9GZ4D7ZoNnCKTsg7/Hl1rW480fJ9AUyLGsY3y9p/SF9MzNmuF9662gqiRPLv22jrj0JBgRQghxRXj+1vqE+5o4nprHB38dKJ7BKxju/NT1ft1UOLysxHJ8DD7uhfQ+2/4ZCTkJpV4zZPRTZydC+/ffi22CqCAJRoQQQlwRvE163ihc2XfGqiPsOJFRPFPd7tBqmOv9glGQl1ZiWbfF3EbrsNYUOAp4d2PpvR6GqCj8778fgOR330N1Oi+qDaJiJBgRQghxxegSG0rvphE4VXjupx3YHCUEB93fgMDakJ0Ii8aUOP+IoiiMbTMWraLlr7i/WJOwptRrBo0aicbLC8vevWT++mtlNkeUkQQjQgghrijjejfAz0PPvqRsZq4+WjyDwQPu/gI0Otj9M+woeSbVOv516B/bH4BJGyaVOphV5+9P4COPAHD6409QrdbKaYgoMwlGhBBCXFGCvIy8eFssAFP+Okh8Wl7xTNVaQMcXXO8XPwMZcSWWNbLpSPdg1m/2flPqNQMGPIg2KAhbQgIZ8+ZddBtE+UgwIoQQ4opzb8tI2sQEkG9z8Oovu4qu7HvGzaMhso3rcd+fR4DTUSyLt8GbMa3GADB9+3RO5Z4q8XoaDw+CHn0UgNPTpuMsKH0tHFH5JBgRQghxxVEUhYl3NUavVfhnfwq//3eqeACtDu7+DAxecPxf2PBFiWX1qtmLZsHNyLfn897m90q9pl+/+9BFhGNPTib9/76vrKaIMpBgRAghxBWpdogXIzvVBuC1X3eTVVDCmI+AmtCtcM6R5RMhN7VYFo2i4cW2L6Kg8PvR39mYtLHE62kMBoJHjQIg9YsvcOTkVk5DxAVJMCKEEOKKNapTLWIKp4p/d2kps6S2HAqhjaEgE/55s8QssYGx3FfvPgAmrp+IzVnyYFbfPn0wREXhSE8nbXbpE6aJyiXBiBBCiCuWSa/lzcK5R75Zd5ytcenFM2m00PNt1/vNX0HSzhLL+l/z/+Fn9ONQxiHm7JtTYh5FpyPoif8BkDbzKxwZGRfdBnFhEowIIYS4orWrHcTdLaqhqq6p4kuceyT6Jmh4F6hOWDK2xLlHfI2+PNniSQCmbZtGan7xWzoAPj17YqxXD2dODqlfzqzUtoiSVSgYmTp1KjExMZhMJlq2bMmqVavOm/+7776jadOmeHh4EB4eztChQ0lNLflLIIQQQvzXS7fFuuce+erfEuYeAeg2AXQmOLYK9pY8edldte8iNiCWbFs2n2z7pMQ8ikZD8JNPAJD27bfYU1IqpQ2idOUORubOnctTTz3FSy+9xNatW2nfvj09e/YkLq7kZ7xXr17NoEGDGDZsGLt37+bHH39k48aNDB8+/KIrL4QQ4voQ6GXkxZ6uuUc+/Osgp7JKePTWrwbc5Or5YOnLYMsvlkWr0fJ8m+cBmHdgHvvS9pV4Pa/OnTE1aYKan8/pz0t+SkdUnnIHI++//z7Dhg1j+PDhxMbGMmXKFKpXr860adNKzL9u3Tqio6N54okniImJ4eabb+bRRx9l06ZNpV7DYrGQlZVVZBNCCHF9u6dlJM1r+JFrdTBp8d6SM930FPhUg8w4WFNyz0fL0JbcGn0rKipvb3i7xDlMFEUh5ClXYJMxZw62xMTKaoYoQbmCEavVyubNm+nevXuR9O7du7NmTcnz/rdr144TJ06wePFiVFXl1KlT/PTTT9x+++2lXmfSpEn4+vq6t+rVq5enmkIIIa5BGo3ChDsaoSiwYNtJNh4rYZE8g4frdg3A6vchs+QVe8e0HINRa2TTqU38efzPEvN43HgjHm3aoNpspH4xo7KaIUpQrmDk9OnTOBwOQkNDi6SHhoaSlFTChDS4gpHvvvuOfv36YTAYCAsLw8/Pj48//rjU64wdO5bMzEz3Fh8fX55qCiGEuEY1jvTl/tau/0Ad98tuHM4SZmZt1Bdq3Ai2PPjrtRLLCfcK56FGDwHw3qb3KLAXv+2jKApBjz0GQMaPP2I7VfLsreLiVWgAq6IoRfZVVS2WdsaePXt44oknePXVV9m8eTNLlizh6NGjjBgxotTyjUYjPj4+RTYhhBAC4Jnu9fAx6diTmMX/bShhvKKiwK1vAQrs/AFObiuxnKGNhhLqEcrJ3JN8vbvkOUU82rTG3LKlq3fkyy8rrxGiiHIFI0FBQWi12mK9IMnJycV6S86YNGkSN910E88++yxNmjShR48eTJ06lZkzZ5Io9+CEEEKUU6CXkae71wPg3aX7ScstYZXdiGbQxDXJGSsnl1iOWWdmTEvXujVf7vqyxHVrFEUhaNRIADLm/iBP1lwi5QpGDAYDLVu25M8/i95f+/PPP2nXrl2J5+Tl5aHRFL2MVqsFKHnhIyGEEOICHmxbg/ph3mTm23j3j1JmZm3/DKDAvoWQtKvELD1jetI8pDn59nymbJlSYh7Pdu0wN22KarGQ+tWsSqm/KKrct2nGjBnDjBkzmDlzJnv37mX06NHExcW5b7uMHTuWQYMGufP37t2b+fPnM23aNI4cOcK///7LE088QZs2bYiIiKi8lgghhLhu6LQaXrujIQDfb4hjV0Jm8UzBdV0ToQGserfEchRF4fk2z6OgsPDIQrYlbysxT9BjrjVr0r//HntaCQNnxUUpdzDSr18/pkyZwoQJE2jWrBkrV65k8eLFREVFAZCYmFhkzpEhQ4bw/vvv88knn9CoUSPuvfde6tWrx/z58yuvFUIIIa47N9QM5I6mEagqjPt1d8m97R2ecb3uXgApJfegNAxsSJ/afQCYvGlyieV4tm+PqVEj1Px80qR3pNIp6lVwryQrKwtfX18yMzNlMKsQQgi3pMwCbnlvOXlWB1P6NaNP82rFM80dAHt/g8b3Qd+SJzBLyUvh9p9vJ9+ez+QOk7k15tZiebKXLePEqMfQeHhQe9nfaP38Krk1156y/v2WtWmEEEJctcJ8TTzWuTYAk5fup8DmKJ6pw7Ou110/QerhEssJ9ghmaKOhAEzZMgWLw1Isj1fnzhjr18eZl0fa7NmV0wABSDAihBDiKjfs5hjCfU0kZOTz1b/HimcIbwp1e7oW0Vv1XqnlDG4wmBBzCAk5Cfzf3v8rdlxRFIJGup6sSZv9DQ6ZHbzSSDAihBDiqmbSa3m2h+tR36n/HCI1p3ivBh0Le0e2z4G0khfa89B78L8W/wPgix1fkF6QXiyPd7euGOvUxpmTQ9q331ZOA4QEI0IIIa5+fZpVo2GED9kWOx8vO1Q8Q7WWUKsLqA5Y/UGp5dxR6w7qB9Qn25bNtO3F11xTNJqzvSNfz8aZm1tpbbieSTAihBDiqqfRKLx0m2tV32/XHedISk7xTB1dq/Wy7f8go+RlRjSKhmdauZ7A+XH/jxzNLN6L4t2jB4boaJyZmaT/+GPlNOA6J8GIEEKIa0K72kHcUj8Eu1Pl7SX7imeo0RZiOoDTBv9OKbWctuFt6RjZEbtq54PNxXtRFK2WgIdcg13TZn2Nai1hBlhRLhKMCCGEuGaM7VkfjQJLd59iw9ESJifr8Jzrdeu3kFf65GVjWo1Bq2j5J/4fNiZtLHbc98470QYHYU9KInPR4sqq/nVLghEhhBDXjDqh3vRrXQOANxfvLT6BWfTNrqdr7AWweVap5dT0rck9de8BYPLGyThVZ5HjGqORgMLZxlO/nIHqdBYrQ5SdBCNCCCGuKaO71cHDoGV7fAYLd/xnQVZFgbaFq8ZvnAEOe6nljGo2Ci+9F3vT9rL4aPHeD//770fj5YX10GFylq+ozCZcdyQYEUIIcU0J8TYxomMtAN5esg+L/T8ToTXqC57BkJUA+34rtZwAUwDDGg8D4JOtn2B1FB0bovX2xv/+fgCkzphRiS24/kgwIoQQ4pozvH0MId5GTqTnM2fDf56c0RmhpWsAKuumn7ecB2MfJNgcTEJOAj8eKP7kjP+gQSh6PflbtpC3eXNlVf+6I8GIEEKIa46HQcf/utQB4ONlh8iz/ud2TOthoNFD/Do4ubXUcsw6MyObueYV+Wz7Z+RYiz4yrA8JwbdPHwBSv5DekYqSYEQIIcQ1qV+r6lQPMHM6x8LXa44XPegdBg3vcr1f/9l5y7mr9l1E+0STbknn6z1fFzse8NBQUBRyli+n4MCByqr+dUWCESGEENckg07DU13qAjB9xWGyCmxFM5wZyLprHuQkl1qOTqPjiRZPAPD17q85nX+6yHFjTAze3boBkPblzEqq/fVFghEhhBDXrD7Nq1E7xIvMfBszVv1nNtXIlhDZGhxW2PTVecvpWqMrjYMak2/P57PtxXtSAh8eDkDmokXYTp6stPpfLyQYEUIIcc3SahTGdHP1jny56kjxRfTO9I5s+hLspc+kqigKo1uOBuCnAz8Rn1V0UKy5cWM82rYFu520r4vfyhHnJ8GIEEKIa9qtDcNoVM2HXKuD6SsOFz3Y4E7wDoecU7BnwXnLaR3Wmpuq3YRdtfPx1o+LHQ8c7noMOOOneThySlgbR5RKghEhhBDXNI1G4enu9QCYvfY4SZkFZw9q9a4nawDWTYP/ztj6H6NbjEZB4fdjv7MndU+RY54334yhVi2cublk/PRTpbbhWifBiBBCiGtep7rBtIryx2J38vGyg0UPthwKWiOc3AIniq9Dc656AfW4reZtAEzZPKXIMUVR3FPEp3/zLarD8d/TRSkkGBFCCHHNUxSFZ3q4ekfmbownLjXv7EHPIGh8r+v9hi8uWNbjzR5Hp9GxNnFtsUX0fO+8A62fH7aEBLL/+rvS6n+tk2BECCHEdeGGmoG0rxOE3aky5e//zAfS+iHX655fzruaL0CkdyR96/QFXNPEn7sYn8Zkwq9wivi02bMrr/LXOAlGhBBCXDeeKRw7smBrAkdSzhlkGtECQhuDwwI7frhgOQ83fhiDxsCW5C2sPbm2yDH/B/qDXk/+5s3k79xVqfW/VkkwIoQQ4rrRtLoft9QPwanCJ/8cOntAUaDlYNf7LV9fcCBrqGco/eq7ekA+3vpxkd4RfWgIPj1vBZDHfMtIghEhhBDXlScL16z5ZdtJjp3OPXug8b2gM0PyHjix6YLlDGs0DLPOzK7UXSyPX17kWMBgV2CTtWQJtlOnKqvq1ywJRoQQQlxXmlb3o1O9YBxOtWjviNkPGvZxvd8y64LlBJoD6V+/PwCfbvsUp+o8W1TDhni0agV2O+nf/V/lVf4aJcGIEEKI686Z3pGftyYUfbKmReGtml3zoSDrguUMbTQUL70X+9P38+fxP4scCxjiKitj7lyc+fmVU/FrlAQjQgghrjvNa/jToa6rd+TTc3tHatwAQfXAlge7Ljxxma/Rl0ENXHOLTN02FYfz7NwiXp07o69eHUdmJpm//FLpbbiWSDAihBDiunSmd2TelhPEpxX2jpw7kHVz2QafDmgwAB+DD0cyj7D46GJ3uqLVEjBwAABpX89GdTpLK+K6J8GIEEKI61LLKH/3vCNTl5/TO9LkftAaIHEbnNx2wXK8Dd4MbTQUgGnbp2Fz2tzHfO/ui8bLC+vRo+SuXl3JLbh2SDAihBDiunWmd+THTSc4kV7YO+IZCLG9Xe+3lK13pH/9/gSYAojPjufXQ7+607Venvj1dU2Qlvbdd5VX8WuMBCNCCCGuW62iA7ipdmBh78g5K/qeGci640ew5pZ88jk89B4Ma+RacO+LnV8U6R3xf+B+AHJXrsIaH195lb+GSDAihBDiuvZkl7oA/LgpnoSMwqdeotuDfwxYs2H3z2Uq59569xJoCiQhJ4GFhxe60w3R0XjefDOoKunfz6n0+l8LJBgRQghxXWsTE0C7WoHYHCrTz/SOaDTQwvWUTFkHspp1ZvfYkS92foHdaXcf83/QNR9Jxrx58phvCSQYEUIIcd373y2usSNzN8WTnFXgSmz2IGh0cGIDJO8tUzn31r0Xf6M/8dnx/H70d3e6V4cO6KtVw5mZSdbixecp4fokwYgQQojr3g01A2gZ5Y/V7uTL1Uddid6hUNe1xgzbyjb41EPvwaCGrh6Vz3d87p53RNFq3WNH0r/7vyJr2QgJRoQQQggUReHxzrUB+HbdcTLyrK4DzVy3V9jxAzjspZxd1AP1H8DX6MuxrGP8cfwPd7pv374oBgMFe/ZQsH17pdb/aifBiBBCCAF0qhdMg3Afcq0Ovvr3mCuxdjfwCIScU3DknzKV46n3ZGDsQAA+2/6Ze80anb8/PrfdBkDa/8l6NeeSYEQIIYTA1TvyWGHvyKw1x8ix2EFngMb3uTKU8VYNQP/Y/njrvTmceZi/jv/lTj8zkDX79yXYU1Mrr/JXOQlGhBBCiEK3NgqjZrAnmfk2vlt33JXY7AHX677FkJ9epnK8Dd4MaOCaCv6zHWd7R8yNG2Nq0gTVZiPjp3mVXv+rlQQjQgghRCGtRmFkx1oAfLHqKAU2B4Q1gdBG4LC4VvMtowdjH8RT78mB9AMsj1/uTvfv7wpu0ufMQbWXbRzKtU6CESGEEOIcfZpXo5qfmdM5Fn7cFO9aPK9pYe/I9u/LXI6v0Zf+9V23ZaZvn+5+gsanZ0+0/v7YExPJWb68sqt/VZJgRAghhDiHXqvh0Y41AZi+4gg2hxOa3AeKFk5shNMHy1zWwAYDMevM7E3by6qEVQBojEb87nGtV5MuA1kBCUaEEEKIYu5rVZ0gLyMJGfks2JoAXiFQp5vr4LayBxD+Jn/ur+eaX+TLnV+60/363Q8aDblr1mI5erRS6341kmBECCGE+A+TXsvD7WMAmLbiMA6nes6tmjlQOJlZWQxsMBC9Rs+W5C1sObUFAENkNbw6dAAg44cfK7fyVyEJRoQQQogSPHhDFL5mPUdSclmyKwnq9QSTH2SfhKMrylxOsEcwd9a+E4CZu2a60/36uR4Zzpw/H6fFUql1v9pIMCKEEEKUwMuoY3C7aACmrziMqjVA43tcB7eVfSArwNCGQ9EoGlacWMGB9AOu8jt0QBcejiMzk+w//rhACdc2CUaEEEKIUgxpF41Jr2FnQib/HkqFpoXTw+/9DQqyylxODZ8adItyjTn5atdXgGu9Gr97XcFN+py5lVvxq4wEI0IIIUQpAjwN3N+6BgDTVhyCai0gqB7Y82HPgnKV9VCjhwD4/ejvnMg+AYBf33tAqyV/82YsB8v+lM61RoIRIYQQ4jyGt49Bp1H491AqOxIyz87IWo6nagAaBDagXUQ7HKqDr3d/DYA+NATvWzoDkD73h0qt99VEghEhhBDiPCL9PbijaQTgGjtCk36AAnFrIa18j+UOazQMgJ8P/UxqvmttGr9+rkd/M3/5BWd+fuVV/CoiwYgQQghxAY8WThH/+64kjlh8oGZH14Gd5Xsst3VYaxoHNcbisPDdXtfCe57tbkRfvTrO7GyyFv9eqfW+WkgwIoQQQlxAvTBvusaGoKrw+coj0MTVm8GOuVA4zXtZKIri7h2Zs38OOdYcFI0Gv/vuBSB97vU5kFWCESGEEKIMRnZy9Y7M23KCU9W6gc4MqYcgYUu5yulcozPRPtFkW7P56cBPAPjdfTfo9RTs2EHBnj2VXvcrnQQjQgghRBm0jAqgTXQANofKlxtTILaX68CO8vVmaBSN+8ma2XtmY3VY0QUG4tOtK3B9DmSVYEQIIYQoozO9I9+tO05uPddid+yaBw5bucrpVbMXIR4hpOSnsOjIIuDsQNas337DkZNbeZW+CkgwIoQQQpRRp3rB1A/zJtfqYNapaPAMhrzTcHhZucrRa/UMjB0IwFe7v8KpOvFo0xpDTAzOvDyyFi68BLW/ckkwIoQQQpSRoiju3pGZa05gb3C368D2OeUu65669+Cl9+Jo5lFWnliJoiju9WrSf7i+BrJKMCKEEEKUw+2Nw4n0N5Oaa2WptpMrcf/ick0PD+Bl8OLeeq6naM5MEe97550oBgOWPXvJ3727Mqt9RZNgRAghhCgHnVbDw+1rAvDWdiNqYF2wF7jWqymnAbED0Gl0bEnewrbkbej8/fHu5lrDJuPH8s1hcjWTYEQIIYQop/taVcffQ098egH7Qnu6EneU/1ZNiEcIvWq6nsqZtXsWgHvxvKyFi3Dm5VVKfa90EowIIYQQ5WQ2aBncLhqAdxKauBKProLMhHKXNaThEACWxS3jWOYxPNq0QV+jBs6cHLKWLK2kGl/ZJBgRQgghKmDwjdGY9Vr+OWUmM7g1oJZ7eniAWn616BjZERWV2Xtmu2Zk7et6bPh6uVUjwYgQQghRAf6eBvq1rg7Aj7Z2rsQdFZuwbGijoQD8cugXTuefxveuPqDVkr91K5ZDhyqjule0CgUjU6dOJSYmBpPJRMuWLVm1alWpeYcMGYKiKMW2hg0bVrjSQgghxJVgePsYtBqFj5Ia4tQYIHk3JO0sdzktQlrQJKgJVqeV7/d9jz4kBK9OnQDI+PGnSq71lafcwcjcuXN56qmneOmll9i6dSvt27enZ8+exMXFlZj/ww8/JDEx0b3Fx8cTEBDAvffee9GVF0IIIapSpL8HdzSNIAsvtnvc4EqswJwjiqK4e0fm7JtDni3PPZA185dfcFqtlVbnK1G5g5H333+fYcOGMXz4cGJjY5kyZQrVq1dn2rRpJeb39fUlLCzMvW3atIn09HSGDh160ZUXQgghqtqjHV2P+U5Pb+lK2DUPnI5yl9O5emdqeNcgy5rFz4d+xuvmm9GFhuLIyCDnr78qs8pXnHIFI1arlc2bN9O9e/ci6d27d2fNmjVlKuPLL7+ka9euREVFlZrHYrGQlZVVZBNCCCGuRPXDfOhUL5h/HM3I13pBdiIcW13ucrQaLYMbDgZg9u7ZODTg19c1w2vGT9f2rZpyBSOnT5/G4XAQGhpaJD00NJSkpKQLnp+YmMjvv//O8OHDz5tv0qRJ+Pr6urfq1auXp5pCCCHEZTWiYy2s6PnF1taVUMGBrHfUuoMAUwAnc0/yV9xf+N7dFxSF3DVrscbHV2KNrywVGsCqKEqRfVVVi6WVZNasWfj5+dGnT5/z5hs7diyZmZnuLf4a/gEIIYS4+rWNCaBZdT/mn3mqZu+vYCsodzkmnYl+9foB8PWur9FXi8CznavMjHnzKq2+V5pyBSNBQUFotdpivSDJycnFekv+S1VVZs6cycCBAzEYDOfNazQa8fHxKbIJIYQQVypFURjRsRYb1XqcJAgsWXBgSYXK6levHwaNgV2pu9iSvOXsQNb5P6Pa7ZVZ7StGuYIRg8FAy5Yt+fPPP4uk//nnn7QrjNxKs2LFCg4dOsSwYcPKX0shhBDiCte9QSgxQd4ssF/cnCOB5kDuqH0HAF/v/hrvW25B6++PPTmZnJUrK6u6V5Ry36YZM2YMM2bMYObMmezdu5fRo0cTFxfHiBEjANctlkGDBhU778svv6Rt27Y0atTo4msthBBCXGE0GoVHOtRkgeMmANSDf0BeWoXKGthgIADL45cTV5CIb+Hwhox58yujqleccgcj/fr1Y8qUKUyYMIFmzZqxcuVKFi9e7H46JjExsdicI5mZmcybN096RYQQQlzT7mpRjQyv2uxxRqE4bbBnQYXKqelb0z1F/Dd7vnE/VZOzfDn2lJRKrPGVQVFVVa3qSlxIVlYWvr6+ZGZmyvgRIYQQV7TpKw6T9sdkXtR/j1rjRpSHKjZ2ZGPSRh5a+hBGrZE/7/mTzMEjyd++nZBnnyVw2EOVXOtLo6x/v2VtGiGEEKIS9W9bg2W6DjhVBSVuLWSUPEP5hbQKbUVsQCwWh4W5++fie2bOkZ/ncxX0I5SLBCNCCCFEJfIx6el6QwvWOWNdCRVYyRdcT+gMaTgEgO/3fY+pRxcUkwnrocMU7NhRSbW9MkgwIoQQQlSyh26K5je1PQB5m+dABXsyukV3I8wzjLSCNBafWo5PD9cM6NfaQFYJRoQQQohKFuJjwti0DxZVj0fGATi1q0Ll6DV6BsQOAGD2ntn43H0XAFmLFuHMz6+0+lY1CUaEEEKIS2BQpyYsczYHIG3tNxUu5+46d+Op9+RI5hG2hBegr14dZ24u2X/8UVlVrXISjAghhBCXQM1gL45V6wWAZvf8Cq3kC+Bt8KZvnb4AzN73LX6FvSPX0q0aCUaEEEKIS6TdrfeTqXrgZ0/h9K6/KlzOg7EPolE0rE9cz+lOjUFRyNuwAWtcxZ7UudJIMCKEEEJcIk2jQ1nneQsAaX9/WOFyIrwi6BbVDYBvU5fgeZNrlteMn3+++EpeASQYEUIIIS4h/1uewqkq1M38l8zjOytczpkp4hcfXYymtyswyfx5AaqjYrd/riQSjAghhBCXUOuWrVhruAGA+MXvVLicpsFNaRrcFJvTxi/hiWh9fbEnJZG7Zm1lVbXKSDAihBBCXEKKoqDe+D8A6p5aTF7aiQqXNaiBayHauUfm4Xl7TwAy5s+7+EpWMQlGhBBCiEvsho492aGJxYCdg7++V+FybqlxCxGeEaRb0tnaJgCAnL/+xp6eXllVrRISjAghhBCXmE6rIb3ZowDEHJuLNTezYuVodDwY+yAAXxT8hTG2PqrNRtbixZVW16ogwYgQQghxGbS9dQDHicCHXPYs/rTC5Zw7CVpa56aAayDr1UyCESGEEOIyMBn0HKs3FIDwPTNx2qwVKsfL4MXddVwr+H5T7RjodBTs2kXBgQOVVdXLToIRIYQQ4jJp0XskqfgSqqaw66+vK1zOmUnQluVsRmnXCoDMBb9UVjUvOwlGhBBCiMvE28ubPZH3A+C1eSqq01mhcqp5VaNLjS4ArGji+lOe+duvqHZ75VT0MpNgRAghhLiMYu8YTZ5qpKb9CHvX/Fbhcs485vul11YUfz8cKafJ/fffyqrmZSXBiBBCCHEZBYWEsz24NwCO1RWfIr5pcFOaBDUhX7ERd2M0ABlX6UBWCUaEEEKIy6zGbc/iUBUaF2zm8M71FSpDURQGNBgAwNdRrgXzcv7+G0dGRmVV87KRYEQIIYS4zKrVrM82744ApP31foXL6RrVlVCPUHb4ZVEQE45qs5F5Fc45IsGIEEIIUQW8Oz8FQNOMP0k5eaxCZeg1eh6o/wAA/zRWgatzzhEJRoQQQogqULdlZ/bqG2BQHBxa+EGFy7mn7j2YtCbmRaegarUU7NyJ5dChSqzppSfBiBBCCFFF8luNAqDByR/Jy6nYFPG+Rl/uqHUHWZ4Kxxq61qvJXLCgsqp4WUgwIoQQQlSRpl0e4IQShi+57Fw0rcLlPNjAtV7NT3XSAMj85eqac0SCESGEEKKKaHU6EuoNAaDavlk4KhhA1PStyc3VbmZLLbB4G7GnpJC7Zk0l1vTS0lV1BSqTw+HAZrNVdTXEdUav16PVaqu6GkKIq1TjXqPI3PcxkWoiW5fNoXn3ARUqZ2DsQFYnrGZlrEq3DZDx8894dehQybW9NK6JYERVVZKSksi4Cp+tFtcGPz8/wsLCUBSlqqsihLjKeHj5si6iLzecnI1p41SoYDByY8SN1PKtxZ8ND9FtA+T89TeOzEy0vr6VXOPKd00EI2cCkZCQEDw8POQPgrhsVFUlLy+P5ORkAMLDw6u4RkKIq1GtXk9j/ew7Ym27ObBlOXVbdCp3GWcmQRuf8RonQ/VEnLKRtWQp/v3uq/wKV7KrPhhxOBzuQCQwMLCqqyOuQ2azGYDk5GRCQkLklo0QotyCI6LZ6NeV1plLyf5nClQgGAHoVbMXH275kL8bpjHwFGT+8stVEYxc9QNYz4wR8fDwqOKaiOvZme+fjFkSQlRUQNcxADTNWkHi8f0VKsOkM3Fv3XtZ3UDBqUD+li1Y4+Iqs5qXxFUfjJwht2ZEVZLvnxDiYtVqfAO7jM3QKU6OL674FPH96vUj20fPjmjX76XMBb9UVhUvmWsmGBFCCCGudo4bHgegYdIv5GSlV6iMUM9Qukd3Z0XjwmDkl19Qnc5Kq+OlIMGIEEIIcYVo3OFu4pUIvJV8dv/+WYXLGRA7gI11FfINYEtIIH/LlkqsZeWTYOQaM2TIEPr06XPJyu/UqRNPPfXUJStfCCGuZxqtloS6AwEI2/8NToejQuU0Dm5M/YimrK1/tnfkSibBiCiX+fPn8/rrr19UGStXrqR3795ERESgKAoLSlhD4dSpUwwZMoSIiAg8PDy49dZbOXjwYJE8FouF//3vfwQFBeHp6ckdd9zBiRMniuRJT09n4MCB+Pr64uvry8CBA2U+GiHEFa3hbSPIUc1EOU+we3XFg4iBsQNZ0dj1Zz7r9yU4Cwoqq4qVToIRUS4BAQF4e3tfVBm5ubk0bdqUTz75pMTjqqrSp08fjhw5wi+//MLWrVuJioqia9eu5ObmuvM99dRT/Pzzz8yZM4fVq1eTk5NDr169cJzzXxL9+/dn27ZtLFmyhCVLlrBt2zYGDhx4UfUXQohLyds3gF0hvQBwrKv4rZouUV1IqxtCsi84c3LIWbassqpY+dSrQGZmpgqomZmZxY7l5+ere/bsUfPz81VVVVWn06nmWmxVsjmdzjK3qWPHjurjjz+uPvnkk6qfn58aEhKifvbZZ2pOTo46ZMgQ1cvLS61Zs6a6ePFi9zl2u1196KGH1OjoaNVkMql169ZVp0yZUqTcwYMHq3feead73+l0qm+//bYaExOjmkwmtUmTJuqPP/7oPp6Wlqb2799fDQoKUk0mk1q7dm115syZ5633k08+6d6PiopS33zzTXXo0KGql5eXWr16dfWzzz4r8+cAqD///HORtP3796uAumvXriJtDwgIUL/44gtVVVU1IyND1ev16pw5c9x5EhISVI1Goy5ZskRVVVXds2ePCqjr1q1z51m7dq0KqPv27StzHcviv99DIYS4GHEHtqnqOB/V8aqvGn9wZ4XL+WLHF+rrQ2PVPfXqq8eHP1yJNSyb8/39PtdVP+nZf+XbHDR4dWmVXHvPhB54GMr+kX799dc899xzbNiwgblz5zJy5EgWLFjAXXfdxYsvvsgHH3zAwIEDiYuLw8PDA6fTSWRkJD/88ANBQUGsWbOGRx55hPDwcO67r+RJbV5++WXmz5/PtGnTqFOnDitXrmTAgAEEBwfTsWNHXnnlFfbs2cPvv/9OUFAQhw4dIj8/v1ztfu+993j99dd58cUX+emnnxg5ciQdOnSgfv365SrnDIvFAoDJZHKnabVaDAYDq1evZvjw4WzevBmbzUb37t3deSIiImjUqBFr1qyhR48erF27Fl9fX9q2bevOc8MNN+Dr68uaNWuoV69eheonhBCXWvU6Tdluak3Tgo2c+OMjImt/XqFy7qlzDwOaTqXvmnxy/l2NPSUFXXBwJdf24sltmirUtGlTXn75ZerUqcPYsWMxm80EBQXx8MMPU6dOHV599VVSU1PZsWMH4FqQbfz48bRu3ZqYmBgefPBBhgwZwg8//FBi+bm5ubz//vvMnDmTHj16ULNmTYYMGcKAAQP47DNX119cXBzNmzenVatWREdH07VrV3r37l2udtx2222MGjWK2rVr8/zzzxMUFMTy5csr/LnUr1+fqKgoxo4dS3p6OlarlbfeeoukpCQSExMB1xIABoMBf3//IueGhoaSlJTkzhMSElKs/JCQEHceIYS4UiltRwDQ8NSv5GZnVKgMP5MfrVrfwYEIUJwqmQsXVWINK8811zNi1mvZM6FHlV27PJo0aeJ+r9VqCQwMpHHjxu600NBQAPe6JwDTp09nxowZHD9+nPz8fKxWK82aNSux/D179lBQUEC3bt2KpFutVpo3bw7AyJEj6du3L1u2bKF79+706dOHdu3aVbgdiqIQFhZWpM7lpdfrmTdvHsOGDSMgIACtVkvXrl3p2bPnBc9VVbXIBGQlTUb23zxCCHElatThLuJXvkJ1TrJ+8We07fd8hcp5MPZBpjX+kbonnZz++ScChw6p3IpWgmsuGFEUpVy3SqqSXq8vsq8oSpG0M38wnYWT1fzwww+MHj2a9957jxtvvBFvb28mT57M+vXrSyz/zHmLFi2iWrVqRY4ZjUYAevbsyfHjx1m0aBF//fUXXbp04bHHHuPdd9+9qHY4L3KCnZYtW7Jt2zYyMzOxWq0EBwfTtm1bWrVqBUBYWBhWq5X09PQivSPJycnuYCosLIxTp04VKzslJcUd6AkhxJXqzGO+1fe/Tdj+2ajOZ1E05b+hUce/DrZOrbH9tR79gcMU7NuHqYK30S8VuU1zFVm1ahXt2rVj1KhRNG/enNq1a3P48OFS8zdo0ACj0UhcXBy1a9cuslWvXt2dLzg4mCFDhvDtt98yZcoUPv+8YvcmLwVfX1+Cg4M5ePAgmzZt4s477wRcwYper+fPP/90501MTGTXrl3uYOTGG28kMzOTDRs2uPOsX7+ezMzMcvf+CCFEVWh42whyVRNRzhPsuojHfO9pNZTNtV3/gXt6/k+VVb1Kc3V0IQgAateuzezZs1m6dCkxMTF88803bNy4kZiYmBLze3t788wzzzB69GicTic333wzWVlZrFmzBi8vLwYPHsyrr75Ky5YtadiwIRaLhYULFxIbG3tJ25GTk8OhQ4fc+0ePHmXbtm0EBARQo0YNAH788UeCg4OpUaMGO3fu5Mknn6RPnz7uAau+vr4MGzaMp59+msDAQAICAnjmmWdo3LgxXbt2BSA2NpZbb72Vhx9+2D1G5pFHHqFXr14yeFUIcVXw9g1gfUgv2qb8hGPtdOhwV4XKaR/ZnoVtQrhh/ynSfllAtWefR/lPr3ZVkp6Rq8iIESO4++676devH23btiU1NZVRo0ad95zXX3+dV199lUmTJhEbG0uPHj347bff3AGMwWBg7NixNGnShA4dOqDVapkzZ84lbcemTZto3ry5e9zKmDFjaN68Oa+++qo7T2JiIgMHDqR+/fo88cQTDBw4kO+//75IOR988AF9+vThvvvu46abbsLDw4PffvsNrfbs2J3vvvuOxo0b0717d7p3706TJk345ptvLmn7hBCiMkV0fwKAJnnrSTiyu0JlaBQNze54iAwP0Gfmkr1yZWVW8aIpqqqqVV2JC8nKysLX15fMzEx8fHyKHCsoKODo0aPExMQUeRRUiMtJvodCiEtpx1tdaVKwkXWhD3DDyOkVKiPbms0Xj9xEz3U27De3pPGMbyu5lsWd7+/3uaRnRAghhLjCOVsPB6D+qd8oyMupUBneBm80t7tuY2vWbMGemlpp9btYEowIIYQQV7jGHe8hkWD8yGHnH19XuJyeXR7lUBhonCoJ876/8AmXiQQjQgghxBVOq9NxPNo107bPrtkVLqdeQD0O3xQFQPJPc7hSRmpIMCKEEEJcBWrfOgKbqqWefR+Hd6ypcDn17huGVQtecank7NpRiTWsOAlGhBBCiKtAUFgNdni3B+D0iooNYgXo0uhOtse6Jr7c983USqnbxZJgRAghhLhKmG58BIBGp5eSk5VeoTIMWoN7IKv2rzU4rdZKq19FSTAihBBCXCUa3NiT45pIPJUCdi/5osLldL77SVK9wZxn5/DCqh/IKsGIEEIIcZVQNBoSaz8AQMi+71AruA5YNd/qHGsXDUDCnKqfCFKCESGEEOIqEnvro+SrBmKcx9i/6e8Kl1Or/8MABO9MIOvEsUqqXcVIMFJFVFXlkUceISAgAEVR2LZtW5XV5dixY5e0DsuXL0dRFDIyMi5J+UIIcT3xDQhmp79rzEfO6s8qXE7bNn04EmVEo8KW2e9XVvUqRIKRKrJkyRJmzZrFwoULSUxMpFGjRlVdpUumXbt2JCYm4uvre1HlPPnkk7Rs2RKj0UizZs1KzPPDDz/QrFkzPDw8iIqKYvLkycXyrFixgpYtW2IymahZsybTpxcflT5v3jz3qscNGjTg559/vqi6CyFEZfLrMAKAJpn/kJ6SWKEyNIoGbr8FAO3vK3BW8JZPZZBgpIocPnyY8PBw2rVrR1hYGDrdtbuAssFgICwsDEVRLqocVVV56KGH6NevX4nHf//9dx588EFGjBjBrl27mDp1Ku+//z6ffPKJO8/Ro0e57bbbaN++PVu3buXFF1/kiSeeYN68ee48a9eupV+/fgwcOJDt27czcOBA7rvvPtavX39R9RdCiMpSt0VHDmprY/j/9u48Lqpy/wP4Z2ZYHGRR1hlAhkUvO8iSOmAuoeB6UzOUlCTMLuWCGF0u7le7ElZesm64m6mFC1peFwQVIcJwAUwBlS3RHERLQRbZ5vn94Y9zHQEDRIeZvu/X67xezvM858z360zN13Oecx5eE64e7/ptvtIZ76NeEzC+04DLaYl/vMPzwlRAZWUlA8AqKytb9dXV1bH8/HxWV1f3qEEuZ6y+WjmbXN6hfGbNmsUAcJtEIvn/0OUsNjaW2djYsF69ejE3Nze2b98+br/U1FQGgCUlJbGBAweyXr16sZEjR7Lbt2+zo0ePMgcHB6anp8emT5/OampquP2OHTvGfH19mYGBATM0NGTjx49nRUVFXH9paSkDwHJycri2vLw8NnbsWNa7d29mamrKZs6cye7cucP179u3j7m4uLBevXoxQ0ND5ufnx6qrq9vMtyXue/fuMcYY2759OzMwMGBJSUnMwcGB9e7dmwUEBLBbt2516O9vxYoVzN3dvVV7UFAQmzp1qkLbv//9b2Zpacnk///Z/P3vf2cODg4KY/72t7+xIUOGcK8DAwPZmDFjFMYEBASw6dOntxtTq+8hIYQ8Z1n71zG2Qp/dWPkX1tzU1OXjHA7xZxedHFhKXGQ3RvfI036/H6d+/xxvrAXWmCvnvRffArR6/+Gwzz77DHZ2dti0aRPOnTvHLXm/dOlSHDhwAPHx8RgwYADS09Mxc+ZMmJiYYPjw4dz+K1euxBdffAEdHR0EBgYiMDAQ2tra+Oabb1BdXY3Jkyfj888/R1RUFACgpqYGixYtgqurK2pqarB8+XJMnjwZubm54PNbnxyTyWQYPnw45syZg3Xr1qGurg5RUVEIDAzEqVOnIJPJEBQUhLVr12Ly5Ml48OABfvjhh049Vri2thaffPIJdu7cCT6fj5kzZyIyMhK7d+/u8DGeVF9fDx0dHYU2oVCImzdv4vr167C2tsaZM2fg7++vMCYgIABbt25FY2MjNDU1cebMGURERLQaExcX1+XYCCGku7kEhKLq0lpYsnJc+vEQXIdN7tJxPJZ+DG1dA7iZSbo5wo5Tv2JEBRgYGEBPTw8CgQAikQjAo4Jh3bp1OHXqFKRSKQDA1tYWGRkZ2Lhxo0Ix8uGHH8LX1xcAMHv2bERHR6O4uBi2trYAgKlTpyI1NZUrRl577TWF99+6dStMTU2Rn5/f5lyV+Ph4eHp6Ys2aNVzbtm3b0K9fP1y7dg3V1dVoamrClClTIJE8+vK6urp26u+gsbERGzZsgJ2dHQBg3rx5WLVqVaeO8aSAgABEREQgJCQEI0eORFFREVdAyGQyWFtbo7y8HGZmZgr7mZmZoampCXfv3oVYLG53THl5+TPFRwgh3UlH1wBZxmMw+O4BNJzbAXSxGDG3c+vmyDpP/YoRTZ1HZyiU9d5dlJ+fj4cPH2L06NEK7Q0NDfDw8FBoc3P73xfHzMwMOjo6XCHS0nb27FnudXFxMZYtW4affvoJd+/e5SYplZWVtVmMXLhwAampqdDV1W3VV1xcDH9/f/j5+cHV1RUBAQHw9/fH1KlT0bdv3w7nq6OjwxUiACAWi1FRUdHh/dsyZ84cFBcXY8KECWhsbIS+vj7Cw8OxcuVK7uwTgFZzV1rO6Dze3taYZ53zQggh3c142BzgwAG4Vv2Ae3dk6GsiVnZIXaJ+xQiP16FLJT1NS4Fw5MgRWFhYKPRpa2srvNbU1OT+zOPxFF63tD0+K3rixIno168fNm/eDHNzc8jlcri4uKChnUcAy+VyTJw4EbGxsa36xGIxBAIBUlJSkJmZieTkZHz++edYsmQJsrKyYGNj06F824q5M5d52sLj8RAbG4s1a9agvLwcJiYmOHny0T341tbWAACRSNTqDEdFRQU0NDRgZGT01DFPni0hhBBls3PzQeH3/TGguQjZKVsw5I1lyg6pS+humh6i5TbSsrIy9O/fX2Hr169fl4/722+/oaCgAEuXLoWfnx8cHR1x797T1zPw9PREXl4erK2tW8XSu/ejQo/H48HX1xf//Oc/kZOTAy0trR5z+6tAIICFhQW0tLTw7bffQiqVwtTUFAAglUqRkpKiMD45ORne3t5cgdTeGB8fnxeTACGEdMLv9tMBAKKivV1+IquydakY+fLLL2FjY4NevXrBy8sLP/zww1PH19fXY8mSJZBIJNDW1oadnR22bdvWpYDVlZ6eHiIjIxEREYEdO3aguLgYOTk5+M9//oMdO3Z0+bh9+/aFkZERNm3ahKKiIpw6dQqLFi166j5z587F77//jqCgIJw9exYlJSVITk5GaGgompubkZWVhTVr1uD8+fMoKyvDgQMHcOfOHTg6OnY5zo4oKipCbm4uysvLUVdXh9zcXOTm5nJneO7evYsNGzbgypUryM3NRXh4OPbt26cw8TQsLAzXr1/HokWLUFBQgG3btmHr1q2IjIzkxoSHhyM5ORmxsbG4cuUKYmNjceLECSxcuPC55kcIIV3h6B+KOqYFa3kZrmanKjucLun0ZZo9e/Zg4cKF+PLLL+Hr64uNGzdi7NixyM/Ph5WVVZv7BAYG4vbt29i6dSv69++PiooKNDU1PXPw6mb16tUwNTVFTEwMSkpK0KdPH3h6emLx4sVdPiafz0dCQgIWLFgAFxcX2NvbY/369RgxYkS7+5ibm+PHH39EVFQUAgICUF9fD4lEgjFjxoDP50NfXx/p6emIi4tDVVUVJBIJPv30U4wdO7bLcXbE22+/jbS0NO51y1ya0tJS7jLMjh07EBkZCcYYpFIpTp8+jUGDBnH72NjY4OjRo4iIiMB//vMfmJubY/369QqTfH18fJCQkIClS5di2bJlsLOzw549ezB48ODnmh8hhHSFfh8jnOvzCl6qTEJVxhbA20/ZIXUaj3XyQv3gwYPh6emJ+Ph4rs3R0RGTJk1CTExMq/FJSUmYPn06SkpKYGho2KUgq6qqYGBggMrKSujr6yv0PXz4EKWlpdyZGkKUgb6HhBBlKsg6Dsdjgahl2mhedAV6Bl37ve1uT/v9flynLtM0NDTgwoULrZ7T4O/vj8zMzDb3OXToELy9vbF27VpYWFjgL3/5CyIjI1FXV9fu+9TX16OqqkphI4QQQkjbHF4ajTK+BXR49ShI+UrZ4XRap4qRu3fvorm5uVPPYCgpKUFGRgYuX76MgwcPIi4uDvv378fcuXPbfZ+YmBgYGBhw27NM4CSEEELUHY/Pxy3b1wEAfa58q+RoOq9LE1g78wwGuVwOHo+H3bt3Y9CgQRg3bhzWrVuHr776qt2zI9HR0aisrOS2GzdudCVMQggh5E9jwOg5aGAC/KXpGkouq9ZaWp0qRoyNjSEQCDr1DAaxWAwLCwuFFVsdHR3BGMPNmzfb3EdbWxv6+voKGyGEEELaZ2Rmict6j57OXZG2WcnRdE6nihEtLS14eXm1egZDSkpKu89g8PX1xa1bt1BdXc21Xbt2DXw+H5aWll0ImRBCCCFt0fAOAQA43jmKh3U1yg2mEzp9mWbRokXYsmULtm3bhoKCAkRERKCsrAxhYWEAHl1iefPNN7nxb7zxBoyMjPDWW28hPz8f6enp+OCDDxAaGgqhUNh9mRBCCCF/cs5DX0U5TGCAGlw+2fWFR1+0Thcj06ZNQ1xcHFatWoWBAwciPT0dR48e5RZMk8lkKCsr48br6uoiJSUF9+/fh7e3N2bMmIGJEydi/fr13ZcFIYQQQiDQ0ECp1aMF84Q/71JyNB3X6eeMKAM9Z4T0dPQ9JIT0FOVlhTDd+hL4PIZbs7JgbuOgtFiey3NGSM8XEhKCSZMmPbfjjxgxgh6LTgghPZjIagDyeg0EAFxPVY2lV6gYIZ1y4MABrF69+pmOkZ6ejokTJ8Lc3Bw8Hg/fffddqzG3b99GSEgIzM3NoaOjgzFjxqCwsFBhzIgRI8Dj8RS26dOnK4y5d+8egoODuWfWBAcH4/79+88UPyGE9HT1zo/+Xyi58R3kzc1KjuaPUTFCOsXQ0BB6enrPdIyamhq4u7vjiy++aLOfMYZJkyahpKQE33//PXJyciCRSDBq1CjU1CjODp8zZw5kMhm3bdy4UaH/jTfeQG5uLpKSkpCUlITc3FwEBwc/U/yEENLTOfvNQDUTwpzdxpWzycoO5w9RMaIkI0aMwPz587Fw4UL07dsXZmZm2LRpE2pqavDWW29BT08PdnZ2OHbsGLdPc3MzZs+eDRsbGwiFQtjb2+Ozzz576vswxrB27VrY2tpCKBTC3d0d+/fv5/rv3buHGTNmwMTEBEKhEAMGDMD27dufGvfjl2msra2xZs0ahIaGQk9PD1ZWVti0adNTYxo7diw+/PBDTJkypc3+wsJC/PTTT4iPj8dLL70Ee3t7fPnll6iursa33yo+WVBHRwcikYjbHn+eTUFBAZKSkrBlyxZIpVJIpVJs3rwZhw8fxtWrV58aIyGEqDJhbz3kG74CAKjO+lrJ0fwxtStGGGOobaxVytbZucA7duyAsbExzp49i/nz5+Pdd9/F66+/Dh8fH2RnZyMgIADBwcGora0F8OhptpaWlti7dy/y8/OxfPlyLF68GHv37m33PZYuXYrt27cjPj4eeXl5iIiIwMyZM7nVb5ctW4b8/HwcO3YMBQUFiI+Ph7Gxcafy+PTTT+Ht7Y2cnBy89957ePfdd3HlypVOHeNx9fX1AKAwEVQgEEBLSwsZGRkKY3fv3g1jY2M4OzsjMjISDx484PrOnDkDAwMDhdV2hwwZAgMDg3bXUiKEEHWhN2QWAMD53inUVlcqOZqn01B2AN2trqkOg79RzlLvWW9kQUdTp8Pj3d3dsXTpUgCPns/y0UcfwdjYGHPmzAEALF++HPHx8fj5558xZMgQaGpq4p///Ce3v42NDTIzM7F3714EBga2On5NTQ3WrVuHU6dOQSqVAgBsbW2RkZGBjRs3Yvjw4SgrK4OHhwe8vb0BPDrT0Vnjxo3De++9BwCIiorCv//9b5w+fRoODl2bwe3g4ACJRILo6Ghs3LgRvXv3xrp161BeXg6ZTMaNmzFjBmxsbCASiXD58mVER0fj4sWL3EP5ysvLYWpq2ur4pqam7a6lRAgh6sLhpdG4mSSCJcpx7uRuvPTqe8oOqV1qV4yoEjc3N+7PAoEARkZGcHV15dpaHrFfUVHBtW3YsAFbtmzB9evXUVdXh4aGBgwcOLDN4+fn5+Phw4cYPXq0QntDQwM8PDwAAO+++y5ee+01ZGdnw9/fH5MmTWr3abodyYPH40EkEinE3FmamppITEzE7NmzYWhoCIFAgFGjRmHs2LEK41qKNgBwcXHBgAED4O3tjezsbHh6enLxPOlpaykRQoi64PH5uGE1CZbXN0CYvwegYuTFEWoIkfWGchYIEmp07omympqaCq95PJ5CW8sPplwuBwDs3bsXERER+PTTTyGVSqGnp4ePP/4YWVlt59uy35EjR2BhYaHQp62tDeDR/I3r16/jyJEjOHHiBPz8/DB37lx88sknz5RHy3t3lZeXF3Jzc1FZWYmGhgaYmJhg8ODB3Bmctnh6ekJTUxOFhYXw9PSESCTC7du3W427c+dOu2spEUKIOrF+JRTYvgFODy9Cdv0qxBJ7ZYfUJrUrRng8XqculaiSH374AT4+PtwlEQAoLi5ud7yTkxO0tbVRVlaG4cOHtzvOxMQEISEhCAkJwcsvv4wPPvigU8XI89QyIbWwsBDnz59/6m3FeXl5aGxshFgsBgBIpVJUVlbi7NmzGDRoEAAgKysLlZWVnT77QwghqkgssUeeljucGy7il1PbIH4rVtkhtUntihF11r9/f3z99dc4fvw4bGxssHPnTpw7dw42NjZtjtfT00NkZCQiIiIgl8sxdOhQVFVVITMzE7q6upg1axaWL18OLy8vODs7o76+HocPH4ajo+NzzaO6uhpFRUXc69LSUuTm5sLQ0BBWVlYAgH379sHExARWVla4dOkSwsPDMWnSJPj7+wN4VITt3r0b48aNg7GxMfLz8/H+++/Dw8MDvr6PVq10dHTEmDFjMGfOHO6W33feeQcTJkyAvX3P/NcBIYR0t1qnaUDuRfQr+x5MHgMev+fdu9LzIiLtCgsLw5QpUzBt2jQMHjwYv/32m8JZkrasXr0ay5cvR0xMDBwdHREQEID//ve/XAGjpaWF6OhouLm5YdiwYRAIBEhISHiueZw/fx4eHh7cvJVFixbBw8MDy5cv58bIZDIEBwfDwcEBCxYsQHBwsMJtvVpaWjh58iQCAgJgb2+PBQsWwN/fHydOnIBAIODG7d69G66urvD394e/vz/c3Nywc+fO55ofIYT0JM6jZqKG9YIlk+HquRPKDqdNtDYNId2AvoeEkJ7sXNx0vHT/GM72nYBB4S9uNV9am4YQQgghAACdQW8CAJx+P4m6mgd/MPrFo2KEEEIIUXOOgwNwi2cGXV4d8k6+uDMjHUXFCCGEEKLm+AIBrlv+FQCgld/+U7uVhYoRQggh5E+g3/AQAIBzXTbulpcpN5gnUDFCCCGE/AlY9nfBVQ17CHgMRad61uJ5VIwQQgghfxL37CYBAAxLvlduIE+gYoQQQgj5kxjwyptoYnz8pekabhRdUnY4HCpGCCGEkD8JIzNL5Au9AAA303YoOZr/oWKEEEII+RNpcHoNANDv5mGwZ1zUtLtQMaIkjDG88847MDQ0BI/HQ25urtJi+eWXX55rDKdPnwaPx8P9+/efy/EJIYR0nOPIINQybVgyGQpz05UdDgAqRpQmKSkJX331FQ4fPgyZTAYXFxdlh/Tc+Pj4QCaTcSvwdlV4eDi8vLygra2NgQMHtjlm7969GDhwIHR0dCCRSPDxxx8r9LcURk9uV65cURiXmJjIrXrs5OSEgwcPPlPshBDSU/TW64N8/aEAgHtnesZaXVSMKElxcTHEYjF8fHwgEomgoaG+CyhraWlBJBKBx+M903EYYwgNDcW0adPa7D927BhmzJiBsLAwXL58GV9++SXWrVuHL774otXYq1evQiaTcduAAQO4vjNnzmDatGkIDg7GxYsXERwcjMDAQGRlZT1T/IQQ0lNoegQCAPrfSUFTY4OSo6FiRClCQkIwf/58lJWVgcfjwdraGsCjH9u1a9fC1tYWQqEQ7u7u2L9/P7dfy7/qjx8/Dg8PDwiFQrzyyiuoqKjAsWPH4OjoCH19fQQFBaG2tpbbLykpCUOHDkWfPn1gZGSECRMmoLi4+Kkx5ufnY9y4cdDV1YWZmRmCg4Nx9+5drn///v1wdXWFUCiEkZERRo0ahZqamjaP9eRlmq+++gp9+vTB8ePH4ejoCF1dXYwZMwYymeypMa1fvx5z586Fra1tm/07d+7EpEmTEBYWBltbW4wfPx5RUVGIjY3Fk+tBmpqaQiQScdvjK/3GxcVh9OjRiI6OhoODA6Kjo+Hn54e4uLinxkcIIarCaehk3IM+jFCJ/IxDyg5H/YoRxhjktbVK2Tq6APJnn32GVatWwdLSEjKZDOfOnQMALF26FNu3b0d8fDzy8vIQERGBmTNnIi0tTWH/lStX4osvvkBmZiZu3LiBwMBAxMXF4ZtvvsGRI0eQkpKCzz//nBtfU1ODRYsW4dy5czh58iT4fD4mT54MeTsTl2QyGYYPH46BAwfi/PnzSEpKwu3btxEYGMj1BwUFITQ0FAUFBTh9+jSmTJnS4fwBoLa2Fp988gl27tyJ9PR0lJWVITIyssP7t6W+vr7VirlCoRA3b97E9evXFdo9PDwgFovh5+eH1NRUhb4zZ87A399foS0gIACZmZnPFB8hhPQUmlrauGY8CgDQkJOg5GgAtbs2wOrqcNXTSynvbZ99ATwdnT8cZ2BgAD09PQgEAohEIgCPCoZ169bh1KlTkEqlAABbW1tkZGRg48aNGD58OLf/hx9+CF9fXwDA7NmzER0djeLiYu6MwdSpU5GamoqoqCgAwGuvvabw/lu3boWpqSny8/PbnKsSHx8PT09PrFmzhmvbtm0b+vXrh2vXrqG6uhpNTU2YMmUKJBIJAMDV1bXDf08A0NjYiA0bNsDOzg4AMG/ePKxatapTx3hSQEAAIiIiEBISgpEjR6KoqIg7myGTyWBtbQ2xWIxNmzbBy8sL9fX12LlzJ/z8/HD69GkMGzYMAFBeXg4zMzOFY5uZmaG8vPyZ4iOEkJ7EYPAM4MgBOFWmo7a6Ejq6zzav71moXTGiqvLz8/Hw4UOMHj1aob2hoQEeHh4KbW5ubtyfzczMoKOjo3DpwszMDGfPnuVeFxcXY9myZfjpp59w9+5d7oxIWVlZm8XIhQsXkJqaCl1d3VZ9xcXF8Pf3h5+fH1xdXREQEAB/f39MnToVffv27XC+Ojo6XCECAGKxGBUVFR3evy1z5sxBcXExJkyYgMbGRujr6yM8PBwrV67kLsPY29vD3t6e20cqleLGjRv45JNPuGIEQKv5LYyxZ57zQgghPYm91yv49agZLHAb50/vgfeEd5QWi9oVIzyhEPbZF5T23l3VUiAcOXIEFhYWCn3a2toKrzU1Nf/3njyewuuWtscvwUycOBH9+vXD5s2bYW5uDrlcDhcXFzQ0tD1pSS6XY+LEiYiNjW3VJxaLIRAIkJKSgszMTCQnJ+Pzzz/HkiVLkJWVBRsbmw7l21bMnbnM0xYej4fY2FisWbMG5eXlMDExwcmTJwGAm5fTliFDhmDXrl3ca5FI1OosSEVFRauzJYQQosp4fD7KLMbD4uY2aObtB6gY6T48Hq9Dl0p6mpbbSMvKyhQuyTyr3377DQUFBdi4cSNefvllAEBGRsZT9/H09ERiYiKsra3bvcuHx+PB19cXvr6+WL58OSQSCQ4ePIhFixZ1W+xdJRAIuILu22+/hVQqhampabvjc3JyIBaLuddSqRQpKSmIiIjg2pKTk+Hj4/P8giaEECUwf3kW8O02ONWex707MvQ1Ef/xTs+B2hUjqkpPTw+RkZGIiIiAXC7H0KFDUVVVhczMTOjq6mLWrFldOm7fvn1hZGSETZs2QSwWo6ysDP/4xz+eus/cuXOxefNmBAUF4YMPPoCxsTGKioqQkJCAzZs34/z58zh58iT8/f1hamqKrKws3LlzB46Ojl2KsaOKiopQXV2N8vJy1NXVcQ9pc3JygpaWFu7evYv9+/djxIgRePjwIbZv3459+/YpTACOi4uDtbU1nJ2d0dDQgF27diExMRGJiYncmPDwcAwbNgyxsbF49dVX8f333+PEiRN/WMQRQoiqkdgPRJHADv2bi3Ht1NcYPC1KKXFQMdKDrF69GqampoiJiUFJSQn69OkDT09PLF68uMvH5PP5SEhIwIIFC+Di4gJ7e3usX78eI0aMaHcfc3Nz/Pjjj4iKikJAQADq6+shkUgwZswY8Pl86OvrIz09HXFxcaiqqoJEIsGnn36KsWPHdjnOjnj77bcVCouWuTSlpaXcZZgdO3YgMjISjDFIpVKcPn0agwYN4vZpaGhAZGQkfv31VwiFQjg7O+PIkSMYN24cN8bHxwcJCQlYunQpli1bBjs7O+zZsweDBw9+rvkRQogy3HOdjTN3i9DPa7zSYuCxZ71Q/wJUVVXBwMAAlZWV0NfXV+h7+PAhSktLYWNj0+q2TkJeFPoeEkJIa0/7/X6c2j1nhBBCCCGqhYoRQgghhCgVFSOEEEIIUSoqRgghhBCiVFSMEEIIIUSp1KYYaW/RN0JeBPr+EUJI16n8c0a0tLTA5/Nx69YtmJiYQEtLi9YQIS8MYwwNDQ24c+cO+Hw+tLS0lB0SIYSoHJUvRvh8PmxsbCCTyXDr1i1lh0P+pHR0dGBlZQU+X21ONhJCyAuj8sUI8OjsiJWVFZqamtDc3KzscMifjEAggIaGBp2RI4SQLlKLYgT43+q1T64GSwghhJCejc4pE0IIIUSpqBghhBBCiFJRMUIIIYQQpVKJOSMtCwtXVVUpORJCCCGEdFTL73bL73h7VKIYefDgAQCgX79+So6EEEIIIZ314MEDGBgYtNvPY39UrvQAcrkct27dgp6eXpdvn6yqqkK/fv1w48YN6Ovrd3OEPQPlqB4oR/VAOaoHyvHZMMbw4MEDmJubP/U5TCpxZoTP58PS0rJbjqWvr6+2X6gWlKN6oBzVA+WoHijHrnvaGZEWNIGVEEIIIUpFxQghhBBClOpPU4xoa2tjxYoV0NbWVnYozw3lqB4oR/VAOaoHyvHFUIkJrIQQQghRX3+aMyOEEEII6ZmoGCGEEEKIUlExQgghhBClomKEEEIIIUpFxQghhBBClEqtipGYmBi89NJL0NPTg6mpKSZNmoSrV68qjGGMYeXKlTA3N4dQKMSIESOQl5enpIg7Lz4+Hm5ubtyT8qRSKY4dO8b1q3p+bYmJiQGPx8PChQu5NlXPc+XKleDxeAqbSCTi+lU9vxa//vorZs6cCSMjI+jo6GDgwIG4cOEC16/qeVpbW7f6HHk8HubOnQtA9fMDgKamJixduhQ2NjYQCoWwtbXFqlWrIJfLuTHqkOeDBw+wcOFCSCQSCIVC+Pj44Ny5c1y/KuaYnp6OiRMnwtzcHDweD999951Cf0dyqq+vx/z582FsbIzevXvjr3/9K27evNn9wTI1EhAQwLZv384uX77McnNz2fjx45mVlRWrrq7mxnz00UdMT0+PJSYmskuXLrFp06YxsVjMqqqqlBh5xx06dIgdOXKEXb16lV29epUtXryYaWpqssuXLzPGVD+/J509e5ZZW1szNzc3Fh4ezrWrep4rVqxgzs7OTCaTcVtFRQXXr+r5McbY77//ziQSCQsJCWFZWVmstLSUnThxghUVFXFjVD3PiooKhc8wJSWFAWCpqamMMdXPjzHGPvzwQ2ZkZMQOHz7MSktL2b59+5iuri6Li4vjxqhDnoGBgczJyYmlpaWxwsJCtmLFCqavr89u3rzJGFPNHI8ePcqWLFnCEhMTGQB28OBBhf6O5BQWFsYsLCxYSkoKy87OZiNHjmTu7u6sqampW2NVq2LkSRUVFQwAS0tLY4wxJpfLmUgkYh999BE35uHDh8zAwIBt2LBBWWE+s759+7ItW7aoXX4PHjxgAwYMYCkpKWz48OFcMaIOea5YsYK5u7u32acO+THGWFRUFBs6dGi7/eqS5+PCw8OZnZ0dk8vlapPf+PHjWWhoqELblClT2MyZMxlj6vE51tbWMoFAwA4fPqzQ7u7uzpYsWaIWOT5ZjHQkp/v37zNNTU2WkJDAjfn1118Zn89nSUlJ3RqfWl2meVJlZSUAwNDQEABQWlqK8vJy+Pv7c2O0tbUxfPhwZGZmKiXGZ9Hc3IyEhATU1NRAKpWqXX5z587F+PHjMWrUKIV2dcmzsLAQ5ubmsLGxwfTp01FSUgJAffI7dOgQvL298frrr8PU1BQeHh7YvHkz168uebZoaGjArl27EBoaCh6Ppzb5DR06FCdPnsS1a9cAABcvXkRGRgbGjRsHQD0+x6amJjQ3N6NXr14K7UKhEBkZGWqR45M6ktOFCxfQ2NioMMbc3BwuLi7dnrfaFiOMMSxatAhDhw6Fi4sLAKC8vBwAYGZmpjDWzMyM61MFly5dgq6uLrS1tREWFoaDBw/CyclJbfIDgISEBGRnZyMmJqZVnzrkOXjwYHz99dc4fvw4Nm/ejPLycvj4+OC3335Ti/wAoKSkBPHx8RgwYACOHz+OsLAwLFiwAF9//TUA9fgcH/fdd9/h/v37CAkJAaA++UVFRSEoKAgODg7Q1NSEh4cHFi5ciKCgIADqkaeenh6kUilWr16NW7duobm5Gbt27UJWVhZkMpla5PikjuRUXl4OLS0t9O3bt90x3UWjW4/Wg8ybNw8///wzMjIyWvXxeDyF14yxVm09mb29PXJzc3H//n0kJiZi1qxZSEtL4/pVPb8bN24gPDwcycnJrf6l8jhVznPs2LHcn11dXSGVSmFnZ4cdO3ZgyJAhAFQ7PwCQy+Xw9vbGmjVrAAAeHh7Iy8tDfHw83nzzTW6cqufZYuvWrRg7dizMzc0V2lU9vz179mDXrl345ptv4OzsjNzcXCxcuBDm5uaYNWsWN07V89y5cydCQ0NhYWEBgUAAT09PvPHGG8jOzubGqHqObelKTs8jb7U8MzJ//nwcOnQIqampsLS05Npb7lZ4sqKrqKhoVR32ZFpaWujfvz+8vb0RExMDd3d3fPbZZ2qT34ULF1BRUQEvLy9oaGhAQ0MDaWlpWL9+PTQ0NLhcVD3Px/Xu3Ruurq4oLCxUm89RLBbDyclJoc3R0RFlZWUA1Oe/RwC4fv06Tpw4gbfffptrU5f8PvjgA/zjH//A9OnT4erqiuDgYERERHBnLdUlTzs7O6SlpaG6uho3btzA2bNn0djYCBsbG7XJ8XEdyUkkEqGhoQH37t1rd0x3UatihDGGefPm4cCBAzh16hRsbGwU+lu+VCkpKVxbQ0MD0tLS4OPj86LD7TaMMdTX16tNfn5+frh06RJyc3O5zdvbGzNmzEBubi5sbW3VIs/H1dfXo6CgAGKxWG0+R19f31a31l+7dg0SiQSAev33uH37dpiammL8+PFcm7rkV1tbCz5f8adCIBBwt/aqS54tevfuDbFYjHv37uH48eN49dVX1S5HoGOfm5eXFzQ1NRXGyGQyXL58ufvz7tbpsEr27rvvMgMDA3b69GmF2+1qa2u5MR999BEzMDBgBw4cYJcuXWJBQUE9/vasx0VHR7P09HRWWlrKfv75Z7Z48WLG5/NZcnIyY0z182vP43fTMKb6eb7//vvs9OnTrKSkhP30009swoQJTE9Pj/3yyy+MMdXPj7FHt2VraGiwf/3rX6ywsJDt3r2b6ejosF27dnFj1CHP5uZmZmVlxaKiolr1qUN+s2bNYhYWFtytvQcOHGDGxsbs73//OzdGHfJMSkpix44dYyUlJSw5OZm5u7uzQYMGsYaGBsaYaub44MEDlpOTw3JychgAtm7dOpaTk8OuX7/OGOtYTmFhYczS0pKdOHGCZWdns1deeYVu7f0jANrctm/fzo2Ry+VsxYoVTCQSMW1tbTZs2DB26dIl5QXdSaGhoUwikTAtLS1mYmLC/Pz8uEKEMdXPrz1PFiOqnmfL/fyamprM3NycTZkyheXl5XH9qp5fi//+97/MxcWFaWtrMwcHB7Zp0yaFfnXI8/jx4wwAu3r1aqs+dcivqqqKhYeHMysrK9arVy9ma2vLlixZwurr67kx6pDnnj17mK2tLdPS0mIikYjNnTuX3b9/n+tXxRxTU1Pb/E2cNWsWY6xjOdXV1bF58+YxQ0NDJhQK2YQJE1hZWVm3x8pjjLHuPddCCCGEENJxajVnhBBCCCGqh4oRQgghhCgVFSOEEEIIUSoqRgghhBCiVFSMEEIIIUSpqBghhBBCiFJRMUIIIYQQpaJihBBCCCFKRcUIIYQQQpSKihFCCCGEKBUVI4QQQghRqv8DQfaRym1H3NMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Second, the \"cross-sectional method\", which gives us the probabilities of\n", + "# survivals of individuals of differnet ages that are alive in the given year.\n", + "plt.figure()\n", + "for year in years:\n", + " for s in [\"male\", \"female\"]:\n", + " fem = s == \"female\"\n", + " LivPrb = parse_ssa_life_table(\n", + " female=fem, year=year, cross_sec=True, min_age=min_age, max_age=max_age\n", + " )\n", + "\n", + " plt.plot(ages, LivPrb, label=s + \"s in \" + str(year))\n", + "\n", + "plt.legend()\n", + "plt.title(\"Cross-sectional survival probabilities\")" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "title,-all", + "formats": "ipynb,py:percent" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/Calibration/US_SSA_life_tables.py b/examples/Calibration/US_SSA_life_tables.py index 3c5e5ec00..18a55fc40 100644 --- a/examples/Calibration/US_SSA_life_tables.py +++ b/examples/Calibration/US_SSA_life_tables.py @@ -1,6 +1,23 @@ +# --- +# jupyter: +# jupytext: +# cell_metadata_filter: title,-all +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.14.4 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% from HARK.datasets.life_tables.us_ssa.SSATools import ( parse_ssa_life_table, - get_ssa_life_tables + get_ssa_life_tables, ) import numpy as np @@ -27,16 +44,16 @@ # experienced by agents born in "year" throughout their lived plt.figure() for cohort in years: - for s in ['male', 'female']: + for s in ["male", "female"]: + fem = s == "female" + LivPrb = parse_ssa_life_table( + female=fem, cohort=cohort, min_age=min_age, max_age=max_age + ) - fem = s == 'female' - LivPrb = parse_ssa_life_table(female = fem, cohort = cohort, - min_age = min_age, max_age = max_age) - - plt.plot(ages, LivPrb, label = s + ' born in ' + str(cohort)) + plt.plot(ages, LivPrb, label=s + " born in " + str(cohort)) plt.legend() -plt.title('Longitudinal survival probabilities') +plt.title("Longitudinal survival probabilities") # %% @@ -44,13 +61,13 @@ # survivals of individuals of differnet ages that are alive in the given year. plt.figure() for year in years: - for s in ['male', 'female']: - - fem = s == 'female' - LivPrb = parse_ssa_life_table(female = fem, year = year, cross_sec= True, - min_age = min_age, max_age = max_age) + for s in ["male", "female"]: + fem = s == "female" + LivPrb = parse_ssa_life_table( + female=fem, year=year, cross_sec=True, min_age=min_age, max_age=max_age + ) - plt.plot(ages, LivPrb, label = s + 's in ' + str(year)) + plt.plot(ages, LivPrb, label=s + "s in " + str(year)) plt.legend() -plt.title('Cross-sectional survival probabilities') +plt.title("Cross-sectional survival probabilities") diff --git a/examples/ConsBequestModel/example_AccidentalBequest.ipynb b/examples/ConsBequestModel/example_AccidentalBequest.ipynb new file mode 100644 index 000000000..cb2bf44b3 --- /dev/null +++ b/examples/ConsBequestModel/example_AccidentalBequest.ipynb @@ -0,0 +1,365 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "19c5f531", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T23:49:51.454557Z", + "iopub.status.busy": "2023-03-20T23:49:51.454557Z", + "iopub.status.idle": "2023-03-20T23:49:53.245109Z", + "shell.execute_reply": "2023-03-20T23:49:53.244109Z" + } + }, + "outputs": [], + "source": [ + "from copy import copy\n", + "from time import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "from HARK.Calibration.Income.IncomeTools import (\n", + " CGM_income,\n", + " parse_income_spec,\n", + " parse_time_params,\n", + ")\n", + "from HARK.ConsumptionSaving.ConsBequestModel import (\n", + " BequestWarmGlowConsumerType,\n", + " init_accidental_bequest,\n", + ")\n", + "from HARK.datasets.life_tables.us_ssa.SSATools import parse_ssa_life_table\n", + "from HARK.datasets.SCF.WealthIncomeDist.SCFDistTools import income_wealth_dists_from_scf\n", + "from HARK.utilities import plot_funcs" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8a2d828c", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T23:49:53.247109Z", + "iopub.status.busy": "2023-03-20T23:49:53.247109Z", + "iopub.status.idle": "2023-03-20T23:49:53.307194Z", + "shell.execute_reply": "2023-03-20T23:49:53.306187Z" + }, + "title": "Alter calibration" + }, + "outputs": [], + "source": [ + "birth_age = 25\n", + "death_age = 90\n", + "adjust_infl_to = 1992\n", + "income_calib = CGM_income\n", + "education = \"College\"\n", + "\n", + "# Income specification\n", + "income_params = parse_income_spec(\n", + " age_min=birth_age,\n", + " age_max=death_age,\n", + " adjust_infl_to=adjust_infl_to,\n", + " **income_calib[education],\n", + " SabelhausSong=True,\n", + ")\n", + "\n", + "# Initial distribution of wealth and permanent income\n", + "dist_params = income_wealth_dists_from_scf(\n", + " base_year=adjust_infl_to, age=birth_age, education=education, wave=1995\n", + ")\n", + "\n", + "# We need survival probabilities only up to death_age-1, because survival\n", + "# probability at death_age is 1.\n", + "liv_prb = parse_ssa_life_table(\n", + " female=True, cross_sec=True, year=2004, min_age=birth_age, max_age=death_age - 1\n", + ")\n", + "\n", + "# Parameters related to the number of periods implied by the calibration\n", + "time_params = parse_time_params(age_birth=birth_age, age_death=death_age)\n", + "\n", + "# Update all the new parameters\n", + "params = copy(init_accidental_bequest)\n", + "params.update(time_params)\n", + "params.update(dist_params)\n", + "params.update(income_params)\n", + "params.update({\"LivPrb\": liv_prb})" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fbfff075", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T23:49:53.309694Z", + "iopub.status.busy": "2023-03-20T23:49:53.309190Z", + "iopub.status.idle": "2023-03-20T23:49:53.541027Z", + "shell.execute_reply": "2023-03-20T23:49:53.540194Z" + }, + "title": "Create and solve agent" + }, + "outputs": [], + "source": [ + "# Make and solve an idiosyncratic shocks consumer with a finite lifecycle\n", + "Agent = BequestWarmGlowConsumerType(**params)\n", + "# Make this consumer live a sequence of periods exactly once\n", + "Agent.cycles = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5f41049a", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T23:49:53.543146Z", + "iopub.status.busy": "2023-03-20T23:49:53.543146Z", + "iopub.status.idle": "2023-03-20T23:49:53.742095Z", + "shell.execute_reply": "2023-03-20T23:49:53.742095Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a lifecycle consumer took 0.18708300590515137 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "Agent.solve()\n", + "end_time = time()\n", + "print(f\"Solving a lifecycle consumer took {end_time - start_time} seconds.\")\n", + "Agent.unpack(\"cFunc\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "27d1663e", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T23:49:53.745096Z", + "iopub.status.busy": "2023-03-20T23:49:53.744094Z", + "iopub.status.idle": "2023-03-20T23:49:53.975746Z", + "shell.execute_reply": "2023-03-20T23:49:53.975746Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption functions\n", + "print(\"Consumption functions\")\n", + "plot_funcs(Agent.cFunc, 0, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a16b7032", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T23:49:53.977747Z", + "iopub.status.busy": "2023-03-20T23:49:53.977747Z", + "iopub.status.idle": "2023-03-20T23:49:55.994622Z", + "shell.execute_reply": "2023-03-20T23:49:55.994622Z" + }, + "lines_to_next_cell": 2, + "title": "Simulation" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'aNrm': array([[ 0.29308355, 0.9570509 , 0.35897356, ..., 1.7684826 ,\n", + " 2.84407737, 0.24751228],\n", + " [ 0.24560297, 0.938678 , 0.63105756, ..., 1.70153542,\n", + " 1.81677469, 0.15850134],\n", + " [ 0.60598111, 1.8494616 , 0.60580686, ..., 1.37491855,\n", + " 2.55948322, 0.96661499],\n", + " ...,\n", + " [ 3.9841464 , 109.62976182, 3.4988143 , ..., 4.64289002,\n", + " 9.43144884, 14.43281143],\n", + " [ 4.69003931, 102.77957996, 4.47177149, ..., 3.47631164,\n", + " 10.18674707, 18.65258919],\n", + " [ 7.06787067, 95.98954284, 5.19840374, ..., 3.32887517,\n", + " 8.4678008 , 16.20440513]]),\n", + " 'cNrm': array([[ 0.82973632, 0.94980982, 0.85095005, ..., 1.01988478,\n", + " 1.09574156, 0.81281457],\n", + " [ 0.80242792, 0.93338416, 0.89571756, ..., 0.99728864,\n", + " 1.00571056, 0.76141644],\n", + " [ 0.8840081 , 0.9951231 , 0.88398171, ..., 0.96072933,\n", + " 1.04254393, 0.92625936],\n", + " ...,\n", + " [ 1.13200592, 11.44170176, 0.90100823, ..., 1.03606976,\n", + " 1.26575515, 1.83811696],\n", + " [ 1.15678012, 11.17591682, 0.94968419, ..., 0.9756263 ,\n", + " 1.32703547, 2.16470374],\n", + " [ 1.27302649, 10.91026663, 0.98582206, ..., 0.9865864 ,\n", + " 1.2413397 , 2.05323406]]),\n", + " 'pLvl': array([[ 44.17755524, 20.35577683, 9.62156414, ..., 22.58783801,\n", + " 8.69202078, 11.39484156],\n", + " [ 42.69570423, 17.65771873, 15.2555234 , ..., 29.27932939,\n", + " 13.78168087, 8.1685812 ],\n", + " [ 54.99138173, 15.21967918, 13.14916017, ..., 37.71130629,\n", + " 9.81667739, 7.84428065],\n", + " ...,\n", + " [168.67772028, 332.10427744, 629.7416812 , ..., 121.36453854,\n", + " 264.89759274, 915.62596279],\n", + " [146.1438155 , 332.10427744, 498.99941378, ..., 155.10185875,\n", + " 242.88199398, 676.9427477 ],\n", + " [106.82942396, 332.10427744, 442.15292568, ..., 172.65416349,\n", + " 309.43504077, 754.08506963]]),\n", + " 't_age': array([[ 1., 1., 1., ..., 1., 1., 1.],\n", + " [ 2., 2., 2., ..., 2., 2., 2.],\n", + " [ 3., 3., 3., ..., 3., 3., 3.],\n", + " ...,\n", + " [ 3., 50., 17., ..., 31., 27., 36.],\n", + " [ 4., 51., 18., ..., 32., 28., 37.],\n", + " [ 5., 52., 19., ..., 33., 29., 38.]]),\n", + " 'mNrm': array([[ 1.12281987, 1.90686072, 1.2099236 , ..., 2.78836738,\n", + " 3.93981893, 1.06032685],\n", + " [ 1.04803089, 1.87206216, 1.52677513, ..., 2.69882406,\n", + " 2.82248525, 0.91991778],\n", + " [ 1.48998921, 2.84458471, 1.48978857, ..., 2.33564787,\n", + " 3.60202715, 1.89287436],\n", + " ...,\n", + " [ 5.11615232, 121.07146358, 4.39982253, ..., 5.67895978,\n", + " 10.69720399, 16.27092838],\n", + " [ 5.84681943, 113.95549678, 5.42145567, ..., 4.45193794,\n", + " 11.51378254, 20.81729293],\n", + " [ 8.34089716, 106.89980947, 6.1842258 , ..., 4.31546157,\n", + " 9.70914051, 18.25763919]])}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Number of LifecycleExamples and periods in the simulation.\n", + "Agent.AgentCount = 500\n", + "Agent.T_sim = 200\n", + "\n", + "# Set up the variables we want to keep track of.\n", + "Agent.track_vars = [\"aNrm\", \"cNrm\", \"pLvl\", \"t_age\", \"mNrm\"]\n", + "\n", + "# Run the simulations\n", + "Agent.initialize_sim()\n", + "Agent.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7c7979ec", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T23:49:55.996623Z", + "iopub.status.busy": "2023-03-20T23:49:55.996623Z", + "iopub.status.idle": "2023-03-20T23:49:56.010667Z", + "shell.execute_reply": "2023-03-20T23:49:56.010161Z" + }, + "title": "Extract and format simulation results" + }, + "outputs": [], + "source": [ + "raw_data = {\n", + " \"Age\": Agent.history[\"t_age\"].flatten() + birth_age - 1,\n", + " \"pIncome\": Agent.history[\"pLvl\"].flatten(),\n", + " \"nrmM\": Agent.history[\"mNrm\"].flatten(),\n", + " \"nrmC\": Agent.history[\"cNrm\"].flatten(),\n", + "}\n", + "\n", + "Data = pd.DataFrame(raw_data)\n", + "Data[\"Cons\"] = Data.nrmC * Data.pIncome\n", + "Data[\"M\"] = Data.nrmM * Data.pIncome" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1d8269db", + "metadata": { + "execution": { + "iopub.execute_input": "2023-03-20T23:49:56.012674Z", + "iopub.status.busy": "2023-03-20T23:49:56.012674Z", + "iopub.status.idle": "2023-03-20T23:49:56.211623Z", + "shell.execute_reply": "2023-03-20T23:49:56.211623Z" + }, + "title": "Plots" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Find the mean of each variable at every age\n", + "AgeMeans = Data.groupby([\"Age\"]).median().reset_index()\n", + "\n", + "plt.figure()\n", + "plt.plot(AgeMeans.Age, AgeMeans.pIncome, label=\"Permanent Income\")\n", + "plt.plot(AgeMeans.Age, AgeMeans.M, label=\"Market resources\")\n", + "plt.plot(AgeMeans.Age, AgeMeans.Cons, label=\"Consumption\")\n", + "plt.legend()\n", + "plt.xlabel(\"Age\")\n", + "plt.ylabel(\"Thousands of {} USD\".format(adjust_infl_to))\n", + "plt.title(\"Variable Medians Conditional on Survival\")\n", + "plt.grid()" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:percent" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/ConsBequestModel/example_AccidentalBequest.py b/examples/ConsBequestModel/example_AccidentalBequest.py new file mode 100644 index 000000000..9fa8c2441 --- /dev/null +++ b/examples/ConsBequestModel/example_AccidentalBequest.py @@ -0,0 +1,128 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.14.5 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% +from copy import copy +from time import time + +import matplotlib.pyplot as plt +import pandas as pd + +from HARK.Calibration.Income.IncomeTools import ( + CGM_income, + parse_income_spec, + parse_time_params, +) +from HARK.ConsumptionSaving.ConsBequestModel import ( + BequestWarmGlowConsumerType, + init_accidental_bequest, +) +from HARK.datasets.life_tables.us_ssa.SSATools import parse_ssa_life_table +from HARK.datasets.SCF.WealthIncomeDist.SCFDistTools import income_wealth_dists_from_scf +from HARK.utilities import plot_funcs + +# %% Alter calibration +birth_age = 25 +death_age = 90 +adjust_infl_to = 1992 +income_calib = CGM_income +education = "College" + +# Income specification +income_params = parse_income_spec( + age_min=birth_age, + age_max=death_age, + adjust_infl_to=adjust_infl_to, + **income_calib[education], + SabelhausSong=True, +) + +# Initial distribution of wealth and permanent income +dist_params = income_wealth_dists_from_scf( + base_year=adjust_infl_to, age=birth_age, education=education, wave=1995 +) + +# We need survival probabilities only up to death_age-1, because survival +# probability at death_age is 1. +liv_prb = parse_ssa_life_table( + female=True, cross_sec=True, year=2004, min_age=birth_age, max_age=death_age - 1 +) + +# Parameters related to the number of periods implied by the calibration +time_params = parse_time_params(age_birth=birth_age, age_death=death_age) + +# Update all the new parameters +params = copy(init_accidental_bequest) +params.update(time_params) +params.update(dist_params) +params.update(income_params) +params.update({"LivPrb": liv_prb}) + +# %% Create and solve agent +# Make and solve an idiosyncratic shocks consumer with a finite lifecycle +Agent = BequestWarmGlowConsumerType(**params) +# Make this consumer live a sequence of periods exactly once +Agent.cycles = 1 + +# %% +start_time = time() +Agent.solve() +end_time = time() +print(f"Solving a lifecycle consumer took {end_time - start_time} seconds.") +Agent.unpack("cFunc") + +# %% +# Plot the consumption functions +print("Consumption functions") +plot_funcs(Agent.cFunc, 0, 5) + +# %% Simulation +# Number of LifecycleExamples and periods in the simulation. +Agent.AgentCount = 500 +Agent.T_sim = 200 + +# Set up the variables we want to keep track of. +Agent.track_vars = ["aNrm", "cNrm", "pLvl", "t_age", "mNrm"] + +# Run the simulations +Agent.initialize_sim() +Agent.simulate() + + +# %% Extract and format simulation results +raw_data = { + "Age": Agent.history["t_age"].flatten() + birth_age - 1, + "pIncome": Agent.history["pLvl"].flatten(), + "nrmM": Agent.history["mNrm"].flatten(), + "nrmC": Agent.history["cNrm"].flatten(), +} + +Data = pd.DataFrame(raw_data) +Data["Cons"] = Data.nrmC * Data.pIncome +Data["M"] = Data.nrmM * Data.pIncome + +# %% Plots +# Find the mean of each variable at every age +AgeMeans = Data.groupby(["Age"]).median().reset_index() + +plt.figure() +plt.plot(AgeMeans.Age, AgeMeans.pIncome, label="Permanent Income") +plt.plot(AgeMeans.Age, AgeMeans.M, label="Market resources") +plt.plot(AgeMeans.Age, AgeMeans.Cons, label="Consumption") +plt.legend() +plt.xlabel("Age") +plt.ylabel("Thousands of {} USD".format(adjust_infl_to)) +plt.title("Variable Medians Conditional on Survival") +plt.grid() diff --git a/examples/ConsBequestModel/example_ConsIndShockComp.ipynb b/examples/ConsBequestModel/example_ConsIndShockComp.ipynb new file mode 100644 index 000000000..5c7de1763 --- /dev/null +++ b/examples/ConsBequestModel/example_ConsIndShockComp.ipynb @@ -0,0 +1,127 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsBequestModel import BequestWarmGlowConsumerType\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import (\n", + " IndShockConsumerType,\n", + " init_idiosyncratic_shocks,\n", + ")\n", + "from HARK.utilities import plot_funcs" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPFRaw = 0.984539 \n", + "GPFNrm = 0.993777 \n", + "GPFAggLivPrb = 0.964848 \n", + "Thorn = APF = 0.994384 \n", + "PermGroFacAdj = 1.000611 \n", + "uInvEpShkuInv = 0.990704 \n", + "VAF = 0.932054 \n", + "WRPF = 0.213705 \n", + "DiscFacGPFNrmMax = 0.972061 \n", + "DiscFacGPFAggLivPrbMax = 1.010600 \n" + ] + } + ], + "source": [ + "beq_agent = BequestWarmGlowConsumerType(\n", + " **init_idiosyncratic_shocks, TermBeqFac=0.0, BeqFac=0.0\n", + ")\n", + "beq_agent.cycles = 0\n", + "beq_agent.solve()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPFRaw = 0.984539 \n", + "GPFNrm = 0.993777 \n", + "GPFAggLivPrb = 0.964848 \n", + "Thorn = APF = 0.994384 \n", + "PermGroFacAdj = 1.000611 \n", + "uInvEpShkuInv = 0.990704 \n", + "VAF = 0.932054 \n", + "WRPF = 0.213705 \n", + "DiscFacGPFNrmMax = 0.972061 \n", + "DiscFacGPFAggLivPrbMax = 1.010600 \n" + ] + } + ], + "source": [ + "ind_agent = IndShockConsumerType(**init_idiosyncratic_shocks)\n", + "ind_agent.cycles = 0\n", + "ind_agent.solve()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_funcs([beq_agent.solution[0].cFunc, ind_agent.solution[0].cFunc], 0, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:percent" + }, + "kernelspec": { + "display_name": "hark-dev", + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/ConsBequestModel/example_ConsIndShockComp.py b/examples/ConsBequestModel/example_ConsIndShockComp.py new file mode 100644 index 000000000..09bd1bbcc --- /dev/null +++ b/examples/ConsBequestModel/example_ConsIndShockComp.py @@ -0,0 +1,39 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.14.5 +# kernelspec: +# display_name: hark-dev +# language: python +# name: python3 +# --- + +# %% +from HARK.ConsumptionSaving.ConsBequestModel import BequestWarmGlowConsumerType +from HARK.ConsumptionSaving.ConsIndShockModel import ( + IndShockConsumerType, + init_idiosyncratic_shocks, +) +from HARK.utilities import plot_funcs + +# %% +beq_agent = BequestWarmGlowConsumerType( + **init_idiosyncratic_shocks, TermBeqFac=0.0, BeqFac=0.0 +) +beq_agent.cycles = 0 +beq_agent.solve() + +# %% +ind_agent = IndShockConsumerType(**init_idiosyncratic_shocks) +ind_agent.cycles = 0 +ind_agent.solve() + +# %% +plot_funcs([beq_agent.solution[0].cFunc, ind_agent.solution[0].cFunc], 0, 10) + +# %% diff --git a/examples/ConsBequestModel/example_TerminalBequest.ipynb b/examples/ConsBequestModel/example_TerminalBequest.ipynb new file mode 100644 index 000000000..6b8ff2da2 --- /dev/null +++ b/examples/ConsBequestModel/example_TerminalBequest.ipynb @@ -0,0 +1,365 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "19c5f531", + "metadata": { + "execution": { + "iopub.execute_input": "2023-04-03T19:31:19.277310Z", + "iopub.status.busy": "2023-04-03T19:31:19.277310Z", + "iopub.status.idle": "2023-04-03T19:31:20.984937Z", + "shell.execute_reply": "2023-04-03T19:31:20.983935Z" + } + }, + "outputs": [], + "source": [ + "from copy import copy\n", + "from time import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "from HARK.Calibration.Income.IncomeTools import (\n", + " CGM_income,\n", + " parse_income_spec,\n", + " parse_time_params,\n", + ")\n", + "from HARK.ConsumptionSaving.ConsBequestModel import (\n", + " BequestWarmGlowConsumerType,\n", + " init_warm_glow,\n", + ")\n", + "from HARK.datasets.life_tables.us_ssa.SSATools import parse_ssa_life_table\n", + "from HARK.datasets.SCF.WealthIncomeDist.SCFDistTools import income_wealth_dists_from_scf\n", + "from HARK.utilities import plot_funcs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8a2d828c", + "metadata": { + "execution": { + "iopub.execute_input": "2023-04-03T19:31:20.987533Z", + "iopub.status.busy": "2023-04-03T19:31:20.987533Z", + "iopub.status.idle": "2023-04-03T19:31:21.045107Z", + "shell.execute_reply": "2023-04-03T19:31:21.045107Z" + }, + "title": "Alter calibration" + }, + "outputs": [], + "source": [ + "birth_age = 25\n", + "death_age = 90\n", + "adjust_infl_to = 1992\n", + "income_calib = CGM_income\n", + "education = \"College\"\n", + "\n", + "# Income specification\n", + "income_params = parse_income_spec(\n", + " age_min=birth_age,\n", + " age_max=death_age,\n", + " adjust_infl_to=adjust_infl_to,\n", + " **income_calib[education],\n", + " SabelhausSong=True,\n", + ")\n", + "\n", + "# Initial distribution of wealth and permanent income\n", + "dist_params = income_wealth_dists_from_scf(\n", + " base_year=adjust_infl_to, age=birth_age, education=education, wave=1995\n", + ")\n", + "\n", + "# We need survival probabilities only up to death_age-1, because survival\n", + "# probability at death_age is 1.\n", + "liv_prb = parse_ssa_life_table(\n", + " female=True, cross_sec=True, year=2004, min_age=birth_age, max_age=death_age - 1\n", + ")\n", + "\n", + "# Parameters related to the number of periods implied by the calibration\n", + "time_params = parse_time_params(age_birth=birth_age, age_death=death_age)\n", + "\n", + "# Update all the new parameters\n", + "params = copy(init_warm_glow)\n", + "params.update(time_params)\n", + "params.update(dist_params)\n", + "params.update(income_params)\n", + "params.update({\"LivPrb\": [1.0] * len(liv_prb)})" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fbfff075", + "metadata": { + "execution": { + "iopub.execute_input": "2023-04-03T19:31:21.047613Z", + "iopub.status.busy": "2023-04-03T19:31:21.047613Z", + "iopub.status.idle": "2023-04-03T19:31:21.279221Z", + "shell.execute_reply": "2023-04-03T19:31:21.279221Z" + }, + "title": "Create and solve agent" + }, + "outputs": [], + "source": [ + "# Make and solve an idiosyncratic shocks consumer with a finite lifecycle\n", + "TerminalExample = BequestWarmGlowConsumerType(**params)\n", + "# Make this consumer live a sequence of periods exactly once\n", + "TerminalExample.cycles = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5f41049a", + "metadata": { + "execution": { + "iopub.execute_input": "2023-04-03T19:31:21.282228Z", + "iopub.status.busy": "2023-04-03T19:31:21.282228Z", + "iopub.status.idle": "2023-04-03T19:31:21.481030Z", + "shell.execute_reply": "2023-04-03T19:31:21.481030Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a lifecycle consumer took 0.19502973556518555 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "TerminalExample.solve()\n", + "end_time = time()\n", + "print(f\"Solving a lifecycle consumer took {end_time - start_time} seconds.\")\n", + "TerminalExample.unpack(\"cFunc\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "27d1663e", + "metadata": { + "execution": { + "iopub.execute_input": "2023-04-03T19:31:21.484031Z", + "iopub.status.busy": "2023-04-03T19:31:21.483031Z", + "iopub.status.idle": "2023-04-03T19:31:21.714230Z", + "shell.execute_reply": "2023-04-03T19:31:21.714230Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption functions\n", + "print(\"Consumption functions\")\n", + "plot_funcs(TerminalExample.cFunc, 0, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a16b7032", + "metadata": { + "execution": { + "iopub.execute_input": "2023-04-03T19:31:21.716231Z", + "iopub.status.busy": "2023-04-03T19:31:21.716231Z", + "iopub.status.idle": "2023-04-03T19:31:23.429630Z", + "shell.execute_reply": "2023-04-03T19:31:23.429422Z" + }, + "lines_to_next_cell": 2, + "title": "Simulation" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'aNrm': array([[0.29180317, 0.97445584, 0.36040378, ..., 1.79332645, 2.87342647,\n", + " 0.24466457],\n", + " [0.24197944, 0.97645683, 0.6442841 , ..., 1.74578226, 1.86103899,\n", + " 0.14921818],\n", + " [0.61664841, 1.91975561, 0.63314946, ..., 1.43299487, 2.6504932 ,\n", + " 0.97807016],\n", + " ...,\n", + " [2.57121847, 0.23619627, 0.23789935, ..., 0.51954935, 5.05662923,\n", + " 0.44677126],\n", + " [3.01728285, 0.22740195, 0.43379262, ..., 1.01764029, 5.0196123 ,\n", + " 0.38871327],\n", + " [3.6414104 , 0.39773907, 0.76229044, ..., 2.21032915, 3.25887889,\n", + " 0.4625948 ]]),\n", + " 'cNrm': array([[0.8310167 , 0.93240488, 0.84951983, ..., 0.99504093, 1.06639246,\n", + " 0.81566228],\n", + " [0.80468688, 0.91627163, 0.88342012, ..., 0.97278283, 0.98051186,\n", + " 0.76660798],\n", + " [0.87044306, 0.96997463, 0.87244477, ..., 0.93803717, 1.0155411 ,\n", + " 0.90484725],\n", + " ...,\n", + " [1.01069925, 0.79677493, 0.7973765 , ..., 0.85792327, 1.15653244,\n", + " 0.8468094 ],\n", + " [1.02069239, 0.78696088, 0.83549934, ..., 0.89505671, 1.13496128,\n", + " 0.82765242],\n", + " [1.03878448, 0.81945519, 0.8613672 , ..., 0.9559697 , 1.01704522,\n", + " 0.82938239]]),\n", + " 'pLvl': array([[ 44.17755524, 20.35577683, 9.62156414, ..., 22.58783801,\n", + " 8.69202078, 11.39484156],\n", + " [ 42.69570423, 17.65771873, 15.2555234 , ..., 29.27932939,\n", + " 13.78168087, 8.1685812 ],\n", + " [ 54.99138173, 15.21967918, 13.14916017, ..., 37.71130629,\n", + " 9.81667739, 7.84428065],\n", + " ...,\n", + " [ 334.37065892, 580.46586375, 73.4222415 , ..., 471.44813581,\n", + " 1340.40284941, 2943.53409086],\n", + " [ 383.4323394 , 502.92057514, 113.23140697, ..., 408.46668584,\n", + " 1287.81626232, 3744.83739958],\n", + " [ 333.81288451, 483.3384092 , 98.57828538, ..., 298.58438145,\n", + " 1945.53387791, 4707.55109494]]),\n", + " 't_age': array([[1., 1., 1., ..., 1., 1., 1.],\n", + " [2., 2., 2., ..., 2., 2., 2.],\n", + " [3., 3., 3., ..., 3., 3., 3.],\n", + " ...,\n", + " [3., 3., 3., ..., 3., 3., 3.],\n", + " [4., 4., 4., ..., 4., 4., 4.],\n", + " [5., 5., 5., ..., 5., 5., 5.]]),\n", + " 'mNrm': array([[1.12281987, 1.90686072, 1.2099236 , ..., 2.78836738, 3.93981893,\n", + " 1.06032685],\n", + " [1.04666632, 1.89272845, 1.52770422, ..., 2.71856508, 2.84155086,\n", + " 0.91582616],\n", + " [1.48709147, 2.88973024, 1.50559423, ..., 2.37103204, 3.6660343 ,\n", + " 1.88291741],\n", + " ...,\n", + " [3.58191771, 1.0329712 , 1.03527585, ..., 1.37747262, 6.21316167,\n", + " 1.29358066],\n", + " [4.03797525, 1.01436284, 1.26929197, ..., 1.912697 , 6.15457359,\n", + " 1.21636569],\n", + " [4.68019488, 1.21719426, 1.62365764, ..., 3.16629884, 4.27592411,\n", + " 1.29197719]])}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Number of LifecycleExamples and periods in the simulation.\n", + "TerminalExample.AgentCount = 500\n", + "TerminalExample.T_sim = 200\n", + "\n", + "# Set up the variables we want to keep track of.\n", + "TerminalExample.track_vars = [\"aNrm\", \"cNrm\", \"pLvl\", \"t_age\", \"mNrm\"]\n", + "\n", + "# Run the simulations\n", + "TerminalExample.initialize_sim()\n", + "TerminalExample.simulate()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7c7979ec", + "metadata": { + "execution": { + "iopub.execute_input": "2023-04-03T19:31:23.432629Z", + "iopub.status.busy": "2023-04-03T19:31:23.431628Z", + "iopub.status.idle": "2023-04-03T19:31:23.445655Z", + "shell.execute_reply": "2023-04-03T19:31:23.444657Z" + }, + "title": "Extract and format simulation results" + }, + "outputs": [], + "source": [ + "raw_data = {\n", + " \"Age\": TerminalExample.history[\"t_age\"].flatten() + birth_age - 1,\n", + " \"pIncome\": TerminalExample.history[\"pLvl\"].flatten(),\n", + " \"nrmM\": TerminalExample.history[\"mNrm\"].flatten(),\n", + " \"nrmC\": TerminalExample.history[\"cNrm\"].flatten(),\n", + "}\n", + "\n", + "Data = pd.DataFrame(raw_data)\n", + "Data[\"Cons\"] = Data.nrmC * Data.pIncome\n", + "Data[\"M\"] = Data.nrmM * Data.pIncome" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "1d8269db", + "metadata": { + "execution": { + "iopub.execute_input": "2023-04-03T19:31:23.447656Z", + "iopub.status.busy": "2023-04-03T19:31:23.447656Z", + "iopub.status.idle": "2023-04-03T19:31:23.650170Z", + "shell.execute_reply": "2023-04-03T19:31:23.650170Z" + }, + "title": "Plots" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Find the mean of each variable at every age\n", + "AgeMeans = Data.groupby([\"Age\"]).median().reset_index()\n", + "\n", + "plt.figure()\n", + "plt.plot(AgeMeans.Age, AgeMeans.pIncome, label=\"Permanent Income\")\n", + "plt.plot(AgeMeans.Age, AgeMeans.M, label=\"Market resources\")\n", + "plt.plot(AgeMeans.Age, AgeMeans.Cons, label=\"Consumption\")\n", + "plt.legend()\n", + "plt.xlabel(\"Age\")\n", + "plt.ylabel(\"Thousands of {} USD\".format(adjust_infl_to))\n", + "plt.title(\"Variable Medians Conditional on Survival\")\n", + "plt.grid()" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:percent" + }, + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/ConsBequestModel/example_TerminalBequest.py b/examples/ConsBequestModel/example_TerminalBequest.py new file mode 100644 index 000000000..9aae978ab --- /dev/null +++ b/examples/ConsBequestModel/example_TerminalBequest.py @@ -0,0 +1,128 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.14.5 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% +from copy import copy +from time import time + +import matplotlib.pyplot as plt +import pandas as pd + +from HARK.Calibration.Income.IncomeTools import ( + CGM_income, + parse_income_spec, + parse_time_params, +) +from HARK.ConsumptionSaving.ConsBequestModel import ( + BequestWarmGlowConsumerType, + init_warm_glow, +) +from HARK.datasets.life_tables.us_ssa.SSATools import parse_ssa_life_table +from HARK.datasets.SCF.WealthIncomeDist.SCFDistTools import income_wealth_dists_from_scf +from HARK.utilities import plot_funcs + +# %% Alter calibration +birth_age = 25 +death_age = 90 +adjust_infl_to = 1992 +income_calib = CGM_income +education = "College" + +# Income specification +income_params = parse_income_spec( + age_min=birth_age, + age_max=death_age, + adjust_infl_to=adjust_infl_to, + **income_calib[education], + SabelhausSong=True, +) + +# Initial distribution of wealth and permanent income +dist_params = income_wealth_dists_from_scf( + base_year=adjust_infl_to, age=birth_age, education=education, wave=1995 +) + +# We need survival probabilities only up to death_age-1, because survival +# probability at death_age is 1. +liv_prb = parse_ssa_life_table( + female=True, cross_sec=True, year=2004, min_age=birth_age, max_age=death_age - 1 +) + +# Parameters related to the number of periods implied by the calibration +time_params = parse_time_params(age_birth=birth_age, age_death=death_age) + +# Update all the new parameters +params = copy(init_warm_glow) +params.update(time_params) +params.update(dist_params) +params.update(income_params) +params.update({"LivPrb": [1.0] * len(liv_prb)}) + +# %% Create and solve agent +# Make and solve an idiosyncratic shocks consumer with a finite lifecycle +TerminalExample = BequestWarmGlowConsumerType(**params) +# Make this consumer live a sequence of periods exactly once +TerminalExample.cycles = 1 + +# %% +start_time = time() +TerminalExample.solve() +end_time = time() +print(f"Solving a lifecycle consumer took {end_time - start_time} seconds.") +TerminalExample.unpack("cFunc") + +# %% +# Plot the consumption functions +print("Consumption functions") +plot_funcs(TerminalExample.cFunc, 0, 5) + +# %% Simulation +# Number of LifecycleExamples and periods in the simulation. +TerminalExample.AgentCount = 500 +TerminalExample.T_sim = 200 + +# Set up the variables we want to keep track of. +TerminalExample.track_vars = ["aNrm", "cNrm", "pLvl", "t_age", "mNrm"] + +# Run the simulations +TerminalExample.initialize_sim() +TerminalExample.simulate() + + +# %% Extract and format simulation results +raw_data = { + "Age": TerminalExample.history["t_age"].flatten() + birth_age - 1, + "pIncome": TerminalExample.history["pLvl"].flatten(), + "nrmM": TerminalExample.history["mNrm"].flatten(), + "nrmC": TerminalExample.history["cNrm"].flatten(), +} + +Data = pd.DataFrame(raw_data) +Data["Cons"] = Data.nrmC * Data.pIncome +Data["M"] = Data.nrmM * Data.pIncome + +# %% Plots +# Find the mean of each variable at every age +AgeMeans = Data.groupby(["Age"]).median().reset_index() + +plt.figure() +plt.plot(AgeMeans.Age, AgeMeans.pIncome, label="Permanent Income") +plt.plot(AgeMeans.Age, AgeMeans.M, label="Market resources") +plt.plot(AgeMeans.Age, AgeMeans.Cons, label="Consumption") +plt.legend() +plt.xlabel("Age") +plt.ylabel("Thousands of {} USD".format(adjust_infl_to)) +plt.title("Variable Medians Conditional on Survival") +plt.grid() diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 000000000..cd395c81c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,60 @@ +[build-system] +requires = ["setuptools>=61.2", "setuptools_scm[toml]>=6.2"] +build-backend = "setuptools.build_meta" + +[project] +name = "econ-ark" +version = "0.13.0" +authors = [{name = "Econ-ARK team", email = "econ-ark@jhuecon.org"}] +classifiers = [ + "Development Status :: 3 - Alpha", + "Environment :: Console", + "Intended Audience :: Developers", + "Intended Audience :: Financial and Insurance Industry", + "Intended Audience :: Science/Research", + "Topic :: Scientific/Engineering", + "Topic :: Scientific/Engineering :: Mathematics", + "Topic :: Other/Nonlisted Topic", + "Natural Language :: English", + "Operating System :: OS Independent", + "License :: OSI Approved :: Apache Software License", + "License :: OSI Approved", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", +] +description = "Heterogenous Agents Resources & toolKit" +keywords = ["economics", "modelling", "modeling", "heterogeneity"] +requires-python = ">=3.8" +dynamic = ["dependencies", "optional-dependencies"] + + +[tool.setuptools.dynamic.dependencies] +file = "requirements/base.txt" + +[tool.setuptools.dynamic.optional-dependencies] +dev = {"file" = "requirements/dev.txt"} + +[project.urls] +Homepage = "https://github.com/econ-ark/HARK" +"Bug Reports" = "https://github.com/econ-ark/HARK/issues" +Documentation = "https://econ-ark.github.io/HARK" + +[project.license] +file = "LICENSE" + +[project.readme] +file = "README.md" +content-type = "text/markdown" + +[tool.setuptools.packages.find] +# All the following settings are optional: +exclude = ["binder", "Documentation", "examples"] +namespaces = false + +[tool.setuptools.package-data] +"*" = ["*.csv", "*.txt"] + +[tool.distutils.bdist_wheel] +universal = 1 diff --git a/requirements.txt b/requirements/base.txt similarity index 78% rename from requirements.txt rename to requirements/base.txt index 8f12c3027..5821f865e 100644 --- a/requirements.txt +++ b/requirements/base.txt @@ -1,8 +1,5 @@ -estimagic interpolation>=2.2.3 joblib>=1.2 -jupyterlab>=3.6 -jupytext>=1.14 matplotlib>=3.6 networkx>=3 numba>=0.56 diff --git a/requirements/dev.txt b/requirements/dev.txt new file mode 100644 index 000000000..5f35beda0 --- /dev/null +++ b/requirements/dev.txt @@ -0,0 +1,9 @@ +estimagic +nbsphinx>=0.8 +nbval +pre-commit +pytest +pytest-xdist +recommonmark>=0.7 +sphinx>=6.1 +pydata-sphinx-theme diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index cb8498dd4..000000000 --- a/setup.cfg +++ /dev/null @@ -1,65 +0,0 @@ -[metadata] -name = econ-ark -version = 0.13.0 -url = https://github.com/econ-ark/HARK -project_urls = - Bug Reports = https://github.com/econ-ark/HARK/issues - Documentation = https://econ-ark.github.io/HARK -author = Econ-ARK team -author_email = econ-ark@jhuecon.org -classifiers = - Development Status :: 3 - Alpha - Environment :: Console - Intended Audience :: Developers - Intended Audience :: Financial and Insurance Industry - Intended Audience :: Science/Research - Topic :: Scientific/Engineering - Topic :: Scientific/Engineering :: Mathematics - Topic :: Other/Nonlisted Topic - Natural Language :: English - Operating System :: OS Independent - License :: OSI Approved :: Apache Software License - License :: OSI Approved - Programming Language :: Python :: 3 - Programming Language :: Python :: 3.8 - Programming Language :: Python :: 3.9 - Programming Language :: Python :: 3.10 -license = Apache Software License -description = Heterogenous Agents Resources & toolKit -long_description = file: README.md -long_description_content_type = text/markdown -keywords = economics modelling modeling heterogeneity - -[options] -packages = find: -include_package_data = True -install_requires = - estimagic - interpolation>=2.2.3 - joblib>=1.2 - jupyterlab>=3.6 - jupytext>=1.14 - matplotlib>=3.6 - networkx>=3 - numba>=0.56 - numpy>=1.23 - pandas>=1.5 - quantecon - scipy>=1.10 - seaborn>=0.12 - xarray>=2023 -python_requires = >=3.8 - -[options.extras_require] -dev = - nbsphinx>=0.8 - nbval - pre-commit - pytest - pytest-xdist - recommonmark>=0.7 - sphinx>=6.1 - sphinx-rtd-theme - -[bdist_wheel] -universal=1 diff --git a/setup.py b/setup.py deleted file mode 100644 index 1babec571..000000000 --- a/setup.py +++ /dev/null @@ -1,11 +0,0 @@ -"""A setuptools based setup module. - -See: -https://packaging.python.org/en/latest/distributing.html -https://github.com/pypa/sampleproject -""" - -# Always prefer setuptools over distutils -from setuptools import setup - -setup()