From 6f0e5c8f0e729d08b1b048bba569fad635e2b3ba Mon Sep 17 00:00:00 2001 From: Christoph Hasse Date: Sun, 29 Oct 2023 17:30:49 -0400 Subject: [PATCH] Public release of cfspopcon --- .github/workflows/make_radas_data.sh | 15 + .github/workflows/workflow_actions.yml | 113 + .gitignore | 140 + .pre-commit-config.yaml | 33 + .readthedocs.yaml | 18 + CONTRIBUTING.md | 2 + LICENSE | 19 + README.md | 8 + cfspopcon/__init__.py | 49 + cfspopcon/algorithms/__init__.py | 74 + cfspopcon/algorithms/algorithm_class.py | 413 +++ cfspopcon/algorithms/beta.py | 50 + cfspopcon/algorithms/composite_algorithm.py | 67 + cfspopcon/algorithms/core_radiated_power.py | 90 + .../algorithms/extrinsic_core_radiator.py | 99 + cfspopcon/algorithms/fusion_gain.py | 64 + cfspopcon/algorithms/geometry.py | 54 + cfspopcon/algorithms/heat_exhaust.py | 78 + cfspopcon/algorithms/ohmic_power.py | 56 + cfspopcon/algorithms/peaked_profiles.py | 91 + .../algorithms/plasma_current_from_q_star.py | 44 + .../algorithms/power_balance_from_tau_e.py | 74 + .../algorithms/q_star_from_plasma_current.py | 43 + cfspopcon/algorithms/single_functions.py | 75 + .../algorithms/two_point_model_fixed_fpow.py | 70 + .../algorithms/two_point_model_fixed_qpart.py | 71 + .../algorithms/two_point_model_fixed_tet.py | 67 + .../use_LOC_tau_e_below_threshold.py | 87 + .../zeff_and_dilution_from_impurities.py | 57 + cfspopcon/atomic_data/__init__.py | 4 + cfspopcon/atomic_data/read_radas_data.py | 80 + cfspopcon/cli.py | 79 + cfspopcon/file_io.py | 104 + cfspopcon/formulas/Q_thermal_gain_factor.py | 39 + cfspopcon/formulas/__init__.py | 94 + cfspopcon/formulas/average_fuel_ion_mass.py | 30 + cfspopcon/formulas/beta.py | 135 + .../confinement_regime_threshold_powers.py | 153 + cfspopcon/formulas/current_drive.py | 254 ++ cfspopcon/formulas/density_peaking.py | 52 + cfspopcon/formulas/divertor_metrics.py | 40 + .../__init__.py | 9 + .../tau_e_from_Wp.py | 169 + .../tau_e_scalings.yaml | 342 ++ cfspopcon/formulas/figures_of_merit.py | 108 + cfspopcon/formulas/fusion_rates.py | 241 ++ .../formulas/fusion_reaction_data/__init__.py | 53 + .../fusion_reaction_data/reaction_energies.py | 140 + .../reaction_rate_coefficients.py | 298 ++ cfspopcon/formulas/geometry.py | 41 + cfspopcon/formulas/helpers.py | 23 + cfspopcon/formulas/impurity_effects.py | 65 + cfspopcon/formulas/operational_limits.py | 61 + .../formulas/plasma_profile_data/PRF/aLT.csv | 12 + .../plasma_profile_data/PRF/metadata.yaml | 2 + .../plasma_profile_data/PRF/width.csv | 12 + .../formulas/plasma_profile_data/__init__.py | 1 + .../density_and_temperature_profile_fits.py | 216 ++ cfspopcon/formulas/plasma_profiles.py | 186 ++ cfspopcon/formulas/radiated_power/__init__.py | 17 + cfspopcon/formulas/radiated_power/inherent.py | 141 + .../formulas/radiated_power/mavrin_coronal.py | 192 ++ .../radiated_power/mavrin_noncoronal.py | 251 ++ .../radiated_power/post_and_jensen.py | 158 + cfspopcon/formulas/radiated_power/radas.py | 67 + .../formulas/radiated_power/radiated_power.py | 55 + .../scrape_off_layer_model/__init__.py | 15 + .../scrape_off_layer_model/lambda_q.py | 92 + .../momentum_loss_functions.py | 62 + .../parallel_heat_flux_density.py | 35 + .../required_power_loss_fraction.py | 40 + .../solve_target_first_two_point_model.py | 121 + .../solve_two_point_model.py | 209 ++ .../target_electron_density.py | 93 + .../target_electron_flux.py | 87 + .../target_electron_temp.py | 88 + .../scrape_off_layer_model/total_pressure.py | 65 + .../upstream_electron_temp.py | 33 + cfspopcon/helpers.py | 105 + cfspopcon/input_file_handling.py | 64 + cfspopcon/named_options.py | 127 + cfspopcon/plotting/__init__.py | 12 + cfspopcon/plotting/coordinate_formatter.py | 23 + cfspopcon/plotting/make_plot.py | 156 + cfspopcon/plotting/plot_style_handling.py | 21 + cfspopcon/point_selection.py | 58 + cfspopcon/transform.py | 173 + cfspopcon/unit_handling/__init__.py | 28 + cfspopcon/unit_handling/decorator.py | 294 ++ cfspopcon/unit_handling/default_units.py | 260 ++ .../unit_handling/setup_unit_handling.py | 98 + docs/Makefile | 20 + docs/conf.py | 265 ++ docs/doc_sources/Usage.rst | 38 + docs/doc_sources/api.rst | 26 + docs/doc_sources/bib.rst | 6 + docs/doc_sources/dev_guide.rst | 167 + docs/doc_sources/getting_started.ipynb | 2642 +++++++++++++++ docs/doc_sources/physics_glossary.rst | 373 +++ docs/index.rst | 27 + docs/refs.bib | 438 +++ docs/static/theme_overrides.css | 29 + example_cases/SPARC_PRD/input.yaml | 168 + example_cases/SPARC_PRD/plot_popcon.yaml | 65 + example_cases/SPARC_PRD/plot_remapped.yaml | 65 + poetry.lock | 2929 +++++++++++++++++ poetry.toml | 6 + pyproject.toml | 114 + tests/conftest.py | 40 + tests/regression_results/PRD.json | 1101 +++++++ tests/regression_results/SPARC_PRD_result.nc | Bin 0 -> 2946296 bytes .../generate_regression_results.py | 25 + tests/test_algorithms_class.py | 275 ++ tests/test_cli.py | 20 + tests/test_helpers.py | 55 + tests/test_infra/conftest.py | 42 + tests/test_infra/test_plotting.py | 42 + tests/test_infra/test_point_selection.py | 21 + tests/test_infra/test_transform.py | 27 + tests/test_read_atomic_data.py | 20 + tests/test_regression_against_cases.py | 43 + tests/test_unit_handling/test_custom_units.py | 13 + .../test_wraps_ufunc_decorator.py | 182 + 123 files changed, 17688 insertions(+) create mode 100644 .github/workflows/make_radas_data.sh create mode 100644 .github/workflows/workflow_actions.yml create mode 100644 .gitignore create mode 100644 .pre-commit-config.yaml create mode 100644 .readthedocs.yaml create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE create mode 100644 README.md create mode 100644 cfspopcon/__init__.py create mode 100644 cfspopcon/algorithms/__init__.py create mode 100644 cfspopcon/algorithms/algorithm_class.py create mode 100644 cfspopcon/algorithms/beta.py create mode 100644 cfspopcon/algorithms/composite_algorithm.py create mode 100644 cfspopcon/algorithms/core_radiated_power.py create mode 100644 cfspopcon/algorithms/extrinsic_core_radiator.py create mode 100644 cfspopcon/algorithms/fusion_gain.py create mode 100644 cfspopcon/algorithms/geometry.py create mode 100644 cfspopcon/algorithms/heat_exhaust.py create mode 100644 cfspopcon/algorithms/ohmic_power.py create mode 100644 cfspopcon/algorithms/peaked_profiles.py create mode 100644 cfspopcon/algorithms/plasma_current_from_q_star.py create mode 100644 cfspopcon/algorithms/power_balance_from_tau_e.py create mode 100644 cfspopcon/algorithms/q_star_from_plasma_current.py create mode 100644 cfspopcon/algorithms/single_functions.py create mode 100644 cfspopcon/algorithms/two_point_model_fixed_fpow.py create mode 100644 cfspopcon/algorithms/two_point_model_fixed_qpart.py create mode 100644 cfspopcon/algorithms/two_point_model_fixed_tet.py create mode 100644 cfspopcon/algorithms/use_LOC_tau_e_below_threshold.py create mode 100644 cfspopcon/algorithms/zeff_and_dilution_from_impurities.py create mode 100644 cfspopcon/atomic_data/__init__.py create mode 100644 cfspopcon/atomic_data/read_radas_data.py create mode 100755 cfspopcon/cli.py create mode 100644 cfspopcon/file_io.py create mode 100644 cfspopcon/formulas/Q_thermal_gain_factor.py create mode 100644 cfspopcon/formulas/__init__.py create mode 100644 cfspopcon/formulas/average_fuel_ion_mass.py create mode 100644 cfspopcon/formulas/beta.py create mode 100644 cfspopcon/formulas/confinement_regime_threshold_powers.py create mode 100644 cfspopcon/formulas/current_drive.py create mode 100644 cfspopcon/formulas/density_peaking.py create mode 100644 cfspopcon/formulas/divertor_metrics.py create mode 100644 cfspopcon/formulas/energy_confinement_time_scalings/__init__.py create mode 100644 cfspopcon/formulas/energy_confinement_time_scalings/tau_e_from_Wp.py create mode 100644 cfspopcon/formulas/energy_confinement_time_scalings/tau_e_scalings.yaml create mode 100644 cfspopcon/formulas/figures_of_merit.py create mode 100644 cfspopcon/formulas/fusion_rates.py create mode 100644 cfspopcon/formulas/fusion_reaction_data/__init__.py create mode 100644 cfspopcon/formulas/fusion_reaction_data/reaction_energies.py create mode 100644 cfspopcon/formulas/fusion_reaction_data/reaction_rate_coefficients.py create mode 100644 cfspopcon/formulas/geometry.py create mode 100644 cfspopcon/formulas/helpers.py create mode 100644 cfspopcon/formulas/impurity_effects.py create mode 100644 cfspopcon/formulas/operational_limits.py create mode 100644 cfspopcon/formulas/plasma_profile_data/PRF/aLT.csv create mode 100644 cfspopcon/formulas/plasma_profile_data/PRF/metadata.yaml create mode 100644 cfspopcon/formulas/plasma_profile_data/PRF/width.csv create mode 100644 cfspopcon/formulas/plasma_profile_data/__init__.py create mode 100644 cfspopcon/formulas/plasma_profile_data/density_and_temperature_profile_fits.py create mode 100644 cfspopcon/formulas/plasma_profiles.py create mode 100644 cfspopcon/formulas/radiated_power/__init__.py create mode 100644 cfspopcon/formulas/radiated_power/inherent.py create mode 100644 cfspopcon/formulas/radiated_power/mavrin_coronal.py create mode 100644 cfspopcon/formulas/radiated_power/mavrin_noncoronal.py create mode 100644 cfspopcon/formulas/radiated_power/post_and_jensen.py create mode 100644 cfspopcon/formulas/radiated_power/radas.py create mode 100644 cfspopcon/formulas/radiated_power/radiated_power.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/__init__.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/lambda_q.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/momentum_loss_functions.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/parallel_heat_flux_density.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/required_power_loss_fraction.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/solve_target_first_two_point_model.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/solve_two_point_model.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/target_electron_density.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/target_electron_flux.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/target_electron_temp.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/total_pressure.py create mode 100644 cfspopcon/formulas/scrape_off_layer_model/upstream_electron_temp.py create mode 100644 cfspopcon/helpers.py create mode 100644 cfspopcon/input_file_handling.py create mode 100644 cfspopcon/named_options.py create mode 100644 cfspopcon/plotting/__init__.py create mode 100644 cfspopcon/plotting/coordinate_formatter.py create mode 100644 cfspopcon/plotting/make_plot.py create mode 100644 cfspopcon/plotting/plot_style_handling.py create mode 100644 cfspopcon/point_selection.py create mode 100644 cfspopcon/transform.py create mode 100644 cfspopcon/unit_handling/__init__.py create mode 100644 cfspopcon/unit_handling/decorator.py create mode 100644 cfspopcon/unit_handling/default_units.py create mode 100644 cfspopcon/unit_handling/setup_unit_handling.py create mode 100644 docs/Makefile create mode 100644 docs/conf.py create mode 100644 docs/doc_sources/Usage.rst create mode 100644 docs/doc_sources/api.rst create mode 100644 docs/doc_sources/bib.rst create mode 100644 docs/doc_sources/dev_guide.rst create mode 100644 docs/doc_sources/getting_started.ipynb create mode 100644 docs/doc_sources/physics_glossary.rst create mode 100644 docs/index.rst create mode 100644 docs/refs.bib create mode 100644 docs/static/theme_overrides.css create mode 100644 example_cases/SPARC_PRD/input.yaml create mode 100644 example_cases/SPARC_PRD/plot_popcon.yaml create mode 100644 example_cases/SPARC_PRD/plot_remapped.yaml create mode 100644 poetry.lock create mode 100644 poetry.toml create mode 100644 pyproject.toml create mode 100644 tests/conftest.py create mode 100644 tests/regression_results/PRD.json create mode 100644 tests/regression_results/SPARC_PRD_result.nc create mode 100644 tests/regression_results/generate_regression_results.py create mode 100644 tests/test_algorithms_class.py create mode 100644 tests/test_cli.py create mode 100644 tests/test_helpers.py create mode 100644 tests/test_infra/conftest.py create mode 100644 tests/test_infra/test_plotting.py create mode 100644 tests/test_infra/test_point_selection.py create mode 100644 tests/test_infra/test_transform.py create mode 100644 tests/test_read_atomic_data.py create mode 100644 tests/test_regression_against_cases.py create mode 100644 tests/test_unit_handling/test_custom_units.py create mode 100644 tests/test_unit_handling/test_wraps_ufunc_decorator.py diff --git a/.github/workflows/make_radas_data.sh b/.github/workflows/make_radas_data.sh new file mode 100644 index 00000000..4e93bce6 --- /dev/null +++ b/.github/workflows/make_radas_data.sh @@ -0,0 +1,15 @@ +set -ex + +git clone https://github.com/cfs-energy/radas.git + +pushd radas + +git checkout d9e23824f2edc46ef35e2fd54cf26438a3180733 + +poetry install --only main + +poetry run python adas_data/fetch_adas_data.py + +poetry run python run_radas.py all + +popd diff --git a/.github/workflows/workflow_actions.yml b/.github/workflows/workflow_actions.yml new file mode 100644 index 00000000..3d372376 --- /dev/null +++ b/.github/workflows/workflow_actions.yml @@ -0,0 +1,113 @@ +# This workflow will install Python dependencies, run tests and lint with a variety of Python versions +# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions + +name: workflow_actions + +# Controls when the workflow will run +on: + # Triggers the workflow on push or pull request events but only for the "main" branch + pull_request: [] + push: + branches: + - 'main' + # Allows you to run this workflow manually from the Actions tab + workflow_dispatch: + tag: "Manual run" + +# A workflow run is made up of one or more jobs that can run sequentially or in parallel +jobs: + # This workflow contains a single job called "build" + radas: + runs-on: ubuntu-22.04 + steps: + # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it + - uses: actions/checkout@v3 + + - name: Install Poetry + run: curl -sSL https://install.python-poetry.org | python - --version 1.6.1 + + - name: Set up Python 3.11 + uses: actions/setup-python@v4 + with: + python-version: '3.11' + cache: 'poetry' + + - name: Cache radas results + id: radas + uses: actions/cache@v3 + with: + path: radas + key: radas-${{ hashFiles('.github/workflows/make_radas_data.sh')}} + + - name: Make radas data + if: steps.radas.outputs.cache-hit != 'true' + run: bash .github/workflows/make_radas_data.sh + + build: + needs: radas + # The type of runner that the job will run on + runs-on: ubuntu-22.04 + strategy: + fail-fast: false + matrix: + python-version: ['3.9', '3.10', '3.11'] # should test the versions we allow for in pyproject.toml + + # Steps represent a sequence of tasks that will be executed as part of the job + steps: + # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it + - uses: actions/checkout@v3 + + - name: Install pandoc + run: sudo apt-get update && sudo apt-get install pandoc + + - name: Install Poetry + run: curl -sSL https://install.python-poetry.org | python - --version 1.6.1 + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + cache: 'poetry' + + - name: Setup + run: poetry install + + - uses: actions/cache/restore@v3 + id: radas + with: + path: radas + key: radas-${{ hashFiles('.github/workflows/make_radas_data.sh')}} + + - name: Check cache hit + if: steps.radas.outputs.cache-hit != 'true' + run: exit 1 + + - name: Copy radas data + run: cp ./radas/cases/*/output/*.nc cfspopcon/atomic_data/ + + - name: Tests + run: MPLBACKEND=Agg poetry run pytest tests --nbmake example_cases + + - name: Test package + run: | + poetry build -f wheel + python -m venv test_env + source ./test_env/bin/activate + pip install $(find ./dist -name "*.whl") + # enter tempdir so import cfspopcon doesn't find the cfspopcon directory + mkdir tmp_dir && cd tmp_dir + echo $(python -c 'from cfspopcon import atomic_data;from pathlib import Path; print(Path(atomic_data.__file__).parent)') + cp ../radas/cases/*/output/*.nc $(python -c 'from cfspopcon import atomic_data;from pathlib import Path; print(Path(atomic_data.__file__).parent)') + MPLBACKEND=Agg popcon ../example_cases/SPARC_PRD/input.yaml -p ../example_cases/SPARC_PRD/plot_popcon.yaml --show + + - name: Run pre-commit checks + run: poetry run pre-commit run --show-diff-on-failure --color=always --all-files + + - name: Test docs + # instead of make html we use sphinx-build directly to add more options + run: | + cd docs + poetry run sphinx-build --keep-going -Wnb html . _build/ + poetry run make doctest + poetry run make linkcheck + diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..30980908 --- /dev/null +++ b/.gitignore @@ -0,0 +1,140 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_* + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# vscode +*.vscode + +#macOS metadata +.DS_Store + +# Mess +example_cases/SPARC_PRD/output/* +# avoid committing nc files +*.nc diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 00000000..1a17c1e8 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,33 @@ +# per default we only run over the files in the python package +repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.3.0 + hooks: + - id: check-added-large-files + # but no large files anywhere ;) + files: '' + exclude: ".*getting_started.ipynb" +- repo: local + hooks: + - id: black + name: Black + entry: poetry run black + language: system + types: [python] +- repo: local + hooks: + - id: ruff + name: ruff + entry: poetry run ruff + language: system + types: [python] + files: '^cfspopcon/' +- repo: local + hooks: + - id: mypy + name: mypy + entry: poetry run mypy + language: system + types: [python] + files: '^cfspopcon/' + exclude: ^cfspopcon/plotting diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 00000000..9e53666a --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,18 @@ +version: 2 + +build: + os: "ubuntu-20.04" + tools: + python: "3.10" + jobs: + post_create_environment: + # Install poetry + # https://python-poetry.org/docs/#installing-manually + - pip install poetry + # Tell poetry to not use a virtual environment + - poetry config virtualenvs.create false + post_install: + - poetry install + +sphinx: + configuration: docs/conf.py diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 00000000..2cb0261b --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,2 @@ +Please make sure to check out our [Developer's Guide](docs/doc_sources/dev_guide.rst). +It will show you how to setup a development environment for this project and covers our contributing guidelines. diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..ca440437 --- /dev/null +++ b/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2023 Commonwealth Fusion Systems + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the “Software”), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 00000000..3bc2161d --- /dev/null +++ b/README.md @@ -0,0 +1,8 @@ +cfspopcon: 0D Plasma Calculations & Plasma OPerating CONtours +-------------------------------------------------------------- + +[![Build Status](https://github.com/cfs-energy/cfspopcon/actions/workflows/workflow_actions.yml/badge.svg)](https://github.com/cfs-energy/cfspopcon/actions) +[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/) +[![Documentation Status](https://readthedocs.org/projects/cfspopcon/badge/?version=latest)](https://cfspopcon.readthedocs.io/en/latest/?badge=latest) + +For more information please have a look at our [documentation](https://cfspopcon.readthedocs.io/en/latest/). diff --git a/cfspopcon/__init__.py b/cfspopcon/__init__.py new file mode 100644 index 00000000..28e90179 --- /dev/null +++ b/cfspopcon/__init__.py @@ -0,0 +1,49 @@ +"""Physics calculations & lumped-parameter models.""" +from importlib.metadata import metadata + +__version__ = metadata(__package__)["Version"] +__author__ = metadata(__package__)["Author"] + +from . import algorithms, file_io, formulas, helpers, named_options, unit_handling +from .algorithms.algorithm_class import Algorithm, CompositeAlgorithm +from .input_file_handling import read_case +from .plotting import read_plot_style +from .point_selection import find_coords_of_maximum, find_coords_of_minimum +from .unit_handling import ( + Quantity, + Unit, + convert_to_default_units, + convert_units, + default_unit, + magnitude, + magnitude_in_default_units, + set_default_units, + ureg, + wraps_ufunc, +) + +# export main classes users should need as well as the option enums +__all__ = [ + "helpers", + "named_options", + "algorithms", + "formulas", + "unit_handling", + "ureg", + "Quantity", + "Unit", + "wraps_ufunc", + "magnitude_in_default_units", + "set_default_units", + "default_unit", + "convert_to_default_units", + "convert_units", + "magnitude", + "read_case", + "read_plot_style", + "find_coords_of_maximum", + "find_coords_of_minimum", + "Algorithm", + "CompositeAlgorithm", + "file_io", +] diff --git a/cfspopcon/algorithms/__init__.py b/cfspopcon/algorithms/__init__.py new file mode 100644 index 00000000..8a915b7d --- /dev/null +++ b/cfspopcon/algorithms/__init__.py @@ -0,0 +1,74 @@ +"""POPCON algorithms.""" +from typing import Union + +from ..named_options import Algorithms +from .algorithm_class import Algorithm, CompositeAlgorithm +from .beta import calc_beta +from .composite_algorithm import predictive_popcon +from .core_radiated_power import calc_core_radiated_power +from .extrinsic_core_radiator import calc_extrinsic_core_radiator +from .fusion_gain import calc_fusion_gain +from .geometry import calc_geometry +from .heat_exhaust import calc_heat_exhaust +from .ohmic_power import calc_ohmic_power +from .peaked_profiles import calc_peaked_profiles +from .plasma_current_from_q_star import calc_plasma_current_from_q_star +from .power_balance_from_tau_e import calc_power_balance_from_tau_e +from .q_star_from_plasma_current import calc_q_star_from_plasma_current +from .single_functions import SINGLE_FUNCTIONS +from .two_point_model_fixed_fpow import two_point_model_fixed_fpow +from .two_point_model_fixed_qpart import two_point_model_fixed_qpart +from .two_point_model_fixed_tet import two_point_model_fixed_tet +from .use_LOC_tau_e_below_threshold import use_LOC_tau_e_below_threshold +from .zeff_and_dilution_from_impurities import calc_zeff_and_dilution_from_impurities + +ALGORITHMS: dict[Algorithms, Union[Algorithm, CompositeAlgorithm]] = { + Algorithms["calc_beta"]: calc_beta, + Algorithms["calc_core_radiated_power"]: calc_core_radiated_power, + Algorithms["calc_extrinsic_core_radiator"]: calc_extrinsic_core_radiator, + Algorithms["calc_fusion_gain"]: calc_fusion_gain, + Algorithms["calc_geometry"]: calc_geometry, + Algorithms["calc_heat_exhaust"]: calc_heat_exhaust, + Algorithms["calc_ohmic_power"]: calc_ohmic_power, + Algorithms["calc_peaked_profiles"]: calc_peaked_profiles, + Algorithms["calc_plasma_current_from_q_star"]: calc_plasma_current_from_q_star, + Algorithms["calc_power_balance_from_tau_e"]: calc_power_balance_from_tau_e, + Algorithms["predictive_popcon"]: predictive_popcon, + Algorithms["calc_q_star_from_plasma_current"]: calc_q_star_from_plasma_current, + Algorithms["two_point_model_fixed_fpow"]: two_point_model_fixed_fpow, + Algorithms["two_point_model_fixed_qpart"]: two_point_model_fixed_qpart, + Algorithms["two_point_model_fixed_tet"]: two_point_model_fixed_tet, + Algorithms["calc_zeff_and_dilution_from_impurities"]: calc_zeff_and_dilution_from_impurities, + Algorithms["use_LOC_tau_e_below_threshold"]: use_LOC_tau_e_below_threshold, + **SINGLE_FUNCTIONS, +} + + +def get_algorithm(algorithm: Union[Algorithms, str]) -> Union[Algorithm, CompositeAlgorithm]: + """Accessor for algorithms.""" + if isinstance(algorithm, str): + algorithm = Algorithms[algorithm] + + return ALGORITHMS[algorithm] + + +__all__ = [ + "calc_beta", + "calc_core_radiated_power", + "calc_extrinsic_core_radiator", + "calc_fusion_gain", + "calc_geometry", + "calc_heat_exhaust", + "calc_ohmic_power", + "calc_peaked_profiles", + "calc_plasma_current_from_q_star", + "calc_power_balance_from_tau_e", + "predictive_popcon", + "calc_q_star_from_plasma_current", + "two_point_model_fixed_fpow", + "two_point_model_fixed_qpart", + "two_point_model_fixed_tet", + "calc_zeff_and_dilution_from_impurities", + "ALGORITHMS", + "get_algorithm", +] diff --git a/cfspopcon/algorithms/algorithm_class.py b/cfspopcon/algorithms/algorithm_class.py new file mode 100644 index 00000000..480e29ce --- /dev/null +++ b/cfspopcon/algorithms/algorithm_class.py @@ -0,0 +1,413 @@ +"""Defines a class for different POPCON algorithms.""" +from __future__ import annotations + +import inspect +from collections.abc import Callable, Sequence +from functools import wraps +from typing import Any, Optional, Union +from warnings import warn + +import xarray as xr + +from ..unit_handling import convert_to_default_units + +FunctionType = Callable[..., dict[str, Any]] + + +class Algorithm: + """A class which handles the input and output of POPCON algorithms.""" + + def __init__(self, function: FunctionType, return_keys: list[str], name: Optional[str] = None): + """Initialise an Algorithm. + + Args: + function: a callable function + return_keys: the arguments which are returned from the function + name: Descriptive name for algorithm + """ + self._function = function + self._name = self._function.__name__ if name is None else name + + self._signature = inspect.signature(function) + for p in self._signature.parameters.values(): + if p.kind not in ( + inspect.Parameter.POSITIONAL_OR_KEYWORD, + inspect.Parameter.KEYWORD_ONLY, + inspect.Parameter.VAR_KEYWORD, + ): + raise ValueError( + f"Algorithm only supports functions with keyword arguments, but {function}, has {p.kind} parameter {p.name}" + ) + self.input_keys = list(self._signature.parameters.keys()) + self.return_keys = return_keys + + self.default_values = { + key: val.default for key, val in self._signature.parameters.items() if val.default is not inspect.Parameter.empty + } + self.default_keys = list(self.default_values.keys()) + + self.required_input_keys = [key for key in self.input_keys if key not in self.default_keys] + + self.__doc__ = self._make_docstring() + + self.run = self._make_run(self._function) + + def _make_docstring(self) -> str: + """Makes a doc-string detailing the function inputs and outputs.""" + return_string = ( + f"Algorithm: {self._name}\n" + "Inputs:\n" + ", ".join(self.input_keys) + "\n" + "Outputs:\n" + ", ".join(self.return_keys) + ) + return return_string + + def __repr__(self) -> str: + """Return a simple string description of the Algorithm.""" + return f"Algorithm: {self._name}" + + @classmethod + def _make_run(cls, func: FunctionType) -> Callable[..., xr.Dataset]: + """Helper to create the `run()` function with correct doc string. + + Args: + func: function to be wrapped + + Returns: a xarray DataSet of the result + """ + + @wraps(func) + def run(**kwargs: Any) -> xr.Dataset: + result = func(**kwargs) + dataset = xr.Dataset(result) + return dataset + + return run + + def update_dataset(self, dataset: xr.Dataset, in_place: bool = False) -> Optional[xr.Dataset]: + """Retrieve inputs from passed dataset and return a new dataset combining input and output quantities. + + Specifying in_place=True modifies the dataset in place (changing the input), whereas in_place=False will + return a copy of the dataset with the outputs appended. + + Args: + dataset: input dataset + in_place: modify the dataset in place, otherwise return a modified dataset keeping the input unchanged. + + Returns: modified dataset + """ + if not in_place: + dataset = dataset.copy(deep=True) + + input_values = {} + for key in self.input_keys: + if key in dataset.keys(): + input_values[key] = dataset[key] + elif key in self.default_keys: + input_values[key] = self.default_values[key] + else: + sorted_dataset_keys = ", ".join(sorted(dataset.keys())) # type:ignore[arg-type] + sorted_default_keys = ", ".join(sorted(self.default_keys)) + raise KeyError(f"Key '{key}' not in dataset keys [{sorted_dataset_keys}] or default values [{sorted_default_keys}]") + + result = self._function(**input_values) + + for key, val in result.items(): + dataset[key] = val + + if not in_place: + return dataset + else: + return None + + def __add__(self, other: Union[Algorithm, CompositeAlgorithm]) -> CompositeAlgorithm: + """Build a CompositeAlgorithm composed of this Algorithm and another Algorithm or CompositeAlgorithm.""" + if isinstance(other, CompositeAlgorithm): + return CompositeAlgorithm(algorithms=[self, *other.algorithms]) + else: + return CompositeAlgorithm(algorithms=[self, other]) + + @classmethod + def from_single_function( + cls, func: Callable, return_keys: list[str], name: Optional[str] = None, skip_unit_conversion: bool = False + ) -> Algorithm: + """Build an Algorithm which wraps a single function.""" + + @wraps(func) + def wrapped_function(**kwargs: Any) -> dict: + result = func(**kwargs) + + if not isinstance(result, tuple): + result = (result,) + + result_dict = {} + for i, key in enumerate(return_keys): + if skip_unit_conversion: + result_dict[key] = result[i] + else: + result_dict[key] = convert_to_default_units(result[i], key) + + return result_dict + + return cls(wrapped_function, return_keys, name=name) + + def validate_inputs( + self, configuration: Union[dict, xr.Dataset], quiet: bool = False, raise_error_on_missing_inputs: bool = False + ) -> bool: + """Check that all required inputs are defined, and warn if inputs are unused.""" + return _validate_inputs(self, configuration, quiet=quiet, raise_error_on_missing_inputs=raise_error_on_missing_inputs) + + +class CompositeAlgorithm: + """A class which combined multiple Algorithms into a single object which behaves like an Algorithm.""" + + def __init__(self, algorithms: Sequence[Union[Algorithm, CompositeAlgorithm]], name: Optional[str] = None): + """Initialise a CompositeAlgorithm, combining several other Algorithms. + + Args: + algorithms: a list of Algorithms, in the order that they should be executed. + name: a name used to refer to the composite algorithm. + """ + if not (isinstance(algorithms, Sequence) and all(isinstance(alg, (Algorithm, CompositeAlgorithm)) for alg in algorithms)): + raise TypeError("Should pass a list of algorithms or composites to CompositeAlgorithm.") + + self.algorithms: list[Algorithm] = [] + + # flattens composite algorithms into their respective list of plain Algorithms + for alg in algorithms: + if isinstance(alg, Algorithm): + self.algorithms.append(alg) + else: + self.algorithms.extend(alg.algorithms) + + self.input_keys: list[str] = [] + self.required_input_keys: list[str] = [] + self.return_keys: list[str] = [] + pars: list[inspect.Parameter] = [] + + # traverse list of algorithms in order. + # If an ouput from the set of previous algorithms provides an input to a following algorithm + # the input is not turned into an input to the CompositeAlgorithm + for alg in self.algorithms: + alg_sig = inspect.signature(alg.run) + for key in alg.default_keys: + if key not in self.return_keys: + self.input_keys.append(key) + pars.append(alg_sig.parameters[key]) + for key in alg.required_input_keys: + if key not in self.return_keys: + self.input_keys.append(key) + self.required_input_keys.append(key) + pars.append(alg_sig.parameters[key]) + + for key in alg.return_keys: + if key not in self.return_keys: + self.return_keys.append(key) + + # create a signature for the run() function + # This is a purely aesthetic change, that ensures the run() function + # has a helpful tooltip in editors and in the documentation + + # 1. make sure the list of pars doesn't have any duplicates, if there are duplicates + # we pick the first one. We don't assert that the types of two parameters are compatible + # that's not easy to do. + seen_pars: dict[str, int] = {} + pars = [p for i, p in enumerate(pars) if seen_pars.setdefault(p.name, i) == i] + + # ensure POSITIONAL_OR_KEYWORD are before kw only + pars = sorted(pars, key=lambda p: p.kind) + + def_pars = [p for p in pars if p.default != inspect.Parameter.empty] + non_def_pars = [p for p in pars if p.default == inspect.Parameter.empty] + + # methods are immutable and we don't want to set a signature on the class' run() method + # thus we wrap the original run method and then assign the __signature__ to the wrapped + # wrapper function + def _wrap(f: Callable[..., xr.Dataset]) -> Callable[..., xr.Dataset]: + def wrapper(**kwargs: Any) -> xr.Dataset: + return f(**kwargs) + + wrapper.__doc__ = f.__doc__ + + return wrapper + + self.run = _wrap(self._run) + # ignore due to mypy bug/missing feature https://github.com/python/mypy/issues/3482 + self.run.__signature__ = inspect.Signature( # type:ignore[attr-defined] + non_def_pars + def_pars, return_annotation=xr.Dataset + ) + self._name = name + self.__doc__ = self._make_docstring() + + def _make_docstring(self) -> str: + """Makes a doc-string detailing the function inputs and outputs.""" + components = f"[{', '.join(alg._name for alg in self.algorithms)}]" + + return_string = ( + f"CompositeAlgorithm: {self._name}\n" + if self._name is not None + else "CompositeAlgorithm\n" + f"Composed of {components}\n" + f"Inputs:\n{', '.join(self.input_keys)}\n" + f"Outputs:\n{', '.join(self.return_keys)}" + ) + return return_string + + def __repr__(self) -> str: + """Return a simple string description of the CompositeAlgorithm.""" + return f"CompositeAlgorithm: {self._name}" + + def _run(self, **kwargs: Any) -> xr.Dataset: + """Run the sub-Algorithms, one after the other and return a xarray.Dataset of the results. + + Will throw a warning if parameters are not used by any sub-Algorithm. + """ + result = kwargs + + parameters_extra = set(kwargs) - set(self.required_input_keys) + parameters_missing = set(self.required_input_keys) - set(kwargs) + if parameters_missing: + raise TypeError(f"CompositeAlgorithm.run() missing arguments: {', '.join(parameters_missing)}") + if parameters_extra: + warn(f"Not all input parameters were used. Unused parameters: [{', '.join(parameters_extra)}]", stacklevel=3) + + for alg in self.algorithms: + + alg_kwargs = {key: result[key] for key in result.keys() if key in alg.input_keys} + + alg_result = alg.run(**alg_kwargs) + result.update(alg_result) # type:ignore[arg-type] # dict.update() doesn't like KeysView[Hashable] + + return xr.Dataset(result) + + def update_dataset(self, dataset: xr.Dataset, in_place: bool = False) -> Optional[xr.Dataset]: + """Retrieve inputs from passed dataset and return a new dataset combining input and output quantities. + + Specifying in_place=True modifies the dataset in place (changing the input), whereas in_place=False will + return a copy of the dataset with the outputs appended. + + N.b. will not throw a warning if the dataset contains unused elements. + + Args: + dataset: input dataset + in_place: modify the dataset in place, otherwise return a modified dataset keeping the input unchanged. + + Returns: modified dataset + """ + if not in_place: + dataset = dataset.copy(deep=True) + + for alg in self.algorithms: + # We've already used copy on the dataset, so can now call update_dataset with + # in_place = True for each of the algorithms. + alg.update_dataset(dataset, in_place=True) + + if not in_place: + return dataset + else: + return None + + def __add__(self, other: Union[Algorithm, CompositeAlgorithm]) -> CompositeAlgorithm: + """Build a CompositeAlgorithm composed of this CompositeAlgorithm and another Algorithm or CompositeAlgorithm.""" + if isinstance(other, Algorithm): + return CompositeAlgorithm(algorithms=[*self.algorithms, other]) + else: + return CompositeAlgorithm(algorithms=[*self.algorithms, *other.algorithms]) + + def validate_inputs( # noqa: PLR0912 + self, + configuration: Union[dict, xr.Dataset], + quiet: bool = False, + raise_error_on_missing_inputs: bool = True, + warn_for_overridden_variables: bool = False, + ) -> bool: + """Check that all required inputs are defined, and warn if inputs are unused.""" + # Check if variables are being silently internally overwritten + config_keys = list(configuration.keys()) + key_setter = {key: ["INPUT"] for key in config_keys} + + for algorithm in self.algorithms: + for key in algorithm.return_keys: + if key not in key_setter.keys(): + key_setter[key] = [algorithm._name] + else: + key_setter[key].append(algorithm._name) + + overridden_variables = [] + for variable, algs in key_setter.items(): + if len(algs) > 1: + overridden_variables.append(f"{variable}: ({', '.join(algs)})") + + if warn_for_overridden_variables and len(overridden_variables) > 0: + warn( + f"The following variables were overridden internally (given as variable: (list of algorithms setting variable)): {', '.join(overridden_variables)}", + stacklevel=3, + ) + + # Check that algorithms are ordered such that dependent algorithms follow those setting their required input keys + available_parameters = config_keys.copy() + out_of_order_parameters = {} + for algorithm in self.algorithms: + for key in algorithm.required_input_keys: + if key not in available_parameters: + out_of_order_parameters[key] = algorithm + for key in algorithm.return_keys: + available_parameters.append(key) + + if len(out_of_order_parameters) > 0: + message = "" + for key, algorithm in out_of_order_parameters.items(): + if key in key_setter and len(key_setter.get(key, [])) > 0: + message += f"{key} needed by {algorithm} defined by output of {key_setter[key]}." + if len(message) > 0: + message = f"Algorithms out of order. {message}. Rearrange the list of algorithms so that dependent algorithm are after algorithms setting their inputs." + if raise_error_on_missing_inputs: + raise RuntimeError(message) + if not quiet: + warn(message, stacklevel=3) + + _validate_inputs(self, configuration, quiet=quiet, raise_error_on_missing_inputs=raise_error_on_missing_inputs) + + return False + else: + return _validate_inputs(self, configuration, quiet=quiet, raise_error_on_missing_inputs=raise_error_on_missing_inputs) + + +def _validate_inputs( + algorithm: Union[Algorithm, CompositeAlgorithm], + configuration: Union[dict, xr.Dataset], + quiet: bool = False, + raise_error_on_missing_inputs: bool = False, +) -> bool: + """Check that all required inputs are defined, and warn if inputs are unused.""" + config_keys = list(configuration.keys()) + + unused_config_keys = config_keys.copy() + missing_input_keys = set(algorithm.required_input_keys) + + for key in config_keys: + if key in missing_input_keys: + missing_input_keys.remove(key) + + if key in algorithm.input_keys: + # required_input_keys gives the list of keys which must + # be provided, while input_puts gives the list of keys + # which can be provided (but which might have default values). + unused_config_keys.remove(key) + + if len(missing_input_keys) == 0 and len(unused_config_keys) == 0: + return True + + elif len(missing_input_keys) > 0 and len(unused_config_keys) > 0: + message = f"Missing input parameters [{', '.join(missing_input_keys)}]. Also had unused input parameters [{', '.join(unused_config_keys)}]." + if raise_error_on_missing_inputs: + raise RuntimeError(message) + + elif len(missing_input_keys) > 0: + message = f"Missing input parameters [{', '.join(missing_input_keys)}]." + if raise_error_on_missing_inputs: + raise RuntimeError(message) + + else: + message = f"Unused input parameters [{', '.join(unused_config_keys)}]." + + if not quiet: + warn(message, stacklevel=3) + return False diff --git a/cfspopcon/algorithms/beta.py b/cfspopcon/algorithms/beta.py new file mode 100644 index 00000000..cfbd730a --- /dev/null +++ b/cfspopcon/algorithms/beta.py @@ -0,0 +1,50 @@ +"""Calculate toroidal, poloidal, total and normalized beta.""" +from .. import formulas +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "beta_toroidal", + "beta_poloidal", + "beta", + "normalized_beta", +] + + +def run_calc_beta( + average_electron_density: Unitfull, + average_electron_temp: Unitfull, + average_ion_temp: Unitfull, + magnetic_field_on_axis: Unitfull, + plasma_current: Unitfull, + minor_radius: Unitfull, +) -> dict[str, Unitfull]: + """Calculate toroidal, poloidal, total and normalized beta. + + Args: + average_electron_density: :term:`glossary link` + average_electron_temp: :term:`glossary link` + average_ion_temp: :term:`glossary link` + magnetic_field_on_axis: :term:`glossary link` + plasma_current: :term:`glossary link` + minor_radius: :term:`glossary link` + + Returns: + :term:`beta_toroidal`, :term:`beta_poloidal`, :term:`beta_total`, :term:`beta_N` + """ + beta_toroidal = formulas.calc_beta_toroidal(average_electron_density, average_electron_temp, average_ion_temp, magnetic_field_on_axis) + beta_poloidal = formulas.calc_beta_poloidal( + average_electron_density, average_electron_temp, average_ion_temp, plasma_current, minor_radius + ) + + beta = formulas.calc_beta_total(beta_toroidal=beta_toroidal, beta_poloidal=beta_poloidal) + normalized_beta = formulas.calc_beta_normalised(beta, minor_radius, magnetic_field_on_axis, plasma_current) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_beta = Algorithm( + function=run_calc_beta, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/composite_algorithm.py b/cfspopcon/algorithms/composite_algorithm.py new file mode 100644 index 00000000..25224087 --- /dev/null +++ b/cfspopcon/algorithms/composite_algorithm.py @@ -0,0 +1,67 @@ +"""Algorithms constructed by combining several smaller algorithms.""" +from .algorithm_class import CompositeAlgorithm +from .beta import calc_beta +from .core_radiated_power import calc_core_radiated_power +from .extrinsic_core_radiator import calc_extrinsic_core_radiator +from .fusion_gain import calc_fusion_gain +from .geometry import calc_geometry +from .heat_exhaust import calc_heat_exhaust +from .ohmic_power import calc_ohmic_power +from .peaked_profiles import calc_peaked_profiles +from .power_balance_from_tau_e import calc_power_balance_from_tau_e +from .q_star_from_plasma_current import calc_q_star_from_plasma_current +from .single_functions import ( + calc_auxillary_power, + calc_average_ion_temp, + calc_average_total_pressure, + calc_bootstrap_fraction, + calc_confinement_transition_threshold_power, + calc_current_relaxation_time, + calc_f_rad_core, + calc_fuel_average_mass_number, + calc_greenwald_fraction, + calc_normalised_collisionality, + calc_P_SOL, + calc_peak_pressure, + calc_ratio_P_LH, + calc_rho_star, + calc_triple_product, + require_P_rad_less_than_P_in, +) +from .two_point_model_fixed_tet import two_point_model_fixed_tet +from .zeff_and_dilution_from_impurities import calc_zeff_and_dilution_from_impurities + +predictive_popcon = CompositeAlgorithm( + [ + calc_geometry, + calc_q_star_from_plasma_current, + calc_fuel_average_mass_number, + calc_average_ion_temp, + calc_zeff_and_dilution_from_impurities, + calc_power_balance_from_tau_e, + calc_beta, + calc_peaked_profiles, + calc_core_radiated_power, + require_P_rad_less_than_P_in, + calc_extrinsic_core_radiator, + calc_peaked_profiles, + calc_fusion_gain, + calc_bootstrap_fraction, + calc_ohmic_power, + calc_auxillary_power, + calc_P_SOL, + calc_average_total_pressure, + calc_heat_exhaust, + two_point_model_fixed_tet, + calc_greenwald_fraction, + calc_confinement_transition_threshold_power, + calc_ratio_P_LH, + calc_f_rad_core, + calc_normalised_collisionality, + calc_rho_star, + calc_triple_product, + calc_peak_pressure, + calc_current_relaxation_time, + ], + name="predictive_popcon", +) diff --git a/cfspopcon/algorithms/core_radiated_power.py b/cfspopcon/algorithms/core_radiated_power.py new file mode 100644 index 00000000..fe71921b --- /dev/null +++ b/cfspopcon/algorithms/core_radiated_power.py @@ -0,0 +1,90 @@ +"""Calculate the power radiated from the confined region due to the fuel and impurity species.""" +import xarray as xr + +from .. import formulas, named_options +from ..atomic_data import read_atomic_data +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = ["P_radiation"] + + +def run_calc_core_radiated_power( + rho: Unitfull, + electron_density_profile: Unitfull, + electron_temp_profile: Unitfull, + z_effective: Unitfull, + plasma_volume: Unitfull, + major_radius: Unitfull, + minor_radius: Unitfull, + magnetic_field_on_axis: Unitfull, + separatrix_elongation: Unitfull, + radiated_power_method: named_options.RadiationMethod, + radiated_power_scalar: Unitfull, + impurities: xr.DataArray, +) -> dict[str, Unitfull]: + """Calculate the power radiated from the confined region due to the fuel and impurity species. + + Args: + rho: :term:`glossary link` + electron_density_profile: :term:`glossary link` + electron_temp_profile: :term:`glossary link` + z_effective: :term:`glossary link` + plasma_volume: :term:`glossary link` + major_radius: :term:`glossary link` + minor_radius: :term:`glossary link` + magnetic_field_on_axis: :term:`glossary link` + separatrix_elongation: :term:`glossary link` + radiated_power_method: :term:`glossary link` + radiated_power_scalar: :term:`glossary link` + impurities: :term:`glossary link` + + Returns: + :term:`P_radiation` + + """ + P_rad_bremsstrahlung = formulas.calc_bremsstrahlung_radiation( + rho, electron_density_profile, electron_temp_profile, z_effective, plasma_volume + ) + P_rad_bremsstrahlung_from_hydrogen = formulas.calc_bremsstrahlung_radiation( + rho, electron_density_profile, electron_temp_profile, 1.0, plasma_volume + ) + P_rad_synchrotron = formulas.calc_synchrotron_radiation( + rho, + electron_density_profile, + electron_temp_profile, + major_radius, + minor_radius, + magnetic_field_on_axis, + separatrix_elongation, + plasma_volume, + ) + + # Calculate radiated power due to Bremsstrahlung, Synchrotron and impurities + if radiated_power_method == named_options.RadiationMethod.Inherent: + P_radiation = radiated_power_scalar * (P_rad_bremsstrahlung + P_rad_synchrotron) + else: + atomic_data = read_atomic_data() + + P_rad_impurity = formulas.calc_impurity_radiated_power( + radiated_power_method=radiated_power_method, + rho=rho, + electron_temp_profile=electron_temp_profile, + electron_density_profile=electron_density_profile, + impurities=impurities, + plasma_volume=plasma_volume, + atomic_data=atomic_data, + ) + + P_radiation = radiated_power_scalar * ( + P_rad_bremsstrahlung_from_hydrogen + P_rad_synchrotron + P_rad_impurity.sum(dim="dim_species") + ) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_core_radiated_power = Algorithm( + function=run_calc_core_radiated_power, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/extrinsic_core_radiator.py b/cfspopcon/algorithms/extrinsic_core_radiator.py new file mode 100644 index 00000000..7931d97e --- /dev/null +++ b/cfspopcon/algorithms/extrinsic_core_radiator.py @@ -0,0 +1,99 @@ +"""Calculate the concentration and effect of a core radiator required to achieve above a defined core radiative fraction.""" +import numpy as np +import xarray as xr + +from .. import formulas, named_options +from ..atomic_data import read_atomic_data +from ..helpers import make_impurities_array +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "core_radiator_concentration", + "P_radiated_by_core_radiator", + "P_radiation", + "core_radiator_concentration", + "core_radiator_charge_state", + "zeff_change_from_core_rad", + "dilution_change_from_core_rad", + "z_effective", + "dilution", +] + + +def run_calc_extrinsic_core_radiator( + minimum_core_radiated_fraction: Unitfull, + P_in: Unitfull, + P_radiation: Unitfull, + average_electron_density: Unitfull, + average_electron_temp: Unitfull, + z_effective: Unitfull, + dilution: Unitfull, + rho: Unitfull, + electron_density_profile: Unitfull, + electron_temp_profile: Unitfull, + plasma_volume: Unitfull, + radiated_power_method: named_options.RadiationMethod, + radiated_power_scalar: Unitfull, + core_radiator: named_options.Impurity, +) -> dict[str, Unitfull]: + """Calculate the concentration and effect of a core radiator required to achieve above a defined core radiative fraction. + + Args: + minimum_core_radiated_fraction: :term:`glossary link` + P_in: :term:`glossary link` + P_radiation: :term:`glossary link` + average_electron_density: :term:`glossary link` + average_electron_temp: :term:`glossary link` + z_effective: :term:`glossary link` + dilution: :term:`dilution` + rho: :term:`glossary link` + electron_density_profile: :term:`glossary link` + electron_temp_profile: :term:`glossary link` + plasma_volume: :term:`glossary link` + radiated_power_method: :term:`glossary link` + radiated_power_scalar: :term:`radiated_power_scalar` + core_radiator: :term:`glossary link` + + Returns: + :term:`core_radiator_concentration`, :term:`P_radiated_by_core_radiator`, :term:`P_radiation`, :term:`core_radiator_concentration`, :term:`core_radiator_charge_state`, :term:`zeff_change_from_core_rad` :term:`dilution_change_from_core_rad`, :term:`z_effective`, :term:`dilution` + + """ + atomic_data = read_atomic_data() + + # Force P_radiated_by_core_radiator to be >= 0.0 (core radiator cannot reduce radiated power) + P_radiated_by_core_radiator = np.maximum(minimum_core_radiated_fraction * P_in - P_radiation, 0.0) + P_radiation = np.maximum(minimum_core_radiated_fraction * P_in, P_radiation) + + P_rad_per_core_radiator = radiated_power_scalar * formulas.calc_impurity_radiated_power( + radiated_power_method=named_options.RadiationMethod.Radas + if radiated_power_method == named_options.RadiationMethod.Inherent + else radiated_power_method, + rho=rho, + electron_temp_profile=electron_temp_profile, + electron_density_profile=electron_density_profile, + impurities=make_impurities_array(core_radiator, 1.0), + plasma_volume=plasma_volume, + atomic_data=atomic_data, + ).sum(dim="dim_species") + core_radiator_concentration = xr.where( # type:ignore[no-untyped-call] + P_radiated_by_core_radiator > 0, P_radiated_by_core_radiator / P_rad_per_core_radiator, 0.0 + ) + + core_radiator_charge_state = formulas.calc_impurity_charge_state( + average_electron_density, average_electron_temp, core_radiator, atomic_data + ) + zeff_change_from_core_rad = formulas.calc_change_in_zeff(core_radiator_charge_state, core_radiator_concentration) + dilution_change_from_core_rad = formulas.calc_change_in_dilution(core_radiator_charge_state, core_radiator_concentration) + + z_effective = z_effective + zeff_change_from_core_rad + dilution = (dilution - dilution_change_from_core_rad).clip(min=0.0) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_extrinsic_core_radiator = Algorithm( + function=run_calc_extrinsic_core_radiator, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/fusion_gain.py b/cfspopcon/algorithms/fusion_gain.py new file mode 100644 index 00000000..e99a2f7a --- /dev/null +++ b/cfspopcon/algorithms/fusion_gain.py @@ -0,0 +1,64 @@ +"""Calculate the fusion power and thermal gain (Q).""" +from .. import formulas, named_options +from ..unit_handling import Unitfull, convert_to_default_units, ureg +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "P_fusion", + "P_neutron", + "P_alpha", + "P_external", + "P_launched", + "Q", + "neutron_power_flux_to_walls", + "neutron_rate", +] + + +def run_calc_fusion_gain( + fusion_reaction: named_options.ReactionType, + ion_temp_profile: Unitfull, + heavier_fuel_species_fraction: Unitfull, + fuel_ion_density_profile: Unitfull, + rho: Unitfull, + plasma_volume: Unitfull, + surface_area: Unitfull, + P_in: Unitfull, + fraction_of_external_power_coupled: Unitfull, +) -> dict[str, Unitfull]: + """Calculate the fusion power and thermal gain (Q). + + Args: + fusion_reaction: :term:`glossary link` + ion_temp_profile: :term:`glossary link` + heavier_fuel_species_fraction: :term:`glossary link` + fuel_ion_density_profile: :term:`glossary link` + rho: :term:`glossary link` + plasma_volume: :term:`glossary link` + surface_area: :term:`glossary link` + P_in: :term:`glossary link` + fraction_of_external_power_coupled: :term:`glossary link` + + Returns: + :term:`P_fusion`, :term:`P_neutron`, :term:`P_alpha`, :term:`P_external`, :term:`P_launched`, :term:`Q`, :term:`neutron_power_flux_to_walls` :term:`neutron_rate` + """ + P_fusion, P_neutron, P_alpha = formulas.calc_fusion_power( + fusion_reaction, ion_temp_profile, heavier_fuel_species_fraction, fuel_ion_density_profile, rho, plasma_volume + ) + + P_external = (P_in - P_alpha).clip(min=0.0 * ureg.MW) + P_launched = P_external / fraction_of_external_power_coupled + Q = formulas.thermal_calc_gain_factor(P_fusion, P_launched) + + neutron_power_flux_to_walls, neutron_rate = formulas.calc_neutron_flux_to_walls( + P_neutron, surface_area, fusion_reaction, ion_temp_profile, heavier_fuel_species_fraction + ) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_fusion_gain = Algorithm( + function=run_calc_fusion_gain, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/geometry.py b/cfspopcon/algorithms/geometry.py new file mode 100644 index 00000000..b472be98 --- /dev/null +++ b/cfspopcon/algorithms/geometry.py @@ -0,0 +1,54 @@ +"""Calculate dependent geometry parameters.""" +from .. import formulas +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "separatrix_elongation", + "separatrix_triangularity", + "minor_radius", + "vertical_minor_radius", + "plasma_volume", + "surface_area", +] + + +def run_calc_geometry( + major_radius: Unitfull, + inverse_aspect_ratio: Unitfull, + areal_elongation: Unitfull, + triangularity_psi95: Unitfull, + elongation_ratio_sep_to_areal: Unitfull, + triangularity_ratio_sep_to_psi95: Unitfull, +) -> dict[str, Unitfull]: + """Calculate dependent geometry parameters. + + Args: + major_radius: :term:`glossary link` + inverse_aspect_ratio: :term:`glossary link` + areal_elongation: :term:`glossary link` + triangularity_psi95: :term:`glossary link` + elongation_ratio_sep_to_areal: :term:`glossary link` + triangularity_ratio_sep_to_psi95: :term:`glossary link` + + Returns: + :term:`separatrix_elongation`, :term:`separatrix_triangularity`, :term:`minor_radius`, :term:`vertical_minor_radius`, :term:`plasma_volume`, :term:`surface_area` + """ + separatrix_elongation = areal_elongation * elongation_ratio_sep_to_areal + + separatrix_triangularity = triangularity_psi95 * triangularity_ratio_sep_to_psi95 + + minor_radius = major_radius * inverse_aspect_ratio + vertical_minor_radius = minor_radius * separatrix_elongation + + plasma_volume = formulas.calc_plasma_volume(major_radius, inverse_aspect_ratio, areal_elongation) + surface_area = formulas.calc_plasma_surface_area(major_radius, inverse_aspect_ratio, areal_elongation) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_geometry = Algorithm( + function=run_calc_geometry, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/heat_exhaust.py b/cfspopcon/algorithms/heat_exhaust.py new file mode 100644 index 00000000..ca3d69a0 --- /dev/null +++ b/cfspopcon/algorithms/heat_exhaust.py @@ -0,0 +1,78 @@ +"""Calculate the parallel heat flux density upstream and related metrics.""" +import numpy as np + +from .. import formulas, named_options +from ..unit_handling import Unitfull, convert_to_default_units, ureg +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "PB_over_R", + "PBpRnSq", + "B_pol_out_mid", + "B_t_out_mid", + "fieldline_pitch_at_omp", + "lambda_q", + "q_parallel", + "q_perp", +] + + +def run_calc_heat_exhaust( + P_sol: Unitfull, + magnetic_field_on_axis: Unitfull, + major_radius: Unitfull, + inverse_aspect_ratio: Unitfull, + plasma_current: Unitfull, + minor_radius: Unitfull, + q_star: Unitfull, + average_electron_density: Unitfull, + average_total_pressure: Unitfull, + fraction_of_P_SOL_to_divertor: Unitfull, + lambda_q_scaling: named_options.LambdaQScaling, + lambda_q_factor: Unitfull = 1.0 * ureg.dimensionless, +) -> dict[str, Unitfull]: + """Calculate the parallel heat flux density upstream and related metrics. + + Args: + P_sol: :term:`glossary link` + magnetic_field_on_axis: :term:`glossary link` + major_radius: :term:`glossary link` + inverse_aspect_ratio: :term:`glossary link` + plasma_current: :term:`glossary link` + minor_radius: :term:`glossary link` + q_star: :term:`glossary link` + average_electron_density: :term:`glossary link` + average_total_pressure: :term:`glossary link ` + fraction_of_P_SOL_to_divertor: :term:`glossary link ` + lambda_q_scaling: :term:`glossary link` + lambda_q_factor: :term:`glossary link` + + Returns: + :term:`PB_over_R`, :term:`PBpRnSq`, :term:`B_pol_out_mid`, :term:`B_t_out_mid`, :term:`fieldline_pitch_at_omp`, :term:`lambda_q`, :term:`q_parallel`, :term:`q_perp` + + """ + PB_over_R = P_sol * magnetic_field_on_axis / major_radius + PBpRnSq = (P_sol * (magnetic_field_on_axis / q_star) / major_radius) / (average_electron_density**2.0) + + B_pol_out_mid = formulas.calc_B_pol_omp(plasma_current=plasma_current, minor_radius=minor_radius) + B_t_out_mid = formulas.calc_B_tor_omp(magnetic_field_on_axis, major_radius, minor_radius) + + fieldline_pitch_at_omp = np.sqrt(B_t_out_mid**2 + B_pol_out_mid**2) / B_pol_out_mid + + lambda_q = lambda_q_factor * formulas.scrape_off_layer_model.calc_lambda_q( + lambda_q_scaling, average_total_pressure, P_sol, major_radius, B_pol_out_mid, inverse_aspect_ratio + ) + + q_parallel = formulas.scrape_off_layer_model.calc_parallel_heat_flux_density( + P_sol, fraction_of_P_SOL_to_divertor, major_radius + minor_radius, lambda_q, fieldline_pitch_at_omp + ) + q_perp = P_sol / (2.0 * np.pi * (major_radius + minor_radius) * lambda_q) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_heat_exhaust = Algorithm( + function=run_calc_heat_exhaust, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/ohmic_power.py b/cfspopcon/algorithms/ohmic_power.py new file mode 100644 index 00000000..b030e406 --- /dev/null +++ b/cfspopcon/algorithms/ohmic_power.py @@ -0,0 +1,56 @@ +"""Calculate the power due to Ohmic resistive heating.""" +from .. import formulas +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "spitzer_resistivity", + "trapped_particle_fraction", + "neoclassical_loop_resistivity", + "loop_voltage", + "P_ohmic", +] + + +def run_calc_ohmic_power( + bootstrap_fraction: Unitfull, + average_electron_temp: Unitfull, + inverse_aspect_ratio: Unitfull, + z_effective: Unitfull, + major_radius: Unitfull, + minor_radius: Unitfull, + areal_elongation: Unitfull, + plasma_current: Unitfull, +) -> dict[str, Unitfull]: + """Calculate the power due to Ohmic resistive heating. + + Args: + bootstrap_fraction: :term:`glossary link` + average_electron_temp: :term:`glossary link` + inverse_aspect_ratio: :term:`glossary link` + z_effective: :term:`glossary link` + major_radius: :term:`glossary link` + minor_radius: :term:`glossary link` + areal_elongation: :term:`glossary link` + plasma_current: :term:`glossary link` + + Returns: + :term:`spitzer_resistivity`, :term:`trapped_particle_fraction`, :term:`neoclassical_loop_resistivity`, :term:`loop_voltage`, :term:`P_ohmic` + """ + inductive_plasma_current = plasma_current * (1.0 - bootstrap_fraction) + spitzer_resistivity = formulas.calc_Spitzer_loop_resistivity(average_electron_temp) + trapped_particle_fraction = formulas.calc_resistivity_trapped_enhancement(inverse_aspect_ratio) + neoclassical_loop_resistivity = formulas.calc_neoclassical_loop_resistivity(spitzer_resistivity, z_effective, trapped_particle_fraction) + loop_voltage = formulas.calc_loop_voltage( + major_radius, minor_radius, inductive_plasma_current, areal_elongation, neoclassical_loop_resistivity + ) + P_ohmic = formulas.calc_ohmic_power(inductive_plasma_current, loop_voltage) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_ohmic_power = Algorithm( + function=run_calc_ohmic_power, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/peaked_profiles.py b/cfspopcon/algorithms/peaked_profiles.py new file mode 100644 index 00000000..ee85876f --- /dev/null +++ b/cfspopcon/algorithms/peaked_profiles.py @@ -0,0 +1,91 @@ +"""Calculate density peaking and the corresponding density and temperature profiles.""" +from .. import formulas +from ..named_options import ProfileForm +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "effective_collisionality", + "ion_density_peaking", + "electron_density_peaking", + "peak_electron_density", + "peak_fuel_ion_density", + "peak_electron_temp", + "peak_ion_temp", + "rho", + "electron_density_profile", + "fuel_ion_density_profile", + "electron_temp_profile", + "ion_temp_profile", +] + + +def run_calc_peaked_profiles( + profile_form: ProfileForm, + average_electron_density: Unitfull, + average_electron_temp: Unitfull, + average_ion_temp: Unitfull, + ion_density_peaking_offset: Unitfull, + electron_density_peaking_offset: Unitfull, + temperature_peaking: Unitfull, + major_radius: Unitfull, + z_effective: Unitfull, + dilution: Unitfull, + beta_toroidal: Unitfull, + normalized_inverse_temp_scale_length: Unitfull, +) -> dict[str, Unitfull]: + """Calculate density peaking and the corresponding density and temperature profiles. + + Args: + profile_form: :term:`glossary link` + average_electron_density: :term:`glossary link` + average_electron_temp: :term:`glossary link` + average_ion_temp: :term:`glossary link` + ion_density_peaking_offset: :term:`glossary link` + electron_density_peaking_offset: :term:`glossary link` + temperature_peaking: :term:`glossary link` + major_radius: :term:`glossary link` + z_effective: :term:`glossary link` + dilution: :term:`glossary link` + beta_toroidal: :term:`glossary link` + normalized_inverse_temp_scale_length: :term:`glossary link` + + Returns: + `effective_collisionality`, :term:`ion_density_peaking`, :term:`electron_density_peaking`, :term:`peak_electron_density`, :term:`peak_electron_temp`, :term:`peak_ion_temp`, :term:`rho`, :term:`electron_density_profile`, :term:`fuel_ion_density_profile`, :term:`electron_temp_profile`, :term:`ion_temp_profile` + + """ + effective_collisionality = formulas.calc_effective_collisionality( + average_electron_density, average_electron_temp, major_radius, z_effective + ) + ion_density_peaking = formulas.calc_density_peaking(effective_collisionality, beta_toroidal, nu_noffset=ion_density_peaking_offset) + electron_density_peaking = formulas.calc_density_peaking( + effective_collisionality, beta_toroidal, nu_noffset=electron_density_peaking_offset + ) + + peak_electron_density = average_electron_density * electron_density_peaking + peak_fuel_ion_density = average_electron_density * dilution * ion_density_peaking + peak_electron_temp = average_electron_temp * temperature_peaking + peak_ion_temp = average_ion_temp * temperature_peaking + + # Calculate the total fusion power by estimating density and temperature profiles and + # using this to calculate fusion power profiles. + (rho, electron_density_profile, fuel_ion_density_profile, electron_temp_profile, ion_temp_profile,) = formulas.calc_1D_plasma_profiles( + profile_form, + average_electron_density, + average_electron_temp, + average_ion_temp, + electron_density_peaking, + ion_density_peaking, + temperature_peaking, + dilution, + normalized_inverse_temp_scale_length, + ) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_peaked_profiles = Algorithm( + function=run_calc_peaked_profiles, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/plasma_current_from_q_star.py b/cfspopcon/algorithms/plasma_current_from_q_star.py new file mode 100644 index 00000000..542e40a0 --- /dev/null +++ b/cfspopcon/algorithms/plasma_current_from_q_star.py @@ -0,0 +1,44 @@ +"""Calculate plasma current from edge safety factor.""" +from .. import formulas +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "f_shaping", + "plasma_current", +] + + +def run_calc_plasma_current_from_q_star( + magnetic_field_on_axis: Unitfull, + major_radius: Unitfull, + q_star: Unitfull, + inverse_aspect_ratio: Unitfull, + areal_elongation: Unitfull, + triangularity_psi95: Unitfull, +) -> dict[str, Unitfull]: + """Calculate plasma current from edge safety factor. + + Args: + magnetic_field_on_axis: :term:`glossary link` + major_radius: :term:`glossary link` + q_star: :term:`glossary link` + inverse_aspect_ratio: :term:`glossary link` + areal_elongation: :term:`glossary link` + triangularity_psi95: :term:`glossary link` + + Returns: + term:`f_shaping`, term:`plasma_current`, + + """ + f_shaping = formulas.calc_f_shaping(inverse_aspect_ratio, areal_elongation, triangularity_psi95) + plasma_current = formulas.calc_plasma_current(magnetic_field_on_axis, major_radius, inverse_aspect_ratio, q_star, f_shaping) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_plasma_current_from_q_star = Algorithm( + function=run_calc_plasma_current_from_q_star, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/power_balance_from_tau_e.py b/cfspopcon/algorithms/power_balance_from_tau_e.py new file mode 100644 index 00000000..f52f6c38 --- /dev/null +++ b/cfspopcon/algorithms/power_balance_from_tau_e.py @@ -0,0 +1,74 @@ +"""Calculate the input power required to maintain the stored energy, given a tau_e scaling.""" +from .. import formulas, named_options +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "energy_confinement_time", + "P_in", +] + + +def run_calc_power_balance_from_tau_e( + plasma_stored_energy: Unitfull, + average_electron_density: Unitfull, + confinement_time_scalar: Unitfull, + plasma_current: Unitfull, + magnetic_field_on_axis: Unitfull, + major_radius: Unitfull, + areal_elongation: Unitfull, + separatrix_elongation: Unitfull, + inverse_aspect_ratio: Unitfull, + fuel_average_mass_number: Unitfull, + triangularity_psi95: Unitfull, + separatrix_triangularity: Unitfull, + q_star: Unitfull, + energy_confinement_scaling: named_options.ConfinementScaling, +) -> dict[str, Unitfull]: + """Calculate the input power required to maintain the stored energy, given a tau_e scaling. + + Args: + plasma_stored_energy: :term:`glossary link` + average_electron_density: :term:`glossary link` + confinement_time_scalar: :term:`glossary link` + plasma_current: :term:`glossary link` + magnetic_field_on_axis: :term:`glossary link` + major_radius: :term:`glossary link` + areal_elongation: :term:`glossary link` + separatrix_elongation: :term:`glossary link` + inverse_aspect_ratio: :term:`glossary link` + fuel_average_mass_number: :term:`glossary link` + triangularity_psi95: :term:`glossary link` + separatrix_triangularity: :term:`glossary link` + q_star: :term:`glossary link` + energy_confinement_scaling: :term:`glossary link` + + Returns: + :term:`energy_confinement_time`, :term:`P_in` + + """ + energy_confinement_time, P_in = formulas.calc_tau_e_and_P_in_from_scaling( + confinement_time_scalar=confinement_time_scalar, + plasma_current=plasma_current, + magnetic_field_on_axis=magnetic_field_on_axis, + average_electron_density=average_electron_density, + major_radius=major_radius, + areal_elongation=areal_elongation, + separatrix_elongation=separatrix_elongation, + inverse_aspect_ratio=inverse_aspect_ratio, + fuel_average_mass_number=fuel_average_mass_number, + triangularity_psi95=triangularity_psi95, + separatrix_triangularity=separatrix_triangularity, + plasma_stored_energy=plasma_stored_energy, + q_star=q_star, + tau_e_scaling=energy_confinement_scaling, + ) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_power_balance_from_tau_e = Algorithm( + function=run_calc_power_balance_from_tau_e, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/q_star_from_plasma_current.py b/cfspopcon/algorithms/q_star_from_plasma_current.py new file mode 100644 index 00000000..164b1eb4 --- /dev/null +++ b/cfspopcon/algorithms/q_star_from_plasma_current.py @@ -0,0 +1,43 @@ +"""Calculate plasma current from edge safety factor.""" +from .. import formulas +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "f_shaping", + "q_star", +] + + +def run_calc_q_star_from_plasma_current( + magnetic_field_on_axis: Unitfull, + major_radius: Unitfull, + plasma_current: Unitfull, + inverse_aspect_ratio: Unitfull, + areal_elongation: Unitfull, + triangularity_psi95: Unitfull, +) -> dict[str, Unitfull]: + """Calculate plasma current from edge safety factor. + + Args: + magnetic_field_on_axis: :term:`glossary link` + major_radius: :term:`glossary link` + plasma_current: :term:`glossary link` + inverse_aspect_ratio: :term:`glossary link` + areal_elongation: :term:`glossary link` + triangularity_psi95: :term:`glossary link` + + Returns: + :term:`f_shaping`, :term:`q_star`, + """ + f_shaping = formulas.calc_f_shaping(inverse_aspect_ratio, areal_elongation, triangularity_psi95) + q_star = formulas.calc_q_star(magnetic_field_on_axis, major_radius, inverse_aspect_ratio, plasma_current, f_shaping) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_q_star_from_plasma_current = Algorithm( + function=run_calc_q_star_from_plasma_current, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/single_functions.py b/cfspopcon/algorithms/single_functions.py new file mode 100644 index 00000000..364b6f19 --- /dev/null +++ b/cfspopcon/algorithms/single_functions.py @@ -0,0 +1,75 @@ +"""Algorithm wrappers for single functions which don't fit into larger algorithms.""" +import numpy as np + +from .. import formulas +from ..named_options import Algorithms +from ..unit_handling import ureg +from .algorithm_class import Algorithm + +calc_confinement_transition_threshold_power = Algorithm.from_single_function( + formulas.calc_confinement_transition_threshold_power, return_keys=["P_LH_thresh"], name="calc_confinement_transition_threshold_power" +) +calc_ratio_P_LH = Algorithm.from_single_function( + func=lambda P_sol, P_LH_thresh: P_sol / P_LH_thresh, return_keys=["ratio_of_P_SOL_to_P_LH"], name="calc_ratio_P_LH" +) +calc_f_rad_core = Algorithm.from_single_function( + func=lambda P_radiation, P_in: P_radiation / P_in, return_keys=["core_radiated_power_fraction"], name="calc_f_rad_core" +) +calc_normalised_collisionality = Algorithm.from_single_function( + func=formulas.calc_normalised_collisionality, return_keys=["nu_star"], name="calc_normalised_collisionality" +) +calc_rho_star = Algorithm.from_single_function(func=formulas.calc_rho_star, return_keys=["rho_star"], name="calc_rho_star") +calc_triple_product = Algorithm.from_single_function( + func=formulas.calc_triple_product, return_keys=["fusion_triple_product"], name="calc_triple_product" +) +calc_greenwald_fraction = Algorithm.from_single_function( + func=formulas.calc_greenwald_fraction, return_keys=["greenwald_fraction"], name="calc_greenwald_fraction" +) +calc_current_relaxation_time = Algorithm.from_single_function( + func=formulas.calc_current_relaxation_time, return_keys=["current_relaxation_time"], name="calc_current_relaxation_time" +) +calc_peak_pressure = Algorithm.from_single_function( + func=formulas.calc_peak_pressure, return_keys=["peak_pressure"], name="calc_peak_pressure" +) +calc_average_total_pressure = Algorithm.from_single_function( + lambda average_electron_density, average_electron_temp, average_ion_temp: average_electron_density + * (average_electron_temp + average_ion_temp), + return_keys=["average_total_pressure"], + name="calc_average_total_pressure", +) +calc_bootstrap_fraction = Algorithm.from_single_function( + formulas.calc_bootstrap_fraction, return_keys=["bootstrap_fraction"], name="calc_bootstrap_fraction" +) +calc_auxillary_power = Algorithm.from_single_function( + lambda P_external, P_ohmic: (P_external - P_ohmic).clip(min=0.0 * ureg.MW), return_keys=["P_auxillary"], name="calc_auxillary_power" +) +calc_average_ion_temp = Algorithm.from_single_function( + lambda average_electron_temp, ion_to_electron_temp_ratio: average_electron_temp * ion_to_electron_temp_ratio, + return_keys=["average_ion_temp"], + name="calc_average_ion_temp", +) +calc_fuel_average_mass_number = Algorithm.from_single_function( + formulas.calc_fuel_average_mass_number, return_keys=["fuel_average_mass_number"], name="calc_fuel_average_mass_number" +) +calc_magnetic_field_on_axis = Algorithm.from_single_function( + lambda product_of_magnetic_field_and_radius, major_radius: product_of_magnetic_field_and_radius / major_radius, + return_keys=["magnetic_field_on_axis"], + name="calc_magnetic_field_on_axis", +) +require_P_rad_less_than_P_in = Algorithm.from_single_function( + lambda P_in, P_radiation: np.minimum(P_radiation, P_in), return_keys=["P_radiation"], name="require_P_rad_less_than_P_in" +) +calc_P_SOL = Algorithm.from_single_function( + lambda P_in, P_radiation: np.maximum(P_in - P_radiation, 0.0), return_keys=["P_sol"], name="calc_P_SOL" +) +calc_plasma_stored_energy = Algorithm.from_single_function( + lambda average_electron_density, average_electron_temp, average_ion_density, summed_impurity_density, average_ion_temp, plasma_volume: ( + (3.0 / 2.0) + * ((average_electron_density * average_electron_temp) + ((average_ion_density + summed_impurity_density) * average_ion_temp)) + * plasma_volume + ).pint.to(ureg.MJ), + return_keys=["plasma_stored_energy"], + name="calc_plasma_stored_energy", +) + +SINGLE_FUNCTIONS = {Algorithms[key]: val for key, val in locals().items() if isinstance(val, Algorithm)} diff --git a/cfspopcon/algorithms/two_point_model_fixed_fpow.py b/cfspopcon/algorithms/two_point_model_fixed_fpow.py new file mode 100644 index 00000000..0bf663cd --- /dev/null +++ b/cfspopcon/algorithms/two_point_model_fixed_fpow.py @@ -0,0 +1,70 @@ +"""Run the two point model with a fixed power loss fraction in the SOL.""" +from typing import Union + +import xarray as xr + +from ..formulas.scrape_off_layer_model import solve_two_point_model +from ..named_options import MomentumLossFunction +from ..unit_handling import Quantity, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "upstream_electron_temp", + "target_electron_density", + "target_electron_temp", + "target_electron_flux", + "target_q_parallel", +] + + +def run_two_point_model_fixed_fpow( + SOL_power_loss_fraction: Union[float, xr.DataArray], + q_parallel: Union[Quantity, xr.DataArray], + parallel_connection_length: Union[Quantity, xr.DataArray], + average_electron_density: Union[Quantity, xr.DataArray], + nesep_over_nebar: Union[float, xr.DataArray], + toroidal_flux_expansion: Union[float, xr.DataArray], + fuel_average_mass_number: Union[Quantity, xr.DataArray], + kappa_e0: Union[Quantity, xr.DataArray], + SOL_momentum_loss_function: Union[MomentumLossFunction, xr.DataArray], + raise_error_if_not_converged: bool = False, +) -> dict[str, Union[float, Quantity, xr.DataArray]]: + """Run the two point model with a fixed power loss fraction in the SOL. + + Args: + SOL_power_loss_fraction: :term:`glossary link` + q_parallel: :term:`glossary link` + parallel_connection_length: :term:`glossary link` + average_electron_density: :term:`glossary link` + nesep_over_nebar: :term:`glossary link` + toroidal_flux_expansion: :term:`glossary link` + fuel_average_mass_number: :term:`glossary link` + kappa_e0: :term:`glossary link` + SOL_momentum_loss_function: :term:`glossary link` + raise_error_if_not_converged: Raise an error if solve does not converge + + Returns: + :term:`upstream_electron_temp`, :term:`target_electron_density`, :term:`target_electron_temp`, :term:`target_electron_flux`, :term:`target_q_parallel`, + """ + (upstream_electron_temp, target_electron_density, target_electron_temp, target_electron_flux,) = solve_two_point_model( + SOL_power_loss_fraction=SOL_power_loss_fraction, + parallel_heat_flux_density=q_parallel, + parallel_connection_length=parallel_connection_length, + upstream_electron_density=nesep_over_nebar * average_electron_density, + toroidal_flux_expansion=toroidal_flux_expansion, + fuel_average_mass_number=fuel_average_mass_number, + kappa_e0=kappa_e0, + SOL_momentum_loss_function=SOL_momentum_loss_function, + raise_error_if_not_converged=raise_error_if_not_converged, + ) + + target_q_parallel = q_parallel * (1.0 - SOL_power_loss_fraction) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +two_point_model_fixed_fpow = Algorithm( + function=run_two_point_model_fixed_fpow, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/two_point_model_fixed_qpart.py b/cfspopcon/algorithms/two_point_model_fixed_qpart.py new file mode 100644 index 00000000..0f86bf8a --- /dev/null +++ b/cfspopcon/algorithms/two_point_model_fixed_qpart.py @@ -0,0 +1,71 @@ +"""Run the two point model with a fixed parallel heat flux density reaching the target.""" +from typing import Union + +import xarray as xr + +from ..formulas.scrape_off_layer_model import solve_two_point_model +from ..named_options import MomentumLossFunction +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "upstream_electron_temp", + "target_electron_density", + "target_electron_temp", + "target_electron_flux", + "SOL_power_loss_fraction", +] + + +def run_two_point_model_fixed_qpart( + target_q_parallel: Unitfull, + q_parallel: Unitfull, + parallel_connection_length: Unitfull, + average_electron_density: Unitfull, + nesep_over_nebar: Unitfull, + toroidal_flux_expansion: Unitfull, + fuel_average_mass_number: Unitfull, + kappa_e0: Unitfull, + SOL_momentum_loss_function: Union[MomentumLossFunction, xr.DataArray], + raise_error_if_not_converged: bool = False, +) -> dict[str, Unitfull]: + """Run the two point model with a fixed parallel heat flux density reaching the target. + + Args: + target_q_parallel: :term:`glossary link` + q_parallel: :term:`glossary link` + parallel_connection_length: :term:`glossary link` + average_electron_density: :term:`glossary link` + nesep_over_nebar: :term:`glossary link` + toroidal_flux_expansion: :term:`glossary link` + fuel_average_mass_number: :term:`glossary link` + kappa_e0: :term:`glossary link` + SOL_momentum_loss_function: :term:`glossary link` + raise_error_if_not_converged: Raise an error if solve does not converge + + Returns: + :term:`upstream_electron_temp`, :term:`target_electron_density`, :term:`target_electron_temp`, :term:`target_electron_flux`, :term:`SOL_power_loss_fraction`, + + """ + SOL_power_loss_fraction = (1.0 - target_q_parallel / q_parallel).clip(min=0.0, max=1.0) + + (upstream_electron_temp, target_electron_density, target_electron_temp, target_electron_flux,) = solve_two_point_model( + SOL_power_loss_fraction=SOL_power_loss_fraction, + parallel_heat_flux_density=q_parallel, + parallel_connection_length=parallel_connection_length, + upstream_electron_density=nesep_over_nebar * average_electron_density, + toroidal_flux_expansion=toroidal_flux_expansion, + fuel_average_mass_number=fuel_average_mass_number, + kappa_e0=kappa_e0, + SOL_momentum_loss_function=SOL_momentum_loss_function, + raise_error_if_not_converged=raise_error_if_not_converged, + ) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +two_point_model_fixed_qpart = Algorithm( + function=run_two_point_model_fixed_qpart, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/two_point_model_fixed_tet.py b/cfspopcon/algorithms/two_point_model_fixed_tet.py new file mode 100644 index 00000000..587c2a80 --- /dev/null +++ b/cfspopcon/algorithms/two_point_model_fixed_tet.py @@ -0,0 +1,67 @@ +"""Run the two point model with a fixed sheath entrance temperature.""" +from typing import Union + +import xarray as xr + +from ..formulas.scrape_off_layer_model import solve_target_first_two_point_model +from ..named_options import MomentumLossFunction +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "upstream_electron_temp", + "target_electron_density", + "SOL_power_loss_fraction", + "target_electron_flux", + "target_q_parallel", +] + + +def run_two_point_model_fixed_tet( + target_electron_temp: Unitfull, + q_parallel: Unitfull, + parallel_connection_length: Unitfull, + average_electron_density: Unitfull, + nesep_over_nebar: Unitfull, + toroidal_flux_expansion: Unitfull, + fuel_average_mass_number: Unitfull, + kappa_e0: Unitfull, + SOL_momentum_loss_function: Union[MomentumLossFunction, xr.DataArray], +) -> dict[str, Unitfull]: + """Run the two point model with a fixed sheath entrance temperature. + + Args: + target_electron_temp: :term:`glossary link` + q_parallel: :term:`glossary link` + parallel_connection_length: :term:`glossary link` + average_electron_density: :term:`glossary link` + nesep_over_nebar: :term:`glossary link` + toroidal_flux_expansion: :term:`glossary link` + fuel_average_mass_number: :term:`glossary link` + kappa_e0: :term:`glossary link` + SOL_momentum_loss_function: :term:`glossary link` + + Returns: + :term:`upstream_electron_temp`, :term:`target_electron_density`, :term:`SOL_power_loss_fraction`, :term:`target_electron_flux`, :term:`target_q_parallel`, + """ + (SOL_power_loss_fraction, upstream_electron_temp, target_electron_density, target_electron_flux,) = solve_target_first_two_point_model( + target_electron_temp=target_electron_temp, + parallel_heat_flux_density=q_parallel, + parallel_connection_length=parallel_connection_length, + upstream_electron_density=nesep_over_nebar * average_electron_density, + toroidal_flux_expansion=toroidal_flux_expansion, + fuel_average_mass_number=fuel_average_mass_number, + kappa_e0=kappa_e0, + SOL_momentum_loss_function=SOL_momentum_loss_function, + ) + + target_q_parallel = q_parallel * (1.0 - SOL_power_loss_fraction) + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +two_point_model_fixed_tet = Algorithm( + function=run_two_point_model_fixed_tet, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/use_LOC_tau_e_below_threshold.py b/cfspopcon/algorithms/use_LOC_tau_e_below_threshold.py new file mode 100644 index 00000000..70ee87be --- /dev/null +++ b/cfspopcon/algorithms/use_LOC_tau_e_below_threshold.py @@ -0,0 +1,87 @@ +"""Switch to the LOC scaling if it predicts a worse energy confinement than our selected tau_e scaling.""" +import xarray as xr + +from .. import formulas, named_options +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "energy_confinement_time", + "P_in", + "SOC_LOC_ratio", +] + + +def run_use_LOC_tau_e_below_threshold( + plasma_stored_energy: Unitfull, + energy_confinement_time: Unitfull, + P_in: Unitfull, + average_electron_density: Unitfull, + confinement_time_scalar: Unitfull, + plasma_current: Unitfull, + magnetic_field_on_axis: Unitfull, + major_radius: Unitfull, + areal_elongation: Unitfull, + separatrix_elongation: Unitfull, + inverse_aspect_ratio: Unitfull, + fuel_average_mass_number: Unitfull, + triangularity_psi95: Unitfull, + separatrix_triangularity: Unitfull, + q_star: Unitfull, +) -> dict[str, Unitfull]: + """Switch to the LOC scaling if it predicts a worse energy confinement than our selected tau_e scaling. + + Args: + plasma_stored_energy: :term:`glossary link` + energy_confinement_time: :term:`glossary link` + P_in: :term:`glossary link` + average_electron_density: :term:`glossary link` + confinement_time_scalar: :term:`glossary link` + plasma_current: :term:`glossary link` + magnetic_field_on_axis: :term:`glossary link` + major_radius: :term:`glossary link` + areal_elongation: :term:`glossary link` + separatrix_elongation: :term:`glossary link` + inverse_aspect_ratio: :term:`glossary link` + fuel_average_mass_number: :term:`glossary link` + triangularity_psi95: :term:`glossary link` + separatrix_triangularity: :term:`glossary link` + q_star: :term:`glossary link` + + Returns: + :term:`energy_confinement_time`, :term:`P_in`, :term:`SOC_LOC_ratio` + + """ + # Calculate linear ohmic confinement for low density + energy_confinement_time_LOC, P_in_LOC = formulas.calc_tau_e_and_P_in_from_scaling( + confinement_time_scalar=confinement_time_scalar, + plasma_current=plasma_current, + magnetic_field_on_axis=magnetic_field_on_axis, + average_electron_density=average_electron_density, + major_radius=major_radius, + areal_elongation=areal_elongation, + separatrix_elongation=separatrix_elongation, + inverse_aspect_ratio=inverse_aspect_ratio, + fuel_average_mass_number=fuel_average_mass_number, + triangularity_psi95=triangularity_psi95, + separatrix_triangularity=separatrix_triangularity, + plasma_stored_energy=plasma_stored_energy, + q_star=q_star, + tau_e_scaling=named_options.ConfinementScaling.LOC, + ) + + # Use Linearized Ohmic Confinement if it gives worse energy confinement. + SOC_LOC_ratio = energy_confinement_time / energy_confinement_time_LOC + energy_confinement_time = xr.where( + SOC_LOC_ratio > 1.0, energy_confinement_time_LOC, energy_confinement_time + ) # type:ignore[no-untyped-call] + P_in = xr.where(SOC_LOC_ratio > 1.0, P_in_LOC, P_in) # type:ignore[no-untyped-call] + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +use_LOC_tau_e_below_threshold = Algorithm( + function=run_use_LOC_tau_e_below_threshold, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/algorithms/zeff_and_dilution_from_impurities.py b/cfspopcon/algorithms/zeff_and_dilution_from_impurities.py new file mode 100644 index 00000000..36221452 --- /dev/null +++ b/cfspopcon/algorithms/zeff_and_dilution_from_impurities.py @@ -0,0 +1,57 @@ +"""Calculate the impact of core impurities on z_effective and dilution.""" +import xarray as xr + +from .. import formulas +from ..atomic_data import read_atomic_data +from ..unit_handling import Unitfull, convert_to_default_units +from .algorithm_class import Algorithm + +RETURN_KEYS = [ + "impurity_charge_state", + "z_effective", + "dilution", + "summed_impurity_density", + "average_ion_density", +] + + +def run_calc_zeff_and_dilution_from_impurities( + average_electron_density: Unitfull, + average_electron_temp: Unitfull, + impurities: xr.DataArray, +) -> dict[str, Unitfull]: + """Calculate the impact of core impurities on z_effective and dilution. + + Args: + average_electron_density: :term:`glossary link` + average_electron_temp: :term:`glossary link` + impurities: :term:`glossary link` + + Returns: + :term:`impurity_charge_state`, :term:`z_effective`, :term:`dilution`, :term:`summed_impurity_density`, :term:`average_ion_density` + + """ + starting_zeff = 1.0 + starting_dilution = 1.0 + + atomic_data = read_atomic_data() + + impurity_charge_state = formulas.calc_impurity_charge_state( + average_electron_density, average_electron_temp, impurities.dim_species, atomic_data + ) + change_in_zeff = formulas.calc_change_in_zeff(impurity_charge_state, impurities) + change_in_dilution = formulas.calc_change_in_dilution(impurity_charge_state, impurities) + + z_effective = starting_zeff + change_in_zeff.sum(dim="dim_species") + dilution = starting_dilution - change_in_dilution.sum(dim="dim_species") + summed_impurity_density = impurities.sum(dim="dim_species") * average_electron_density + average_ion_density = dilution * average_electron_density + + local_vars = locals() + return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS} + + +calc_zeff_and_dilution_from_impurities = Algorithm( + function=run_calc_zeff_and_dilution_from_impurities, + return_keys=RETURN_KEYS, +) diff --git a/cfspopcon/atomic_data/__init__.py b/cfspopcon/atomic_data/__init__.py new file mode 100644 index 00000000..9705e76a --- /dev/null +++ b/cfspopcon/atomic_data/__init__.py @@ -0,0 +1,4 @@ +"""Interface to atomic data from radas.""" +from .read_radas_data import read_atomic_data + +__all__ = ["read_atomic_data"] diff --git a/cfspopcon/atomic_data/read_radas_data.py b/cfspopcon/atomic_data/read_radas_data.py new file mode 100644 index 00000000..8aa15b51 --- /dev/null +++ b/cfspopcon/atomic_data/read_radas_data.py @@ -0,0 +1,80 @@ +"""Open the atomic data files and return corresponding xr.Datasets and interpolators.""" +from pathlib import Path +from typing import Optional, Union + +import numpy as np +import xarray as xr +from scipy.interpolate import RectBivariateSpline, RegularGridInterpolator # type: ignore[import] + +from ..named_options import Impurity +from ..unit_handling import convert_units, magnitude, ureg + + +def read_atomic_data(directory: Optional[Path] = None) -> dict[Impurity, xr.DataArray]: + """Read the atomic data files and return a dictionary mapping Impurity keys to xr.DataArrays of atomic data.""" + if directory is None: + directory = Path(__file__).parent + + atomic_data_files = { + Impurity.Helium: directory / "helium.nc", + Impurity.Lithium: directory / "lithium.nc", + Impurity.Beryllium: directory / "beryllium.nc", + Impurity.Carbon: directory / "carbon.nc", + Impurity.Nitrogen: directory / "nitrogen.nc", + Impurity.Oxygen: directory / "oxygen.nc", + Impurity.Neon: directory / "neon.nc", + Impurity.Argon: directory / "argon.nc", + Impurity.Krypton: directory / "krypton.nc", + Impurity.Xenon: directory / "xenon.nc", + Impurity.Tungsten: directory / "tungsten.nc", + } + + atomic_data = {} + + for key, file in atomic_data_files.items(): + if not file.exists(): + raise FileNotFoundError(f"Could not find the atomic data file {file.absolute()} for species {key}") + + ds = xr.open_dataset(file).pint.quantify() + + # Convert the dimensions from linear to log values + ds["dim_log_electron_temperature"] = xr.DataArray( + np.log10(magnitude(convert_units(ds.electron_temperature, ureg.eV))), dims="dim_electron_temperature" + ) + ds["dim_log_electron_density"] = xr.DataArray( + np.log10(magnitude(convert_units(ds.electron_density, ureg.m**-3))), dims="dim_electron_density" + ) + ds["dim_log_ne_tau"] = xr.DataArray(np.log10(magnitude(convert_units(ds.ne_tau, ureg.m**-3 * ureg.s))), dims="dim_ne_tau") + + ds = ds.swap_dims({"dim_electron_temperature": "dim_log_electron_temperature"}) + ds = ds.swap_dims({"dim_electron_density": "dim_log_electron_density"}) + ds = ds.swap_dims({"dim_ne_tau": "dim_log_ne_tau"}) + + def build_interpolator(curve: xr.Dataset) -> Union[RectBivariateSpline, RegularGridInterpolator]: + if curve.ndim == 2: + return RectBivariateSpline( + x=curve.dim_log_electron_temperature, + y=curve.dim_log_electron_density, + z=np.log10(magnitude(curve.transpose("dim_log_electron_temperature", "dim_log_electron_density"))), # type: ignore[arg-type] + ) + elif curve.ndim == 3: + return RegularGridInterpolator( + points=(curve.dim_log_electron_temperature, curve.dim_log_electron_density, curve.dim_log_ne_tau), + values=np.log10(magnitude(curve.transpose("dim_log_electron_temperature", "dim_log_electron_density", "dim_log_ne_tau"))), # type: ignore[arg-type] + bounds_error=False, + method="linear", + ) + else: + raise NotImplementedError(f"Cannot build an interpolator for a curve with ndim={curve.ndim}") + + ds = ds.assign_attrs( + coronal_Lz_interpolator=build_interpolator(ds.coronal_electron_emission_prefactor), + coronal_mean_Z_interpolator=build_interpolator(ds.coronal_mean_charge_state), + noncoronal_Lz_interpolator=build_interpolator(ds.noncoronal_electron_emission_prefactor), + noncoronal_mean_Z_interpolator=build_interpolator(ds.noncoronal_mean_charge_state), + ) + + # Drop the linear coordinates + atomic_data[key] = ds.drop_vars(("dim_ne_tau", "dim_electron_temperature", "dim_electron_density")) + + return atomic_data diff --git a/cfspopcon/cli.py b/cfspopcon/cli.py new file mode 100755 index 00000000..2c9357a3 --- /dev/null +++ b/cfspopcon/cli.py @@ -0,0 +1,79 @@ +#!.venv/bin/python +# Run this script from the repository directory. +"""CLI for cfspopcon.""" +import sys +from pathlib import Path + +import click +import matplotlib.pyplot as plt # type:ignore[import] +import xarray as xr +from ipdb import launch_ipdb_on_exception # type:ignore[import] + +from cfspopcon import file_io +from cfspopcon.input_file_handling import read_case +from cfspopcon.plotting import make_plot, read_plot_style + + +@click.command() +@click.argument("case", type=click.Path(exists=True)) +@click.option( + "--plots", + "-p", + type=click.Path(exists=True), + multiple=True, +) +@click.option("--show", is_flag=True, help="Display an interactive figure of the result") +@click.option("--debug", is_flag=True, help="Enable the ipdb exception catcher") +def run_popcon_cli(case: str, plots: tuple[str], show: bool, debug: bool) -> None: + """Run POPCON from the command line. + + This function uses "Click" to develop the command line interface. You can execute it using + poetry run python cfspopcon/cli.py --help + + You can specify a set of plots to create by specifying a plot style file after `-p` on the command-line. Multiple entries are supported. + """ + if show and not plots: + print(f"Speficied show={show}, but did not specify a plot style, see --plots!") + sys.exit(1) + + if not debug: + run_popcon(case, plots, show) + else: + with launch_ipdb_on_exception(): + run_popcon(case, plots, show) + + +def run_popcon(case: str, plots: tuple[str], show: bool) -> None: + """Run popcon case. + + Args: + case: specify case to run (corresponding to a case in cases) + plots: specify which plots to make (corresponding to a plot_style in plot_styles) + show: show the resulting plots + """ + input_parameters, algorithm, points = read_case(case) + + dataset = xr.Dataset(input_parameters) + + algorithm.validate_inputs(dataset) + algorithm.update_dataset(dataset, in_place=True) + + output_dir = Path(case) / "output" if Path(case).is_dir() else Path(case).parent / "output" + output_dir.mkdir(exist_ok=True) + + file_io.write_dataset_to_netcdf(dataset, filepath=output_dir / "dataset.nc") + + for point, point_params in points.items(): + file_io.write_point_to_file(dataset, point, point_params, output_dir=output_dir) + + # Plot the results + for plot_style in plots: + make_plot(dataset, read_plot_style(plot_style), points, title=input_parameters.get("plot_title", "POPCON"), output_dir=output_dir) + + print("Done") + if show: + plt.show() + + +if __name__ == "__main__": + run_popcon_cli() diff --git a/cfspopcon/file_io.py b/cfspopcon/file_io.py new file mode 100644 index 00000000..56e304d5 --- /dev/null +++ b/cfspopcon/file_io.py @@ -0,0 +1,104 @@ +"""Functions for saving results to file and loading those files.""" +import json +from pathlib import Path +from typing import Any + +import xarray as xr + +from .helpers import convert_named_options +from .point_selection import build_mask_from_dict, find_coords_of_minimum +from .unit_handling import convert_to_default_units, set_default_units + + +def sanitize_variable(val: xr.DataArray, key: str) -> xr.DataArray: + """Strip units and Enum values from a variable so that it can be stored in a NetCDF file.""" + try: + val = convert_to_default_units(val, key).pint.dequantify() + except KeyError: + pass + + if val.dtype == object: + if val.size == 1: + val = val.item().name + else: + val = xr.DataArray([v.name for v in val.values]) + + return val + + +def write_dataset_to_netcdf(dataset: xr.Dataset, filepath: Path) -> None: + """Write a dataset to a NetCDF file.""" + serialized_dataset = dataset.copy() + for key in dataset.keys(): + assert isinstance(key, str) # because hashable type of key is broader str but we know it's str + serialized_dataset[key] = sanitize_variable(dataset[key], key) + + for key in dataset.coords: + assert isinstance(key, str) # because hashable type of key is broader str but we know it's str + serialized_dataset[key] = sanitize_variable(dataset[key], key) + + serialized_dataset.to_netcdf(filepath) + + +def promote_variable(val: xr.DataArray, key: str) -> Any: + """Add back in units and Enum values that were removed by sanitize_variable.""" + try: + val = set_default_units(val, key) + except KeyError: + pass + + if val.dtype == object: + if val.size == 1: + return convert_named_options(key, val.item()) + else: + return [convert_named_options(key, v) for v in val.values] + + return val + + +def read_dataset_from_netcdf(filepath: Path) -> xr.Dataset: + """Open a dataset from a NetCDF file.""" + dataset = xr.open_dataset(filepath) + + for key in dataset.keys(): + assert isinstance(key, str) + dataset[key] = promote_variable(dataset[key], key) + + for key in dataset.coords: + if key == "dim_species": + dataset[key] = promote_variable(dataset[key], key="impurity") + else: + assert isinstance(key, str) # because hashable type of key is broader str but we know it's str + dataset[key] = promote_variable(dataset[key], key) + + return dataset + + +def write_point_to_file(dataset: xr.Dataset, point_key: str, point_params: dict, output_dir: Path) -> None: + """Write the analysis values at the named points to a json file.""" + mask = build_mask_from_dict(dataset, point_params) + + if "minimize" not in point_params.keys() and "maximize" not in point_params.keys(): + raise ValueError(f"Need to provide either minimize or maximize in point specification. Keys were {point_params.keys()}") + + if "minimize" in point_params.keys(): + array = dataset[point_params["minimize"]] + else: + array = -dataset[point_params["maximize"]] + + point_coords = find_coords_of_minimum(array, keep_dims=point_params.get("keep_dims", []), mask=mask) + + point = dataset.isel(point_coords) + + for key in point.keys(): + assert isinstance(key, str) # because hashable type of key is broader str but we know it's str + point[key] = sanitize_variable(point[key], key) + + for key in point.coords: + assert isinstance(key, str) # because hashable type of key is broader str but we know it's str + point[key] = sanitize_variable(point[key], key) + + output_dir.mkdir(parents=True, exist_ok=True) + + with open(output_dir / f"{point_key}.json", "w") as file: + json.dump(point.to_dict(), file, indent=4) diff --git a/cfspopcon/formulas/Q_thermal_gain_factor.py b/cfspopcon/formulas/Q_thermal_gain_factor.py new file mode 100644 index 00000000..2f609114 --- /dev/null +++ b/cfspopcon/formulas/Q_thermal_gain_factor.py @@ -0,0 +1,39 @@ +"""Calculate the thermal gain factor (Q, Q_plasma, Q_thermal).""" +import numpy as np + +from ..unit_handling import ureg, wraps_ufunc + +_IGNITED_THRESHOLD = 1e3 +_IGNITED = 1e6 + + +def _ignition_above_threshold(Q: float) -> float: + """If Q > _IGNITED_THRESHOLD, set equal to _IGNITED. + + Args: + Q: Fusion power gain [~] + + Returns: + Q [~] + """ + if Q > _IGNITED_THRESHOLD: + return _IGNITED + else: + return Q + + +@wraps_ufunc(return_units=dict(Q=ureg.dimensionless), input_units=dict(P_fusion=ureg.MW, P_launched=ureg.MW)) +def thermal_calc_gain_factor(P_fusion: float, P_launched: float) -> float: + """Calculate the fusion gain. + + Args: + P_fusion: [MW] :term:`glossary link` + P_launched: [MW] :term:`glossary link` + + Returns: + Q [~] + """ + if np.isclose(P_launched, 0.0): + return _IGNITED + else: + return _ignition_above_threshold(P_fusion / P_launched) diff --git a/cfspopcon/formulas/__init__.py b/cfspopcon/formulas/__init__.py new file mode 100644 index 00000000..68239238 --- /dev/null +++ b/cfspopcon/formulas/__init__.py @@ -0,0 +1,94 @@ +"""Formulas for POPCONs analysis.""" + +from . import energy_confinement_time_scalings, fusion_reaction_data, plasma_profile_data, radiated_power +from .average_fuel_ion_mass import calc_fuel_average_mass_number +from .beta import calc_beta_normalised, calc_beta_poloidal, calc_beta_toroidal, calc_beta_total +from .confinement_regime_threshold_powers import ( + calc_confinement_transition_threshold_power, + calc_LH_transition_threshold_power, + calc_LI_transition_threshold_power, +) +from .current_drive import ( + calc_bootstrap_fraction, + calc_current_relaxation_time, + calc_f_shaping, + calc_loop_voltage, + calc_neoclassical_loop_resistivity, + calc_ohmic_power, + calc_plasma_current, + calc_q_star, + calc_resistivity_trapped_enhancement, + calc_Spitzer_loop_resistivity, +) +from .density_peaking import calc_density_peaking, calc_effective_collisionality +from .divertor_metrics import calc_B_pol_omp, calc_B_tor_omp +from .energy_confinement_time_scalings import calc_tau_e_and_P_in_from_scaling +from .figures_of_merit import calc_normalised_collisionality, calc_peak_pressure, calc_rho_star, calc_triple_product +from .fusion_rates import calc_fusion_power, calc_neutron_flux_to_walls +from .geometry import calc_plasma_surface_area, calc_plasma_volume +from .impurity_effects import calc_change_in_dilution, calc_change_in_zeff, calc_impurity_charge_state +from .operational_limits import calc_greenwald_density_limit, calc_greenwald_fraction, calc_troyon_limit +from .plasma_profiles import calc_1D_plasma_profiles +from .Q_thermal_gain_factor import thermal_calc_gain_factor +from .radiated_power import ( + calc_bremsstrahlung_radiation, + calc_impurity_radiated_power, + calc_impurity_radiated_power_mavrin_coronal, + calc_impurity_radiated_power_mavrin_noncoronal, + calc_impurity_radiated_power_post_and_jensen, + calc_impurity_radiated_power_radas, + calc_synchrotron_radiation, +) + +__all__ = [ + "energy_confinement_time_scalings", + "fusion_reaction_data", + "calc_density_peaking", + "calc_effective_collisionality", + "plasma_profile_data", + "calc_fuel_average_mass_number", + "calc_B_pol_omp", + "calc_B_tor_omp", + "calc_beta_normalised", + "calc_beta_poloidal", + "calc_beta_toroidal", + "calc_troyon_limit", + "calc_greenwald_density_limit", + "calc_beta_total", + "calc_bootstrap_fraction", + "calc_current_relaxation_time", + "calc_f_shaping", + "calc_fusion_power", + "calc_greenwald_fraction", + "calc_LH_transition_threshold_power", + "calc_LI_transition_threshold_power", + "calc_loop_voltage", + "calc_resistivity_trapped_enhancement", + "calc_neoclassical_loop_resistivity", + "calc_neutron_flux_to_walls", + "calc_normalised_collisionality", + "calc_1D_plasma_profiles", + "calc_ohmic_power", + "calc_peak_pressure", + "calc_plasma_current", + "calc_plasma_surface_area", + "calc_plasma_volume", + "calc_rho_star", + "calc_Spitzer_loop_resistivity", + "calc_q_star", + "calc_triple_product", + "calc_tau_e_and_P_in_from_scaling", + "thermal_calc_gain_factor", + "calc_confinement_transition_threshold_power", + "calc_change_in_zeff", + "calc_change_in_dilution", + "calc_bremsstrahlung_radiation", + "calc_synchrotron_radiation", + "calc_impurity_radiated_power_post_and_jensen", + "calc_impurity_radiated_power_radas", + "calc_impurity_radiated_power", + "calc_impurity_radiated_power_mavrin_coronal", + "calc_impurity_radiated_power_mavrin_noncoronal", + "radiated_power", + "calc_impurity_charge_state", +] diff --git a/cfspopcon/formulas/average_fuel_ion_mass.py b/cfspopcon/formulas/average_fuel_ion_mass.py new file mode 100644 index 00000000..1bd23c54 --- /dev/null +++ b/cfspopcon/formulas/average_fuel_ion_mass.py @@ -0,0 +1,30 @@ +"""Calculate the average fuel mass in atomic mass units.""" +from typing import Callable + +from ..named_options import ReactionType +from ..unit_handling import ureg, wraps_ufunc + +FUEL_MASS_AMU: dict[ReactionType, Callable[[float], float]] = { + ReactionType.DT: lambda heavier_fuel_species_fraction: 2.0 + heavier_fuel_species_fraction, + ReactionType.DD: lambda _: 2.0, + ReactionType.DHe3: lambda heavier_fuel_species_fraction: 2.0 + heavier_fuel_species_fraction, + ReactionType.pB11: lambda heavier_fuel_species_fraction: 11.0 * heavier_fuel_species_fraction + + 1.0 * (1.0 - heavier_fuel_species_fraction), +} + + +@wraps_ufunc( + return_units=dict(fuel_average_mass_number=ureg.amu), + input_units=dict(fusion_reaction=None, heavier_fuel_species_fraction=ureg.dimensionless), +) +def calc_fuel_average_mass_number(fusion_reaction: ReactionType, heavier_fuel_species_fraction: float) -> float: + """Calculate the average mass of the fuel ions, based on reaction type and fuel mixture ratio. + + Args: + fusion_reaction: reaction type. + heavier_fuel_species_fraction: n_heavier / (n_heavier + n_lighter) number fraction. + + Returns: + :term:`fuel_average_mass_number` [amu] + """ + return FUEL_MASS_AMU[fusion_reaction](heavier_fuel_species_fraction) diff --git a/cfspopcon/formulas/beta.py b/cfspopcon/formulas/beta.py new file mode 100644 index 00000000..8b17ec0e --- /dev/null +++ b/cfspopcon/formulas/beta.py @@ -0,0 +1,135 @@ +"""Calculate the ratio of magnetic to plasma (kinetic) pressure.""" +import numpy as np + +from ..unit_handling import Quantity, Unitfull, convert_units, ureg + + +def _calc_beta_general( + average_electron_density: Unitfull, average_electron_temp: Unitfull, average_ion_temp: Unitfull, magnetic_field: Unitfull +) -> Unitfull: + """Calculate the average ratio of the plasma pressure to the magnetic pressure due to a magnetic_field. + + Using equation 11.58 from Freidberg, "Plasma Physics and Fusion Energy" :cite:`freidberg_plasma_2007` + + The unit_conversion_factor comes from cancelling the units to get a dimensionless quantity + + >>> from pint import Quantity + >>> n = Quantity(1e19, "m^-3") + >>> T = Quantity(1, "keV") + >>> B = Quantity(1, "T") + >>> mu_0 = Quantity(1, "mu_0") + >>> ((2*mu_0 * n * T / (B**2)).to('').units + + + Args: + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + average_ion_temp: [keV] :term:`glossary link` + magnetic_field: magnetic field generating magnetic pressure [T] + + Returns: + beta (toroidal or poloidal) [~] + """ + mu_0 = Quantity(1, "mu_0") + # to make the result dimensionless + unit_conversion_factor = 2 * mu_0 + ret = unit_conversion_factor * (average_electron_density * (average_electron_temp + average_ion_temp)) / (magnetic_field**2) + return convert_units(ret, ureg.dimensionless) + + +def calc_beta_toroidal( + average_electron_density: Unitfull, average_electron_temp: Unitfull, average_ion_temp: Unitfull, magnetic_field_on_axis: Unitfull +) -> Unitfull: + """Calculate the average ratio of the plasma pressure to the magnetic pressure due to the toroidal field. + + Also called beta_external, since the toroidal field is generated by external toroidal field coils. + Using equation 11.58 from Freidberg, "Plasma Physics and Fusion Energy" :cite:`freidberg_plasma_2007` + + Args: + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + average_ion_temp: [keV] :term:`glossary link` + magnetic_field_on_axis: [T] :term:`glossary link` + + Returns: + :term:`beta_toroidal` [~] + """ + return _calc_beta_general(average_electron_density, average_electron_temp, average_ion_temp, magnetic_field=magnetic_field_on_axis) + + +def calc_beta_poloidal( + average_electron_density: Unitfull, + average_electron_temp: Unitfull, + average_ion_temp: Unitfull, + plasma_current: Unitfull, + minor_radius: Unitfull, +) -> Unitfull: + """Calculate the average ratio of the plasma pressure to the magnetic pressure due to the plasma current. + + Calculates the poloidal magnetic field at radius a from the plasma current using + equation 11.55 from Freidberg, "Plasma Physics and Fusion Energy" :cite:`freidberg_plasma_2007` + and then evaluates beta_poloidal using + equation 11.58 from Freidberg, "Plasma Physics and Fusion Energy" :cite:`freidberg_plasma_2007` + + The unit_conversion_factor cancels the units, and can be calculated using the following + + >>> from pint import Quantity + >>> from numpy import pi + >>> mu_0 = Quantity(1, "mu_0") + >>> I = Quantity(1, "MA") + >>> minor_radius = Quantity(1, "m") + >>> (mu_0 * I / (2 * pi * minor_radius)).to("T").units + + + Args: + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + average_ion_temp: [keV] :term:`glossary link` + plasma_current: [MA] :term:`glossary link` + minor_radius: [m] :term:`glossary link` + + Returns: + :term:`beta_poloidal` [~] + """ + mu_0 = Quantity(1, "mu_0") + # to ensure the final result is in units of tesla + units_conversion_factor = mu_0 / (2 * np.pi) + B_pol = units_conversion_factor * plasma_current / minor_radius + + return _calc_beta_general(average_electron_density, average_electron_temp, average_ion_temp, magnetic_field=B_pol) + + +def calc_beta_total(beta_toroidal: Unitfull, beta_poloidal: Unitfull) -> Unitfull: + """Calculate the total beta from the toroidal and poloidal betas. + + Using equation 11.59 from Freidberg, "Plasma Physics and Fusion Energy" :cite:`freidberg_plasma_2007` + + Args: + beta_toroidal: [~] :term:`glossary link` + beta_poloidal: [~] :term:`glossary link` + + Returns: + :term:`beta_total` [~] + """ + return 1.0 / (1.0 / beta_toroidal + 1.0 / beta_poloidal) + + +def calc_beta_normalised(beta: Unitfull, minor_radius: Unitfull, magnetic_field_on_axis: Unitfull, plasma_current: Unitfull) -> Unitfull: + """Normalize beta to stability (Troyon) parameters. + + See section 6.18 in Wesson :cite:`wesson_tokamaks_2011`. + + Args: + beta: plasma pressure normalized against toroidal B-on-axis [%] + minor_radius: [m] :term:`glossary link` + magnetic_field_on_axis: [T] :term:`glossary link` + plasma_current: [MA] :term:`glossary link` + + Returns: + :term:`beta_N` + """ + normalisation = plasma_current / (minor_radius * magnetic_field_on_axis) + + beta_N = beta / normalisation + + return beta_N diff --git a/cfspopcon/formulas/confinement_regime_threshold_powers.py b/cfspopcon/formulas/confinement_regime_threshold_powers.py new file mode 100644 index 00000000..3d080e83 --- /dev/null +++ b/cfspopcon/formulas/confinement_regime_threshold_powers.py @@ -0,0 +1,153 @@ +"""Threshold powers required to enter improved confinement regimes.""" +from ..named_options import ConfinementScaling +from ..unit_handling import ureg, wraps_ufunc + + +def _calc_Martin_LH_threshold( + magnetic_field_on_axis: float, surface_area: float, fuel_average_mass_number: float, electron_density_profile: float +) -> float: + """See below.""" + _DEUTERIUM_MASS_NUMBER = 2.0 + + return float(0.0488 * ((electron_density_profile / 10.0) ** 0.717) * (magnetic_field_on_axis**0.803) * (surface_area**0.941)) * ( + _DEUTERIUM_MASS_NUMBER / fuel_average_mass_number + ) + + +@wraps_ufunc( + return_units=dict(P_LH_thresh=ureg.MW), + input_units=dict( + plasma_current=ureg.MA, + magnetic_field_on_axis=ureg.T, + minor_radius=ureg.m, + major_radius=ureg.m, + surface_area=ureg.m**2, + fuel_average_mass_number=ureg.amu, + average_electron_density=ureg.n19, + scale=ureg.dimensionless, + ), +) +def calc_LH_transition_threshold_power( + plasma_current: float, + magnetic_field_on_axis: float, + minor_radius: float, + major_radius: float, + surface_area: float, + fuel_average_mass_number: float, + average_electron_density: float, + scale: float = 1.0, +) -> float: + """Calculate the threshold power (crossing the separatrix) to transition into H-mode. + + From Martin NF 2008 Scaling, with mass correction :cite:`martin_power_2008` + Added in low density branch from Ryter 2014 :cite:`Ryter_2014` + + Args: + plasma_current: [MA] :term:`glossary link` + magnetic_field_on_axis: [T] :term:`glossary link` + minor_radius: [m] :term:`glossary link` + major_radius: [m] :term:`glossary link` + surface_area: [m^2] :term:`glossary link` + fuel_average_mass_number: [amu] :term:`glossary link` + average_electron_density: [1e19 m^-3] :term:`glossary link` + scale: (optional) scaling factor for P_LH adjustment studies [~] + + Returns: + :term:`P_LH_thresh` [MW] + """ + neMin19 = ( + 0.7 * (plasma_current**0.34) * (magnetic_field_on_axis**0.62) * (minor_radius**-0.95) * ((major_radius / minor_radius) ** 0.4) + ) + + if average_electron_density < neMin19: + P_LH_thresh = _calc_Martin_LH_threshold( + magnetic_field_on_axis, surface_area, fuel_average_mass_number, electron_density_profile=neMin19 + ) + return float(P_LH_thresh * (neMin19 / average_electron_density) ** 2.0) * scale + else: + P_LH_thresh = _calc_Martin_LH_threshold( + magnetic_field_on_axis, surface_area, fuel_average_mass_number, electron_density_profile=average_electron_density + ) + return P_LH_thresh * scale + + +@wraps_ufunc( + return_units=dict(P_LI_thresh=ureg.MW), + input_units=dict(plasma_current=ureg.MA, average_electron_density=ureg.n19, scale=ureg.dimensionless), +) +def calc_LI_transition_threshold_power(plasma_current: float, average_electron_density: float, scale: float = 1.0) -> float: + """Calculate the threshold power (crossing the separatrix) to transition into I-mode. + + Note: uses scaling described in Fig 5 of ref :cite:`hubbard_threshold_2012` + + Args: + plasma_current: [MA] :term:`glossary link` + average_electron_density: [1e19 m^-3] :term:`glossary link` + scale: (optional) scaling factor for P_LI adjustment studies [~] + + Returns: + :term:`P_LI_thresh` [MW] + """ + return float(2.11 * plasma_current**0.94 * ((average_electron_density / 10.0) ** 0.65)) * scale + + +@wraps_ufunc( + return_units=dict(P_LH_thresh=ureg.MW), + input_units=dict( + energy_confinement_scaling=None, + plasma_current=ureg.MA, + magnetic_field_on_axis=ureg.T, + minor_radius=ureg.m, + major_radius=ureg.m, + surface_area=ureg.m**2, + fuel_average_mass_number=ureg.amu, + average_electron_density=ureg.n19, + confinement_threshold_scalar=ureg.dimensionless, + ), +) +def calc_confinement_transition_threshold_power( + energy_confinement_scaling: ConfinementScaling, + plasma_current: float, + magnetic_field_on_axis: float, + minor_radius: float, + major_radius: float, + surface_area: float, + fuel_average_mass_number: float, + average_electron_density: float, + confinement_threshold_scalar: float = 1.0, +) -> float: + """Calculate the threshold power (crossing the separatrix) to transition into an improved confinement mode. + + Args: + energy_confinement_scaling: [] :term:`glossary link` + plasma_current: [MA] :term:`glossary link` + magnetic_field_on_axis: [T] :term:`glossary link` + minor_radius: [m] :term:`glossary link` + major_radius: [m] :term:`glossary link` + surface_area: [m^2] :term:`glossary link` + fuel_average_mass_number: [amu] :term:`glossary link` + average_electron_density: [1e19 m^-3] :term:`glossary link` + confinement_threshold_scalar: (optional) scaling factor for P_LH adjustment studies [~] + + Returns: + :term:`P_LH_thresh` [MW] + """ + if energy_confinement_scaling not in [ConfinementScaling.LOC, ConfinementScaling.IModey2]: + P_LH_thresh = calc_LH_transition_threshold_power.__wrapped__( + plasma_current, + magnetic_field_on_axis, + minor_radius, + major_radius, + surface_area, + fuel_average_mass_number, + average_electron_density, + scale=confinement_threshold_scalar, + ) + elif energy_confinement_scaling == ConfinementScaling.IModey2: + P_LH_thresh = calc_LI_transition_threshold_power.__wrapped__( + plasma_current, average_electron_density, scale=confinement_threshold_scalar + ) + else: + raise ValueError("Encountered unhandled confinement time scaling.") + + return float(P_LH_thresh) diff --git a/cfspopcon/formulas/current_drive.py b/cfspopcon/formulas/current_drive.py new file mode 100644 index 00000000..95be3129 --- /dev/null +++ b/cfspopcon/formulas/current_drive.py @@ -0,0 +1,254 @@ +"""Ohmic and bootstrap plasma current, loop resistivity & voltage, and current relaxation time.""" +from ..unit_handling import Unitfull, ureg, wraps_ufunc + + +def calc_f_shaping(inverse_aspect_ratio: Unitfull, areal_elongation: Unitfull, triangularity_psi95: Unitfull) -> Unitfull: + """Calculate the shaping function. + + Equation A11 from ITER Physics Basis Ch. 1. Eqn. A-11 :cite:`editors_iter_1999` + See following discussion for how this function is used. + q_95 = 5 * minor_radius^2 * magnetic_field_on_axis / (R * plasma_current) f_shaping + + Args: + inverse_aspect_ratio: [~] :term:`glossary link` + areal_elongation: [~] :term:`glossary link` + triangularity_psi95: [~] :term:`glossary link` + + Returns: + :term:`f_shaping` [~] + """ + return ((1.0 + areal_elongation**2.0 * (1.0 + 2.0 * triangularity_psi95**2.0 - 1.2 * triangularity_psi95**3.0)) / 2.0) * ( + (1.17 - 0.65 * inverse_aspect_ratio) / (1.0 - inverse_aspect_ratio**2.0) ** 2.0 + ) + + +@wraps_ufunc( + input_units=dict( + magnetic_field_on_axis=ureg.T, + major_radius=ureg.m, + inverse_aspect_ratio=ureg.dimensionless, + q_star=ureg.dimensionless, + f_shaping=ureg.dimensionless, + ), + return_units=dict(plasma_current=ureg.MA), +) +def calc_plasma_current( + magnetic_field_on_axis: float, major_radius: float, inverse_aspect_ratio: float, q_star: float, f_shaping: float +) -> float: + """Calculate the plasma current in mega-amperes. + + Updated formula from ITER Physics Basis Ch. 1. :cite:`editors_iter_1999` + + Args: + magnetic_field_on_axis: [T] :term:`glossary link` + major_radius: [m] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + q_star: [~] :term:`glossary link` + f_shaping: [~] :term:`glossary link` + + Returns: + :term:`plasma_current` [MA] + """ + return float(5.0 * ((inverse_aspect_ratio * major_radius) ** 2.0) * (magnetic_field_on_axis / (q_star * major_radius)) * f_shaping) + + +@wraps_ufunc( + input_units=dict( + magnetic_field_on_axis=ureg.T, + major_radius=ureg.m, + inverse_aspect_ratio=ureg.dimensionless, + plasma_current=ureg.MA, + f_shaping=ureg.dimensionless, + ), + return_units=dict(q_star=ureg.dimensionless), +) +def calc_q_star( + magnetic_field_on_axis: float, major_radius: float, inverse_aspect_ratio: float, plasma_current: float, f_shaping: float +) -> float: + """Calculate an analytical estimate for the edge safety factor q_star. + + Updated formula from ITER Physics Basis Ch. 1. :cite:`editors_iter_1999` + + Args: + magnetic_field_on_axis: [T] :term:`glossary link` + major_radius: [m] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + plasma_current: [MA] :term:`glossary link` + f_shaping: [~] :term:`glossary link` + + Returns: + :term:`plasma_current` [MA] + """ + return float(5.0 * (inverse_aspect_ratio * major_radius) ** 2.0 * magnetic_field_on_axis / (plasma_current * major_radius) * f_shaping) + + +def calc_ohmic_power(inductive_plasma_current: Unitfull, loop_voltage: Unitfull) -> Unitfull: + """Calculate the Ohmic heating power. + + Args: + inductive_plasma_current: [MA] :term:`glossary link` + loop_voltage: [V] :term:`glossary link` + + Returns: + :term:`P_Ohmic` [MW] + """ + return inductive_plasma_current * loop_voltage + + +@wraps_ufunc(input_units=dict(average_electron_temp=ureg.keV), return_units=dict(spitzer_resistivity=ureg.ohm * ureg.m)) +def calc_Spitzer_loop_resistivity(average_electron_temp: float) -> float: + """Calculate the parallel Spitzer loop resistivity assuming the Coulomb logarithm = 17 and Z=1. + + Resistivity from Wesson 2.16.2 :cite:`wesson_tokamaks_2011` + + Args: + average_electron_temp: [keV] :term:`glossary link` + + Returns: + :term:`spitzer_resistivity` [Ohm-m] + """ + return float((2.8e-8) * (average_electron_temp ** (-1.5))) + + +def calc_resistivity_trapped_enhancement(inverse_aspect_ratio: Unitfull, definition: int = 3) -> Unitfull: + """Calculate the enhancement of the plasma resistivity due to trapped particles. + + Definition 1 is the denominator of eta_n (neoclassical resistivity) on p801 of Wesson :cite:`wesson_tokamaks_2011` + + Args: + inverse_aspect_ratio: [~] :term:`glossary link` + definition: [~] choice of [1,2,3] to specify which definition to use + + Returns: + :term:`trapped_particle_fraction` [~] + + Raises: + NotImplementedError: if definition doesn't match an implementation + """ + if definition == 1: + trapped_particle_fraction = 1 / ((1.0 - (inverse_aspect_ratio**0.5)) ** 2.0) # pragma: nocover + elif definition == 2: + trapped_particle_fraction = 2 / (1.0 - 1.31 * (inverse_aspect_ratio**0.5) + 0.46 * inverse_aspect_ratio) # pragma: nocover + elif definition == 3: + trapped_particle_fraction = 0.609 / (0.609 - 0.785 * (inverse_aspect_ratio**0.5) + 0.269 * inverse_aspect_ratio) + else: + raise NotImplementedError(f"No implementation {definition} for calc_resistivity_trapped_enhancement.") # pragma: nocover + + return trapped_particle_fraction + + +def calc_neoclassical_loop_resistivity( + spitzer_resistivity: Unitfull, z_effective: Unitfull, trapped_particle_fraction: Unitfull +) -> Unitfull: + """Calculate the neoclassical loop resistivity including impurity ions. + + Wesson Section 14.10. Impact of ion charge. Impact of dilution ~ 0.9. + + Args: + spitzer_resistivity: [Ohm-m] :term:`glossary link` + z_effective: [~] :term:`glossary link` + trapped_particle_fraction: [~] :term:`glossary link` + + Returns: + :term:`neoclassical_loop_resistivity` [Ohm-m] + """ + return spitzer_resistivity * z_effective * 0.9 * trapped_particle_fraction + + +@wraps_ufunc( + input_units=dict( + major_radius=ureg.m, + inverse_aspect_ratio=ureg.dimensionless, + areal_elongation=ureg.dimensionless, + average_electron_temp=ureg.keV, + z_effective=ureg.dimensionless, + ), + return_units=dict(current_relaxation_time=ureg.s), +) +def calc_current_relaxation_time( + major_radius: float, inverse_aspect_ratio: float, areal_elongation: float, average_electron_temp: float, z_effective: float +) -> float: + """Calculate the current relaxation time. + + from :cite:`Bonoli` + + Args: + major_radius: [m] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + areal_elongation: [~] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + z_effective: [~] :term:`glossary link` + + Returns: + :term:`current_relaxation_time` [s] + """ + return float( + 1.4 * ((major_radius * inverse_aspect_ratio) ** 2.0) * areal_elongation * (average_electron_temp**1.5) / z_effective + ) # [s] + + +def calc_loop_voltage( + major_radius: Unitfull, + minor_radius: Unitfull, + inductive_plasma_current: Unitfull, + areal_elongation: Unitfull, + neoclassical_loop_resistivity: Unitfull, +) -> Unitfull: + """Calculate plasma toroidal loop voltage at flattop. + + Plasma loop voltage from Alex Creely's original work. + + Args: + major_radius: [m] :term:`glossary link` + minor_radius: [m] :term:`glossary link` + inductive_plasma_current: [MA] :term:`glossary link` + areal_elongation: [~] :term:`glossary link` + neoclassical_loop_resistivity: [Ohm-m] :term:`glossary link` + + Returns: + :term:`loop_voltage` [V] + """ + Iind = inductive_plasma_current # Inductive plasma current [A] + + _term1 = 2 * major_radius / (minor_radius**2 * areal_elongation) # Toroidal length over plasma cross-section surface area [1/m] + return Iind * _term1 * neoclassical_loop_resistivity + + +def calc_bootstrap_fraction( + ion_density_peaking: Unitfull, + electron_density_peaking: Unitfull, + temperature_peaking: Unitfull, + z_effective: Unitfull, + q_star: Unitfull, + inverse_aspect_ratio: Unitfull, + beta_poloidal: Unitfull, +) -> Unitfull: + """Calculate bootstrap current fraction. + + K. Gi et al, Bootstrap current fraction scaling :cite:`gi_bootstrap_2014` + Equation assumes q0 = 1 + + Args: + ion_density_peaking: [~] :term:`glossary link` + electron_density_peaking: [~] :term:`glossary link` + temperature_peaking: [~] :term:`glossary link` + z_effective: [~] :term:`glossary link` + q_star: [~] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + beta_poloidal: [~] :term:`glossary link` + + Returns: + :term:`bootstrap_fraction` [~] + """ + nu_n = (ion_density_peaking + electron_density_peaking) / 2 + + bootstrap_fraction = 0.474 * ( + (temperature_peaking - 1.0 + nu_n - 1.0) ** 0.974 + * (temperature_peaking - 1.0) ** -0.416 + * z_effective**0.178 + * q_star**-0.133 + * inverse_aspect_ratio**0.4 + * beta_poloidal + ) + + return bootstrap_fraction diff --git a/cfspopcon/formulas/density_peaking.py b/cfspopcon/formulas/density_peaking.py new file mode 100644 index 00000000..2e1065ff --- /dev/null +++ b/cfspopcon/formulas/density_peaking.py @@ -0,0 +1,52 @@ +"""Estimate the density peaking based on scaling from C. Angioni.""" +import numpy as np +import xarray as xr + +from ..unit_handling import Unitfull, ureg, wraps_ufunc + + +def calc_density_peaking(effective_collisionality: Unitfull, betaE: Unitfull, nu_noffset: Unitfull) -> Unitfull: + """Calculate the density peaking (peak over volume average). + + Equation 3 from p1334 of Angioni et al, "Scaling of density peaking in H-mode plasmas based on a combined + database of AUG and JET observations" :cite:`angioni_scaling_2007` + + Args: + effective_collisionality: [~] :term:`glossary link ` + betaE: beta due to external field [~] + nu_noffset: scalar offset added to peaking factor [~] + + Returns: + :term:`nu_n` [~] + """ + nu_n = (1.347 - 0.117 * np.log(effective_collisionality) - 4.03 * betaE) + nu_noffset + if isinstance(nu_n, xr.DataArray): + return nu_n.clip(1.0, float("inf")) + else: + return max(nu_n, 1.0 * ureg.dimensionless) + + +@wraps_ufunc( + return_units=dict(effective_collisionality=ureg.dimensionless), + input_units=dict( + average_electron_density=ureg.n19, average_electron_temp=ureg.keV, major_radius=ureg.m, z_effective=ureg.dimensionless + ), +) +def calc_effective_collisionality( + average_electron_density: float, average_electron_temp: float, major_radius: float, z_effective: float +) -> float: + """Calculate the effective collisionality. + + From p1327 of Angioni et al, "Scaling of density peaking in H-mode plasmas based on a combined + database of AUG and JET observations" :cite:`angioni_scaling_2007` + + Args: + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + major_radius: [m] :term:`glossary link` + z_effective: [~] :term:`glossary link` + + Returns: + :term:`effective_collisionality` [~] + """ + return float((0.1 * z_effective * average_electron_density * major_radius) / (average_electron_temp**2.0)) diff --git a/cfspopcon/formulas/divertor_metrics.py b/cfspopcon/formulas/divertor_metrics.py new file mode 100644 index 00000000..025ee269 --- /dev/null +++ b/cfspopcon/formulas/divertor_metrics.py @@ -0,0 +1,40 @@ +"""Divertor loading and functions to calculate OMP pitch (for q_parallel calculation).""" +import numpy as np +from scipy import constants # type: ignore[import] + +from ..unit_handling import ureg, wraps_ufunc + + +@wraps_ufunc( + return_units=dict(B_pol_omp=ureg.T), + input_units=dict(plasma_current=ureg.A, minor_radius=ureg.m), +) +def calc_B_pol_omp(plasma_current: float, minor_radius: float) -> float: + """Calculate the poloidal magnetic field at the outboard midplane. + + Args: + plasma_current: [MA] :term:`glossary link` + minor_radius: [m] :term:`glossary link` + + Returns: + B_pol_omp [T] + """ + return float(constants.mu_0 * plasma_current / (2.0 * np.pi * minor_radius)) + + +@wraps_ufunc( + return_units=dict(B_tor_omp=ureg.T), + input_units=dict(magnetic_field_on_axis=ureg.T, major_radius=ureg.m, minor_radius=ureg.m), +) +def calc_B_tor_omp(magnetic_field_on_axis: float, major_radius: float, minor_radius: float) -> float: + """Calculate the toroidal magnetic field at the outboard midplane. + + Args: + magnetic_field_on_axis: [T] :term:`glossary link` + major_radius: [m] :term:`glossary link` + minor_radius: [m] :term:`glossary link` + + Returns: + B_tor_omp [T] + """ + return magnetic_field_on_axis * (major_radius / (major_radius + minor_radius)) diff --git a/cfspopcon/formulas/energy_confinement_time_scalings/__init__.py b/cfspopcon/formulas/energy_confinement_time_scalings/__init__.py new file mode 100644 index 00000000..9f2c993c --- /dev/null +++ b/cfspopcon/formulas/energy_confinement_time_scalings/__init__.py @@ -0,0 +1,9 @@ +"""Empirical scalings for energy confinement time.""" + +from .tau_e_from_Wp import calc_tau_e_and_P_in_from_scaling, get_datasets, load_metadata + +__all__ = [ + "calc_tau_e_and_P_in_from_scaling", + "load_metadata", + "get_datasets", +] diff --git a/cfspopcon/formulas/energy_confinement_time_scalings/tau_e_from_Wp.py b/cfspopcon/formulas/energy_confinement_time_scalings/tau_e_from_Wp.py new file mode 100644 index 00000000..319df285 --- /dev/null +++ b/cfspopcon/formulas/energy_confinement_time_scalings/tau_e_from_Wp.py @@ -0,0 +1,169 @@ +"""Calculate tau_e and P_in from a tau_e scaling and the stored energy.""" +from pathlib import Path + +import numpy as np +import yaml + +from ...named_options import ConfinementScaling +from ...unit_handling import ureg, wraps_ufunc + +# Preload the scalings (instead of doing fileio in loop) +with open(Path(__file__).parent / "tau_e_scalings.yaml") as f: + TAU_E_SCALINGS = yaml.safe_load(f) + + +@wraps_ufunc( + return_units=dict(tau_e=ureg.s, P_tau=ureg.MW), + input_units=dict( + confinement_time_scalar=ureg.dimensionless, + plasma_current=ureg.MA, + magnetic_field_on_axis=ureg.T, + average_electron_density=ureg.n19, + major_radius=ureg.m, + areal_elongation=ureg.dimensionless, + separatrix_elongation=ureg.dimensionless, + inverse_aspect_ratio=ureg.dimensionless, + fuel_average_mass_number=ureg.amu, + triangularity_psi95=ureg.dimensionless, + separatrix_triangularity=ureg.dimensionless, + plasma_stored_energy=ureg.MJ, + q_star=ureg.dimensionless, + tau_e_scaling=None, + ), + output_core_dims=[(), ()], +) +def calc_tau_e_and_P_in_from_scaling( + confinement_time_scalar: float, + plasma_current: float, + magnetic_field_on_axis: float, + average_electron_density: float, + major_radius: float, + areal_elongation: float, + separatrix_elongation: float, + inverse_aspect_ratio: float, + fuel_average_mass_number: float, + triangularity_psi95: float, + separatrix_triangularity: float, + plasma_stored_energy: float, + q_star: float, + tau_e_scaling: ConfinementScaling, +) -> tuple[float, float]: + r"""Calculate energy confinement time and input power from a tau_E scaling. + + The energy confinement time can generally be written as + + .. math:: + \tau_e = H \cdot C \cdot P_{\tau}^{\alpha_P} + \cdot I_{MA}^{\alpha_I} \cdot B_0^{\alpha_B} \cdot \bar{n_{e,19}}^{\alpha_n} \cdot R_0^{\alpha_R} + \cdot \kappa_A^{\alpha_{ka}} \cdot \kappa_{sep}^{\alpha_{ks}} \cdot \epsilon^{\alpha_e} + \cdot m_i^{\alpha_A} \cdot \delta^{\alpha_d} + + We don't know :math:`P_{\tau}` in advance, so instead write + + .. math:: \tau_e = \gamma \cdot P_{\tau}^{\alpha_P} + + with + + .. math:: + \gamma = H \cdot C + \cdot I_{MA}^{\alpha_I} \cdot B_0^{\alpha_B} \cdot \bar{n_{e,19}}^{\alpha_n} \cdot R_0^{\alpha_R} + \cdot \kappa_A^{\alpha_{ka}} \cdot \kappa_{sep}^{\alpha_{ks}} \cdot \epsilon^{\alpha_e} + \cdot m_i^{\alpha_A} \cdot \delta^{\alpha_d} + + We have everything that we need to evaluate :math:`\gamma`. Then, we also know that + + .. math:: \tau_e = W_p / P_{loss} + + Then, we crucially need to define what exactly we mean by the two powers that we've introduced + (:math:`P_{\tau}` and :math:`P_{loss}`). We usually take + :math:`P_{\tau} = P_{heating} = P_{ohmic} + P_{\alpha} + P_{aux}` and + :math:`P_{loss}=P_{SOL} + P_{rad,core}` [Wesson definition]. From a + simple power balance, :math:`P_{heating}=P_{loss}` and so, setting the two :math:`\tau_e` equations equal, we get that + + .. math:: + W_p / P = \gamma \cdot P^{\alpha_P} + P^{\alpha_P + 1} = W_p / \gamma + P = \left(W_p / \gamma \right)^{\frac{1}{\alpha_P + 1}} + + Once we have :math:`P = P_{ohmic} + P_{\alpha} + P_{aux} = P_{SOL} + P_{rad,core}`, we can calculate :math:`W_p/P`. + + However, it is also possible that the core radiated power is subtracted when calculating :math:`\tau_e` + [Freidberg definition of :math:`W_p`], giving + + .. math:: + P_{\tau} = P_{ohmic} + P_{\alpha} + P_{aux} - P_{rad} = P_{loss} = P_{SOL} + + If you are using a scaling where this is the case, set ``tau_e_scaling_uses_P_in=False``. + Then, the returned value should be interpreted as :math:`P_{SOL}`. + + N.b. there are two more possible cases, where different powers are used in the two :math:`\tau_e` scalings. + We don't allow these cases, since 1) experiments generally pick a consistent definition for :math:`P` + and 2) this results in an equation for :math:`P` which cannot be solved analytically. + + Args: + confinement_time_scalar: [~] confinement scaling factor + plasma_current: [MA] :term:`glossary link` + magnetic_field_on_axis: [T] :term:`glossary link` + average_electron_density: [1e19 m^-3] :term:`glossary link` + major_radius: [m] :term:`glossary link` + areal_elongation: [~] :term:`glossary link` + separatrix_elongation: [~] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + fuel_average_mass_number: [amu] :term:`glossary link` + triangularity_psi95: [~] :term:`glossary link` + separatrix_triangularity: [~] :term:`glossary link` + plasma_stored_energy: [MJ] :term:`glossary link` + q_star: [~] :term:`glossary link` + tau_e_scaling: [] :term:`glossary link` + + Returns: + :term:`energy_confinement_time` [s], :term:`P_in` if tau_e_scaling_uses_P_in=False, else :term:`P_SOL` [MW] + """ + scaling = TAU_E_SCALINGS[tau_e_scaling.name] + + gamma = ( + confinement_time_scalar + * scaling["params"]["C"] + * plasma_current ** scaling["params"]["a_I"] + * magnetic_field_on_axis ** scaling["params"]["a_B"] + * average_electron_density ** scaling["params"]["a_n"] + * major_radius ** scaling["params"]["a_R"] + * areal_elongation ** scaling["params"]["a_ka"] + * separatrix_elongation ** scaling["params"]["a_ks"] + * inverse_aspect_ratio ** scaling["params"]["a_e"] + * fuel_average_mass_number ** scaling["params"]["a_A"] + * (1.0 + np.mean([triangularity_psi95, separatrix_triangularity])) ** scaling["params"]["a_d"] + * q_star ** scaling["params"]["a_q"] + ) + + if gamma > 0.0: + P_tau = (plasma_stored_energy / gamma) ** (1.0 / (1.0 + scaling["params"]["a_P"])) + else: + P_tau = np.inf + + tau_E = plasma_stored_energy / P_tau + + return float(tau_E), float(P_tau) + + +def load_metadata(dataset: str) -> dict[str, str]: + """Load dataset metadata from YAML file. + + Args: + dataset: name of scaling in ./energy_confinement_time.yaml + + Returns: + Metadata + """ + metadata: dict[str, str] = TAU_E_SCALINGS[dataset]["metadata"] + return metadata + + +def get_datasets() -> list[str]: + """Get a list of names of valid datasets. + + Returns: + List of names of valid datasets + """ + datasets: list[str] = list(TAU_E_SCALINGS.keys()) # Unpack iterator to list + return datasets diff --git a/cfspopcon/formulas/energy_confinement_time_scalings/tau_e_scalings.yaml b/cfspopcon/formulas/energy_confinement_time_scalings/tau_e_scalings.yaml new file mode 100644 index 00000000..5568c1ae --- /dev/null +++ b/cfspopcon/formulas/energy_confinement_time_scalings/tau_e_scalings.yaml @@ -0,0 +1,342 @@ +# Power law scaling parameters + +# References +# [1]: P. N. Yushmanov, T. Takizuka, K. S. Riedel, O. J. W. F. Kardaun, J. G. Cordey, S. M. Kaye, +# and D. E. Post, "Scalings for tokamak energy confinement" Nuclear Fusion, vol. 30, +# no. 10, pp. 4-6, 1990. +# [2]: Verdoolaege, G., Kaye, S. M., Angioni, C., Kardaun, O. J. W. F., Ryter, F., Thomsen, K., +# Maslov, M., & Romanelli, M. (2018). (publication). First Analysis of the Updated ITPA +# Global H-mode Confinement Database. International Atomic Energy Agency. +# [3]: Verdoolaege, G., Kaye, S. M., Angioni, C., Kardaun, O. J. W. F., Ryter, F., Thomsen, K., +# Maslov, M., & Romanelli, M. (2021). (publication). The Updated ITPA Global H-mode +# Confinement Database: Description and Analysis. International Atomic Energy Agency. +# [4]: ITER Physics Expert Group on Confinement and Transport et al 1999 Nucl. Fusion 39 2175 +# "ITER Physics Basis Chapter 2, Plasma confinement and transport" p. 2206 +# [5]: Petty, C.C., Deboo, J.C., La Haye, R.J., Luce, T.C., Politzer, P.A., Wong, C.P-C. (2003), +# Fusion Science and Technology, 43, "Feasibility Study of a Compact Ignition Tokamak Based +# Upon GyroBohm Scaling Physics." +# [6]: J.E. Rice et al 2020 Nucl. Fusion 60 105001, "Understanding LOC/SOC phenomenology in tokamaks" +# [7]: S.M. Kaye et al 1997 Nucl. Fusion 37 1303, "ITER L mode confinement database" + +IModey2: + metadata: + documentation: "Walk, J. R., Pedestal structure and stability in high-performance plasmas on Alcator C-Mod, https://dspace.mit.edu/handle/1721.1/95524, equation 5.2" + notes: "Coefficient C adjusted to account for ne in 1e19m^-3" + regime: "I-Mode" + params: + C: 0.01346 + a_A: 0.0 + a_B: 0.768 + a_I: 0.685 + a_P: -0.286 + a_R: 0.0 + a_d: 0.0 + a_e: 0.0 + a_ka: 0.0 + a_ks: 0.0 + a_n: 0.017 + a_q: 0.0 + +ITER89P: + metadata: + documentation: "From Yushmanov NF 1990, ref. [1] in tau_e_scalings.yaml" + notes: "For L-mode. C is corrected for average_electron_density convention. N.b. The different factor of a_R is because we use inverse_aspect_ratio=a/R instead of a. R^1.2 a^0.3 = R^1.5 inverse_aspect_ratio^0.3." + regime: "L-Mode" + params: + C: 0.03812775526676551 + a_A: 0.5 + a_B: 0.2 + a_I: 0.85 + a_P: -0.5 + a_R: 1.5 + a_d: 0.0 + a_e: 0.3 + a_ka: 0.0 + a_ks: 0.5 + a_n: 0.1 + a_q: 0.0 + +ITER89P_ka: + metadata: + documentation: "From Yushmanov NF 1990, ref. [1] in tau_e_scalings.yaml" + notes: "For L-mode. C is corrected for average_electron_density convention. Using kappa_A instead of separatrix_elongation, which is likely more accurate for double-nulls. N.b. The different factor of a_R is because we use inverse_aspect_ratio=a/R instead of a. R^1.2 a^0.3 = R^1.5 inverse_aspect_ratio^0.3." + regime: "L-Mode" + params: + C: 0.03812775526676551 + a_A: 0.5 + a_B: 0.2 + a_I: 0.85 + a_P: -0.5 + a_R: 1.5 + a_d: 0.0 + a_e: 0.3 + a_ka: 0.5 + a_ks: 0.0 + a_n: 0.1 + a_q: 0.0 + +ITER97L: + metadata: + documentation: "From Kaye NF 1997, ref. [7] in tau_e_scalings.yaml" + notes: "" + regime: "L-Mode" + params: + C: 0.023 + a_I: 0.96 + a_B: 0.03 + a_R: 1.83 + a_e: -0.06 # inverse_aspect_ratio = (R / minor_radius)^-1 + a_ka: 0.64 + a_n: 0.40 + a_A: 0.20 # M_eff + a_P: -0.73 + a_d: 0.0 + a_ks: 0.0 + a_q: 0.0 + +ITER98y2: + metadata: + documentation: "ITER98y2 scaling , ref. [2] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.0562 + a_A: 0.19 + a_B: 0.15 + a_I: 0.93 + a_P: -0.69 + a_R: 1.97 + a_d: 0.0 + a_e: 0.58 + a_ka: 0.78 + a_ks: 0.0 + a_n: 0.41 + a_q: 0.0 + +ITERL96Pth: + metadata: + documentation: "ITERL96P(th) scaling, ref. [4] in tau_e_scalings.yaml" + notes: "" + regime: "L-Mode" + params: + C: 0.023 + a_A: 0.20 + a_B: 0.03 + a_I: 0.96 + a_P: -0.73 + a_R: 1.83 + a_d: 0.0 + a_e: -0.06 + a_ka: 0.64 + a_ks: 0.0 + a_n: 0.40 + a_q: 0.0 + +ITPA_2018_STD5_GLS: + metadata: + documentation: "ITPA 2018 STD5-GLS (G. Verdoolaege et al, EX_P7- 1), ref. [2] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.042 + a_A: 0.47 + a_B: 0.068 + a_I: 1.2 + a_P: -0.78 + a_R: 1.6 + a_d: 0.0 + a_e: -0.052 + a_ka: 0.88 + a_ks: 0.0 + a_n: 0.21 + a_q: 0.0 + +ITPA_2018_STD5_OLS: + metadata: + documentation: "ITPA 2018 STD5-OLS (G. Verdoolaege et al, EX_P7- 1), ref. [2] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.049 + a_A: 0.25 + a_B: 0.085 + a_I: 1.1 + a_P: -0.71 + a_R: 1.5 + a_d: 0.0 + a_e: -0.043 + a_ka: 0.8 + a_ks: 0.0 + a_n: 0.19 + a_q: 0.0 + +ITPA_2018_STD5_SEL1_GLS: + metadata: + documentation: "ITPA 2018 STD5-SEL1-GLS (G. Verdoolaege et al, EX_P7- 1), ref. [2] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.023 + a_A: 0.33 + a_B: -0.018 + a_I: 1.3 + a_P: -0.79 + a_R: 1.5 + a_d: 0.0 + a_e: -0.38 + a_ka: 1.9 + a_ks: 0.0 + a_n: 0.17 + a_q: 0.0 + +ITPA_2018_STD5_SEL1_OLS: + metadata: + documentation: "ITPA 2018 STD5-SEL1-OLS (G. Verdoolaege et al, EX_P7- 1), ref. [2] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.045 + a_A: 0.24 + a_B: -0.1 + a_I: 1.3 + a_P: -0.71 + a_R: 1.2 + a_d: 0.0 + a_e: -0.32 + a_ka: 1.1 + a_ks: 0.0 + a_n: 0.13 + a_q: 0.0 + +ITPA_2018_STD5_SEL1_WLS: + metadata: + documentation: "ITPA 2018 STD5-SEL1-WLS (G. Verdoolaege et al, EX_P7- 1), ref. [2] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.03 + a_A: 0.094 + a_B: -0.069 + a_I: 1.3 + a_P: -0.64 + a_R: 1.3 + a_d: 0.0 + a_e: -0.46 + a_ka: 1.3 + a_ks: 0.0 + a_n: 0.19 + a_q: 0.0 + +ITPA_2018_STD5_WLS: + metadata: + documentation: "ITPA 2018 STD5-WLS (G. Verdoolaege et al, EX_P7- 1), ref. [2] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.04 + a_A: 0.25 + a_B: 0.11 + a_I: 0.99 + a_P: -0.64 + a_R: 1.7 + a_d: 0.0 + a_e: 0.093 + a_ka: 0.79 + a_ks: 0.0 + a_n: 0.29 + a_q: 0.0 + +ITPA20_IL_HighZ: + metadata: + documentation: "ITER H20, DB5.2.3, High Z walls only, ref. [3] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.189 + a_A: 0.312 + a_B: -0.356 + a_I: 1.485 + a_P: -0.6077 + a_R: 0.671 + a_d: 0.0 + a_e: 0.0 + a_ka: 0.0 + a_ks: 0.0 + a_n: 0.018 + a_q: 0.0 + +ITPA20_IL: + metadata: + documentation: "ITER H20, DB5.2.3, ITER-like discharges, ref. [3] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.067 + a_A: 0.3 + a_B: -0.13 + a_I: 1.29 + a_P: -0.644 + a_R: 1.19 + a_d: 0.56 + a_e: 0.0 + a_ka: 0.67 + a_ks: 0.0 + a_n: 0.15 + a_q: 0.0 + +ITPA20_STD5: + metadata: + documentation: "ITER H20, DB5.2.3, STD5 discharges, ref. [3] in tau_e_scalings.yaml" + notes: "" + regime: "H-Mode" + params: + C: 0.053 + a_A: 0.2 + a_B: 0.22 + a_I: 0.98 + a_P: -0.669 + a_R: 1.71 + a_d: 0.36 + a_e: 0.35 + a_ka: 0.80 + a_ks: 0.0 + a_n: 0.24 + a_q: 0.0 + +LOC: + metadata: + documentation: "Linear Ohmic Confinement, from page 2 of ref. [6] in tau_e_scalings.yaml" + notes: "" + regime: "LOC" + params: + C: 0.0070 + a_n: 1.0 + a_q: 1.0 + a_ka: 0.5 + a_e: 1.0 + a_R: 3.0 + a_B: 0.0 + a_I: 0.0 + a_A: 0.0 + a_P: 0.0 + a_d: 0.0 + a_ks: 0.0 + +H_DS03: + metadata: + documentation: "Electrostatic, GyroBohm-like confinement scaling, eqn 21 from ref. [5] in tau_e_scalings.yaml" + notes: "" + regime: "H-mode" + params: + C: 0.028 + a_I: 0.83 + a_B: 0.07 + a_n: 0.49 + a_P: -0.55 + a_R: 2.11 + a_e: 0.3 # (major_radius/a)^-0.3 = (a/major_radius)^0.3 + a_ks: 0.75 + a_A: 0.14 # a_M — isotope mass scaling + a_ka: 0.0 + a_d: 0.0 + a_q: 0.0 diff --git a/cfspopcon/formulas/figures_of_merit.py b/cfspopcon/formulas/figures_of_merit.py new file mode 100644 index 00000000..d24df3ce --- /dev/null +++ b/cfspopcon/formulas/figures_of_merit.py @@ -0,0 +1,108 @@ +"""OD figures-of-merit to characterize a design point.""" +import numpy as np + +from ..unit_handling import Unitfull, convert_units, ureg, wraps_ufunc + + +def calc_triple_product(peak_fuel_ion_density: Unitfull, peak_ion_temp: Unitfull, energy_confinement_time: Unitfull) -> Unitfull: + """Calculate the fusion triple product. + + Args: + peak_fuel_ion_density: [1e20 m^-3] :term:`glossary link` + peak_ion_temp: [keV] :term:`glossary link` + energy_confinement_time: [s] :term:`glossary link` + + Returns: + fusion_triple_product [10e20 m**-3 keV s] + """ + return peak_fuel_ion_density * peak_ion_temp * energy_confinement_time + + +def calc_rho_star( + fuel_average_mass_number: Unitfull, average_ion_temp: Unitfull, magnetic_field_on_axis: Unitfull, minor_radius: Unitfull +) -> Unitfull: + """Calculate rho* (normalized gyroradius). + + Equation 1a from :cite:`Verdoolaege_2021` + + Args: + fuel_average_mass_number: [amu] :term:`glossary link` + average_ion_temp: [keV] :term:`glossary link` + magnetic_field_on_axis: :term:`glossary link` + minor_radius: [m] :term:`glossary link` + + Returns: + rho_star [~] + """ + return convert_units( + np.sqrt(fuel_average_mass_number * average_ion_temp) / (ureg.e * magnetic_field_on_axis * minor_radius), ureg.dimensionless + ) + + +@wraps_ufunc(input_units=dict(ne=ureg.m**-3, Te=ureg.eV), return_units=dict(Lambda_c=ureg.dimensionless)) +def calc_coulomb_logarithm(ne: float, Te: float) -> float: + """Calculate the Coulomb logarithm, for electron-electron or electron-ion collisions. + + From text on page 6 of :cite:`Verdoolaege_2021` + """ + return float(30.9 - np.log(ne**0.5 * Te**-1.0)) + + +def calc_normalised_collisionality( + average_electron_density: Unitfull, + average_electron_temp: Unitfull, + average_ion_temp: Unitfull, + q_star: Unitfull, + major_radius: Unitfull, + inverse_aspect_ratio: Unitfull, + z_effective: Unitfull, +) -> Unitfull: + """Calculate normalized collisionality. + + Equation 1c from :cite:`Verdoolaege_2021` + + Extra factor of ureg.e**2, presumably related to Te**-2 for Te in eV + + Args: + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + average_ion_temp: [keV] :term:`glossary link` + q_star: [~] :term:`glossary link` + major_radius: [m] :term:`glossary link` + inverse_aspect_ratio: [m] :term:`glossary link` + z_effective: [~] :term:`glossary link` + + Returns: + nu_star [~] + """ + return convert_units( + ureg.e**4 + / (2.0 * np.pi * 3**1.5 * ureg.epsilon_0**2) + * calc_coulomb_logarithm(average_electron_density, average_electron_temp) + * average_electron_density + * q_star + * major_radius + * z_effective + / (average_ion_temp**2 * inverse_aspect_ratio**1.5), + ureg.dimensionless, + ) + + +def calc_peak_pressure( + peak_electron_temp: Unitfull, + peak_ion_temp: Unitfull, + peak_electron_density: Unitfull, + peak_fuel_ion_density: Unitfull, +) -> Unitfull: + """Calculate the peak pressure (needed for solving for the magnetic equilibrium). + + Args: + peak_electron_temp: [keV] :term:`glossary link` + peak_ion_temp: [keV] :term:`glossary link` + peak_electron_density: [1e19 m^-3] :term:`glossary link` + peak_fuel_ion_density: [~] :term:`glossary link` + + Returns: + peak_pressure [Pa] + """ + return convert_units(peak_electron_temp * peak_electron_density + peak_ion_temp * peak_fuel_ion_density, ureg.Pa) diff --git a/cfspopcon/formulas/fusion_rates.py b/cfspopcon/formulas/fusion_rates.py new file mode 100644 index 00000000..e9d2e0b8 --- /dev/null +++ b/cfspopcon/formulas/fusion_rates.py @@ -0,0 +1,241 @@ +"""Calculate fusion power and corresponding neutron wall loading.""" + +from typing import Union + +from numpy import float64 +from numpy.typing import NDArray + +from ..named_options import ReactionType +from ..unit_handling import ureg, wraps_ufunc +from .fusion_reaction_data import ENERGY, SIGMAV +from .helpers import integrate_profile_over_volume + + +@wraps_ufunc( + return_units=dict(P_fusion=ureg.MW, P_neutron=ureg.MW, P_alpha=ureg.MW), + input_units=dict( + fusion_reaction=None, + ion_temp_profile=ureg.keV, + heavier_fuel_species_fraction=ureg.dimensionless, + nfuel19=ureg.n19, + rho=ureg.dimensionless, + plasma_volume=ureg.m**3, + ), + input_core_dims=[(), ("dim_rho",), (), ("dim_rho",), ("dim_rho",), ()], + output_core_dims=[(), (), ()], +) +def calc_fusion_power( + fusion_reaction: ReactionType, + ion_temp_profile: NDArray[float64], + heavier_fuel_species_fraction: float, + nfuel19: NDArray[float64], + rho: NDArray[float64], + plasma_volume: float, +) -> tuple[float, float, float]: + """Calculate the fusion power. + + Args: + fusion_reaction: which nuclear reaction is being considered + ion_temp_profile: [keV] :term:`glossary link` + heavier_fuel_species_fraction: [~] fraction of fuel mixture which is the heavier nuclide + nfuel19: [1e19 m^-3] average fuel density + rho: [~] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + + Returns: + :term:`P_fusion` [MW], :term:`P_neutron` [MW], :term:`P_alpha` [MW] + """ + reaction_at_Ti = _calc_fusion_reaction_rate(fusion_reaction, ion_temp_profile, heavier_fuel_species_fraction) + + power_density_factor_MW_m3 = reaction_at_Ti[4] + neutral_power_density_factor_MW_m3 = reaction_at_Ti[5] + charged_power_density_factor_MW_m3 = reaction_at_Ti[6] + + total_fusion_power_MW = _integrate_power( + power_density_factor_MW_m3=power_density_factor_MW_m3, + fuel_density_per_m3=nfuel19 * 1e19, + rho=rho, + plasma_volume=plasma_volume, + ) + + fusion_power_to_neutral_MW = _integrate_power( + power_density_factor_MW_m3=neutral_power_density_factor_MW_m3, + fuel_density_per_m3=nfuel19 * 1e19, + rho=rho, + plasma_volume=plasma_volume, + ) + + fusion_power_to_charged_MW = _integrate_power( + power_density_factor_MW_m3=charged_power_density_factor_MW_m3, + fuel_density_per_m3=nfuel19 * 1e19, + rho=rho, + plasma_volume=plasma_volume, + ) + + return total_fusion_power_MW, fusion_power_to_neutral_MW, fusion_power_to_charged_MW + + +@wraps_ufunc( + return_units=dict(neutron_power_flux_to_walls=ureg.MW / ureg.m**2, neutron_rate=ureg.s**-1), + input_units=dict( + P_neutron=ureg.MW, + surface_area=ureg.m**2, + fusion_reaction=None, + ion_temp_profile=ureg.keV, + heavier_fuel_species_fraction=ureg.dimensionless, + ), + input_core_dims=[(), (), (), ("dim_rho",), ()], + output_core_dims=[(), ()], +) +def calc_neutron_flux_to_walls( + P_neutron: float, + surface_area: float, + fusion_reaction: ReactionType, + ion_temp_profile: NDArray[float64], + heavier_fuel_species_fraction: float, +) -> tuple[float, float]: + """Calculate the neutron loading on the wall. + + Args: + P_neutron: [MW] :term:`glossary link` + surface_area: [m^2] :term:`glossary link` + fusion_reaction: which nuclear reaction is being considered + ion_temp_profile: [keV] :term:`glossary link` + heavier_fuel_species_fraction: fraction of fuel mixture which is the heavier nuclide + + Returns: + neutron_power_flux_to_walls [MW / m^2], neutron_rate [s^-1] + """ + neutron_power_flux_to_walls = P_neutron / surface_area + rxn_energy_neut = _calc_fusion_reaction_rate(fusion_reaction, ion_temp_profile, heavier_fuel_species_fraction)[2] + if rxn_energy_neut > 0: # This will happen for D-He3 reactions + neutron_rate = P_neutron / rxn_energy_neut # [MW / MJ] -> [1 / s] + else: + neutron_rate = 0.0 + + return neutron_power_flux_to_walls, neutron_rate + + +@wraps_ufunc( + return_units=dict( + sigmav=ureg.cm**3 / ureg.s, + rxn_energy=ureg.MJ, + rxn_energy_neut=ureg.MJ, + rxn_energy_charged=ureg.MJ, + number_power_dens=ureg.MW * ureg.m**3, + number_power_dens_neut=ureg.MW * ureg.m**3, + number_power_dens_charged=ureg.MW * ureg.m**3, + ), + input_units=dict( + fusion_reaction=None, + ion_temp_profile=ureg.keV, + heavier_fuel_species_fraction=ureg.dimensionless, + ), + input_core_dims=[(), ("dim_rho",), ()], + output_core_dims=[("dim_rho",), (), (), (), ("dim_rho",), ("dim_rho",), ("dim_rho",)], +) +def calc_fusion_reaction_rate( + fusion_reaction: ReactionType, ion_temp_profile: NDArray[float64], heavier_fuel_species_fraction: float +) -> tuple[ + NDArray[float64], + Union[NDArray[float64], float], + float, + Union[NDArray[float64], float], + NDArray[float64], + NDArray[float64], + NDArray[float64], +]: + """Calculate reaction properties based on reaction type, mixture ratio, and temperature. + + Args: + fusion_reaction: which nuclear reaction is being considered + ion_temp_profile: [keV] :term:`glossary link` + heavier_fuel_species_fraction: fraction of fuel mixture which is the heavier nuclide + + Returns: + :A tuple holding: + + :sigmav: rate coefficient for the given ion temperature [cm^3/s] + :rxn_energy: total energy released per reaction [MJ] + :rxn_energy_neut: energy released to neutral products per reaction [MJ] + :rxn_energy_charged: energy released to charged products per reaction [MJ] + :number_power_dens: power per unit volume divided by reactant densities [MW*m^3] + :number_power_dens_neut: power per unit volume divided by reactant densities deposited in neutral products [MW*m^3] + :number_power_dens_charged: power per unit volume divided by reactant densities deposited in charged products [MW*m^3] + """ + return _calc_fusion_reaction_rate(fusion_reaction, ion_temp_profile, heavier_fuel_species_fraction) + + +def _calc_fusion_reaction_rate( + fusion_reaction: ReactionType, ion_temp_profile: NDArray[float64], heavier_fuel_species_fraction: float +) -> tuple[ + NDArray[float64], + Union[NDArray[float64], float], + float, + Union[NDArray[float64], float], + NDArray[float64], + NDArray[float64], + NDArray[float64], +]: + """Calculate reaction properties based on reaction type, mixture ratio, and temperature, without unit-handling. + + Args: + fusion_reaction: which nuclear reaction is being considered + ion_temp_profile: [keV] :term:`glossary link` + heavier_fuel_species_fraction: fraction of fuel mixture which is the heavier nuclide + + Returns: + :A tuple holding: + + :sigmav: rate coefficient for the given ion temperature [cm^3/s] + :rxn_energy: total energy released per reaction [MJ] + :rxn_energy_neut: energy released to neutral products per reaction [MJ] + :rxn_energy_charged: energy released to charged products per reaction [MJ] + :number_power_dens: power per unit volume divided by reactant densities [MW*m^3] + :number_power_dens_neut: power per unit volume divided by reactant densities deposited in neutral products [MW*m^3] + :number_power_dens_charged: power per unit volume divided by reactant densities deposited in charged products [MW*m^3] + """ + sigmav_func = SIGMAV[fusion_reaction] # Reaction rate function to use based on reaction type + energy_func = ENERGY[fusion_reaction] # Reaction energy function to use based on reaction type + + sigmav = sigmav_func(ion_temp_profile) + + # This generates a false positive when type checking, as the type checker doesn't + # realize that the sigmav_func and energy_func pair always correctly matches. + # That's because the return type of a dictionary can't be narrowed based on a runtime key. + (rxn_energy, rxn_energy_neut, rxn_energy_charged, number_power_dens, number_power_dens_neut, number_power_dens_charged,) = energy_func( + sigmav=sigmav, heavier_fuel_species_fraction=heavier_fuel_species_fraction # type:ignore[call-arg] + ) + + return ( + sigmav, + rxn_energy, + rxn_energy_neut, + rxn_energy_charged, + number_power_dens, + number_power_dens_neut, + number_power_dens_charged, + ) # type:ignore[return-value] + + +def _integrate_power( + power_density_factor_MW_m3: NDArray[float64], + fuel_density_per_m3: NDArray[float64], + rho: NDArray[float64], + plasma_volume: float, +) -> float: + """Calculate the total power due to a nuclear reaction. + + Args: + power_density_factor_MW_m3: energy per unit volume divided by fuel species densities [MW*m^3] + fuel_density_per_m3: density of fuel species [m^-3] + rho: [~] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + + Returns: + power [MW] + """ + power_density_MW_per_m3 = power_density_factor_MW_m3 * fuel_density_per_m3 * fuel_density_per_m3 + power_MW = integrate_profile_over_volume(power_density_MW_per_m3, rho, plasma_volume) + + return power_MW diff --git a/cfspopcon/formulas/fusion_reaction_data/__init__.py b/cfspopcon/formulas/fusion_reaction_data/__init__.py new file mode 100644 index 00000000..7430f8b7 --- /dev/null +++ b/cfspopcon/formulas/fusion_reaction_data/__init__.py @@ -0,0 +1,53 @@ +"""Reactions rates and power densities for various fusion reactions.""" +from typing import Callable, Union + +from numpy import float64 +from numpy.typing import NDArray + +from ...named_options import ReactionType +from .reaction_energies import reaction_energy_DD, reaction_energy_DHe3, reaction_energy_DT, reaction_energy_pB11 +from .reaction_rate_coefficients import sigmav_DD, sigmav_DD_BoschHale, sigmav_DHe3, sigmav_DT, sigmav_DT_BoschHale, sigmav_pB11 + +SIGMAV: dict[ + ReactionType, + Union[ + Callable[[NDArray[float64]], NDArray[float64]], + Callable[[NDArray[float64]], tuple[NDArray[float64], NDArray[float64], NDArray[float64]]], + ], +] = { + ReactionType.DT: sigmav_DT, + ReactionType.DD: sigmav_DD_BoschHale, + ReactionType.DHe3: sigmav_DHe3, + ReactionType.pB11: sigmav_pB11, +} + +ENERGY: dict[ + ReactionType, + Union[ + Callable[[NDArray[float64], float], tuple[float, float, float, NDArray[float64], NDArray[float64], NDArray[float64]]], + Callable[ + [tuple[NDArray[float64], NDArray[float64], NDArray[float64]]], + tuple[NDArray[float64], float, NDArray[float64], NDArray[float64], NDArray[float64], NDArray[float64]], + ], + ], +] = { + ReactionType.DT: reaction_energy_DT, + ReactionType.DD: reaction_energy_DD, + ReactionType.DHe3: reaction_energy_DHe3, + ReactionType.pB11: reaction_energy_pB11, +} + +__all__ = [ + "SIGMAV", + "ENERGY", + "reaction_energy_DD", + "reaction_energy_DHe3", + "reaction_energy_DT", + "reaction_energy_pB11", + "sigmav_DD_BoschHale", + "sigmav_DHe3", + "sigmav_DT", + "sigmav_pB11", + "sigmav_DD", + "sigmav_DT_BoschHale", +] diff --git a/cfspopcon/formulas/fusion_reaction_data/reaction_energies.py b/cfspopcon/formulas/fusion_reaction_data/reaction_energies.py new file mode 100644 index 00000000..bb8218f3 --- /dev/null +++ b/cfspopcon/formulas/fusion_reaction_data/reaction_energies.py @@ -0,0 +1,140 @@ +"""Reaction energies and power densities.""" + +from typing import Any + +from numpy import float64 +from numpy.typing import NDArray +from scipy import constants # type: ignore[import] + + +def reaction_energy_DT( + sigmav: NDArray[float64], heavier_fuel_species_fraction: float +) -> tuple[float, float, float, NDArray[float64], NDArray[float64], NDArray[float64]]: + r"""Deuterium-Tritium reaction. + + Calculate reaction energies and power density values. + + Args: + sigmav: :math:`\langle \sigma v \rangle` product in cm^3/s. + heavier_fuel_species_fraction: n_Tritium / (n_Tritium + n_Deuterium) number fraction. + + Returns: + Tuple of reaction energies and corresponding power densities. + """ + rxn_energy: float = 17.6 * constants.value("electron volt") # [MJ] + rxn_energy_neut: float = rxn_energy * (4.0 / 5.0) # [MJ] + rxn_energy_charged: float = rxn_energy * (1.0 / 5.0) # [MJ] + convert_volume: float = 1e-6 # [m^3/cm^3] + number_power_dens: NDArray[float64] = ( + sigmav * rxn_energy * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + number_power_dens_neut: NDArray[float64] = ( + sigmav * rxn_energy_neut * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + number_power_dens_charged: NDArray[float64] = ( + sigmav * rxn_energy_charged * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + + # Units: [MJ], [MW*m^3] + return rxn_energy, rxn_energy_neut, rxn_energy_charged, number_power_dens, number_power_dens_neut, number_power_dens_charged + + +def reaction_energy_DD( + sigmav: tuple[ + NDArray[float64], + NDArray[float64], + NDArray[float64], + ], + **_: Any, +) -> tuple[NDArray[float64], float, NDArray[float64], NDArray[float64], NDArray[float64], NDArray[float64]]: + r"""Deuterium-Deuterium reaction. + + Calculate reaction energies and power density values. + + Args: + sigmav: :math:`\langle \sigma v \rangle` product in cm^3/s. + _: Unused placeholder to enable unified call syntax with e.g. :func:`reaction_energy_DT`. + + Returns: + Tuple of reaction energies and corresponding power densities. + """ + sigmav_tot, sigmav_1, sigmav_2 = sigmav + path_1_energy: float = (1.01 + 3.02) * constants.value("electron volt") # MJ, D+D -> p+T + path_2_energy: float = (0.82 + 2.45) * constants.value("electron volt") # MJ, D+D -> n+He3 + rxn_energy: NDArray[float64] = (path_1_energy * sigmav_1 + path_2_energy * sigmav_2) / sigmav_tot + rxn_energy_neut: float = path_2_energy * (3.0 / 4.0) + rxn_energy_charged: NDArray[float64] = (path_1_energy * sigmav_1 + (path_2_energy * (1.0 / 4.0)) * sigmav_2) / sigmav_tot + + # So number_power_dens*electron_density_profile**2 = power_dens [MW/m^3] no need to divide since nD=ne + convert_volume = 1e-6 # m^3/cm^3 + number_power_dens: NDArray[float64] = (sigmav_1 * path_1_energy + sigmav_2 * path_2_energy) * convert_volume + number_power_dens_neut: NDArray[float64] = sigmav_2 * rxn_energy_neut * convert_volume + number_power_dens_charged: NDArray[float64] = (sigmav_1 * path_1_energy + sigmav_2 * path_2_energy * (1.0 / 4.0)) * convert_volume + + # Units: [MJ], [MW/m^3] + return rxn_energy, rxn_energy_neut, rxn_energy_charged, number_power_dens, number_power_dens_neut, number_power_dens_charged + + +def reaction_energy_DHe3( + sigmav: NDArray[float64], heavier_fuel_species_fraction: float +) -> tuple[float, float, float, NDArray[float64], NDArray[float64], NDArray[float64]]: + r"""Deuterium-Helium 3 reaction. + + Calculate reaction energies and power density values. + + Args: + sigmav: :math:`\langle \sigma v \rangle` product in cm^3/s. + heavier_fuel_species_fraction: n_heavier / (n_heavier + n_lighter) number fraction. + + Returns: + Tuple of reaction energies and corresponding power densities. + """ + rxn_energy: float = 18.3 * constants.value("electron volt") # MJoules + rxn_energy_neut: float = 0.0 + rxn_energy_charged: float = rxn_energy + convert_volume: float = 1e-6 # m^3/cm^3 + number_power_dens: NDArray[float64] = ( + sigmav * rxn_energy * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + number_power_dens_neut: NDArray[float64] = ( + sigmav * rxn_energy_neut * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + number_power_dens_charged: NDArray[float64] = ( + sigmav * rxn_energy_charged * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + + # Units: [MJ], [MW/m^3] + return rxn_energy, rxn_energy_neut, rxn_energy_charged, number_power_dens, number_power_dens_neut, number_power_dens_charged + + +def reaction_energy_pB11( + sigmav: NDArray[float64], heavier_fuel_species_fraction: float +) -> tuple[float, float, float, NDArray[float64], NDArray[float64], NDArray[float64]]: + r"""Proton (hydrogen)-Boron-11 reaction. + + Calculate reaction energies and power density values. + + Args: + sigmav: :math:`\langle \sigma v \rangle` product in cm^3/s. + heavier_fuel_species_fraction: n_heavier / (n_heavier + n_lighter) number fraction. + + Returns: + Tuple of reaction energies and corresponding power densities. + """ + rxn_energy: float = 8.7 * constants.value("electron volt") # MJoules + rxn_energy_neut: float = 0.0 + rxn_energy_charged: float = rxn_energy + # This is accurate to within 1% + convert_volume: float = 1e-6 # m^3/cm^3 + number_power_dens: NDArray[float64] = ( + sigmav * rxn_energy * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + number_power_dens_neut: NDArray[float64] = ( + sigmav * rxn_energy_neut * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + number_power_dens_charged: NDArray[float64] = ( + sigmav * rxn_energy_charged * convert_volume * heavier_fuel_species_fraction * (1.0 - heavier_fuel_species_fraction) + ) + + # Units: [MJ], [MW/m^3] + return rxn_energy, rxn_energy_neut, rxn_energy_charged, number_power_dens, number_power_dens_neut, number_power_dens_charged diff --git a/cfspopcon/formulas/fusion_reaction_data/reaction_rate_coefficients.py b/cfspopcon/formulas/fusion_reaction_data/reaction_rate_coefficients.py new file mode 100644 index 00000000..de09f4b6 --- /dev/null +++ b/cfspopcon/formulas/fusion_reaction_data/reaction_rate_coefficients.py @@ -0,0 +1,298 @@ +"""Reaction rates () as a function of ion temperature.""" + +import numpy as np +from numpy import float64 +from numpy.typing import NDArray + + +def sigmav_DT(ion_temp_profile: NDArray[float64]) -> NDArray[float64]: + r"""Deuterium-Tritium reaction. + + Calculate :math:`\langle \sigma v \rangle` for a given characteristic ion energy. + Formulation from table 1, column S5 in :cite:`hively_convenient_1977`. + Curvefit was performed for the range of [1,80]keV. + + Args: + ion_temp_profile: ion temperature profile [keV] + + Returns: + :math:`\langle \sigma v \rangle` in cm^3/s. + """ + A = [-21.377692, -25.204054, -7.1013427 * 1e-2, 1.9375451 * 1e-4, 4.9246592 * 1e-6, -3.9836572 * 1e-8] + r = 0.2935 + sigmav = np.exp( + A[0] / ion_temp_profile**r + + A[1] + + A[2] * ion_temp_profile + + A[3] * ion_temp_profile**2.0 + + A[4] * ion_temp_profile**3.0 + + A[5] * ion_temp_profile**4.0 + ) + return sigmav # type: ignore[no-any-return] # [cm^3/s] + + +def sigmav_DT_BoschHale(ion_temp_profile: NDArray[float64]) -> NDArray[float64]: + r"""Deuterium-Tritium reaction. + + Calculate :math:`\langle \sigma v \rangle` product for a given characteristic ion energy using Bosch Hale method. + + :func:`sigmav_DT_BoschHale` is more accurate than :func:`sigmav_DT` for ion_temp_profile > ~48.45 keV (estimate based on + linear interp between errors found at available datapoints). + Maximum error = 1.4% within range 50-1000 keV from available NRL data. + + Formulation from :cite:`bosch_improved_1992` + + Args: + ion_temp_profile: ion temperature profile [keV] + + Returns: + :math:`\langle \sigma v \rangle` in cm^3/s. + + """ + # Bosch Hale coefficients for DT reaction + C = [0.0, 1.173e-9, 1.514e-2, 7.519e-2, 4.606e-3, 1.35e-2, -1.068e-4, 1.366e-5] + B_G = 34.3827 + mr_c2 = 1124656 + + theta = ion_temp_profile / ( + 1 + - (ion_temp_profile * (C[2] + ion_temp_profile * (C[4] + ion_temp_profile * C[6]))) + / (1 + ion_temp_profile * (C[3] + ion_temp_profile * (C[5] + ion_temp_profile * C[7]))) + ) + eta = (B_G**2 / (4 * theta)) ** (1 / 3) + sigmav = C[1] * theta * np.sqrt(eta / (mr_c2 * ion_temp_profile**3)) * np.exp(-3 * eta) + return sigmav # type: ignore[no-any-return] # [cm^3/s] + + +def sigmav_DD(ion_temp_profile: NDArray[float64]) -> tuple[NDArray[float64], NDArray[float64], NDArray[float64]]: + r"""Deuterium-Deuterium reaction. + + Calculate :math:`\langle \sigma v \rangle` for a given characteristic ion energy. + Formulation from column S5, in table 3 and 4 in :cite:`hively_convenient_1977`. + Curvefit was performed for the range of [1,80]keV. + + Args: + ion_temp_profile: ion temperature profile [keV] + + Returns: + :math:`\langle \sigma v \rangle` tuple (total, D(d,p)T, D(d,n)3He) in cm^3/s. + """ + a_1 = [ + -15.511891, + -35.318711, + -1.2904737 * 1e-2, + 2.6797766 * 1e-4, + -2.9198685 * 1e-6, + 1.2748415 * 1e-8, + ] # For D(d,p)T + r_1 = 0.3735 + a_2 = [ + -15.993842, + -35.017640, + -1.3689787 * 1e-2, + 2.7089621 * 1e-4, + -2.9441547 * 1e-6, + 1.2841202 * 1e-8, + ] # For D(d,n)3He + r_2 = 0.3725 + # Ti in units of keV, sigmav in units of cm^3/s + sigmav_1: NDArray[float64] = np.exp( + a_1[0] / ion_temp_profile**r_1 + + a_1[1] + + a_1[2] * ion_temp_profile + + a_1[3] * ion_temp_profile**2.0 + + a_1[4] * ion_temp_profile**3.0 + + a_1[5] * ion_temp_profile**4.0 + ) + sigmav_2: NDArray[float64] = np.exp( + a_2[0] / ion_temp_profile**r_2 + + a_2[1] + + a_2[2] * ion_temp_profile + + a_2[3] * ion_temp_profile**2.0 + + a_2[4] * ion_temp_profile**3.0 + + a_2[5] * ion_temp_profile**4.0 + ) + sigmav_tot: NDArray[float64] = sigmav_1 + sigmav_2 + return sigmav_tot, sigmav_1, sigmav_2 # [cm^3/s] + + +def sigmav_DD_BoschHale(ion_temp_profile: NDArray[float64]) -> tuple[NDArray[float64], NDArray[float64], NDArray[float64]]: + r"""Deuterium-Deuterium reaction. + + Calculate :math:`\langle \sigma v \rangle` product for a given characteristic ion energy using Bosch Hale method. + + Function tested on available data at [1, 2, 5, 10, 20, 50, 100] keV. + Maximum error = 3.8% within range 5-50 keV and increases significantly outside of [5, 50] keV. + + Uses DD cross section formulation from :cite:`bosch_improved_1992`. + + Other form in :cite:`langenbrunner_analytic_2017`. + + Args: + ion_temp_profile: ion temperature profile [keV] + + Returns: + :math:`\langle \sigma v \rangle` tuple (total, D(d,p)T, D(d,n)3He) in cm^3/s. + """ + # For D(d,n)3He + cBH_1 = [((31.3970**2) / 4.0) ** (1.0 / 3.0), 5.65718e-12, 3.41e-03, 1.99e-03, 0, 1.05e-05, 0, 0] # 3.72e-16, + + mc2_1 = 937814.0 + + # For D(d,p)T + cBH_2 = [((31.3970**2) / 4.0) ** (1.0 / 3.0), 5.43360e-12, 5.86e-03, 7.68e-03, 0, -2.96e-06, 0, 0] # 3.57e-16, + + mc2_2 = 937814.0 + + thetaBH_1 = ion_temp_profile / ( + 1 + - ( + (cBH_1[2] * ion_temp_profile + cBH_1[4] * ion_temp_profile**2 + cBH_1[6] * ion_temp_profile**3) + / (1 + cBH_1[3] * ion_temp_profile + cBH_1[5] * ion_temp_profile**2 + cBH_1[7] * ion_temp_profile**3) + ) + ) + + thetaBH_2 = ion_temp_profile / ( + 1 + - ( + (cBH_2[2] * ion_temp_profile + cBH_2[4] * ion_temp_profile**2 + cBH_2[6] * ion_temp_profile**3) + / (1 + cBH_2[3] * ion_temp_profile + cBH_2[5] * ion_temp_profile**2 + cBH_2[7] * ion_temp_profile**3) + ) + ) + + etaBH_1: float = cBH_1[0] / (thetaBH_1 ** (1.0 / 3.0)) + etaBH_2: float = cBH_2[0] / (thetaBH_2 ** (1.0 / 3.0)) + + sigmav_1: NDArray[float64] = cBH_1[1] * thetaBH_1 * np.sqrt(etaBH_1 / (mc2_1 * (ion_temp_profile**3.0))) * np.exp(-3.0 * etaBH_1) + sigmav_2: NDArray[float64] = cBH_2[1] * thetaBH_2 * np.sqrt(etaBH_2 / (mc2_2 * (ion_temp_profile**3.0))) * np.exp(-3.0 * etaBH_2) + sigmav_tot: NDArray[float64] = sigmav_1 + sigmav_2 + + return sigmav_tot, sigmav_1, sigmav_2 # [cm^3/s] + + +def sigmav_DHe3(ion_temp_profile: NDArray[float64]) -> NDArray[float64]: + r"""Deuterium-Helium-3 reaction. + + Calculate :math:`\langle \sigma v \rangle` for a given characteristic ion energy. + + Function tested on available data at [1, 2, 5, 10, 20, 50, 100] keV. + Maximum error = 8.4% within range 2-100 keV and should not be used outside range [2, 100] keV. + + Uses DD cross section formulation :cite:`bosch_improved_1992`. + + Args: + ion_temp_profile: ion temperature profile [keV] + + Returns: + :math:`\langle \sigma v \rangle` in cm^3/s. + """ + # For He3(d,p)4He + cBH_1 = [ + ((68.7508**2) / 4.0) ** (1.0 / 3.0), + 5.51036e-10, # 3.72e-16, + 6.41918e-03, + -2.02896e-03, + -1.91080e-05, + 1.35776e-04, + 0, + 0, + ] + + mc2_1 = 1124572.0 + + thetaBH_1 = ion_temp_profile / ( + 1 + - ( + (cBH_1[2] * ion_temp_profile + cBH_1[4] * ion_temp_profile**2 + cBH_1[6] * ion_temp_profile**3) + / (1 + cBH_1[3] * ion_temp_profile + cBH_1[5] * ion_temp_profile**2 + cBH_1[7] * ion_temp_profile**3.0) + ) + ) + + etaBH_1: float = cBH_1[0] / (thetaBH_1 ** (1.0 / 3.0)) + + sigmav: NDArray[float64] = cBH_1[1] * thetaBH_1 * np.sqrt(etaBH_1 / (mc2_1 * (ion_temp_profile**3.0))) * np.exp(-3.0 * etaBH_1) + + return sigmav # [cm^3/s] + + +def sigmav_pB11(ion_temp_profile: NDArray[float64]) -> NDArray[float64]: + r"""Proton (hydrogen)-Boron11 reaction. + + Calculate :math:`\langle \sigma v \rangle` for a given characteristic ion energy. + + Uses cross section from Nevins and Swain :cite:`nevins_thermonuclear_2000`. + Updated cross sections in :cite:`sikora_new_2016`, and :cite:`putvinski_fusion_2019` are not in analytic form. + + Args: + ion_temp_profile: characteristic ion energy in keV. + + Returns: + :math:`\langle \sigma v \rangle` in cm^3/s. + """ + # High temperature (T>60 keV) + # For B11(p,alpha)alpha,alpha + cBH_1 = [ + ((22589.0) / 4.0) ** (1.0 / 3.0), + 4.4467e-14, + -5.9357e-02, + 2.0165e-01, + 1.0404e-03, + 2.7621e-03, + -9.1653e-06, + 9.8305e-07, + ] + + mc2_1 = 859526.0 + + thetaBH_1 = ion_temp_profile / ( + 1 + - ( + (cBH_1[2] * ion_temp_profile + cBH_1[4] * ion_temp_profile**2 + cBH_1[6] * ion_temp_profile**3) + / (1 + cBH_1[3] * ion_temp_profile + cBH_1[5] * ion_temp_profile**2 + cBH_1[7] * ion_temp_profile**3) + ) + ) + + etaBH_1 = cBH_1[0] / (thetaBH_1 ** (1.0 / 3.0)) + + sigmavNRhigh = ( + cBH_1[1] * thetaBH_1 * np.sqrt(etaBH_1 / (mc2_1 * (ion_temp_profile**3.0))) * np.exp(-3.0 * etaBH_1) + ) * 1e6 # m3 to cm3 + + # Low temperature (T<60 keV) + E0 = ((17.81) ** (1.0 / 3.0)) * (ion_temp_profile ** (2.0 / 3.0)) + + deltaE0 = 4.0 * np.sqrt(ion_temp_profile * E0 / 3.0) + + tau = (3.0 * E0) / ion_temp_profile + + Mp = 1.0 # *1.67e-27 + MB = 11.0 # *1.67e-27 + + Mr = (Mp * MB) / (Mp + MB) + + C0 = 197.000 * 1e-25 # MeVb to kev/m^2 + C1 = 0.240 * 1e-25 # MeVb to kev/m^2 + C2 = 0.000231 * 1e-25 # MeVb to kev/m^2 + + Seff = ( + C0 * (1 + (5.0 / (12.0 * tau))) + + C1 * (E0 + (35.0 / 36.0) * ion_temp_profile) + + C2 * (E0**2.0 + (89.0 / 36.0) * E0 * ion_temp_profile) + ) + + sigmavNRlow: NDArray[float64] = ( + np.sqrt(2 * ion_temp_profile / Mr) * ((deltaE0 * Seff) / (ion_temp_profile ** (2.0))) * np.exp(-tau) + ) * 1e6 # m3 to cm3 + # 148 keV resonance + sigmavR: NDArray[float64] = ( + (5.41e-21) * ((1.0 / ion_temp_profile) ** (3.0 / 2.0)) * np.exp(-148.0 / ion_temp_profile) + ) * 1e6 # m3 to cm3 + sigmav: NDArray[float64] = sigmavNRhigh + + for i in range(len(ion_temp_profile)): + if ion_temp_profile[i] < 60.0: # keV + sigmav[i] = sigmavNRlow[i] + sigmavR[i] + elif (ion_temp_profile[i] > 60.0) and (ion_temp_profile[i] < 130): # keV + sigmav[i] = sigmavNRhigh[i] + sigmavR[i] + + return sigmav # [cm^3/s] diff --git a/cfspopcon/formulas/geometry.py b/cfspopcon/formulas/geometry.py new file mode 100644 index 00000000..f81548f5 --- /dev/null +++ b/cfspopcon/formulas/geometry.py @@ -0,0 +1,41 @@ +"""Plasma geometry (inside the last-closed-flux-surface).""" +import numpy as np + +from ..unit_handling import Unitfull + + +def calc_plasma_volume(major_radius: Unitfull, inverse_aspect_ratio: Unitfull, areal_elongation: Unitfull) -> Unitfull: + """Calculate the plasma volume inside the last-closed-flux-surface. + + Args: + major_radius: [m] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + areal_elongation: [~] :term:`glossary link` + + Returns: + Vp [m^3] + """ + return ( + 2.0 + * np.pi + * major_radius**3.0 + * inverse_aspect_ratio**2.0 + * areal_elongation + * (np.pi - (np.pi - 8.0 / 3.0) * inverse_aspect_ratio) + ) + + +def calc_plasma_surface_area(major_radius: Unitfull, inverse_aspect_ratio: Unitfull, areal_elongation: Unitfull) -> Unitfull: + """Calculate the plasma surface area inside the last-closed-flux-surface. + + Args: + major_radius: [m] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + areal_elongation: [~] :term:`glossary link` + + Returns: + Sp [m^2] + """ + return ( + 2.0 * np.pi * (major_radius**2.0) * inverse_aspect_ratio * areal_elongation * (np.pi + 2.0 - (np.pi - 2.0) * inverse_aspect_ratio) + ) diff --git a/cfspopcon/formulas/helpers.py b/cfspopcon/formulas/helpers.py new file mode 100644 index 00000000..9da05324 --- /dev/null +++ b/cfspopcon/formulas/helpers.py @@ -0,0 +1,23 @@ +"""Common functionality shared between other functions.""" +import numpy as np +from numpy import float64 +from numpy.typing import NDArray + + +def integrate_profile_over_volume( + array_per_m3: NDArray[float64], + rho: NDArray[float64], + plasma_volume: float, +) -> float: + """Approximate the volume integral of a profile given as a function of rho. + + Args: + array_per_m3: a profile of values [units * m^-3] + rho: [~] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + + Returns: + volume_integrated_value [units] + """ + drho = rho[1] - rho[0] + return float(np.sum(array_per_m3 * 2.0 * rho * drho) * plasma_volume) diff --git a/cfspopcon/formulas/impurity_effects.py b/cfspopcon/formulas/impurity_effects.py new file mode 100644 index 00000000..b7efa955 --- /dev/null +++ b/cfspopcon/formulas/impurity_effects.py @@ -0,0 +1,65 @@ +"""Calculate the effect of impurities on the effective charge and dilution.""" +import numpy as np +import xarray as xr + +from ..named_options import Impurity +from ..unit_handling import ureg, wraps_ufunc + + +@wraps_ufunc( + return_units=dict(mean_charge_state=ureg.dimensionless), + input_units=dict( + average_electron_density=ureg.m**-3, + average_electron_temp=ureg.eV, + impurity_species=None, + atomic_data=None, + ), + pass_as_kwargs=("atomic_data",), +) +def calc_impurity_charge_state( + average_electron_density: float, + average_electron_temp: float, + impurity_species: Impurity, + atomic_data: dict[Impurity, xr.DataArray], +) -> float: + """Calculate the impurity charge state of the specified impurity species. + + Args: + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + impurity_species: [] :term:`glossary link` + atomic_data: :term:`glossary link` + + Returns: + :term:`impurity_charge_state` + """ + mean_charge_curve = atomic_data[impurity_species].coronal_mean_Z_interpolator + return float( + np.squeeze(np.power(10, mean_charge_curve(np.log10(average_electron_temp), np.log10(average_electron_density), grid=True))) + ) + + +def calc_change_in_zeff(impurity_charge_state: float, impurity_concentration: xr.DataArray) -> xr.DataArray: + """Calculate the change in the effective charge due to the specified impurities. + + Args: + impurity_charge_state: [~] :term:`glossary link` + impurity_concentration: [~] :term:`glossary link` + + Returns: + change in zeff [~] + """ + return impurity_charge_state * (impurity_charge_state - 1.0) * impurity_concentration + + +def calc_change_in_dilution(impurity_charge_state: float, impurity_concentration: xr.DataArray) -> xr.DataArray: + """Calculate the change in n_fuel/n_e due to the specified impurities. + + Args: + impurity_charge_state: [~] :term:`glossary link` + impurity_concentration: [~] :term:`glossary link` + + Returns: + change in dilution [~] + """ + return impurity_charge_state * impurity_concentration diff --git a/cfspopcon/formulas/operational_limits.py b/cfspopcon/formulas/operational_limits.py new file mode 100644 index 00000000..ad563447 --- /dev/null +++ b/cfspopcon/formulas/operational_limits.py @@ -0,0 +1,61 @@ +"""Operational limits to avoid disruptive regions.""" +import numpy as np + +from ..unit_handling import ureg, wraps_ufunc + + +@wraps_ufunc( + return_units=dict(greenwald_fraction=ureg.dimensionless), + input_units=dict( + average_electron_density=ureg.n20, inverse_aspect_ratio=ureg.dimensionless, major_radius=ureg.m, plasma_current=ureg.MA + ), +) +def calc_greenwald_fraction( + average_electron_density: float, inverse_aspect_ratio: float, major_radius: float, plasma_current: float +) -> float: + """Calculate the fraction of the Greenwald density limit. + + Args: + average_electron_density: [1e20 m^-3] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + major_radius: [m] :term:`glossary link` + plasma_current: [MA] :term:`glossary link` + + Returns: + :term:`greenwald_fraction` [~] + """ + n_Greenwald = calc_greenwald_density_limit.__wrapped__(plasma_current, inverse_aspect_ratio * major_radius) + + return float(average_electron_density / n_Greenwald) + + +@wraps_ufunc(return_units=dict(nG=ureg.n20), input_units=dict(plasma_current=ureg.MA, minor_radius=ureg.m)) +def calc_greenwald_density_limit(plasma_current: float, minor_radius: float) -> float: + """Calculate the Greenwald density limit. + + Args: + plasma_current: [MA] :term:`glossary link` + minor_radius: [m] :term:`glossary link` + + Returns: + nG Greenwald density limit [n20] + """ + return plasma_current / (np.pi * minor_radius**2) + + +@wraps_ufunc( + return_units=dict(troyon_max_beta=ureg.percent), + input_units=dict(minor_radius=ureg.m, magnetic_field_on_axis=ureg.T, plasma_current=ureg.MA), +) +def calc_troyon_limit(minor_radius: float, magnetic_field_on_axis: float, plasma_current: float) -> float: + """Calculate the maximum value for beta, according to the Troyon limit. + + Args: + minor_radius: [m] :term:`glossary link` + magnetic_field_on_axis: [T] :term:`glossary link` + plasma_current: [MA] :term:`glossary link` + + Returns: + troyon_max_beta [~] + """ + return 2.8 * plasma_current / (minor_radius * magnetic_field_on_axis) diff --git a/cfspopcon/formulas/plasma_profile_data/PRF/aLT.csv b/cfspopcon/formulas/plasma_profile_data/PRF/aLT.csv new file mode 100644 index 00000000..22672e3c --- /dev/null +++ b/cfspopcon/formulas/plasma_profile_data/PRF/aLT.csv @@ -0,0 +1,12 @@ +,,width,width,width,width,width,width,width,width,width,width +,,0,0.10555556,0.21111111,0.31666667,0.42222222,0.52777778,0.63333333,0.73888889,0.84444444,0.95 +peaking,1,-0.05069091,-0.05582754,-0.06176364,-0.06864038,-0.07662657,-0.08590871,-0.09666655,-0.1090216,-0.12294055,-0.13807588 +peaking,1.22222222,0.25014517,0.27424909,0.30241125,0.33536809,0.37396822,0.41910617,0.47157803,0.5318111,0.59941914,0.67257332 +peaking,1.44444444,0.51647618,0.56574693,0.62368044,0.69191175,0.772276,0.86662501,0.9764702,1.10238582,1.243156,1.39477072 +peaking,1.66666667,0.75227265,0.82363737,0.90825389,1.0087155,1.12785707,1.26841447,1.43241685,1.6202727,1.82964466,2.05439189 +peaking,1.88888889,0.96150508,1.05289181,1.16234156,1.29350424,1.45027173,1.63624119,1.8538249,2.1030419,2.38025976,2.67731241 +peaking,2.11111111,1.14814398,1.25848166,1.39215342,1.55400289,1.74908029,1.98187183,2.25510124,2.56826356,2.91637592,3.28940788 +peaking,2.33333333,1.31615985,1.44537832,1.60389941,1.79793635,2.03384305,2.31707304,2.65065277,3.03350782,3.45936777,3.91655387 +peaking,2.55555556,1.46952321,1.61855318,1.8037895,2.03302952,2.31412033,2.65361146,3.05488639,3.51634484,4.03060994,4.58462596 +peaking,2.77777778,1.61220457,1.78297764,1.99803364,2.26700733,2.59947242,3.00325374,3.482209,4.03434476,4.65147707,5.31949974 +peaking,3,1.74817444,1.94362311,2.19284179,2.50759466,2.89945963,3.37776654,3.94702751,4.60507774,5.34334378,6.1470508 diff --git a/cfspopcon/formulas/plasma_profile_data/PRF/metadata.yaml b/cfspopcon/formulas/plasma_profile_data/PRF/metadata.yaml new file mode 100644 index 00000000..1cef18a2 --- /dev/null +++ b/cfspopcon/formulas/plasma_profile_data/PRF/metadata.yaml @@ -0,0 +1,2 @@ +notes: "From Pablo Rodriguez-Fernandez, based on outputs from TRANSP." +documentation: "" diff --git a/cfspopcon/formulas/plasma_profile_data/PRF/width.csv b/cfspopcon/formulas/plasma_profile_data/PRF/width.csv new file mode 100644 index 00000000..dead5542 --- /dev/null +++ b/cfspopcon/formulas/plasma_profile_data/PRF/width.csv @@ -0,0 +1,12 @@ +,,aLT,aLT,aLT,aLT,aLT,aLT,aLT,aLT,aLT,aLT +,,1.0,1.33333333,1.66666667,2.0,2.33333333,2.66666667,3.0,3.33333333,3.66666667,4.0 +peaking,1.5,0.55525657,0.78965428,0.94114763,1.04129876,1.10808831,1.15259499,1.18196076,1.20093812,1.2127608,1.21966273 +peaking,1.66666667,0.30947926,0.57192988,0.75135627,0.87761883,0.96722366,1.03104933,1.07655831,1.10896602,1.13196415,1.14819024 +peaking,1.83333333,0.11214453,0.39602688,0.59122468,0.73461171,0.84095725,0.920017,0.9788843,1.02278864,1.05559384,1.08015795 +peaking,2.0,-0.06643852,0.25158105,0.45634084,0.61014671,0.72816489,0.81886394,0.88856167,0.9421717,0.98349881,1.01546521 +peaking,2.16666667,-0.2559608,0.12822814,0.34229274,0.50209313,0.62772236,0.72695611,0.80521335,0.86688094,0.91552797,0.95401137 +peaking,2.33333333,-0.4861132,0.01560391,0.24466838,0.40832025,0.53850546,0.64365945,0.72846229,0.79668207,0.85153022,0.89569578 +peaking,2.5,-0.78658663,-0.09665591,0.15905574,0.3266974,0.45938999,0.56833991,0.65793142,0.73134083,0.7913545,0.8404178 +peaking,2.66666667,-1.18707197,-0.21891553,0.08104281,0.25509385,0.38925174,0.50036343,0.59324367,0.67062294,0.7348497,0.78807679 +peaking,2.83333333,-1.71726012,-0.36153923,0.00621758,0.19137892,0.32696652,0.43909596,0.53402199,0.61429414,0.68186476,0.73857209 +peaking,3.0,-2.406842,-0.53489122,-0.06983196,0.1334219,0.27141011,0.38390344,0.47988931,0.56212015,0.63224858,0.69180306 diff --git a/cfspopcon/formulas/plasma_profile_data/__init__.py b/cfspopcon/formulas/plasma_profile_data/__init__.py new file mode 100644 index 00000000..3f9cfd28 --- /dev/null +++ b/cfspopcon/formulas/plasma_profile_data/__init__.py @@ -0,0 +1 @@ +"""1D plasma profiles based on TRANSP runs.""" diff --git a/cfspopcon/formulas/plasma_profile_data/density_and_temperature_profile_fits.py b/cfspopcon/formulas/plasma_profile_data/density_and_temperature_profile_fits.py new file mode 100644 index 00000000..fb75ba6b --- /dev/null +++ b/cfspopcon/formulas/plasma_profile_data/density_and_temperature_profile_fits.py @@ -0,0 +1,216 @@ +"""Realistic functional forms for T and n for POPCON analysis. + +private communication, P. Rodriguez-Fernandez (MIT PSFC), 2020 + +Description: + This functional form imposes: + 1) tanh pedestal for T and n. + 2) Linear aLT profile from 0 at rho=0 to X at rho=x_a, + where X is the specified core aLT value (default 2.0) + and x_a is calculated by matching specified temperature_peaking (peaking) + 3) Flat aLT profile from rho=x_a to rho=1-width_ped, where + width_ped is the pedestal width (default 0.05). + 4) T and n share the same x_a, and aLn is calculated by matching + specified nu_n (peaking) + 5) Pedestal is rescaled to match specified volume averages for + T and n. + +Notes: + - Not all combinations of aLT and temperature_peaking are valid. If aLT is too low, + temperature_peaking cannot be excessively high and viceversa. The code will not + crash, but will give profiles that do not match the specified + temperature peaking. + e.g. aLT = 2.0 requires temperature_peaking to be within [1.5,3.0] + + - It is not recommended to change width_ped from the default value, + since the Look-Up-Table hard-coded was computed using + width_ped=0.05 + + - If rho-grid is passed as argument, it is recommended to have equally + spaced 100 points. + +Example use: + + T_avol = 7.6 + n_avol = 3.1 + temperature_peaking = 2.5 + nu_n = 1.4 + + x, T, n = evaluate_density_and_temperature_profile_fits( T_avol, n_avol, temperature_peaking, nu_n, aLT = 2.0 ) + + Optionally: + - rho-grid can be passed (100 points recommended) + - Pedestal width can be passed (0.05 recommended) + +____________________________________________________________________ +""" # TODO: figure out valid regions of fits and print a warning when they are exceeded + +import warnings +from functools import cache +from pathlib import Path +from typing import Optional + +import numpy as np +import pandas as pd +import yaml +from numpy.typing import NDArray +from scipy.interpolate import RectBivariateSpline # type: ignore[import] + +plasma_profiles_directory = Path(__file__).parent + + +def load_dataframe(dataset: str, df_name: str) -> pd.DataFrame: + """Load specified dataframe for given dataset.""" + filepath = plasma_profiles_directory / dataset / f"{df_name}.csv" + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + df = pd.read_csv(filepath, index_col=[0, 1], header=[0, 1]) + + return df + + +@cache +def get_df_interpolator(dataset: str, df_name: str) -> RectBivariateSpline: + """Return an interpolator for the given dataframe of the specified dataset.""" + df = load_dataframe(dataset, df_name) + interpolator = RectBivariateSpline( + [np.float64(x[1]) for x in df.columns.values], + [np.float64(x[1]) for x in df.index.values], + df.T.values, + ) + return interpolator + + +def evaluate_density_and_temperature_profile_fits( + T_avol: float, + n_avol: float, + temperature_peaking: float, + nu_n: float, + aLT: float = 2.0, + width_ped: float = 0.05, + rho: Optional[NDArray[np.float64]] = None, + dataset: str = "PRF", +) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]: # TODO: fill out docstring + """Evaluate temperature-density profile fits.""" + # ---- Get interpolator functions corresponding to this dataset + width_interpolator = get_df_interpolator(dataset=dataset, df_name="width") + aLT_interpolator = get_df_interpolator(dataset=dataset, df_name="aLT") + + # ---- Find parameters consistent with peaking + x_a = width_interpolator(aLT, temperature_peaking)[0] + aLn = aLT_interpolator(x_a, nu_n)[0] + + # ---- Evaluate profiles + x, T, _ = evaluate_profile(T_avol, width_ped=width_ped, aLT_core=aLT, width_axis=x_a, rho=rho) + x, n, _ = evaluate_profile(n_avol, width_ped=width_ped, aLT_core=aLn, width_axis=x_a, rho=rho) + + return x, T, n + + +def evaluate_profile( + Tavol: float, + aLT_core: float, + width_axis: float, + width_ped: float = 0.05, + rho: Optional[NDArray[np.float64]] = None, +) -> tuple[NDArray[np.float64], NDArray[np.float64], float]: + r"""This function generates a profile from :math:`\langle T \rangle`, aLT and :math:`x_a`. + + Example: + x, T, temperature_peaking = evaluate_profile(7.6, 2.0, 0.2) + """ + # ~~~~ Grid + if rho is None: + x = np.linspace(0, 1, 100) + else: + x = rho + + ix_c = np.argmin(np.abs(x - (1 - width_ped))) # Extend of core + ix_a = np.min([ix_c, np.argmin(np.abs(x - width_axis))]) # Extend of axis + + # ~~~~ aLT must be different from zero, adding non-rational small offset + aLT_core = aLT_core + np.pi * 1e-8 + + # ~~~~~~~~~~~~~~~~~~~~~~~~~~ + # Functional Forms (normalized to pedestal temperature) + # ~~~~~~~~~~~~~~~~~~~~~~~~~~ + + # ~~~~ Pedestal + # Notes: + # - Because width_ped and Teped in my function represent the top values, I need to rescale them + # - The tanh does not result exactly in the top value (since it's an asymptote), so I need to correct for it + + wped_tanh = width_ped / 1.5 # The pedestal width in the tanh formula is 50% inside the pedestal-top width + Tedge_aux = 1 / 2 * (1 + np.tanh((1 - x - (wped_tanh / 2)) / (wped_tanh / 2))) + Tedge = Tedge_aux[int(ix_c) :] / Tedge_aux[ix_c] + + # ~~~~ Core + Tcore_aux = np.e ** (aLT_core * (1 - width_ped - x)) + Tcore = Tcore_aux[ix_a : int(ix_c)] + + # ~~~~ Axis + Taxis_aux = np.e ** (aLT_core * (-1 / 2 * x**2 / width_axis - 1 / 2 * width_axis + 1 - width_ped)) + Taxis = Taxis_aux[:ix_a] + + # ~~~~~~~~~~~~~~~~~~~~~~~~~~ + # Analytical Integral ("pre-factor") + # ~~~~~~~~~~~~~~~~~~~~~~~~~~ + + # Pedestal contribution (solved with Matematica) + I1 = -0.0277778 * width_ped * (-23.3473 + 14.6132 * width_ped) + + # Core and axis contributions + I23 = ( + 1 + / aLT_core**2 + * ( + (width_axis * aLT_core * np.e ** (width_axis * aLT_core / 2) + 1) * np.e ** (-aLT_core * (width_axis + width_ped - 1)) + + aLT_core * width_ped + - aLT_core + - 1 + ) + ) + + # Total (this is the factor that relates Teped to Tavol) + I = 2 * (I1 + I23) # noqa: E741 + + # ~~~~~~~~~~~~~~~~~~~~~~~~~~ + # Evaluation of the profile + # ~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Teped = Tavol / I + T: NDArray[np.float64] = Teped * np.hstack((Taxis, Tcore, Tedge)).ravel() + if np.isclose(Tavol, 0.0) and np.isclose(T[0], 0.0): + peaking = 0.0 + else: + peaking = float(T[0] / Tavol) + + return x, T, peaking + + +def load_metadata(dataset: str) -> dict[str, str]: + r"""Load dataset metadata from YAML file. + + Args: + dataset: name of subfolder that holds metadata.yaml + + Returns: + metadata + """ + filepath = plasma_profiles_directory / dataset / "metadata.yaml" + with open(filepath) as f: + metadata: dict[str, str] = yaml.safe_load(f) + return metadata + + +def get_datasets() -> list[str]: + """Get a list of names of valid datasets. + + Every immediate subdirectory of the source folder represents a dataset + + Returns: + [str]*N, list of names of valid datasets + """ + datasets = [f.name for f in plasma_profiles_directory.iterdir() if (f.is_dir() and not f.name.startswith("_"))] + + return datasets diff --git a/cfspopcon/formulas/plasma_profiles.py b/cfspopcon/formulas/plasma_profiles.py new file mode 100644 index 00000000..ddb89e8f --- /dev/null +++ b/cfspopcon/formulas/plasma_profiles.py @@ -0,0 +1,186 @@ +"""Estimate 1D plasma profiles of density and temperature.""" + +from typing import Optional + +import numpy as np +from numpy import float64 +from numpy.typing import NDArray + +from ..named_options import ProfileForm +from ..unit_handling import ureg, wraps_ufunc +from .plasma_profile_data.density_and_temperature_profile_fits import evaluate_density_and_temperature_profile_fits + + +@wraps_ufunc( + return_units=dict( + rho=ureg.dimensionless, + electron_density_profile=ureg.n19, + fuel_ion_density_profile=ureg.n19, + electron_temp_profile=ureg.keV, + ion_temp_profile=ureg.keV, + ), + input_units=dict( + profile_form=None, + average_electron_density=ureg.n19, + average_electron_temp=ureg.keV, + average_ion_temp=ureg.keV, + electron_density_peaking=ureg.dimensionless, + ion_density_peaking=ureg.dimensionless, + temperature_peaking=ureg.dimensionless, + dilution=ureg.dimensionless, + normalized_inverse_temp_scale_length=ureg.dimensionless, + npoints=None, + ), + output_core_dims=[("dim_rho",), ("dim_rho",), ("dim_rho",), ("dim_rho",), ("dim_rho",)], +) +def calc_1D_plasma_profiles( + profile_form: ProfileForm, + average_electron_density: float, + average_electron_temp: float, + average_ion_temp: float, + electron_density_peaking: float, + ion_density_peaking: float, + temperature_peaking: float, + dilution: float, + normalized_inverse_temp_scale_length: Optional[float] = None, + npoints: int = 50, +) -> tuple[NDArray[float64], NDArray[float64], NDArray[float64], NDArray[float64], NDArray[float64]]: + """Estimate density and temperature profiles. + + Args: + profile_form: select between analytic fit or profiles from Pablo Rodriguez-Fernandez + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + average_ion_temp: [keV] :term:`glossary link` + electron_density_peaking: [~] :term:`glossary link` + ion_density_peaking: [~] :term:`glossary link` + temperature_peaking: [~] :term:`glossary link` + dilution: dilution of main ions [~] + normalized_inverse_temp_scale_length: [~] :term:`glossary link` + npoints: number of points to return in profile + + Returns: + :term:`rho` [~], :term:`electron_density_profile` [1e19 m^-3], fuel_ion_density_profile [1e19 m^-3], :term:`electron_temp_profile` [keV], :term:`ion_temp_profile` [keV] + + Raises: + ValueError: if profile_form == prf and normalized_inverse_temp_scale_length is not set + """ + if profile_form == ProfileForm.analytic: + rho, electron_density_profile, fuel_ion_density_profile, electron_temp_profile, ion_temp_profile = calc_analytic_profiles( + average_electron_density, + average_electron_temp, + average_ion_temp, + electron_density_peaking, + ion_density_peaking, + temperature_peaking, + dilution, + npoints=npoints, + ) + + elif profile_form == ProfileForm.prf: + if normalized_inverse_temp_scale_length is None: + raise ValueError("normalized_inverse_temp_scale_length must be set if using profile_form = prf") + + rho, electron_density_profile, fuel_ion_density_profile, electron_temp_profile, ion_temp_profile = calc_prf_profiles( + average_electron_density, + average_electron_temp, + average_ion_temp, + electron_density_peaking, + ion_density_peaking, + temperature_peaking, + dilution, + normalized_inverse_temp_scale_length, + npoints=npoints, + ) + + return rho, electron_density_profile, fuel_ion_density_profile, electron_temp_profile, ion_temp_profile + + +def calc_analytic_profiles( + average_electron_density: float, + average_electron_temp: float, + average_ion_temp: float, + electron_density_peaking: float, + ion_density_peaking: float, + temperature_peaking: float, + dilution: float, + npoints: int = 50, +) -> tuple[NDArray[float64], NDArray[float64], NDArray[float64], NDArray[float64], NDArray[float64]]: + """Estimate density and temperature profiles using a simple analytic fit. + + Args: + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + average_ion_temp: [keV] :term:`glossary link` + electron_density_peaking: [~] :term:`glossary link` + ion_density_peaking: [~] :term:`glossary link` + temperature_peaking: [~] :term:`glossary link` + dilution: dilution of main ions [~] + npoints: number of points to return in profile + + Returns: + :term:`rho` [~], :term:`electron_density_profile` [1e19 m^-3], fuel_ion_density_profile [1e19 m^-3], :term:`electron_temp_profile` [keV], :term:`ion_temp_profile` [keV] + """ + rho = np.linspace(0, 1, num=npoints, endpoint=False) + + electron_density_profile = ( + average_electron_density * electron_density_peaking * ((1.0 - rho**2.0) ** (electron_density_peaking - 1.0)) + ) + fuel_ion_density_profile = ( + average_electron_density * dilution * (ion_density_peaking) * ((1.0 - rho**2.0) ** (ion_density_peaking - 1.0)) + ) + electron_temp_profile = average_electron_temp * temperature_peaking * ((1.0 - rho**2.0) ** (temperature_peaking - 1.0)) + ion_temp_profile = average_ion_temp * temperature_peaking * ((1.0 - rho**2.0) ** (temperature_peaking - 1.0)) + + return rho, electron_density_profile, fuel_ion_density_profile, electron_temp_profile, ion_temp_profile + + +def calc_prf_profiles( + average_electron_density: float, + average_electron_temp: float, + average_ion_temp: float, + electron_density_peaking: float, + ion_density_peaking: float, + temperature_peaking: float, + dilution: float, + normalized_inverse_temp_scale_length: float, + npoints: int = 50, +) -> tuple[NDArray[float64], NDArray[float64], NDArray[float64], NDArray[float64], NDArray[float64]]: + """Estimate density and temperature profiles using profiles from Pablo Rodriguez-Fernandez. + + Args: + average_electron_density: [1e19 m^-3] :term:`glossary link` + average_electron_temp: [keV] :term:`glossary link` + average_ion_temp: [keV] :term:`glossary link` + electron_density_peaking: [~] :term:`glossary link` + ion_density_peaking: [~] :term:`glossary link` + temperature_peaking: [~] :term:`glossary link` + dilution: dilution of main ions [~] + normalized_inverse_temp_scale_length: [~] :term:`glossary link` + npoints: number of points to return in profile + + Returns: + :term:`rho` [~], :term:`electron_density_profile` [1e19 m^-3], fuel_ion_density_profile [1e19 m^-3], :term:`electron_temp_profile` [keV], :term:`ion_temp_profile` [keV] + """ + rho = np.linspace(0, 1, num=npoints, endpoint=False) + + rho, electron_temp_profile, electron_density_profile = evaluate_density_and_temperature_profile_fits( + average_electron_temp, + average_electron_density, + temperature_peaking, + electron_density_peaking, + aLT=normalized_inverse_temp_scale_length, + rho=rho, + dataset="PRF", + ) + rho, ion_temp_profile, fuel_ion_density_profile = evaluate_density_and_temperature_profile_fits( + average_ion_temp, + average_electron_density * dilution, + temperature_peaking, + ion_density_peaking, + aLT=normalized_inverse_temp_scale_length, + rho=rho, + dataset="PRF", + ) + + return rho, electron_density_profile, fuel_ion_density_profile, electron_temp_profile, ion_temp_profile diff --git a/cfspopcon/formulas/radiated_power/__init__.py b/cfspopcon/formulas/radiated_power/__init__.py new file mode 100644 index 00000000..20ab0c1f --- /dev/null +++ b/cfspopcon/formulas/radiated_power/__init__.py @@ -0,0 +1,17 @@ +"""Calculate the radiated power due to fuel and impurity species.""" +from .inherent import calc_bremsstrahlung_radiation, calc_synchrotron_radiation +from .mavrin_coronal import calc_impurity_radiated_power_mavrin_coronal +from .mavrin_noncoronal import calc_impurity_radiated_power_mavrin_noncoronal +from .post_and_jensen import calc_impurity_radiated_power_post_and_jensen +from .radas import calc_impurity_radiated_power_radas +from .radiated_power import calc_impurity_radiated_power + +__all__ = [ + "calc_bremsstrahlung_radiation", + "calc_synchrotron_radiation", + "calc_impurity_radiated_power_mavrin_coronal", + "calc_impurity_radiated_power_mavrin_noncoronal", + "calc_impurity_radiated_power_post_and_jensen", + "calc_impurity_radiated_power_radas", + "calc_impurity_radiated_power", +] diff --git a/cfspopcon/formulas/radiated_power/inherent.py b/cfspopcon/formulas/radiated_power/inherent.py new file mode 100644 index 00000000..0313334d --- /dev/null +++ b/cfspopcon/formulas/radiated_power/inherent.py @@ -0,0 +1,141 @@ +"""Calculate the inherent (Bremsstrahlung and Synchrotron) radiated power.""" + +import numpy as np +from numpy import float64 +from numpy.typing import NDArray + +from ...unit_handling import ureg, wraps_ufunc +from ..helpers import integrate_profile_over_volume + + +@wraps_ufunc( + return_units=dict(P_rad_bremsstrahlung=ureg.MW), + input_units=dict( + rho=ureg.dimensionless, + electron_density_profile=ureg.n19, + electron_temp_profile=ureg.keV, + z_effective=ureg.dimensionless, + plasma_volume=ureg.m**3, + ), + input_core_dims=[("dim_rho",), ("dim_rho",), ("dim_rho",), (), ()], +) +def calc_bremsstrahlung_radiation( + rho: NDArray[float64], + electron_density_profile: NDArray[float64], + electron_temp_profile: NDArray[float64], + z_effective: float, + plasma_volume: float, +) -> float: + """Calculate the Bremsstrahlung radiated power due to the main plasma. + + Formula 13 in :cite:`stott_feasibility_2005` + + Args: + electron_density_profile: [1e19 m^-3] :term:`glossary link` + electron_temp_profile: [keV] :term:`glossary link` + z_effective: [~] :term:`glossary link` + rho: [~] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + + Returns: + Radiated bremsstrahlung power per cubic meter [MW / m^3] + """ + ne20 = electron_density_profile / 10 + + Tm = 511.0 # keV, Tm = m_e * c**2 + xrel = (1.0 + 2.0 * electron_temp_profile / Tm) * ( + 1.0 + (2.0 / z_effective) * (1.0 - 1.0 / (1.0 + electron_temp_profile / Tm)) + ) # relativistic correction factor + + fKb = ne20**2 * np.sqrt(electron_temp_profile) * xrel + Kb = integrate_profile_over_volume(fKb, rho, plasma_volume) # radial profile factor + + P_brem = 5.35e-3 * z_effective * Kb # volume-averaged bremsstrahlung radiaton in MW + + return P_brem + + +@wraps_ufunc( + return_units=dict(P_rad_synchrotron=ureg.MW), + input_units=dict( + rho=ureg.dimensionless, + electron_density_profile=ureg.n19, + electron_temp_profile=ureg.keV, + major_radius=ureg.m, + minor_radius=ureg.m, + magnetic_field_on_axis=ureg.T, + separatrix_elongation=ureg.dimensionless, + plasma_volume=ureg.m**3, + ), + input_core_dims=[("dim_rho",), ("dim_rho",), ("dim_rho",), (), (), (), (), ()], +) +def calc_synchrotron_radiation( + rho: NDArray[float64], + electron_density_profile: NDArray[float64], + electron_temp_profile: NDArray[float64], + major_radius: float, + minor_radius: float, + magnetic_field_on_axis: float, + separatrix_elongation: float, + plasma_volume: float, +) -> float: + """Calculate the Synchrotron radiated power due to the main plasma. + + This can be an important loss mechanism in high temperature plasmas. + + Formula 15 in :cite:`stott_feasibility_2005` + + For now this calculation assumes 90% wall reflectivity, consistent with stott_feasibility_2005. + + This calculation also assumes profiles of the form n(r) = n[1 - (r/a)**2]**alpha_n and + T(r) = Tedge + (T - Tedge)[1 - (r/a)**gamma_T]**alpha_T. For now, these are assumed as + gamma_T = 2, alpha_n = 0.5 and alpha_T = 1, consistent with stott_feasibility_2005. + + An alternative approach could be developed using formula 6 in :cite:`zohm_use_2019`, which assumes 80% wall reflectivity. + + Args: + electron_density_profile: [1e19 m^-3] :term:`glossary link` + electron_temp_profile: [keV] :term:`glossary link` + major_radius: [m] :term:`glossary link` + minor_radius: [m] :term:`glossary link` + magnetic_field_on_axis: [T] :term:`glossary link` + separatrix_elongation: [~] :term:`glossary link` + rho: [~] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + + Returns: + Radiated bremsstrahlung power per cubic meter [MW / m^3] + """ + ne20 = electron_density_profile / 10 + + Rw = 0.8 # wall reflectivity + gamma_T = 2 # temperature profile inner exponent (2 is ~parabolic) + alpha_n = 0.5 # density profile outer exponent (0.5 is rather broad) + alpha_T = 1 # temperature profile outer exponent (1 is ~parabolic) + + # effective optical thickness + rhoa = 6.04e3 * minor_radius * ne20 / magnetic_field_on_axis + # profile peaking correction + Ks = ( + (alpha_n + 3.87 * alpha_T + 1.46) ** (-0.79) + * (1.98 + alpha_n) ** (1.36) + * gamma_T**2.14 + * (gamma_T**1.53 + 1.87 * alpha_T - 0.16) ** (-1.33) + ) + # aspect ratio correction + Gs = 0.93 * (1 + 0.85 * np.exp(-0.82 * major_radius / minor_radius)) + + # dimensionless parameter to account for plasma transparency and wall reflections + Phi = ( + 6.86e-5 + * separatrix_elongation ** (-0.21) + * (16 + electron_temp_profile) ** (2.61) + * ((rhoa / (1 - Rw)) ** (0.41) + 0.12 * electron_temp_profile) ** (-1.51) + * Ks + * Gs + ) + + P_sync_r = 6.25e-3 * ne20 * electron_temp_profile * magnetic_field_on_axis**2 * Phi + P_sync = integrate_profile_over_volume(P_sync_r, rho, plasma_volume) + + return P_sync diff --git a/cfspopcon/formulas/radiated_power/mavrin_coronal.py b/cfspopcon/formulas/radiated_power/mavrin_coronal.py new file mode 100644 index 00000000..88e8689d --- /dev/null +++ b/cfspopcon/formulas/radiated_power/mavrin_coronal.py @@ -0,0 +1,192 @@ +"""Calculate the radiated power due to impurities, according to an analytical fitted curve from Mavrin 2018.""" + +import warnings + +import numpy as np +from numpy import float64 +from numpy.polynomial.polynomial import polyval +from numpy.typing import NDArray + +from ...named_options import Impurity +from ...unit_handling import ureg, wraps_ufunc +from ..helpers import integrate_profile_over_volume + + +@wraps_ufunc( + return_units=dict(radiated_power=ureg.MW), + input_units=dict( + rho=ureg.dimensionless, + electron_temp_profile=ureg.keV, + electron_density_profile=ureg.n19, + impurity_concentration=ureg.dimensionless, + impurity_species=None, + plasma_volume=ureg.m**3, + ), + input_core_dims=[("dim_rho",), ("dim_rho",), ("dim_rho",), (), (), ()], +) +def calc_impurity_radiated_power_mavrin_coronal( # noqa: PLR0912, PLR0915 + rho: NDArray[float64], + electron_temp_profile: NDArray[float64], + electron_density_profile: NDArray[float64], + impurity_concentration: float, + impurity_species: Impurity, + plasma_volume: float, +) -> float: + """Calculation of radiated power, using fits from A.A. Mavrin's 2018 paper. + + "Improved fits of coronal radiative cooling rates for high-temperature plasmas." + + :cite:`mavrin_improved_2018` + + Args: + rho: [~] :term:`glossary link` + electron_temp_profile: [keV] :term:`glossary link` + electron_density_profile: [1e19 m^-3] :term:`glossary link` + impurity_species: [] :term:`glossary link` + impurity_concentration: [~] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + + Returns: + k [MW] Estimated radiation power due to this impurity + """ + impurity_Z = impurity_species.value + + zimp = np.array([2, 3, 4, 6, 7, 8, 10, 18, 36, 54, 74]) + + if impurity_Z not in zimp: # pragma: no cover + warnings.warn(f"Mavrin 2018 line radiation calculation not supported for impurity with Z={impurity_Z}", stacklevel=3) + return np.nan + + # If trying to evaluate for a temperature outside of the given range, assume nearest neighbor + # and throw a warning + if any(electron_density_profile < 0.1) or any(electron_density_profile > 100): # pragma: no cover + warnings.warn( + "Mavrin 2018 line radiation calculation is only valid between 0.1-100keV. Using nearest neighbor extrapolation.", stacklevel=3 + ) + electron_density_profile = np.maximum(electron_density_profile, 0.1) + electron_density_profile = np.minimum(electron_density_profile, 100) + + # L_z coefficients for the 11 supported impurities + if impurity_Z == 2: # Helium + temperature_bin_borders = np.array([0.0, 100.0]) + radc = np.array( + [ + [-3.5551e01, 3.1469e-01, 1.0156e-01, -9.3730e-02, 2.5020e-02], + ] + ) + + elif impurity_Z == 3: # Lithium + temperature_bin_borders = np.array([0.0, 100.0]) + radc = np.array( + [ + [-3.5115e01, 1.9475e-01, 2.5082e-01, -1.6070e-01, 3.5190e-02], + ] + ) + + elif impurity_Z == 4: # Beryllium + temperature_bin_borders = np.array([0.0, 100.0]) + radc = np.array( + [ + [-3.4765e01, 3.7270e-02, 3.8363e-01, -2.1384e-01, 4.1690e-02], + ] + ) + + elif impurity_Z == 6: # Carbon + temperature_bin_borders = np.array([0.0, 0.5, 100.0]) + radc = np.array( + [ + [-3.4738e01, -5.0085e00, -1.2788e01, -1.6637e01, -7.2904e00], + [-3.4174e01, -3.6687e-01, 6.8856e-01, -2.9191e-01, 4.4470e-02], + ] + ) + + elif impurity_Z == 7: # Nitrogen + temperature_bin_borders = np.array([0.0, 0.5, 2.0, 100.0]) + radc = np.array( + [ + [-3.4065e01, -2.3614e00, -6.0605e00, -1.1570e01, -6.9621e00], + [-3.3899e01, -5.9668e-01, 7.6272e-01, -1.7160e-01, 5.8770e-02], + [-3.3913e01, -5.2628e-01, 7.0047e-01, -2.2790e-01, 2.8350e-02], + ] + ) + + elif impurity_Z == 8: # Oxygen + temperature_bin_borders = np.array([0.0, 0.3, 100.0]) + radc = np.array( + [ + [-3.7257e01, -1.5635e01, -1.7141e01, -5.3765e00, 0.0000e00], + [-3.3640e01, -7.6211e-01, 7.9655e-01, -2.0850e-01, 1.4360e-02], + ] + ) + + elif impurity_Z == 10: # Neon + temperature_bin_borders = np.array([0.0, 0.7, 5, 100.0]) + radc = np.array( + [ + [-3.3132e01, 1.7309e00, 1.5230e01, 2.8939e01, 1.5648e01], + [-3.3290e01, -8.7750e-01, 8.6842e-01, -3.9544e-01, 1.7244e-01], + [-3.3410e01, -4.5345e-01, 2.9731e-01, 4.3960e-02, -2.6930e-02], + ] + ) + + elif impurity_Z == 18: # Argon + temperature_bin_borders = np.array([0.0, 0.6, 3, 100.0]) + radc = np.array( + [ + [-3.2155e01, 6.5221e00, 3.0769e01, 3.9161e01, 1.5353e01], + [-3.2530e01, 5.4490e-01, 1.5389e00, -7.6887e00, 4.9806e00], + [-3.1853e01, -1.6674e00, 6.1339e-01, 1.7480e-01, -8.2260e-02], + ] + ) + + elif impurity_Z == 36: # Krypton + temperature_bin_borders = np.array([0.0, 0.447, 2.364, 100.0]) + radc = np.array( + [ + [-3.4512e01, -2.1484e01, -4.4723e01, -4.0133e01, -1.3564e01], + [-3.1399e01, -5.0091e-01, 1.9148e00, -2.5865e00, -5.2704e00], + [-2.9954e01, -6.3683e00, 6.6831e00, -2.9674e00, 4.8356e-01], + ] + ) + + elif impurity_Z == 54: # Xenon + temperature_bin_borders = np.array([0.0, 0.5, 2.5, 10, 100.0]) + radc = np.array( + [ + [-2.9303e01, 1.4351e01, 4.7081e01, 5.9580e01, 2.5615e01], + [-3.1113e01, 5.9339e-01, 1.2808e00, -1.1628e01, 1.0748e01], + [-2.5813e01, -2.7526e01, 4.8614e01, -3.6885e01, 1.0069e01], + [-2.2138e01, -2.2592e01, 1.9619e01, -7.5181e00, 1.0858e00], + ] + ) + + elif impurity_Z == 74: # Tungsten + temperature_bin_borders = np.array([0.0, 1.5, 4, 100.0]) + radc = np.array( + [ + [-3.0374e01, 3.8304e-01, -9.5126e-01, -1.0311e00, -1.0103e-01], + [-3.0238e01, -2.9208e00, 2.2824e01, -6.3303e01, 5.1849e01], + [-3.2153e01, 5.2499e00, -6.2740e00, 2.6627e00, -3.6759e-01], + ] + ) + + # solve for radiated power + + Tlog = np.log10(electron_density_profile) + log10_Lz = np.zeros(electron_density_profile.size) + + for i in range(len(radc)): + it = np.nonzero( + (electron_density_profile >= temperature_bin_borders[i]) & (electron_density_profile < temperature_bin_borders[i + 1]) + )[0] + if it.size > 0: + log10_Lz[it] = polyval(Tlog[it], radc[i]) # type: ignore[no-untyped-call] + + radrate = 10.0**log10_Lz + radrate[np.isnan(radrate)] = 0 + + # 1e38 factor to account for the fact that our n_e values are electron_density_profile values + qRad = radrate * electron_temp_profile * electron_temp_profile * impurity_concentration * 1e38 # W / (m^3 s) + radiated_power = integrate_profile_over_volume(qRad, rho, plasma_volume) # [W] + + return float(radiated_power) / 1e6 # MW diff --git a/cfspopcon/formulas/radiated_power/mavrin_noncoronal.py b/cfspopcon/formulas/radiated_power/mavrin_noncoronal.py new file mode 100644 index 00000000..cc1f6df9 --- /dev/null +++ b/cfspopcon/formulas/radiated_power/mavrin_noncoronal.py @@ -0,0 +1,251 @@ +"""Calculate the radiated power due to impurities, according to an analytical fitted curve from Mavrin 2017.""" + +import warnings + +import numpy as np +from numpy import float64 +from numpy.typing import NDArray + +from ...named_options import Impurity +from ...unit_handling import Quantity, ureg, wraps_ufunc +from ..helpers import integrate_profile_over_volume + + +@wraps_ufunc( + return_units=dict(radiated_power=ureg.MW), + input_units=dict( + rho=ureg.dimensionless, + electron_temp_profile=ureg.keV, + electron_density_profile=ureg.n19, + tau_i=ureg.s, + impurity_concentration=ureg.dimensionless, + impurity_species=None, + plasma_volume=ureg.m**3, + ), + input_core_dims=[("dim_rho",), ("dim_rho",), ("dim_rho",), (), (), (), ()], +) +def calc_impurity_radiated_power_mavrin_noncoronal( # noqa: PLR0912 + rho: NDArray[float64], + electron_temp_profile: NDArray[float64], + electron_density_profile: NDArray[float64], + tau_i: Quantity, + impurity_concentration: float, + impurity_species: Impurity, + plasma_volume: float, +) -> float: + """Calculation of radiated power, using fits from A.A. Mavrin's 2017 paper. + + "Radiative Cooling Rates for Low-Z Impurities in Non-coronal Equilibrium State." + + :cite:`mavrin_radiative_2017` + + Args: + rho: [~] :term:`glossary link` + electron_temp_profile: [keV] :term:`glossary link` + electron_density_profile: [1e19 m^-3] :term:`glossary link` + tau_i: [s] :term:`glossary link` + impurity_concentration: [~] :term:`glossary link` + impurity_species: [] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + + Returns: + [MW] Estimated radiation power due to this impurity + """ + impurity_Z = impurity_species.value + + # He, Li, Be, C, N, O, Ne, Ar + zimp = np.array([2, 3, 4, 6, 7, 8, 10, 18]) + + if impurity_Z not in zimp: # pragma: no cover + warnings.warn(f"Mavrin 2017 line radiation calculation not supported for impurity with Z={impurity_Z}", stacklevel=3) + return np.nan + + # L_z coefficients for the 11 supported impurities + if impurity_Z == 2: # Helium + temperature_bin_borders = np.array([1.0, 3.0, 10.0, 30.0, 100.0, 15000.0]) + radc = np.array( + [ + [-3.9341e01, -2.7185e01, -3.4950e01, -3.1299e01, -3.3203e01], + [2.2742e01, -3.4465e01, 5.5957e00, -4.4749e00, -2.3306e00], + [-8.5940e-02, 3.2223e-01, 2.1542e00, 2.9614e-01, -5.3911e-01], + [-2.5420e01, 5.0933e01, -7.4762e00, 1.5259e00, 7.2592e-01], + [1.8843e00, 1.0589e-01, -3.7391e00, -6.1433e-01, 9.7550e-02], + [-3.5681e-01, 1.1632e-01, 1.4444e-01, 3.2651e-01, 2.6917e-01], + [-3.2771e00, -2.3641e01, 2.4534e00, -1.6652e-01, -6.6110e-02], + [-4.9766e00, -7.4782e-01, 1.5000e00, 1.5704e-01, 8.9900e-03], + [1.9730e-02, -7.6200e-03, 2.1307e-01, -8.0601e-04, 2.9240e-02], + [-7.4260e-02, 2.1030e-02, 7.6590e-02, 5.0330e-02, 5.1180e-02], + ] + ) + + elif impurity_Z == 3: # Lithium + temperature_bin_borders = np.array([1.0, 7.0, 30.0, 60.0, 100.0, 1000.0, 10000.0]) + radc = np.array( + [ + [-3.5752e01, -3.1170e01, -3.6558e01, -3.0560e01, -3.0040e01, -3.4199e01], + [-1.6780e00, -1.6918e01, 9.4272e00, -2.4680e00, -4.2963e00, -8.5686e-01], + [9.5500e-03, 1.1481e-01, 3.5299e00, 1.7912e00, 2.7407e-01, -6.3246e-01], + [-6.1560e00, 2.0492e01, -8.1056e00, -2.8659e-01, 1.1569e00, 2.4968e-01], + [-1.5027e00, 2.6136e-01, -4.4113e00, -1.9929e00, -4.5453e-01, 9.9930e-02], + [2.5568e-01, 2.4870e-01, 5.1430e-02, 2.8150e-01, 3.0616e-01, 2.5080e-01], + [1.1009e01, -7.0035e00, 1.9427e00, 2.3898e-01, -9.1510e-02, -1.7230e-02], + [2.1169e00, -3.3910e-01, 1.3459e00, 5.0412e-01, 9.7550e-02, 1.4410e-02], + [-9.6420e-02, -3.5570e-02, 2.3865e-01, 5.8550e-02, 1.6540e-02, 3.7030e-02], + [1.3460e-02, 4.1910e-02, 8.6850e-02, 6.7410e-02, 5.4690e-02, 5.5670e-02], + ] + ) + + elif impurity_Z == 4: # Beryllium + temperature_bin_borders = np.array([0.2, 0.7, 3.0, 11.0, 45.0, 170.0, 10000.0]) + radc = np.array( + [ + [-3.0242e01, -3.2152e01, -3.0169e01, -3.7201e01, -4.0868e01, -2.8539e01], + [2.1405e01, 3.1572e00, -8.9830e00, -2.5643e00, 1.4625e01, -5.0020e00], + [1.0117e-01, 1.4168e-01, 6.3656e-01, -4.0467e00, 3.3373e00, 3.1089e-01], + [2.7450e01, -1.4617e01, 4.5232e00, 7.1732e00, -8.8128e00, 1.3149e00], + [8.8367e-01, 1.4646e-01, -1.5126e00, 5.8147e00, -3.1064e00, -4.0022e-01], + [-6.6110e-02, 1.4683e-01, 4.0756e-01, 4.0114e-01, 2.4343e-01, 3.1788e-01], + [3.0202e01, 4.3653e00, -3.7497e-01, -2.5926e00, 1.5996e00, -1.0780e-01], + [1.2175e00, -1.1290e00, 7.2552e-01, -2.0708e00, 6.8069e-01, 7.3280e-02], + [-1.4883e-01, 3.4914e-01, -2.9810e-02, -1.4775e-01, 6.0120e-02, 1.7320e-02], + [4.8900e-03, 4.1730e-02, 5.5620e-02, 2.1900e-02, 6.8350e-02, 6.1360e-02], + ] + ) + + elif impurity_Z == 6: # Carbon + temperature_bin_borders = np.array([1.0, 7.0, 20.0, 70.0, 200.0, 700.0, 15000.0]) + radc = np.array( + [ + [-3.4509e01, -4.9228e01, -1.9100e01, -6.7743e01, -2.4016e01, -2.8126e01], + [6.7599e00, 5.3922e01, -1.5476e01, 4.1606e01, -7.3974e00, -4.1679e00], + [-1.7140e-02, 8.4584e-01, 4.2962e00, -5.3665e00, 2.9707e00, 4.9937e-01], + [-4.0337e00, -5.1128e01, 2.1893e00, -1.5734e01, 1.6859e00, 9.0578e-01], + [1.5517e-01, -8.9366e-01, -6.1658e00, 6.1760e00, -2.1965e00, -5.3687e-01], + [2.1110e-02, -2.2710e-02, 1.6098e-01, 7.8010e-01, 3.0521e-01, 2.5962e-01], + [6.5977e-01, 1.4758e01, 1.1021e00, 1.7905e00, -1.1147e-01, -5.8310e-02], + [-1.7392e-01, 1.6371e-01, 2.1568e00, -1.7320e00, 3.8653e-01, 1.0420e-01], + [-2.9270e-02, 2.9362e-01, 1.1101e-01, -2.7897e-01, 3.8970e-02, 4.6610e-02], + [1.7600e-03, 5.5880e-02, 4.2700e-02, 2.3450e-02, 7.8690e-02, 7.3950e-02], + ] + ) + + elif impurity_Z == 7: # Nitrogen + temperature_bin_borders = np.array([1.0, 10.0, 30.0, 100.0, 300.0, 1000.0, 15000.0]) + radc = np.array( + [ + [-3.5312e01, -5.8692e01, -2.0301e01, -7.7571e01, -2.9401e01, -2.7201e01], + [7.1926e00, 6.8148e01, -8.8594e00, 5.0488e01, -3.8191e-01, -4.4640e00], + [7.8200e-03, 3.6209e-01, 6.0500e00, -6.5889e00, 3.5270e00, 7.6960e-01], + [-3.5696e00, -5.4257e01, -2.7129e00, -1.8187e01, -1.0347e00, 9.2450e-01], + [-1.2800e-02, 1.4835e-01, -7.6700e00, 6.8691e00, -2.4192e00, -6.7720e-01], + [1.1180e-02, -1.4700e-03, 1.0705e-01, 8.3119e-01, 3.2269e-01, 2.6185e-01], + [3.5812e-01, 1.3476e01, 1.9691e00, 2.0259e00, 2.2501e-01, -5.6280e-02], + [-2.5100e-03, -2.9646e-01, 2.3943e00, -1.7572e00, 3.9511e-01, 1.2014e-01], + [-2.2020e-02, 2.2706e-01, 1.4088e-01, -2.9376e-01, 2.6510e-02, 4.6870e-02], + [-1.0000e-03, 5.4220e-02, 4.7450e-02, 1.7200e-02, 7.8930e-02, 7.9250e-02], + ] + ) + + elif impurity_Z == 8: # Oxygen + temperature_bin_borders = np.array([1.0, 10.0, 30.0, 100.0, 300.0, 1000.0, 15000.0]) + radc = np.array( + [ + [-3.6208e01, -2.9057e01, -2.9370e01, -4.4120e-02, -3.7073e01, -2.5037e01], + [7.5487e00, -1.5228e01, 8.7451e00, -5.4918e01, 7.8826e00, -5.7568e00], + [2.3340e-02, -3.1460e00, 6.3827e00, -9.5003e00, 3.7999e00, 1.2973e00], + [-2.1983e00, 2.0826e01, -1.2357e01, 2.8883e01, -3.8006e00, 1.2040e00], + [-1.0131e-01, 5.9427e00, -7.6451e00, 8.5536e00, -2.2619e00, -9.1955e-01], + [8.0600e-03, 1.0610e-01, -2.2230e-02, 5.5336e-01, 5.0270e-01, 2.8988e-01], + [-6.5108e-01, -8.0843e00, 3.4958e00, -4.8731e00, 5.2144e-01, -7.6780e-02], + [8.4570e-02, -2.6827e00, 2.2661e00, -1.9172e00, 3.0219e-01, 1.4568e-01], + [-2.1710e-02, 1.0350e-02, 2.5727e-01, -1.5709e-01, -6.6330e-02, 3.9250e-02], + [-2.1200e-03, 2.6480e-02, 7.7800e-02, 1.6370e-02, 6.1140e-02, 8.3010e-02], + ] + ) + + elif impurity_Z == 10: # Neon + temperature_bin_borders = np.array([1.0, 10.0, 70.0, 300.0, 1000.0, 3000.0, 15000.0]) + radc = np.array( + [ + [-3.8610e01, -3.6822e01, -6.6901e00, -1.1261e02, -2.6330e02, -1.1174e02], + [1.2606e01, 4.9706e00, -2.4212e01, 8.5765e01, 2.1673e02, 6.1907e01], + [1.7866e-01, -1.5334e00, 7.3589e00, -2.1093e00, 1.2973e00, 4.7967e00], + [-1.0213e01, 1.1973e00, 5.7352e00, -3.0372e01, -6.7799e01, -1.6289e01], + [-7.7051e-01, 2.7279e00, -7.4602e00, 2.2928e00, -7.3310e-01, -2.5731e00], + [2.7510e-02, 9.0090e-02, -7.9030e-02, 7.7055e-01, 4.4883e-01, 4.2620e-01], + [4.3390e00, -1.3992e00, -8.5020e-02, 3.5346e00, 7.0398e00, 1.4263e00], + [6.4207e-01, -1.1084e00, 1.8679e00, -5.6062e-01, 9.3190e-02, 3.3443e-01], + [-3.3560e-02, 1.3620e-02, 2.2507e-01, -1.8569e-01, -1.5390e-02, -9.3734e-04], + [-1.3333e-04, 2.4300e-02, 7.1420e-02, 3.7550e-02, 7.7660e-02, 8.4220e-02], + ] + ) + + elif impurity_Z == 18: # Argon + temperature_bin_borders = np.array([1.0, 10.0, 50.0, 150.0, 500.0, 1500.0, 10000.0]) + radc = np.array( + [ + [-3.6586e01, -4.8732e01, -2.3157e01, -6.8134e01, 5.5851e01, -6.2758e01], + [1.2841e01, 3.8185e01, -8.5132e00, 3.6408e01, -7.8618e01, 2.5163e01], + [2.3080e-02, -7.0622e-01, 1.5617e00, -7.3868e00, 1.0520e01, -7.4717e-01], + [-1.2087e01, -2.5859e01, 1.5478e00, -1.0735e01, 2.2871e01, -6.8170e00], + [-9.8000e-03, 1.2850e00, -1.8880e00, 6.8800e00, -7.7061e00, 6.9486e-01], + [-2.4600e-03, -6.8710e-02, 2.2830e-01, 3.1142e-01, -1.8530e-01, 4.6946e-01], + [4.8823e00, 5.4372e00, 2.8279e-01, 8.0440e-01, -2.1616e00, 5.9969e-01], + [-3.7470e-02, -5.2157e-01, 5.5767e-01, -1.5740e00, 1.4123e00, -1.3487e-01], + [1.1100e-03, 1.4016e-01, -9.9600e-02, -9.9180e-02, 1.8409e-01, -8.1380e-02], + [1.1100e-03, 1.9120e-02, -1.5280e-02, 9.4500e-03, 6.7470e-02, 2.5840e-02], + ] + ) + else: + raise RuntimeError("This should never happen, please ensure all impurity cases in zimp array are covered!") + + # If trying to evaluate for a temperature outside of the given range, assume nearest neighbor + # and throw a warning + if any(electron_temp_profile < temperature_bin_borders[0]) or any( + electron_temp_profile > temperature_bin_borders[-1] + ): # pragma: no cover + warnings.warn( + f"Mavrin 2017 line radiation calculation is only valid between {temperature_bin_borders[0]}eV-{temperature_bin_borders[-1]}eV. Using nearest neighbor extrapolation.", + stacklevel=3, + ) + electron_temp_profile = np.maximum(electron_temp_profile, temperature_bin_borders[0]) + electron_temp_profile = np.minimum(electron_temp_profile, temperature_bin_borders[-1]) + + # solve for radiated power + ne_tau_i_per_m3 = electron_density_profile * tau_i + + X_vals = np.log10(electron_temp_profile) + Y_vals = np.log10(ne_tau_i_per_m3 / 1e19) + if np.any(Y_vals > 0.0): # pragma: no cover + warnings.warn("Warning: treating points with ne_tau_i_per_m3 > 1e19 m^-3 s as coronal.", stacklevel=3) + Y_vals = np.minimum(Y_vals, 0.0) + + log10_Lz = np.zeros(electron_temp_profile.size) + + for i, Te_test in enumerate(electron_temp_profile): + X, Y = X_vals[i], Y_vals[i] + + for j in range(temperature_bin_borders.size - 1): + Te_min, Te_max = temperature_bin_borders[j], temperature_bin_borders[j + 1] + + if Te_min <= Te_test <= Te_max: + log10_Lz[i] = ( + radc[0, j] + + radc[1, j] * X + + radc[2, j] * Y + + radc[3, j] * X**2 + + radc[4, j] * X * Y + + radc[5, j] * Y**2 + + radc[6, j] * X**3 + + radc[7, j] * X**2 * Y + + radc[8, j] * X * Y**2 + + radc[9, j] * Y**3 + ) + continue + + radrate = 10.0**log10_Lz + + qRad = radrate * electron_density_profile * electron_density_profile * impurity_concentration # W / (m^3 s) + radiated_power = integrate_profile_over_volume(qRad, rho, plasma_volume) # [W] + + return float(radiated_power) / 1e6 # MW diff --git a/cfspopcon/formulas/radiated_power/post_and_jensen.py b/cfspopcon/formulas/radiated_power/post_and_jensen.py new file mode 100644 index 00000000..dfde2533 --- /dev/null +++ b/cfspopcon/formulas/radiated_power/post_and_jensen.py @@ -0,0 +1,158 @@ +"""Calculate the radiated power due to impurities, according to an analytical fitted curve.""" + +import warnings + +import numpy as np +from numpy import float64 +from numpy.polynomial.polynomial import polyval +from numpy.typing import NDArray + +from ...named_options import Impurity +from ...unit_handling import ureg, wraps_ufunc +from ..helpers import integrate_profile_over_volume + + +@wraps_ufunc( + return_units=dict(radiated_power=ureg.MW), + input_units=dict( + rho=ureg.dimensionless, + electron_temp_profile=ureg.keV, + electron_density_profile=ureg.n19, + impurity_concentration=ureg.dimensionless, + impurity_species=None, + plasma_volume=ureg.m**3, + ), + input_core_dims=[("dim_rho",), ("dim_rho",), ("dim_rho",), (), (), ()], +) +def calc_impurity_radiated_power_post_and_jensen( + rho: NDArray[float64], + electron_temp_profile: NDArray[float64], + electron_density_profile: NDArray[float64], + impurity_concentration: float, + impurity_species: Impurity, + plasma_volume: float, +) -> float: + """Calculation of radiated power using Post & Jensen 1977. + + Radiation fits to the Post & Jensen cooling curves, which use the + coronal equilibrium model with data in :cite:`post_steady_1977`. + + Args: + rho: [~] :term:`glossary link` + electron_temp_profile: [keV] :term:`glossary link` + electron_density_profile: [1e19 m^-3] :term:`glossary link` + impurity_species: [] :term:`glossary link` + impurity_concentration: [~] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + + Returns: + [MW] Estimated radiation power due to this impurity + """ + impurity_Z = impurity_species.value + + zimp = np.array([2, 4, 5, 6, 8, 18, 22, 26, 28, 42, 74]) + + if impurity_Z not in zimp: # pragma: no cover + warnings.warn(f"Post & Jenson radiation calculation not supported for impurity with Z={impurity_Z}", stacklevel=3) + return np.nan + + # get the index of the impurity + iz = np.nonzero(zimp == impurity_Z)[0][0] + + # supported minimum temperature for each supported impurity above + Tmin = np.array([0.002, 0.002, 0.002, 0.003, 0.005, 0.03, 0.02, 0.02, 0.03, 0.06, 0.1]) + + # If trying to evaluate for a temperature outside of the given range, assume nearest neighbor + # and throw a warning + if any(electron_temp_profile < Tmin[iz]) or any(electron_temp_profile > 100): # pragma: no cover + warnings.warn( + f"Post 1977 line radiation calculation is only valid for Z={impurity_Z} between {Tmin[iz]}-100keV. Using nearest neighbor extrapolation.", + stacklevel=3, + ) + electron_temp_profile = np.maximum(electron_temp_profile, Tmin[iz]) + electron_temp_profile = np.minimum(electron_temp_profile, 100) + + temperature_bin_borders = np.array([0.0, 0.02, 0.2, 2.0, 20.0, 100.0]) + + # A_i coefficients for the first temperature bin, for the 10 supported impurities + # e.g. radc1[0][3] would be the A(0) coefficient for the first temperature + # bin for Carbon (zimp[3]==6). + # radc1[:][0] would be the [A_0, A_1..., A_5] coefficients for Helium. + radc1 = np.array( + [ + [144.1278, -342.5149, -1508.695, 1965.3, 652.374, 0, 0, 0, 0, 0, 0], + [294.0867, -947.126, -3512.267, 4572.039, 1835.499, 0, 0, 0, 0, 0, 0], + [176.1164, -1035.776, -3286.123, 4159.59, 1984.266, 0, 0, 0, 0, 0, 0], + [33.8743, -538.2415, -1520.07, 1871.56, 1059.846, 0, 0, 0, 0, 0, 0], + [-3.075936, -134.9198, -347.0698, 417.3889, 280.0476, 0, 0, 0, 0, 0, 0], + [-1.204179, -13.19063, -31.27689, 36.99382, 29.33792, 0, 0, 0, 0, 0, 0], + ], + dtype=float64, + ) + + # Coefficients for 2nd temperature bin + radc2 = np.array( + [ + [-22.7421, -34.29832, -63.7016, 74.67599, -55.15118, -20.53043, 23.91331, -27.52599, -12.03248, -139.1054, 5.340828], + [-0.7402954, -58.04948, -215.6758, 454.9038, -154.3956, -2.834287, 183.3595, -39.08228, 32.53908, -649.3335, 156.0876], + [-2.177691, -103.257, -430.8101, 837.2937, -248.992, 15.06902, 301.9617, -64.69423, 67.90773, -1365.838, 417.1704], + [-2.426768, -88.53015, -422.2842, 740.2515, -180.8154, 35.17177, 237.6019, -55.55048, 65.29924, -1406.464, 550.2576], + [-1.026211, -35.30521, -200.8412, 314.7607, -57.64175, 24.00122, 90.49792, -24.05568, 29.73465, -708.6213, 356.7583], + [-0.1798547, -5.13446, -36.87482, 51.64578, -6.149181, 5.072723, 13.4509, -4.09316, 5.271279, -140.0571, 90.42786], + ] + ) + + # Coefficients for 3rd temperature bin + radc3 = np.array( + [ + [-22.54156, -21.77747, -21.47874, -21.20151, -20.68816, -19.65204, -18.99097, -18.34973, -18.30482, -17.72591, -17.23894], + [0.350319, 0.04617764, -0.15653, -0.3668933, -0.7482238, -0.1172763, -3.403261, -1.252028, -0.003319243, -1.058217, 0.05423752], + [0.1210755, 0.4411196, 0.6181287, 0.7295099, 0.7390959, 7.83322, 1.43983, -7.533115, -3.332313, -3.583172, -1.22107], + [-0.1171573, -0.2972147, -0.2477378, -0.1944827, -0.672159, -6.351577, 17.35576, -3.289693, -11.12798, 1.660089, 0.4411812], + [0.08237547, 0.04526295, -0.1060488, -0.1263576, 1.338345, -30.58849, 0.2804832, 28.66739, 0.1053073, 8.565372, -4.485821], + [0.04361719, 0.1266794, -0.04537644, -0.1491027, 3.734628, -15.28534, -19.43971, 28.30249, 9.448907, 4.532909, -7.836137], + ] + ) + + # Coefficients for 4th temperature bin + radc4 = np.array( + [ + [-22.58311, -21.77388, -21.47337, -21.21979, -20.66766, -19.74883, -19.29037, -16.71042, -16.97678, -13.85096, -14.7488], + [0.6858961, 0.0147862, -0.1829426, -0.2346986, -0.955559, 2.964839, -3.260377, -16.46143, -9.49547, -36.78452, -14.39542], + [-0.8628176, 0.5259617, 0.6678447, 0.4093794, 1.467982, -8.829391, 14.54427, 37.66238, 11.09362, 114.0587, 21.05855], + [1.205242, -0.381643, -0.3864809, 0.07874548, -0.9822488, 9.791004, -23.83997, -39.4408, 0.04045904, -163.5634, -4.394746], + [-0.738631, 0.15834, 0.116592, -0.1841379, 0.4171964, -4.960018, 16.42804, 19.18529, -6.521934, 107.626, -11.06006], + [0.168653, -0.02891062, -0.01400226, 0.05590744, -0.08244216, 0.9820032, -4.084697, -3.509238, 2.654915, -26.42488, 5.616985], + ] + ) + + # Coefficients for 5th temperature bin + radc5 = np.array( + [ + [-17.30458, -20.31496, -24.46008, -24.76796, -27.80602, -21.17935, -13.4178, -24.53957, -28.64081, 39.92683, -262.426], + [-16.24615, -4.2026, 9.26496, 9.408181, 21.46056, 5.191481, -16.75967, 17.95222, 29.99289, -175.7093, 712.5586], + [21.00786, 5.289472, -11.10684, -9.657446, -26.65906, -7.439717, 18.4332, -23.5636, -37.26082, 207.4927, -825.0168], + [-13.12075, -3.002456, 6.837004, 4.999161, 16.70831, 4.969023, -10.33234, 14.84503, 22.5806, -121.4589, 474.2407], + [4.06935, 0.8528627, -2.065106, -1.237382, -5.191943, -1.55318, 2.96053, -4.542323, -6.716598, 35.31804, -135.5175], + [-0.5009445, -0.09687936, 0.2458526, 0.116061, 0.6410295, 0.1877047, -0.3423194, 0.5477462, 0.7911687, -4.083832, 15.41889], + ] + ) + + radc = np.array([radc1, radc2, radc3, radc4, radc5]) + + Tlog = np.log10(electron_temp_profile) + log10_Lz = np.zeros(electron_temp_profile.size) + + for i in range(len(radc)): + it = np.nonzero((electron_temp_profile >= temperature_bin_borders[i]) & (electron_temp_profile < temperature_bin_borders[i + 1]))[0] + if it.size > 0: + log10_Lz[it] = polyval(Tlog[it], radc[i, :, iz]) # type: ignore[no-untyped-call] + + radrate = 10.0**log10_Lz + radrate[np.isnan(radrate)] = 0 + radrate /= 1e13 # convert from erg cm^3 -> J m^3 (erg == 1e-7 J) + + # 1e38 factor to account for the fact that our n_e values are electron_density_profile values + qRad = radrate * electron_density_profile * electron_density_profile * impurity_concentration * 1e38 # W / (m^3 s) + radiated_power = integrate_profile_over_volume(qRad, rho, plasma_volume) # [W] + return float(radiated_power) / 1e6 # MW diff --git a/cfspopcon/formulas/radiated_power/radas.py b/cfspopcon/formulas/radiated_power/radas.py new file mode 100644 index 00000000..54d3132c --- /dev/null +++ b/cfspopcon/formulas/radiated_power/radas.py @@ -0,0 +1,67 @@ +"""Calculate the impurity radiated power using the radas atomic_data.""" +import numpy as np +import xarray as xr +from numpy import float64 +from numpy.typing import NDArray + +from ...named_options import Impurity +from ...unit_handling import magnitude, ureg, wraps_ufunc +from ..helpers import integrate_profile_over_volume + + +@wraps_ufunc( + return_units=dict(radiated_power=ureg.MW), + input_units=dict( + rho=ureg.dimensionless, + electron_temp_profile=ureg.eV, + electron_density_profile=ureg.m**-3, + impurity_concentration=ureg.dimensionless, + impurity_species=None, + plasma_volume=ureg.m**3, + atomic_data=None, + ), + input_core_dims=[("dim_rho",), ("dim_rho",), ("dim_rho",), (), (), ()], + pass_as_kwargs=("atomic_data",), +) +def calc_impurity_radiated_power_radas( + rho: NDArray[float64], + electron_temp_profile: NDArray[float64], + electron_density_profile: NDArray[float64], + impurity_concentration: float, + impurity_species: Impurity, + plasma_volume: float, + atomic_data: dict[Impurity, xr.DataArray], +) -> float: + """Calculation of radiated power using radas atomic_data datasets. + + Args: + rho: [~] :term:`glossary link` + electron_temp_profile: [keV] :term:`glossary link` + electron_density_profile: [1e19 m^-3] :term:`glossary link` + impurity_species: [] :term:`glossary link` + impurity_concentration: [~] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + atomic_data: :term:`glossary link` + + Returns: + [MW] Estimated radiation power due to this impurity + """ + MW_per_W = 1e6 + + ds = atomic_data[impurity_species] + Lz_curve = ds.coronal_Lz_interpolator + + # Use nearest neighbor extrapolation if evaluating for a + # point off-grid + + electron_temp_profile = np.minimum(electron_temp_profile, magnitude(ds.electron_temperature.max())) + electron_temp_profile = np.maximum(electron_temp_profile, magnitude(ds.electron_temperature.min())) + electron_density_profile = np.minimum(electron_density_profile, magnitude(ds.electron_density.max())) + electron_density_profile = np.maximum(electron_density_profile, magnitude(ds.electron_density.min())) + + Lz = np.power(10, Lz_curve(np.log10(electron_temp_profile), np.log10(electron_density_profile), grid=False)) + radiated_power_profile = electron_density_profile**2 * Lz + + radiated_power = impurity_concentration * integrate_profile_over_volume(radiated_power_profile, rho, plasma_volume) / MW_per_W + + return radiated_power diff --git a/cfspopcon/formulas/radiated_power/radiated_power.py b/cfspopcon/formulas/radiated_power/radiated_power.py new file mode 100644 index 00000000..7f660a9f --- /dev/null +++ b/cfspopcon/formulas/radiated_power/radiated_power.py @@ -0,0 +1,55 @@ +"""Compute the total radiated power.""" +import numpy as np +import xarray as xr + +from ...named_options import Impurity, RadiationMethod +from ...unit_handling import Unitfull, ureg +from .mavrin_coronal import calc_impurity_radiated_power_mavrin_coronal +from .mavrin_noncoronal import calc_impurity_radiated_power_mavrin_noncoronal +from .post_and_jensen import calc_impurity_radiated_power_post_and_jensen +from .radas import calc_impurity_radiated_power_radas + + +def calc_impurity_radiated_power( + radiated_power_method: RadiationMethod, + rho: Unitfull, + electron_temp_profile: Unitfull, + electron_density_profile: Unitfull, + impurities: xr.DataArray, + plasma_volume: Unitfull, + atomic_data: dict[Impurity, xr.DataArray], +) -> xr.DataArray: + """Compute the total radiated power due to fuel and impurity species. + + Args: + radiated_power_method: [] :term:`glossary link` + rho: [~] :term:`glossary link` + electron_temp_profile: [keV] :term:`glossary link` + electron_density_profile: [1e19 m^-3] :term:`glossary link` + impurities: [] :term:`glossary link` + plasma_volume: [m^3] :term:`glossary link` + atomic_data: :term:`glossary link` + + Returns: + [MW] Estimated radiation power due to this impurity + """ + P_rad_kwargs = dict( + rho=rho, + electron_temp_profile=electron_temp_profile, + electron_density_profile=electron_density_profile, + impurity_concentration=impurities, + impurity_species=impurities.dim_species, + plasma_volume=plasma_volume, + ) + if radiated_power_method == RadiationMethod.PostJensen: + P_rad_impurity = calc_impurity_radiated_power_post_and_jensen(**P_rad_kwargs) + elif radiated_power_method == RadiationMethod.MavrinCoronal: + P_rad_impurity = calc_impurity_radiated_power_mavrin_coronal(**P_rad_kwargs) + elif radiated_power_method == RadiationMethod.MavrinNoncoronal: + P_rad_impurity = calc_impurity_radiated_power_mavrin_noncoronal(**P_rad_kwargs, tau_i=np.inf * ureg.s) + elif radiated_power_method == RadiationMethod.Radas: + P_rad_impurity = calc_impurity_radiated_power_radas(**P_rad_kwargs, atomic_data=atomic_data) + else: + raise NotImplementedError(f"No implementation for radiated_power_method = {radiated_power_method}") + + return P_rad_impurity # type:ignore[no-any-return] diff --git a/cfspopcon/formulas/scrape_off_layer_model/__init__.py b/cfspopcon/formulas/scrape_off_layer_model/__init__.py new file mode 100644 index 00000000..e58586a5 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/__init__.py @@ -0,0 +1,15 @@ +"""Module to perform simple scrape-off-layer calculations. + +These are mostly based on the two-point-model, from :cite:`stangeby_2018`. +""" +from .lambda_q import calc_lambda_q +from .parallel_heat_flux_density import calc_parallel_heat_flux_density +from .solve_target_first_two_point_model import solve_target_first_two_point_model +from .solve_two_point_model import solve_two_point_model + +__all__ = [ + "solve_two_point_model", + "calc_parallel_heat_flux_density", + "calc_lambda_q", + "solve_target_first_two_point_model", +] diff --git a/cfspopcon/formulas/scrape_off_layer_model/lambda_q.py b/cfspopcon/formulas/scrape_off_layer_model/lambda_q.py new file mode 100644 index 00000000..f983a938 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/lambda_q.py @@ -0,0 +1,92 @@ +"""Routines to calculate the heat flux decay length (lambda_q), for several different scalings.""" + +from ...named_options import LambdaQScaling +from ...unit_handling import ureg, wraps_ufunc + + +@wraps_ufunc( + return_units=dict(lambda_q=ureg.millimeter), + input_units=dict( + lambda_q_scaling=None, + average_total_pressure=ureg.atm, + power_crossing_separatrix=ureg.megawatt, + major_radius=ureg.meter, + B_pol_omp=ureg.tesla, + inverse_aspect_ratio=ureg.dimensionless, + ), +) +def calc_lambda_q( + lambda_q_scaling: LambdaQScaling, + average_total_pressure: float, + power_crossing_separatrix: float, + major_radius: float, + B_pol_omp: float, + inverse_aspect_ratio: float, +) -> float: + """Calculate SOL heat flux decay length (lambda_q) from a scaling. + + Args: + lambda_q_scaling: :term:`glossary link` + average_total_pressure: [atm] :term:`glossary link ` + power_crossing_separatrix: [MW] :term:`glossary link` + major_radius: [m] :term:`glossary link` + B_pol_omp: [T] :term:`glossary link` + inverse_aspect_ratio: [~] :term:`glossary link` + + Returns: + :term:`lambda_q` [mm] + """ + if lambda_q_scaling == LambdaQScaling.Brunner: + return float(calc_lambda_q_with_brunner.__wrapped__(average_total_pressure)) + elif lambda_q_scaling == LambdaQScaling.EichRegression14: + return float(calc_lambda_q_with_eich_regression_14.__wrapped__(B_pol_omp)) + elif lambda_q_scaling == LambdaQScaling.EichRegression15: + return float( + calc_lambda_q_with_eich_regression_15.__wrapped__(power_crossing_separatrix, major_radius, B_pol_omp, inverse_aspect_ratio) + ) + else: + raise NotImplementedError(f"No implementation for lambda_q scaling {lambda_q_scaling}") + + +@wraps_ufunc( + return_units=dict(lambda_q=ureg.millimeter), + input_units=dict(average_total_pressure=ureg.atm), +) +def calc_lambda_q_with_brunner(average_total_pressure: float) -> float: + """Return lambda_q according to the Brunner scaling. + + Equation 4 in :cite:`brunner_2018_heat_flux` + """ + return float(0.91 * average_total_pressure**-0.48) + + +@wraps_ufunc(return_units=dict(lambda_q=ureg.millimeter), input_units=dict(B_pol_omp=ureg.tesla)) +def calc_lambda_q_with_eich_regression_14(B_pol_omp: float) -> float: + """Return lambda_q according to Eich regression 14. + + #14 in Table 3 in :cite:`eich_scaling_2013` + """ + return float(0.63 * B_pol_omp**-1.19) + + +@wraps_ufunc( + return_units=dict(lambda_q=ureg.millimeter), + input_units=dict( + power_crossing_separatrix=ureg.megawatt, + major_radius=ureg.meter, + B_pol_omp=ureg.tesla, + inverse_aspect_ratio=ureg.dimensionless, + ), +) +def calc_lambda_q_with_eich_regression_15( + power_crossing_separatrix: float, major_radius: float, B_pol_omp: float, inverse_aspect_ratio: float +) -> float: + """Return lambda_q according to Eich regression 15. + + #15 in Table 3 in :cite:`eich_scaling_2013` + """ + lambda_q = 1.35 * major_radius**0.04 * B_pol_omp**-0.92 * inverse_aspect_ratio**0.42 + if power_crossing_separatrix > 0: + return float(lambda_q * power_crossing_separatrix**-0.02) + else: + return float(lambda_q) diff --git a/cfspopcon/formulas/scrape_off_layer_model/momentum_loss_functions.py b/cfspopcon/formulas/scrape_off_layer_model/momentum_loss_functions.py new file mode 100644 index 00000000..4dec8e3b --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/momentum_loss_functions.py @@ -0,0 +1,62 @@ +"""Calculate SOL momentum loss as a function target electron temperature. + +See Figure 15 of :cite:`stangeby_2018`. +""" +import numpy as np + +from ...named_options import MomentumLossFunction +from ...unit_handling import Quantity, ureg, wraps_ufunc + + +def _calc_SOL_momentum_loss_fraction(A: float, Tstar: float, n: float, target_electron_temp: float) -> float: + """Calculates the fraction of momentum lost in the SOL, for a generic SOL momentum loss function. + + This is equation 33 of :cite:`stangeby_2018`, rearranged for $f^{total}_{mom-loss}$ + """ + return float(1.0 - A * (1.0 - np.exp(-target_electron_temp / Tstar)) ** n) + + +@wraps_ufunc( + return_units=dict(momentum_loss_fraction=ureg.dimensionless), + input_units=dict(key=None, target_electron_temp=ureg.eV), +) +def calc_SOL_momentum_loss_fraction(key: MomentumLossFunction, target_electron_temp: Quantity) -> float: + """Calculate the fraction of momentum lost in the SOL. + + The coefficients come from figure captions in :cite:`stangeby_2018` + * KotovReiter: SOLPS scans with Deuterium only, no impurities for JET vertical target. Figure 7a) + * Sang: SOLPS scans for Deuterium with Carbon impurity, for DIII-D, variety of divertor configurations. Figure 7b) + * Jarvinen: EDGE2D density scan for JET with a horizontal target, for a variety of targets and injected impurities. Figure 10a) + * Moulton: SOLPS density scan for narrow slot divertor, no impurities. Figure 10b) + * PerezH: SOLPS density scan for AUG H-mode, only trace impurities. Figure 11a) + * PerezL: SOLPS density scan for AUG L-mode, with Carbon impurity. Figure 11b) + + Comparison is in Figure 15. + + Args: + key: which momentum loss function to use + target_electron_temp: electron temperature at the target [eV] + + Returns: + SOL_momentum_loss_fraction [~] + """ + if key == MomentumLossFunction.KotovReiter: + return _calc_SOL_momentum_loss_fraction(1.0, 0.8, 2.1, target_electron_temp) + + elif key == MomentumLossFunction.Sang: + return _calc_SOL_momentum_loss_fraction(1.3, 1.8, 1.6, target_electron_temp) + + elif key == MomentumLossFunction.Jarvinen: + return _calc_SOL_momentum_loss_fraction(1.7, 2.2, 1.2, target_electron_temp) + + elif key == MomentumLossFunction.Moulton: + return _calc_SOL_momentum_loss_fraction(1.0, 1.0, 1.5, target_electron_temp) + + elif key == MomentumLossFunction.PerezH: + return _calc_SOL_momentum_loss_fraction(0.8, 2.0, 1.2, target_electron_temp) + + elif key == MomentumLossFunction.PerezL: + return _calc_SOL_momentum_loss_fraction(1.1, 3.0, 0.9, target_electron_temp) + + else: + raise NotImplementedError(f"No implementation for MomentumLossFunction {key}") diff --git a/cfspopcon/formulas/scrape_off_layer_model/parallel_heat_flux_density.py b/cfspopcon/formulas/scrape_off_layer_model/parallel_heat_flux_density.py new file mode 100644 index 00000000..e304aa74 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/parallel_heat_flux_density.py @@ -0,0 +1,35 @@ +"""Routines to calculate the upstream (unmitigated) parallel heat flux density.""" +from numpy import pi + +from ...unit_handling import Unitfull + + +def calc_parallel_heat_flux_density( + power_crossing_separatrix: Unitfull, + fraction_of_P_SOL_to_divertor: Unitfull, + upstream_major_radius: Unitfull, + lambda_q: Unitfull, + upstream_fieldline_pitch: Unitfull, +) -> Unitfull: + """Calculate the parallel heat flux density entering the flux tube (q_par). + + This expression is power to target divided by the area perpendicular to the flux tube. + 1. Power to target = power crossing separatrix * fraction of that power going to the target considered + 2. The poloidal area of a ring at the outboard midplane is 2 * pi * (R + minor_radius) * width + 3. For the width, we take the heat flux decay length lambda_q + 4. P_SOL * f_share / (2 * pi * (R + minor_radius) lambda_q) gives the heat flux per poloidal area + 5. We project this poloidal heat flux density into a parallel heat flux density by dividing by the field-line pitch + + Args: + power_crossing_separatrix: [MW] :term:`glossary link` + fraction_of_P_SOL_to_divertor: :term:`glossary link ` + upstream_major_radius: [m] R + minor_radius, major radius at outboard midplane separatrix + lambda_q: [mm] :term:`glossary link` + upstream_fieldline_pitch: B_total / B_poloidal at outboard midplane separatrix [~] + + Returns: + q_parallel [GW/m^2] + """ + return ( + power_crossing_separatrix * fraction_of_P_SOL_to_divertor / (2.0 * pi * upstream_major_radius * lambda_q) * upstream_fieldline_pitch + ) diff --git a/cfspopcon/formulas/scrape_off_layer_model/required_power_loss_fraction.py b/cfspopcon/formulas/scrape_off_layer_model/required_power_loss_fraction.py new file mode 100644 index 00000000..79859b22 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/required_power_loss_fraction.py @@ -0,0 +1,40 @@ +"""Calculate the SOL power loss fraction required to achieve a specified target electron temperature.""" + +from typing import Union + +import numpy as np +import xarray as xr + +from ...unit_handling import Quantity + + +def calc_required_SOL_power_loss_fraction( + target_electron_temp_basic: Union[Quantity, xr.DataArray], + f_other_target_electron_temp: Union[float, xr.DataArray], + SOL_momentum_loss_fraction: Union[Quantity, xr.DataArray], + required_target_electron_temp: Union[Quantity, xr.DataArray], +) -> Union[float, xr.DataArray]: + """Calculate the SOL radiated power fraction required to reach a desired target electron temperature. + + This equation is equation 15 of :cite:`stangeby_2018`, rearranged for $f_{cooling}$. + + Args: + target_electron_temp_basic: from target_electron_temp module [eV] + f_other_target_electron_temp: from target_electron_temp module [~] + SOL_momentum_loss_fraction: fraction of momentum lost in SOL [~] + required_target_electron_temp: what target temperature do we want? [eV] + + Returns: + SOL_power_loss_fraction [~] + """ + required_SOL_power_loss_fraction = xr.DataArray( + 1.0 + - np.sqrt( + required_target_electron_temp + / target_electron_temp_basic + * (1.0 - SOL_momentum_loss_fraction) ** 2 + / f_other_target_electron_temp + ) + ) + + return required_SOL_power_loss_fraction.clip(min=0.0) diff --git a/cfspopcon/formulas/scrape_off_layer_model/solve_target_first_two_point_model.py b/cfspopcon/formulas/scrape_off_layer_model/solve_target_first_two_point_model.py new file mode 100644 index 00000000..f5c364a0 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/solve_target_first_two_point_model.py @@ -0,0 +1,121 @@ +"""Compute all terms in the two-point-model for a fixed target electron temperature.""" +from typing import Union + +import xarray as xr + +from ...named_options import MomentumLossFunction +from ...unit_handling import Unitfull, ureg +from .momentum_loss_functions import calc_SOL_momentum_loss_fraction +from .required_power_loss_fraction import calc_required_SOL_power_loss_fraction +from .target_electron_density import ( + calc_f_other_target_electron_density, + calc_f_vol_loss_target_electron_density, + calc_target_electron_density, + calc_target_electron_density_basic, +) +from .target_electron_flux import ( + calc_f_other_target_electron_flux, + calc_f_vol_loss_target_electron_flux, + calc_target_electron_flux, + calc_target_electron_flux_basic, +) +from .target_electron_temp import calc_f_other_target_electron_temp, calc_target_electron_temp_basic +from .total_pressure import calc_upstream_total_pressure +from .upstream_electron_temp import calc_upstream_electron_temp + + +def solve_target_first_two_point_model( + target_electron_temp: Unitfull, + parallel_heat_flux_density: Unitfull, + parallel_connection_length: Unitfull, + upstream_electron_density: Unitfull, + toroidal_flux_expansion: Unitfull, + fuel_average_mass_number: Unitfull, + kappa_e0: Unitfull, + SOL_momentum_loss_function: Union[MomentumLossFunction, xr.DataArray], + sheath_heat_transmission_factor: Unitfull = 7.5 * ureg.dimensionless, + SOL_conduction_fraction: Unitfull = 1.0 * ureg.dimensionless, + target_ratio_of_ion_to_electron_temp: Unitfull = 1.0 * ureg.dimensionless, + target_ratio_of_electron_to_ion_density: Unitfull = 1.0 * ureg.dimensionless, + target_mach_number: Unitfull = 1.0 * ureg.dimensionless, + upstream_ratio_of_ion_to_electron_temp: Unitfull = 1.0 * ureg.dimensionless, + upstream_ratio_of_electron_to_ion_density: Unitfull = 1.0 * ureg.dimensionless, + upstream_mach_number: Unitfull = 0.0 * ureg.dimensionless, +) -> tuple[Unitfull, Unitfull, Unitfull, Unitfull]: + """Calculate the SOL_power_loss_fraction required to keep the target temperature at a given value. + + Args: + target_electron_temp: [eV] + parallel_heat_flux_density: [GW/m^2] + parallel_connection_length: [m] + upstream_electron_density: [m^-3] + toroidal_flux_expansion: [~] + fuel_average_mass_number: [~] + kappa_e0: electron heat conductivity constant [W / (eV^3.5 * m)] + SOL_momentum_loss_function: which momentum loss function to use + sheath_heat_transmission_factor: [~] + SOL_conduction_fraction: [~] + target_ratio_of_ion_to_electron_temp: [~] + target_ratio_of_electron_to_ion_density: [~] + target_mach_number: [~] + upstream_ratio_of_ion_to_electron_temp: [~] + upstream_ratio_of_electron_to_ion_density: [~] + upstream_mach_number: [~] + + Returns: + SOL_power_loss_fraction [~], upstream_electron_temp [eV], target_electron_density [m^-3], target_electron_flux [m^-2 s^-1] + """ + SOL_momentum_loss_fraction = calc_SOL_momentum_loss_fraction(SOL_momentum_loss_function, target_electron_temp) + + upstream_electron_temp = calc_upstream_electron_temp( + target_electron_temp=target_electron_temp, + parallel_heat_flux_density=parallel_heat_flux_density, + parallel_connection_length=parallel_connection_length, + SOL_conduction_fraction=SOL_conduction_fraction, + kappa_e0=kappa_e0, + ) + + upstream_total_pressure = calc_upstream_total_pressure( + upstream_electron_density=upstream_electron_density, + upstream_electron_temp=upstream_electron_temp, + upstream_ratio_of_ion_to_electron_temp=upstream_ratio_of_ion_to_electron_temp, + upstream_ratio_of_electron_to_ion_density=upstream_ratio_of_electron_to_ion_density, + upstream_mach_number=upstream_mach_number, + ) + + f_basic_kwargs = dict( + fuel_average_mass_number=fuel_average_mass_number, + parallel_heat_flux_density=parallel_heat_flux_density, + upstream_total_pressure=upstream_total_pressure, + sheath_heat_transmission_factor=sheath_heat_transmission_factor, + ) + + f_other_kwargs = dict( + target_ratio_of_ion_to_electron_temp=target_ratio_of_ion_to_electron_temp, + target_ratio_of_electron_to_ion_density=target_ratio_of_electron_to_ion_density, + target_mach_number=target_mach_number, + toroidal_flux_expansion=toroidal_flux_expansion, + ) + + SOL_power_loss_fraction = calc_required_SOL_power_loss_fraction( + target_electron_temp_basic=calc_target_electron_temp_basic(**f_basic_kwargs), + f_other_target_electron_temp=calc_f_other_target_electron_temp(**f_other_kwargs), + SOL_momentum_loss_fraction=SOL_momentum_loss_fraction, + required_target_electron_temp=target_electron_temp, + ) + + f_vol_loss_kwargs = dict(SOL_power_loss_fraction=SOL_power_loss_fraction, SOL_momentum_loss_fraction=SOL_momentum_loss_fraction) + + target_electron_density = calc_target_electron_density( + target_electron_density_basic=calc_target_electron_density_basic(**f_basic_kwargs), + f_vol_loss_target_electron_density=calc_f_vol_loss_target_electron_density(**f_vol_loss_kwargs), + f_other_target_electron_density=calc_f_other_target_electron_density(**f_other_kwargs), + ) + + target_electron_flux = calc_target_electron_flux( + target_electron_flux_basic=calc_target_electron_flux_basic(**f_basic_kwargs), + f_vol_loss_target_electron_flux=calc_f_vol_loss_target_electron_flux(**f_vol_loss_kwargs), + f_other_target_electron_flux=calc_f_other_target_electron_flux(**f_other_kwargs), + ) + + return SOL_power_loss_fraction, upstream_electron_temp, target_electron_density, target_electron_flux diff --git a/cfspopcon/formulas/scrape_off_layer_model/solve_two_point_model.py b/cfspopcon/formulas/scrape_off_layer_model/solve_two_point_model.py new file mode 100644 index 00000000..cde26ad1 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/solve_two_point_model.py @@ -0,0 +1,209 @@ +"""Compute all terms in the two-point-model for a fixed SOL power loss fraction.""" +from typing import Union + +import numpy as np +import xarray as xr + +from ...named_options import MomentumLossFunction +from ...unit_handling import Quantity, Unitfull, ureg +from .momentum_loss_functions import calc_SOL_momentum_loss_fraction +from .target_electron_density import ( + calc_f_other_target_electron_density, + calc_f_vol_loss_target_electron_density, + calc_target_electron_density, + calc_target_electron_density_basic, +) +from .target_electron_flux import ( + calc_f_other_target_electron_flux, + calc_f_vol_loss_target_electron_flux, + calc_target_electron_flux, + calc_target_electron_flux_basic, +) +from .target_electron_temp import ( + calc_f_other_target_electron_temp, + calc_f_vol_loss_target_electron_temp, + calc_target_electron_temp, + calc_target_electron_temp_basic, +) +from .total_pressure import calc_upstream_total_pressure +from .upstream_electron_temp import calc_upstream_electron_temp + + +def solve_two_point_model( + SOL_power_loss_fraction: Unitfull, + parallel_heat_flux_density: Unitfull, + parallel_connection_length: Unitfull, + upstream_electron_density: Unitfull, + toroidal_flux_expansion: Unitfull, + fuel_average_mass_number: Unitfull, + kappa_e0: Unitfull, + SOL_momentum_loss_function: Union[MomentumLossFunction, xr.DataArray], + initial_target_electron_temp: Unitfull = 10.0 * ureg.eV, + sheath_heat_transmission_factor: Unitfull = 7.5 * ureg.dimensionless, + SOL_conduction_fraction: Unitfull = 1.0 * ureg.dimensionless, + target_ratio_of_ion_to_electron_temp: Unitfull = 1.0 * ureg.dimensionless, + target_ratio_of_electron_to_ion_density: Unitfull = 1.0 * ureg.dimensionless, + target_mach_number: Unitfull = 1.0 * ureg.dimensionless, + upstream_ratio_of_ion_to_electron_temp: Unitfull = 1.0 * ureg.dimensionless, + upstream_ratio_of_electron_to_ion_density: Unitfull = 1.0 * ureg.dimensionless, + upstream_mach_number: Unitfull = 0.0 * ureg.dimensionless, + # Controlling the iterative solve + max_iterations: int = 100, + upstream_temp_relaxation: float = 0.5, + target_electron_density_relaxation: float = 0.5, + target_temp_relaxation: float = 0.5, + upstream_temp_max_residual: float = 1e-2, + target_electron_density_max_residual: float = 1e-2, + target_temp_max_residual: float = 1e-2, + # Return converged values even if not whole array is converged + raise_error_if_not_converged: bool = True, + # Print information about the solve to terminal + quiet: bool = True, +) -> tuple[Union[Quantity, xr.DataArray], Union[Quantity, xr.DataArray], Union[Quantity, xr.DataArray], Union[Quantity, xr.DataArray]]: + """Calculate the upstream and target electron temperature and target electron density according to the extended two-point-model. + + Args: + SOL_power_loss_fraction: [~] + parallel_heat_flux_density: [GW/m^2] + parallel_connection_length: [m] + upstream_electron_density: [m^-3] + toroidal_flux_expansion: [~] + fuel_average_mass_number: [~] + kappa_e0: electron heat conductivity constant [W / (eV^3.5 * m)] + SOL_momentum_loss_function: which momentum loss function to use + initial_target_electron_temp: starting guess for target electron temp [eV] + sheath_heat_transmission_factor: [~] + SOL_conduction_fraction: [~] + target_ratio_of_ion_to_electron_temp: [~] + target_ratio_of_electron_to_ion_density: [~] + target_mach_number: [~] + upstream_ratio_of_ion_to_electron_temp: [~] + upstream_ratio_of_electron_to_ion_density: [~] + upstream_mach_number: [~] + max_iterations: how many iterations to try before returning NaN + upstream_temp_relaxation: step-size for upstream Te evolution + target_electron_density_relaxation: step-size for target ne evolution + target_temp_relaxation: step-size for target Te evolution + upstream_temp_max_residual: relative rate of change for convergence for upstream Te evolution + target_electron_density_max_residual: relative rate of change for convergence for target ne evolution + target_temp_max_residual: relative rate of change for convergence for target Te evolution + raise_error_if_not_converged: raise an error if not all point converge within max iterations (otherwise return NaN) + quiet: if not True, print additional information about the iterative solve to terminal + Returns: + upstream_electron_temp [eV], target_electron_density [m^-3], target_electron_temp [eV], target_electron_flux [m^-2 s^-1] + """ + f_other_kwargs = dict( + target_ratio_of_ion_to_electron_temp=target_ratio_of_ion_to_electron_temp, + target_ratio_of_electron_to_ion_density=target_ratio_of_electron_to_ion_density, + target_mach_number=target_mach_number, + toroidal_flux_expansion=toroidal_flux_expansion, + ) + f_other_target_electron_density = calc_f_other_target_electron_density(**f_other_kwargs) + f_other_target_electron_temp = calc_f_other_target_electron_temp(**f_other_kwargs) + f_other_target_electron_flux = calc_f_other_target_electron_flux(**f_other_kwargs) + + iteration = 0 + target_electron_temp = initial_target_electron_temp + + while iteration < max_iterations: + iteration += 1 + + new_upstream_electron_temp = calc_upstream_electron_temp( + target_electron_temp=target_electron_temp, + parallel_heat_flux_density=parallel_heat_flux_density, + parallel_connection_length=parallel_connection_length, + SOL_conduction_fraction=SOL_conduction_fraction, + kappa_e0=kappa_e0, + ) + + upstream_total_pressure = calc_upstream_total_pressure( + upstream_electron_density=upstream_electron_density, + upstream_electron_temp=new_upstream_electron_temp, + upstream_ratio_of_ion_to_electron_temp=upstream_ratio_of_ion_to_electron_temp, + upstream_ratio_of_electron_to_ion_density=upstream_ratio_of_electron_to_ion_density, + upstream_mach_number=upstream_mach_number, + ) + + f_vol_loss_kwargs = dict( + SOL_power_loss_fraction=SOL_power_loss_fraction, + SOL_momentum_loss_fraction=calc_SOL_momentum_loss_fraction(SOL_momentum_loss_function, target_electron_temp), + ) + + f_basic_kwargs = dict( + fuel_average_mass_number=fuel_average_mass_number, + parallel_heat_flux_density=parallel_heat_flux_density, + upstream_total_pressure=upstream_total_pressure, + sheath_heat_transmission_factor=sheath_heat_transmission_factor, + ) + + target_electron_density_basic = calc_target_electron_density_basic(**f_basic_kwargs) + target_electron_temp_basic = calc_target_electron_temp_basic(**f_basic_kwargs) + + f_vol_loss_target_electron_density = calc_f_vol_loss_target_electron_density(**f_vol_loss_kwargs) + f_vol_loss_target_electron_temp = calc_f_vol_loss_target_electron_temp(**f_vol_loss_kwargs) + + new_target_electron_density = calc_target_electron_density( + target_electron_density_basic=target_electron_density_basic, + f_vol_loss_target_electron_density=f_vol_loss_target_electron_density, + f_other_target_electron_density=f_other_target_electron_density, + ) + + new_target_electron_temp = calc_target_electron_temp( + target_electron_temp_basic=target_electron_temp_basic, + f_vol_loss_target_electron_temp=f_vol_loss_target_electron_temp, + f_other_target_electron_temp=f_other_target_electron_temp, + ) + + if iteration == 1: + upstream_electron_temp = new_upstream_electron_temp + target_electron_density = new_target_electron_density + target_electron_temp = new_target_electron_temp + continue + + change_in_upstream_electron_temp = new_upstream_electron_temp - upstream_electron_temp + change_in_target_electron_density = new_target_electron_density - target_electron_density + change_in_target_electron_temp = new_target_electron_temp - target_electron_temp + + upstream_electron_temp = upstream_electron_temp + upstream_temp_relaxation * change_in_upstream_electron_temp + target_electron_density = target_electron_density + target_electron_density_relaxation * change_in_target_electron_density + target_electron_temp = target_electron_temp + target_temp_relaxation * change_in_target_electron_temp + + if np.all( + [ + np.abs(change_in_upstream_electron_temp / upstream_electron_temp).max() < upstream_temp_max_residual, + np.abs(change_in_target_electron_density / target_electron_density).max() < target_electron_density_max_residual, + np.abs(change_in_target_electron_temp / target_electron_temp).max() < target_temp_max_residual, + ] + ): + if not quiet: + print(f"Converged in {iteration} iterations") + break + else: + if raise_error_if_not_converged: + raise RuntimeError("Iterative solve did not converge.") + + target_electron_flux_basic = calc_target_electron_flux_basic(**f_basic_kwargs) + f_vol_loss_target_electron_flux = calc_f_vol_loss_target_electron_flux(**f_vol_loss_kwargs) + + target_electron_flux = calc_target_electron_flux( + target_electron_flux_basic=target_electron_flux_basic, + f_vol_loss_target_electron_flux=f_vol_loss_target_electron_flux, + f_other_target_electron_flux=f_other_target_electron_flux, + ) + + mask = ( + (np.abs(change_in_upstream_electron_temp / upstream_electron_temp) < upstream_temp_max_residual) + & (np.abs(change_in_target_electron_density / target_electron_density) < target_electron_density_max_residual) + & (np.abs(change_in_target_electron_temp / target_electron_temp) < target_temp_max_residual) + ) + + number_nonconverged = np.count_nonzero(~mask) + if number_nonconverged > 0 and not quiet: + print(f"{number_nonconverged} values did not converge in {max_iterations} iterations.") + + upstream_electron_temp = xr.where(mask, upstream_electron_temp, np.nan) # type:ignore[no-untyped-call] + target_electron_density = xr.where(mask, target_electron_density, np.nan) # type:ignore[no-untyped-call] + target_electron_temp = xr.where(mask, target_electron_temp, np.nan) # type:ignore[no-untyped-call] + target_electron_flux = xr.where(mask, target_electron_flux, np.nan) # type:ignore[no-untyped-call] + + return upstream_electron_temp, target_electron_density, target_electron_temp, target_electron_flux diff --git a/cfspopcon/formulas/scrape_off_layer_model/target_electron_density.py b/cfspopcon/formulas/scrape_off_layer_model/target_electron_density.py new file mode 100644 index 00000000..f2659407 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/target_electron_density.py @@ -0,0 +1,93 @@ +"""Routines to calculate the target electron density, following the 2-point-model method of Stangeby, PPCF 2018.""" +from typing import Union + +import xarray as xr + +from ...unit_handling import Quantity + + +def calc_target_electron_density( + target_electron_density_basic: Union[Quantity, xr.DataArray], + f_vol_loss_target_electron_density: Union[float, xr.DataArray], + f_other_target_electron_density: Union[float, xr.DataArray], +) -> Union[Quantity, xr.DataArray]: + """Calculate the target electron density, correcting for volume-losses and other effects. + + Components are calculated using the other functions in this file. + """ + return target_electron_density_basic * f_vol_loss_target_electron_density * f_other_target_electron_density + + +def calc_target_electron_density_basic( + fuel_average_mass_number: Union[Quantity, xr.DataArray], + parallel_heat_flux_density: Union[Quantity, xr.DataArray], + upstream_total_pressure: Union[Quantity, xr.DataArray], + sheath_heat_transmission_factor: Union[float, xr.DataArray], +) -> Union[Quantity, xr.DataArray]: + """Calculate the electron density at the target according to the basic two-point-model. + + From equation 24, :cite:`stangeby_2018`. + + Args: + fuel_average_mass_number: [amu] + parallel_heat_flux_density: [GW/m^2] + upstream_total_pressure: [atm] + sheath_heat_transmission_factor: [~] + + Returns: + target_electron_density_basic [m^-3] + """ + return ( + sheath_heat_transmission_factor**2 + / (32.0 * fuel_average_mass_number) + * upstream_total_pressure**3 + / parallel_heat_flux_density**2 + ) + + +def calc_f_vol_loss_target_electron_density( + SOL_power_loss_fraction: Union[float, xr.DataArray], + SOL_momentum_loss_fraction: Union[float, xr.DataArray], +) -> Union[float, xr.DataArray]: + """Calculate the volume-loss correction term for the electron density at the target. + + From equation 24, :cite:`stangeby_2018`. + + Args: + SOL_power_loss_fraction: f_cooling [~] + SOL_momentum_loss_fraction: f_mom-loss [~] + + Returns: + f_vol_loss_target_electron_density [~] + """ + return (1.0 - SOL_momentum_loss_fraction) ** 3 / (1.0 - SOL_power_loss_fraction) ** 2 + + +def calc_f_other_target_electron_density( + target_ratio_of_ion_to_electron_temp: Union[float, xr.DataArray], + target_ratio_of_electron_to_ion_density: Union[float, xr.DataArray], + target_mach_number: Union[float, xr.DataArray], + toroidal_flux_expansion: Union[float, xr.DataArray], +) -> Union[float, xr.DataArray]: + """Calculate correction terms other than the volume-loss correction for the electron density at the target. + + Includes flux expansion, dilution of ions, different electron and ion temperatures and sub/super-sonic outflow. + + From equation 24, :cite:`stangeby_2018`., with + + Args: + target_ratio_of_ion_to_electron_temp: tau_t = (T_i / T_e)_target [equation 21] [~] + target_ratio_of_electron_to_ion_density: z_t = (ne / total ion density)_target [equation 22] [~] + target_mach_number: M_t = (parallel ion velocity / sound speed)_target [~] + toroidal_flux_expansion: R_t/R_u = major radius at target / major radius upstream [see discussion around equation 12] [~] + + Returns: + f_other_target_electron_density [~] + """ + return ( + (4.0 / (1.0 + target_ratio_of_ion_to_electron_temp / target_ratio_of_electron_to_ion_density) ** 2) + * 8.0 + * target_mach_number**2 + / (1.0 + target_mach_number**2) ** 3 + * toroidal_flux_expansion**2 + ) diff --git a/cfspopcon/formulas/scrape_off_layer_model/target_electron_flux.py b/cfspopcon/formulas/scrape_off_layer_model/target_electron_flux.py new file mode 100644 index 00000000..ce6292ae --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/target_electron_flux.py @@ -0,0 +1,87 @@ +"""Routines to calculate the target electron flux, following the 2-point-model method of Stangeby, PPCF 2018.""" +from typing import Union + +import xarray as xr + +from ...unit_handling import Quantity + + +def calc_target_electron_flux( + target_electron_flux_basic: Union[Quantity, xr.DataArray], + f_vol_loss_target_electron_flux: Union[float, xr.DataArray], + f_other_target_electron_flux: Union[float, xr.DataArray], +) -> Union[Quantity, xr.DataArray]: + """Calculate the target electron flux, correcting for volume-losses and other effects. + + Components are calculated using the other functions in this file. + """ + return target_electron_flux_basic * f_vol_loss_target_electron_flux * f_other_target_electron_flux + + +def calc_target_electron_flux_basic( + fuel_average_mass_number: Union[Quantity, xr.DataArray], + parallel_heat_flux_density: Union[Quantity, xr.DataArray], + upstream_total_pressure: Union[Quantity, xr.DataArray], + sheath_heat_transmission_factor: Union[float, xr.DataArray], +) -> Union[Quantity, xr.DataArray]: + """Calculate the flux of electrons (particles per square-metre per second) at the target according to the basic two-point-model. + + From equation 24, :cite:`stangeby_2018`. + + Args: + fuel_average_mass_number: [amu] + parallel_heat_flux_density: [GW/m^2] + upstream_total_pressure: [atm] + sheath_heat_transmission_factor: [~] + + Returns: + target_electron_flux_basic [m^-2 s^-1] + """ + return sheath_heat_transmission_factor / (8.0 * fuel_average_mass_number) * upstream_total_pressure**2 / parallel_heat_flux_density + + +def calc_f_vol_loss_target_electron_flux( + SOL_power_loss_fraction: Union[float, xr.DataArray], + SOL_momentum_loss_fraction: Union[float, xr.DataArray], +) -> Union[float, xr.DataArray]: + """Calculate the volume-loss correction term for the electron flux at the target. + + From equation 24, :cite:`stangeby_2018`. + + Args: + SOL_power_loss_fraction: f_cooling [~] + SOL_momentum_loss_fraction: f_mom-loss [~] + + Returns: + f_vol_loss_target_electron_flux [~] + """ + return (1.0 - SOL_momentum_loss_fraction) ** 2 / (1.0 - SOL_power_loss_fraction) + + +def calc_f_other_target_electron_flux( + target_ratio_of_ion_to_electron_temp: Union[float, xr.DataArray], + target_ratio_of_electron_to_ion_density: Union[float, xr.DataArray], + target_mach_number: Union[float, xr.DataArray], + toroidal_flux_expansion: Union[float, xr.DataArray], +) -> Union[float, xr.DataArray]: + """Calculate correction terms other than the volume-loss correction for the electron flux at the target. + + Includes flux expansion, dilution of ions, different electron and ion temperatures and sub/super-sonic outflow. + From equation 24, :cite:`stangeby_2018`., with + + Args: + target_ratio_of_ion_to_electron_temp: tau_t = (T_i / T_e)_target [equation 21] [~] + target_ratio_of_electron_to_ion_density: z_t = (ne / total ion density)_target [equation 22] [~] + target_mach_number: M_t = (parallel ion velocity / sound speed)_target [~] + toroidal_flux_expansion: R_t/R_u = major radius at target / major radius upstream [see discussion around equation 12] [~] + + Returns: + f_other_target_electron_flux [~] + """ + return ( + (2.0 / (1.0 + target_ratio_of_ion_to_electron_temp / target_ratio_of_electron_to_ion_density)) + * 4.0 + * target_mach_number**2 + / (1.0 + target_mach_number**2) ** 2 + * toroidal_flux_expansion + ) diff --git a/cfspopcon/formulas/scrape_off_layer_model/target_electron_temp.py b/cfspopcon/formulas/scrape_off_layer_model/target_electron_temp.py new file mode 100644 index 00000000..32065fec --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/target_electron_temp.py @@ -0,0 +1,88 @@ +"""Routines to calculate the target electron temperature, following the 2-point-model method of Stangeby, PPCF 2018.""" +from typing import Union + +import xarray as xr + +from ...unit_handling import Quantity + + +def calc_target_electron_temp( + target_electron_temp_basic: Union[Quantity, xr.DataArray], + f_vol_loss_target_electron_temp: Union[float, xr.DataArray], + f_other_target_electron_temp: Union[float, xr.DataArray], +) -> Union[Quantity, xr.DataArray]: + """Calculate the target electron temperature, correcting for volume-losses and other effects. + + Components are calculated using the other functions in this file. + """ + return target_electron_temp_basic * f_vol_loss_target_electron_temp * f_other_target_electron_temp + + +def calc_target_electron_temp_basic( + fuel_average_mass_number: Union[Quantity, xr.DataArray], + parallel_heat_flux_density: Union[Quantity, xr.DataArray], + upstream_total_pressure: Union[Quantity, xr.DataArray], + sheath_heat_transmission_factor: Union[float, xr.DataArray], +) -> Union[Quantity, xr.DataArray]: + """Calculate the electron temperature at the target according to the basic two-point-model. + + From equation 24, :cite:`stangeby_2018`. + + Args: + fuel_average_mass_number: [amu] + parallel_heat_flux_density: [GW/m^2] + upstream_total_pressure: [atm] + sheath_heat_transmission_factor: [~] + + Returns: + target_electron_temp_basic [eV] + """ + return (8.0 * fuel_average_mass_number / sheath_heat_transmission_factor**2) * ( + parallel_heat_flux_density**2 / upstream_total_pressure**2 + ) + + +def calc_f_vol_loss_target_electron_temp( + SOL_power_loss_fraction: Union[float, xr.DataArray], + SOL_momentum_loss_fraction: Union[float, xr.DataArray], +) -> Union[float, xr.DataArray]: + """Calculate the volume-loss correction term for the electron temperature at the target. + + From equation 24, :cite:`stangeby_2018`. + + Args: + SOL_power_loss_fraction: f_cooling [~] + SOL_momentum_loss_fraction: f_mom-loss [~] + + Returns: + f_vol_loss_target_electron_temp [~] + """ + return (1.0 - SOL_power_loss_fraction) ** 2 / (1.0 - SOL_momentum_loss_fraction) ** 2 + + +def calc_f_other_target_electron_temp( + target_ratio_of_ion_to_electron_temp: Union[float, xr.DataArray], + target_ratio_of_electron_to_ion_density: Union[float, xr.DataArray], + target_mach_number: Union[float, xr.DataArray], + toroidal_flux_expansion: Union[float, xr.DataArray], +) -> Union[float, xr.DataArray]: + """Calculate correction terms other than the volume-loss correction for the electron temperature at the target. + + Includes flux expansion, dilution of ions, different electron and ion temperatures and sub/super-sonic outflow. + + From equation 24, :cite:`stangeby_2018`., with + + Args: + target_ratio_of_ion_to_electron_temp: tau_t = (T_i / T_e)_target [equation 21] [~] + target_ratio_of_electron_to_ion_density: z_t = (ne / total ion density)_target [equation 22] [~] + target_mach_number: M_t = (parallel ion velocity / sound speed)_target [~] + toroidal_flux_expansion: R_t/R_u = major radius at target / major radius upstream [see discussion around equation 12] [~] + + Returns: + f_other_target_electron_temp [~] + """ + return ( + ((1.0 + target_ratio_of_ion_to_electron_temp / target_ratio_of_electron_to_ion_density) / 2.0) + * ((1.0 + target_mach_number**2) ** 2 / (4.0 * target_mach_number**2)) + * toroidal_flux_expansion**-2 + ) diff --git a/cfspopcon/formulas/scrape_off_layer_model/total_pressure.py b/cfspopcon/formulas/scrape_off_layer_model/total_pressure.py new file mode 100644 index 00000000..46a74ac8 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/total_pressure.py @@ -0,0 +1,65 @@ +"""Routines to calculate the combined electron and ion pressure in the SOL.""" +from typing import Union + +import xarray as xr + +from ...unit_handling import Quantity + + +def calc_upstream_total_pressure( + upstream_electron_density: Union[Quantity, xr.DataArray], + upstream_electron_temp: Union[Quantity, xr.DataArray], + upstream_ratio_of_ion_to_electron_temp: Union[float, xr.DataArray], + upstream_ratio_of_electron_to_ion_density: Union[float, xr.DataArray], + upstream_mach_number: Union[float, xr.DataArray] = 0.0, +) -> Union[Quantity, xr.DataArray]: + """Calculate the upstream total pressure (including the ion temperature contribution). + + Same as calc_total_pressure, but with a default value upstream_mach_number=0.0. + + Args: + upstream_electron_density: [m^-3] + upstream_electron_temp: [eV] + upstream_ratio_of_ion_to_electron_temp: tau_t = (T_i / T_e) [~] + upstream_ratio_of_electron_to_ion_density: z_t = (ne / ni) [~] + upstream_mach_number: M_t = (parallel ion velocity / sound speed) [~] + + Returns: + upstream_total_pressure [atm] + """ + return calc_total_pressure( + electron_density=upstream_electron_density, + electron_temp=upstream_electron_temp, + ratio_of_ion_to_electron_temp=upstream_ratio_of_ion_to_electron_temp, + ratio_of_electron_to_ion_density=upstream_ratio_of_electron_to_ion_density, + mach_number=upstream_mach_number, + ) + + +def calc_total_pressure( + electron_density: Union[Quantity, xr.DataArray], + electron_temp: Union[Quantity, xr.DataArray], + ratio_of_ion_to_electron_temp: Union[float, xr.DataArray], + ratio_of_electron_to_ion_density: Union[float, xr.DataArray], + mach_number: Union[float, xr.DataArray], +) -> Union[Quantity, xr.DataArray]: + """Calculate the total pressure (including ion temperature contribution). + + From equation 20, :cite:`stangeby_2018`. + + Args: + electron_density: [m^-3] + electron_temp: [eV] + ratio_of_ion_to_electron_temp: tau_t = (T_i / T_e) [~] + ratio_of_electron_to_ion_density: z_t = (ne / ni) [~] + mach_number: M_t = (parallel ion velocity / sound speed) [~] + + Returns: + upstream_total_pressure [atm] + """ + return ( + (1.0 + mach_number**2) + * electron_density + * electron_temp + * (1.0 + ratio_of_ion_to_electron_temp / ratio_of_electron_to_ion_density) + ) diff --git a/cfspopcon/formulas/scrape_off_layer_model/upstream_electron_temp.py b/cfspopcon/formulas/scrape_off_layer_model/upstream_electron_temp.py new file mode 100644 index 00000000..e5f02f50 --- /dev/null +++ b/cfspopcon/formulas/scrape_off_layer_model/upstream_electron_temp.py @@ -0,0 +1,33 @@ +"""Routines to calculate the upstream electron temperature.""" + +from typing import Union + +import xarray as xr + +from ...unit_handling import Quantity + + +def calc_upstream_electron_temp( + target_electron_temp: Union[Quantity, xr.DataArray], + parallel_heat_flux_density: Union[Quantity, xr.DataArray], + parallel_connection_length: Union[Quantity, xr.DataArray], + kappa_e0: Union[Quantity, xr.DataArray], + SOL_conduction_fraction: Union[float, xr.DataArray] = 1.0, +) -> Union[Quantity, xr.DataArray]: + """Calculate the upstream electron temperature. + + Equation 38 from :cite:`stangeby_2018`, keeping the dependence on target_electron_temp. + + Args: + target_electron_temp: [eV] + parallel_heat_flux_density: [GW/m^2] + parallel_connection_length: [m] + kappa_e0: [W / (eV**3.5 m)] + SOL_conduction_fraction: [eV] + + Returns: + upstream_electron_temp [eV] + """ + return ( + target_electron_temp**3.5 + 3.5 * (SOL_conduction_fraction * parallel_heat_flux_density * parallel_connection_length / kappa_e0) + ) ** (2.0 / 7.0) diff --git a/cfspopcon/helpers.py b/cfspopcon/helpers.py new file mode 100644 index 00000000..cd03cb95 --- /dev/null +++ b/cfspopcon/helpers.py @@ -0,0 +1,105 @@ +"""Constructors and helper functions.""" +from typing import Any, Union + +import xarray as xr + +from .named_options import ( + Algorithms, + ConfinementScaling, + Impurity, + LambdaQScaling, + MomentumLossFunction, + ProfileForm, + RadiationMethod, + ReactionType, +) + + +def convert_named_options(key: str, val: Any) -> Any: # noqa: PLR0911, PLR0912 + """Given a 'key' matching a named_option, return the corresponding Enum value.""" + if key == "algorithms": + return Algorithms[val] + elif key == "energy_confinement_scaling": + return ConfinementScaling[val] + elif key == "profile_form": + return ProfileForm[val] + elif key == "radiated_power_method": + return RadiationMethod[val] + elif key == "fusion_reaction": + return ReactionType[val] + elif key == "impurity": + return Impurity[val] + elif key == "impurities": + return make_impurities_array(list(val.keys()), list(val.values())) + elif key == "core_radiator": + return Impurity[val] + elif key == "lambda_q_scaling": + return LambdaQScaling[val] + elif key == "SOL_momentum_loss_function": + return MomentumLossFunction[val] + elif key == "tauE_scaling": + return ConfinementScaling[val] + elif key == "reaction_type": + return ReactionType[val] + elif key == "radiation_method": + return RadiationMethod[val] + else: + # If the key doesn't match, don't convert the value + return val + + +def make_impurities_array( + species_list: Union[list[Union[str, Impurity]], Union[str, Impurity]], + concentrations_list: Union[list[Union[float, xr.DataArray]], Union[float, xr.DataArray]], +) -> xr.DataArray: + """Make an xr.DataArray with impurity species and their corresponding concentrations. + + This array should be used as the `impurities` variable. + """ + # Convert DataArrays of species into plain lists. This is useful if you want to store Impurity objects in a dataset. + if isinstance(species_list, (xr.DataArray)): + species_list = species_list.values.tolist() + # Deal with single-value input (not recommended, but avoids a confusing user error) + if isinstance(species_list, (str, Impurity)): + species_list = [ + species_list, + ] + if isinstance(concentrations_list, (float, xr.DataArray)): + concentrations_list = [ + concentrations_list, + ] + + if not len(species_list) == len(concentrations_list): + raise ValueError(f"Dimension mismatch. Input was species list [{species_list}], concentrations list [{concentrations_list}]") + + array = xr.DataArray() + for species, concentration in zip(species_list, concentrations_list): + array = extend_impurities_array(array, species, concentration) + + return array + + +def make_impurities_array_from_kwargs(**kwargs: Any) -> xr.DataArray: + """Make an xr.DataArray with impurity species and their corresponding concentrations, using the format (species1=concentration1, ...).""" + return make_impurities_array(list(kwargs.keys()), list(kwargs.values())) + + +def extend_impurities_array(array: xr.DataArray, species: Union[str, Impurity], concentration: Union[float, xr.DataArray]) -> xr.DataArray: + """Append a new element to the impurities array. + + This method automatically handles broadcasting. + + N.b. You can also 'extend' an empty array, constructed via xr.DataArray() + """ + if not isinstance(species, Impurity): + species = Impurity[species.capitalize()] + + if not isinstance(concentration, xr.DataArray): + concentration = xr.DataArray(concentration) + concentration = concentration.expand_dims("dim_species").assign_coords(dim_species=[species]) + + if array.ndim == 0: + return concentration + else: + other_species = array.sel(dim_species=[s for s in array.dim_species if s != species]) + return xr.concat((other_species, concentration), dim="dim_species") diff --git a/cfspopcon/input_file_handling.py b/cfspopcon/input_file_handling.py new file mode 100644 index 00000000..25e91e04 --- /dev/null +++ b/cfspopcon/input_file_handling.py @@ -0,0 +1,64 @@ +"""Methods to run analyses configured via input files.""" + +from pathlib import Path +from typing import Any, Union + +import numpy as np +import xarray as xr +import yaml + +from .algorithms import get_algorithm +from .algorithms.algorithm_class import Algorithm, CompositeAlgorithm +from .helpers import convert_named_options +from .unit_handling import set_default_units + + +def read_case(case: Union[str, Path]) -> tuple[dict[str, Any], Union[CompositeAlgorithm, Algorithm], dict[str, Any]]: + """Read a yaml file corresponding to a given case. + + case should be passed either as a complete filepath to an input.yaml file or to + the parent folder of an input.yaml file. + """ + if Path(case).exists(): + case = Path(case) + if case.is_dir(): + input_file = case / "input.yaml" + else: + input_file = case + else: + raise FileNotFoundError(f"Could not find {case}.") + + with open(input_file) as file: + repr_d: dict[str, Any] = yaml.load(file, Loader=yaml.FullLoader) + + algorithms = repr_d.pop("algorithms") + algorithm_list = [get_algorithm(algorithm) for algorithm in algorithms] + + # why doesn't mypy deduce the below without hint? + algorithm: Union[Algorithm, CompositeAlgorithm] = CompositeAlgorithm(algorithm_list) if len(algorithm_list) > 1 else algorithm_list[0] + + points = repr_d.pop("points") + + grid_values = repr_d.pop("grid") + for key, grid_spec in grid_values.items(): + grid_spacing = grid_spec.get("spacing", "linear") + + if grid_spacing == "linear": + grid_vals = np.linspace(grid_spec["min"], grid_spec["max"], num=grid_spec["num"]) + elif grid_spacing == "log": + grid_vals = np.logspace(np.log10(grid_spec["min"]), np.log10(grid_spec["max"]), num=grid_spec["num"]) + else: + raise NotImplementedError(f"No implementation for grid with {grid_spec['spacing']} spacing.") + + repr_d[key] = xr.DataArray(grid_vals, coords={f"dim_{key}": grid_vals}) + + for key, val in repr_d.items(): + if isinstance(val, (list, tuple)): + repr_d[key] = [convert_named_options(key=key, val=v) for v in val] + else: + repr_d[key] = convert_named_options(key=key, val=val) + + for key, val in repr_d.items(): + repr_d[key] = set_default_units(key=key, value=val) + + return repr_d, algorithm, points diff --git a/cfspopcon/named_options.py b/cfspopcon/named_options.py new file mode 100644 index 00000000..f905efc3 --- /dev/null +++ b/cfspopcon/named_options.py @@ -0,0 +1,127 @@ +"""Enumerators to constrain options for functions.""" +from enum import Enum, auto + + +class Algorithms(Enum): + """Select which top-level algorithm to run.""" + + predictive_popcon = auto() + two_point_model_fixed_fpow = auto() + two_point_model_fixed_qpart = auto() + two_point_model_fixed_tet = auto() + calc_beta = auto() + calc_core_radiated_power = auto() + calc_fusion_gain = auto() + calc_geometry = auto() + calc_heat_exhaust = auto() + calc_ohmic_power = auto() + calc_peaked_profiles = auto() + calc_plasma_current_from_q_star = auto() + calc_q_star_from_plasma_current = auto() + calc_power_balance_from_tau_e = auto() + calc_zeff_and_dilution_from_impurities = auto() + calc_confinement_transition_threshold_power = auto() + calc_ratio_P_LH = auto() + calc_f_rad_core = auto() + calc_normalised_collisionality = auto() + calc_rho_star = auto() + calc_triple_product = auto() + calc_greenwald_fraction = auto() + calc_current_relaxation_time = auto() + calc_peak_pressure = auto() + calc_average_total_pressure = auto() + calc_bootstrap_fraction = auto() + calc_auxillary_power = auto() + calc_average_ion_temp = auto() + calc_fuel_average_mass_number = auto() + calc_magnetic_field_on_axis = auto() + calc_extrinsic_core_radiator = auto() + require_P_rad_less_than_P_in = auto() + calc_P_SOL = auto() + use_LOC_tau_e_below_threshold = auto() + calc_plasma_stored_energy = auto() + + +class ProfileForm(Enum): + """Methods to calculate nT profiles.""" + + analytic = auto() + prf = auto() + + +class RadiationMethod(Enum): + """Methods to calculate radiation losses.""" + + Inherent = "Bremsstrahlung and synchrotron radiation only" + PostJensen = "Impurity radiation, using a coronal equilibrium model from Post & Jensen 1977" + MavrinCoronal = "Impurity radiation, using a coronal equilibrium model from Mavrin 2018" + MavrinNoncoronal = "Impurity radiation, using a non-coronal model from Mavrin 2017" + Radas = "Impurity line and bremsstrahlung radiation, using coronal Lz curves from Radas" + + +class ReactionType(Enum): + """Supported Fusion Fuel Reaction Types.""" + + DT = "Deuterium-Tritium" + DD = "Deuterium-Deuterium" + DHe3 = "Deuterium-Helium3" + pB11 = "Proton-Boron11" + + +class Impurity(Enum): + """Enum of possible impurity elements. + + The enum value represents the element's atomic number (Z). + """ + + Helium = 2 + Lithium = 3 + Beryllium = 4 + Carbon = 6 + Nitrogen = 7 + Oxygen = 8 + Neon = 10 + Argon = 18 + Krypton = 36 + Xenon = 54 + Tungsten = 74 + + +class ConfinementScaling(Enum): + r"""Enum of implemented \tau_{E} scalings.""" + ITER98y2 = auto() + ITER89P = auto() + ITER89P_ka = auto() + ITERL96Pth = auto() + ITER97L = auto() + IModey2 = auto() + ITPA20_STD5 = auto() + ITPA20_IL = auto() + ITPA20_IL_HighZ = auto() + ITPA_2018_STD5_OLS = auto() + ITPA_2018_STD5_WLS = auto() + ITPA_2018_STD5_GLS = auto() + ITPA_2018_STD5_SEL1_OLS = auto() + ITPA_2018_STD5_SEL1_WLS = auto() + ITPA_2018_STD5_SEL1_GLS = auto() + LOC = auto() + H_DS03 = auto() + + +class MomentumLossFunction(Enum): + """Select which SOL momentum loss function to use.""" + + KotovReiter = auto() + Sang = auto() + Jarvinen = auto() + Moulton = auto() + PerezH = auto() + PerezL = auto() + + +class LambdaQScaling(Enum): + """Options for heat flux decay length scaling.""" + + Brunner = auto() + EichRegression14 = auto() + EichRegression15 = auto() diff --git a/cfspopcon/plotting/__init__.py b/cfspopcon/plotting/__init__.py new file mode 100644 index 00000000..308326d9 --- /dev/null +++ b/cfspopcon/plotting/__init__.py @@ -0,0 +1,12 @@ +"""Plotting functionality.""" +from .coordinate_formatter import CoordinateFormatter +from .make_plot import label_contour, make_plot, units_to_string +from .plot_style_handling import read_plot_style + +__all__ = [ + "CoordinateFormatter", + "label_contour", + "make_plot", + "units_to_string", + "read_plot_style", +] diff --git a/cfspopcon/plotting/coordinate_formatter.py b/cfspopcon/plotting/coordinate_formatter.py new file mode 100644 index 00000000..a66c594c --- /dev/null +++ b/cfspopcon/plotting/coordinate_formatter.py @@ -0,0 +1,23 @@ +"""Adds a readout of the field at the current mouse position for a colormapped field plotted with pcolormesh, contour, quiver, etc. + +Usage: +>>> fig, ax = plt.subplots() +>>> ax.format_coord = CoordinateFormatter(x, y, z) +""" +import xarray as xr + + +class CoordinateFormatter: + """Data storage object used for providing a coordinate formatter.""" + + def __init__(self, array: xr.DataArray): # pragma: nocover + """Stores the data required for grid lookup.""" + self.array = array + + def __call__(self, mouse_x, mouse_y): # pragma: nocover + """Returns a string which gives the field value at the queried mouse position.""" + lookup = dict(zip(self.array.dims, (mouse_y, mouse_x))) + + mouse_z = float(self.array.sel(lookup, method="nearest").item()) + + return f"x={mouse_x:f}, y={mouse_y:f}, z={mouse_z:f}" diff --git a/cfspopcon/plotting/make_plot.py b/cfspopcon/plotting/make_plot.py new file mode 100644 index 00000000..ff03a4e4 --- /dev/null +++ b/cfspopcon/plotting/make_plot.py @@ -0,0 +1,156 @@ +"""Plot creation functions.""" +from pathlib import Path +from typing import Optional + +import matplotlib +import matplotlib.contour +import matplotlib.pyplot as plt +import numpy as np +import xarray as xr +from matplotlib.axes import Axes + +from cfspopcon import __version__ + +from ..point_selection import build_mask_from_dict, find_coords_of_minimum +from ..transform import build_transform_function_from_dict +from ..unit_handling import Quantity, Unit, dimensionless_magnitude +from .coordinate_formatter import CoordinateFormatter + + +def make_plot( + dataset: xr.Dataset, plot_params: dict, points: dict, title: str, ax: Optional[Axes] = None, output_dir: Path = Path(".") +) -> None: + """Given a dictionary corresponding to a plotting style, build a standard plot from the results of the POPCON.""" + if plot_params["type"] == "popcon": + if ax is None: + _, ax = plt.subplots(figsize=plot_params["figsize"], dpi=plot_params["show_dpi"]) + fig, ax = make_popcon_plot(dataset, title, plot_params, points, ax=ax) + else: + raise NotImplementedError(f"No plotting method for type '{plot_params['type']}'") + + if "save_as" in plot_params.keys() and output_dir is not None: + fig.savefig(output_dir / plot_params["save_as"]) + + +def make_popcon_plot(dataset: xr.Dataset, title: str, plot_params: dict, points: dict, ax: Axes): + """Make a plot.""" + fig = ax.figure + transform_func = build_transform_function_from_dict(dataset, plot_params) + + coords = plot_params["coords"] if "coords" in plot_params else plot_params["new_coords"] + legend_elements = dict() + + if "fill" in plot_params: + # Make a filled plot (max 1 variable) + subplot_params = plot_params["fill"] + field = dataset[subplot_params["variable"]] + units = subplot_params.get("units", field.pint.units) + field = field.pint.to(units) + + mask = build_mask_from_dict(dataset, plot_params=subplot_params) + transformed_field = transform_func(field.where(mask)) + + im = transformed_field.plot(ax=ax, add_colorbar=False) + cbar = fig.colorbar(im, ax=ax) + + ax.format_coord = CoordinateFormatter(transformed_field) + + cbar.ax.set_ylabel( + f"{subplot_params.get('cbar_label', subplot_params['variable'])} {units_to_string(field.pint.units)}", + rotation=270, + labelpad=subplot_params.get("labelpad", 15.0), + ) + + if "contour" in plot_params: + # Overlay contour plots + + for variable, subplot_params in plot_params["contour"].items(): + + field = dataset[variable] + units = subplot_params.get("units", field.pint.units) + field = field.pint.to(units) + + mask = build_mask_from_dict(dataset, plot_params=subplot_params) + transformed_field = transform_func(field.where(mask)) + + contour_set = transformed_field.plot.contour( + ax=ax, levels=subplot_params["levels"], colors=[subplot_params["color"]], linestyles=[subplot_params.get("line", "solid")] + ) + legend_entry = label_contour( + ax, contour_set, fontsize=subplot_params.get("fontsize", 10.0), format_spec=subplot_params.get("format", "") + ) + + legend_elements[subplot_params["label"]] = legend_entry + + for key, point_params in points.items(): + point_style = plot_params.get("points", dict()).get(key, dict()) + label = point_style.get("label", key) + + mask = build_mask_from_dict(dataset, point_params) + + if "minimize" not in point_params.keys() and "maximize" not in point_params.keys(): + raise ValueError(f"Need to provide either minimize or maximize in point specification. Keys were {point_params.keys()}") + + if "minimize" in point_params.keys(): + field = dataset[point_params["minimize"]] + else: + field = -dataset[point_params["maximize"]] + + transformed_field = transform_func(field.where(mask)) + + point_coords = find_coords_of_minimum(transformed_field, keep_dims=point_params.get("keep_dims", [])) + + point = transformed_field.isel(point_coords) + plotting_coords = [] + for dim in [coords["x"]["dimension"], coords["y"]["dimension"]]: + if dim not in point.coords and f"dim_{dim}" in point.coords: + dim = f"dim_{dim}" # noqa: PLW2901 + plotting_coords.append(point[dim]) + + legend_elements[label] = ax.scatter( + *plotting_coords, + s=point_style.get("size", None), + c=point_style.get("color", None), + marker=point_style.get("marker", None), + ) + + ax.set_title(f"{title} [{__version__}]") + ax.set_xlabel(coords["x"]["label"]) + ax.set_ylabel(coords["y"]["label"]) + ax.legend(legend_elements.values(), legend_elements.keys()) + plt.tight_layout() + + return fig, ax + + +def units_to_string(units: Unit) -> str: + """Given a pint Unit, return a string to represent the unit.""" + dummy_var = Quantity(1.0, units) + if dummy_var.check("") and np.isclose(dimensionless_magnitude(dummy_var), 1.0): + return "" + else: + return f"[{units:~P}]" + + +def label_contour(ax: plt.Axes, contour_set: matplotlib.contour.QuadContourSet, format_spec: str = "1.1f", fontsize: float = 10.0): + """Add in-line labels to contours. + + Returns the first label element, which can be used to construct a legend. + Works best with contour sets with only one color. + >>> contour_labels = dict() + >>> contour_labels["key"] = label_contour(...) + >>> ax.legend(contour_labels.values(), contour_labels.keys()) + + Inputs: + ax: the matplotlib axis of the contour plot + contour_set: the return argument of plt.contour(...) + format_spec: a format specification for the string formatting + fontsize: the font size of the label + """ + + def fmt(x): + return f"{x:{format_spec}}" + + ax.clabel(contour_set, contour_set.levels, inline=True, fmt=fmt, fontsize=fontsize) + + return contour_set.legend_elements()[0][0] diff --git a/cfspopcon/plotting/plot_style_handling.py b/cfspopcon/plotting/plot_style_handling.py new file mode 100644 index 00000000..226566e6 --- /dev/null +++ b/cfspopcon/plotting/plot_style_handling.py @@ -0,0 +1,21 @@ +"""Handling of yaml plot configuration.""" +from pathlib import Path +from typing import Any, Union + +import yaml + + +def read_plot_style(plot_style: Union[str, Path]) -> dict[str, Any]: + """Read a yaml file corresponding to a given plot_style. + + plot_style may be passed either as a complete filepath or as a string matching a plot_style in "plot_styles" + """ + if Path(plot_style).exists(): + input_file = plot_style + else: + raise FileNotFoundError(f"Could not find {plot_style}!") + + with open(input_file) as file: + repr_d: dict[str, Any] = yaml.load(file, Loader=yaml.FullLoader) + + return repr_d diff --git a/cfspopcon/point_selection.py b/cfspopcon/point_selection.py new file mode 100644 index 00000000..6a0297bf --- /dev/null +++ b/cfspopcon/point_selection.py @@ -0,0 +1,58 @@ +"""Routines to find the coordinates of the minimum or maximum value of a field.""" +from collections.abc import Sequence +from typing import Optional + +import numpy as np +import xarray as xr +from xarray.core.coordinates import DataArrayCoordinates + +from .unit_handling import Quantity + + +def find_coords_of_minimum(array: xr.DataArray, keep_dims: Sequence[str] = [], mask: Optional[xr.DataArray] = None) -> DataArrayCoordinates: + """Find the coordinates the minimum value of array. + + These coordinates can be used to find the value of other arrays at the same point. + + For example + >>> import xarray as xr + >>> import matplotlib.pyplot as plt + >>> import numpy as np + >>> from cfspopcon.operational_space import find_coords_of_minimum + >>> x = xr.DataArray(np.linspace(0, 1, num=10), dims="x") + >>> y = xr.DataArray(np.linspace(-1, 1, num=20), dims="y") + >>> z = xr.DataArray(np.abs(x + y), coords=dict(x=x, y=y)) + >>> z.T.plot() + >>> line = z.isel(find_coords_of_minimum(z, keep_dims="y")) + >>> plt.scatter(line.x, line.y) + """ + large = Quantity(np.inf, array.pint.units) + + along_dims = [dim for dim in array.dims if dim not in keep_dims] + + if mask is None: + point_coords = array.fillna(large).argmin(dim=along_dims) + else: + point_coords = array.where(mask).fillna(large).argmin(dim=along_dims) + + return point_coords # type:ignore[return-value] + + +def find_coords_of_maximum(array: xr.DataArray, keep_dims: Sequence[str] = [], mask: Optional[xr.DataArray] = None) -> DataArrayCoordinates: + """Find the coordinates of the maximum value of array.""" + return find_coords_of_minimum(-array, keep_dims=keep_dims, mask=mask) + + +def build_mask_from_dict(dataset: xr.Dataset, plot_params: dict) -> xr.DataArray: + """Build a mask field which hides inaccessible parts of the operational space.""" + mask = xr.DataArray(True) + + for mask_key, mask_range in plot_params.get("where", dict()).items(): + + mask_field = dataset[mask_key] + mask_min = Quantity(mask_range.get("min", -np.inf), mask_range.get("units", "")) + mask_max = Quantity(mask_range.get("max", +np.inf), mask_range.get("units", "")) + + mask = mask & ((mask_field > mask_min) & (mask_field < mask_max)) + + return mask diff --git a/cfspopcon/transform.py b/cfspopcon/transform.py new file mode 100644 index 00000000..38f680f6 --- /dev/null +++ b/cfspopcon/transform.py @@ -0,0 +1,173 @@ +"""Functions to reshape xarrays.""" +from collections.abc import Sequence +from typing import Callable, Optional, Union + +import numpy as np +import xarray as xr +from scipy.interpolate import griddata # type:ignore[import] + +from cfspopcon.unit_handling import Unit, magnitude + + +def order_dimensions( + array: xr.DataArray, + dims: Sequence[str], + units: Optional[dict[str, Unit]] = None, + template: Optional[Union[xr.DataArray, xr.Dataset]] = None, + order_for_plotting: bool = True, +) -> xr.DataArray: + """Reorder the dimensions of the array, broadcasting against `template` if necessary. + + This is particularly useful for plotting. + """ + if template is None: + template = xr.zeros_like(array) + + processed_dims = [] + for dim in dims: + # We sometimes add a "dim_" in front of coord to differentiate between + # variables and coordinates (in particular, coordinates can't have units) + if dim not in array.dims and f"dim_{dim}" in array.dims: + dim = f"dim_{dim}" # noqa: PLW2901 + + if dim in array.dims: + processed_dims.append(dim) + else: + # If we've asked for a dimension, but didn't find it in array.dims, + # look in the template. + if dim not in template.dims and f"dim_{dim}" in template.dims: + dim = f"dim_{dim}" # noqa: PLW2901 + if dim in template.dims: + # If we find the dimension in the template, broadcast the array + # to have the correct dimensions. + array = array.broadcast_like(template[dim]) + processed_dims.append(dim) + else: + raise ValueError(f"Array does not have dimension {dim.lstrip('dim_')}") + + if units is not None: + for dim, processed_dim in zip(dims, processed_dims): + array[processed_dim] = magnitude(template[dim.lstrip("dim_")].pint.to(units[dim])) + + if order_for_plotting: + processed_dims = processed_dims[::-1] + + return array.transpose(*processed_dims) + + +def interpolate_array_onto_new_coords( + array: xr.DataArray, + new_coords: dict[str, xr.DataArray], + resolution: Optional[dict[str, int]] = None, + coord_min: Optional[dict[str, int]] = None, + coord_max: Optional[dict[str, int]] = None, + default_resolution: int = 50, + max_distance: float = 2.0, + griddata_method: str = "linear", +) -> xr.DataArray: + """Take an xarray of values and map it to a grid of new coordinates. + + The input array and the new_coords must share the same coordinates (or be + able to be broadcast to the same coordinates). + + The new mesh will usually not overlap perfectly with the original mesh, and + may include regions not included in the original mesh. These regions are set + to NaN (based on the distance between a sample point and a new-grid point). + + This method works for arbitrary number of new_coords, but works best and makes + most sense for 2D (two new_coords). + """ + coords, coord_spacing = dict(), dict() + for key, coord_array in new_coords.items(): + coords[key], coord_spacing[key] = np.linspace( + start=coord_min.get(key, magnitude(coord_array.min())) if coord_min else magnitude(coord_array.min()), + stop=coord_max.get(key, magnitude(coord_array.max())) if coord_max else magnitude(coord_array.max()), + num=resolution.get(key, default_resolution) if resolution else default_resolution, + retstep=True, + ) + + mesh_coords = tuple(np.meshgrid(*coords.values(), indexing="ij")) + + broadcast_arrays = xr.broadcast(*(*list(new_coords.values()), array)) + sample_points = tuple([np.ravel(magnitude(broadcast_array)) for broadcast_array in broadcast_arrays[:-1]]) + array = broadcast_arrays[-1] + + interpolated_array = xr.DataArray( + griddata( + sample_points, + np.ravel(magnitude(array)), + mesh_coords, + method=griddata_method, + rescale=True, + ), + coords=coords, + attrs=array.attrs, + ).pint.quantify(array.pint.units) + + # Calculate the out-of-bounds mask based on distance to nearest sample point + mesh_shape = [coord.size for coord in coords.values()] + distance_to_nearest = np.zeros(mesh_shape, dtype=float) + stacked_samples = np.vstack(sample_points) + spacing = np.expand_dims(list(coord_spacing.values()), axis=-1) + + for index in np.ndindex(tuple(mesh_shape)): + # Iterate over each grid point + mesh_point = [mesh_coords[dimension][index] for dimension in range(len(index))] + broadcast_mesh_point = np.broadcast_to(np.expand_dims(mesh_point, axis=-1), stacked_samples.shape) + + distance_to_points = ((broadcast_mesh_point - stacked_samples) / spacing) ** 2 + distance_to_nearest[index] = np.min(np.sum(distance_to_points, axis=0)) + + clipped_array = interpolated_array.where(distance_to_nearest < max_distance).clip(min=array.min(), max=array.max()) + + return clipped_array # type:ignore[no-any-return] + + +def build_transform_function_from_dict(dataset: xr.Dataset, plot_params: dict) -> Callable[[xr.DataArray], xr.DataArray]: + """Build a function which can be called on a field to return an array with transformed coordinates. + + The simplest function is a transpose function, which makes sure that the dimensions are correctly ordered + for plotting. + + We can also build a more complicated function which transforms the field in terms of other computed fields, + remapping the field onto new axes. + """ + if "coords" in plot_params and "new_coords" in plot_params: + raise ValueError("Can only pass one of 'coords' or 'new_coords'.") + + if "coords" in plot_params: + xdim = plot_params["coords"]["x"]["dimension"] + ydim = plot_params["coords"]["y"]["dimension"] + units = { + xdim: plot_params["coords"]["x"].get("units"), + ydim: plot_params["coords"]["y"].get("units"), + } + + return lambda array: order_dimensions(array, dims=(xdim, ydim), units=units, template=dataset, order_for_plotting=True) + + elif "new_coords" in plot_params: + new_coords, new_coord_min, new_coord_max, new_coord_res = {}, {}, {}, {} + + for coord in ["y", "x"]: + new_coord = plot_params["new_coords"][coord] + new_key = new_coord["dimension"] + field = dataset[new_key] + new_coords[new_key] = field.pint.to(new_coord.get("units", field.pint.units)) + if "min" in new_coord: + new_coord_min[new_key] = new_coord["min"] + if "max" in new_coord: + new_coord_max[new_key] = new_coord["max"] + if "resolution" in new_coord: + new_coord_res[new_key] = new_coord["resolution"] + + return lambda array: interpolate_array_onto_new_coords( + array=array, + new_coords=new_coords, + resolution=new_coord_res, + coord_min=new_coord_min, + coord_max=new_coord_max, + max_distance=plot_params["new_coords"].get("max_distance", 5.0), + ) + + else: + raise NotImplementedError("Must provide either 'coords' or 'new_coords' for the transform function.") diff --git a/cfspopcon/unit_handling/__init__.py b/cfspopcon/unit_handling/__init__.py new file mode 100644 index 00000000..2bd60af4 --- /dev/null +++ b/cfspopcon/unit_handling/__init__.py @@ -0,0 +1,28 @@ +"""Uses pint and xarray to enable unit-handling over multi-dimensional arrays.""" +from typing import Union + +import xarray as xr +from pint import DimensionalityError, UnitStrippedWarning + +from .decorator import wraps_ufunc +from .default_units import convert_to_default_units, default_unit, magnitude_in_default_units, set_default_units +from .setup_unit_handling import Quantity, Unit, convert_units, dimensionless_magnitude, magnitude, ureg + +Unitfull = Union[Quantity, xr.DataArray] + +__all__ = [ + "ureg", + "Quantity", + "Unit", + "Unitfull", + "wraps_ufunc", + "magnitude_in_default_units", + "set_default_units", + "default_unit", + "convert_to_default_units", + "convert_units", + "magnitude", + "dimensionless_magnitude", + "DimensionalityError", + "UnitStrippedWarning", +] diff --git a/cfspopcon/unit_handling/decorator.py b/cfspopcon/unit_handling/decorator.py new file mode 100644 index 00000000..e2beb41d --- /dev/null +++ b/cfspopcon/unit_handling/decorator.py @@ -0,0 +1,294 @@ +"""Defines the wraps_ufunc decorator used to perform unit conversions and dimension handling.""" +import functools +import warnings +from collections.abc import Callable, Mapping, Sequence, Set +from inspect import Parameter, Signature, signature +from types import GenericAlias +from typing import Any, Optional, Union + +import xarray as xr +from pint import Unit, UnitStrippedWarning + +from .setup_unit_handling import Quantity, convert_units, magnitude, ureg + +FunctionType = Callable[..., Any] + + +def wraps_ufunc( # noqa: PLR0915 + input_units: dict[str, Union[str, Unit, None]], + return_units: dict[str, Union[str, Unit, None]], + pass_as_kwargs: tuple = (), + # kwargs for apply_ufunc + input_core_dims: Optional[Sequence[Sequence]] = None, + output_core_dims: Optional[Sequence[Sequence]] = ((),), + exclude_dims: Set = frozenset(), + vectorize: bool = True, + join: str = "exact", + dataset_join: str = "exact", + keep_attrs: str = "drop_conflicts", + dask: str = "forbidden", + output_dtypes: Optional[Sequence] = None, + output_sizes: Optional[Mapping[Any, int]] = None, + dask_gufunc_kwargs: Optional[dict[str, Any]] = None, +) -> FunctionType: + """Decorator for functions to add in unit and dimension handling. + + input_units and return_units must be provided, as dictionaries giving + a mapping between the function arguments/returns and their units. + + pass_as_kwargs can be used to optionally declare that specific arguments + should be pass directly into the function, rather than vectorized. + + The remaining arguments for the wrapper correspond to arguments for + xr.apply_ufunc. + https://docs.xarray.dev/en/stable/examples/apply_ufunc_vectorize_1d.html + """ + input_units = _check_units(input_units) + return_units = _check_units(return_units) + + ufunc_kwargs: dict[str, Any] = dict( + input_core_dims=input_core_dims, + output_core_dims=output_core_dims, + exclude_dims=exclude_dims, + vectorize=vectorize, + join=join, + dataset_join=dataset_join, + keep_attrs=keep_attrs, + dask=dask, + output_dtypes=output_dtypes, + output_sizes=output_sizes, + dask_gufunc_kwargs=dask_gufunc_kwargs, + ) + input_keys = list(input_units.keys()) + + if not isinstance(pass_as_kwargs, tuple): + raise ValueError(f"pass_as_kwargs must be passed as a tuple of keys, not {str(type(pass_as_kwargs))[1:-1]}") + + pass_as_positional_args = [key for key in input_keys if key not in pass_as_kwargs] + for arg in pass_as_kwargs: + kwarg_position = input_keys.index(arg) + if kwarg_position < len(pass_as_positional_args): + raise ValueError(f"Argument {arg} in pass_as_kwargs appears before the positional args {pass_as_positional_args}") + + if input_core_dims is not None: + if not len(input_core_dims) == len(pass_as_positional_args): + raise ValueError( + f"input_core_dims (len {len(input_core_dims)}) must the same length as positional_args ({pass_as_positional_args}, len {len(pass_as_positional_args)})" + ) + else: + input_core_dims = len(pass_as_positional_args) * [()] + + def _wraps_ufunc(func: FunctionType) -> FunctionType: + + func_signature = signature(func) + func_parameters = func_signature.parameters + + if not list(input_units.keys()) == list(func_parameters.keys()): + raise ValueError( + f"Keys for input_units {input_units.keys()} did not match func_parameters {func_parameters.keys()} (n.b. order matters!)" + ) + + default_values = {key: val.default for key, val in func_parameters.items() if val.default is not Parameter.empty} + + @functools.wraps(func) + def popcon_ufunc_wrapped_call(*args: Any, **kwargs: Any) -> Any: # noqa: PLR0912 + """Transform args and kwargs, then call the inner function.""" + # if anything goes wrong we can do some extra work to provide a better error below + try: + args_dict = dict(zip(input_keys, args)) + + if not set(args_dict.keys()).isdisjoint(kwargs.keys()): + raise RuntimeError( + f"{func.__name__} was called with repeat arguments. Input was interpreted as args={args_dict}, kwargs={kwargs}" + ) + + args_dict = {**args_dict, **kwargs} + args_dict = {**args_dict, **{key: val for key, val in default_values.items() if key not in args_dict.keys()}} + + args_dict = _return_magnitude_in_specified_units(args_dict, input_units) + + positional_args = [] + for i, key in enumerate(pass_as_positional_args): + arg = args_dict[key] + if not isinstance(arg, xr.DataArray): + positional_args.append(xr.DataArray(arg).expand_dims(input_core_dims[i])) + else: + positional_args.append(arg) + + with warnings.catch_warnings(): + warnings.simplefilter("error", category=UnitStrippedWarning) + function_return = xr.apply_ufunc( + func, + *positional_args, + kwargs={key: args_dict[key] for key in pass_as_kwargs}, + **ufunc_kwargs, + ) + + if len(return_units) == 0: + # Assume that the function return None + return function_return.item() + + function_return = _convert_return_to_quantities(function_return, return_units) + + function_return = list(function_return.values()) + + if len(function_return) > 1: + return tuple(function_return) + else: + return function_return[0] + + except Exception as e: + # the below checks if we are inside FunctionWrapper being called from another FunctionWrapper + # if that is the case we try and give a more helpful error + # if anything goes wrong in our frame inspection or we find that we aren't in a chained + # call we raise the previous exception + err = "" + try: + import inspect + + frames = inspect.getouterframes(inspect.currentframe()) + # the first entry is the current call so check if any of the earlier callees are a __call__ from a FunctionWrapper + for frame in frames[1:]: + if frame.function == "popcon_ufunc_wrapped_call": + f = frames[1] + err = "Calling `wraps_ufunc` decorated function from within `wraps_ufunc` decorated function is not allowed!\n" + err += f"Error at {f.filename}:{f.lineno}\n" + err += "\n".join(f.code_context) if f.code_context else "" + err += f"Try using `{frames[0].frame.f_locals['func'].__name__}.unitless_func(...)` instead." + break + except Exception: + # error while determining if we are withing a chained FunctionWrapper so re-raise original error + raise e from None + + # if err is not empty we have determined we are within a chained call so we raise a better error + if err: + raise RuntimeError(err) from None + else: + raise e + + # more meaningfull alias to the scalar non-unit version of the function + popcon_ufunc_wrapped_call.unitless_func = popcon_ufunc_wrapped_call.__wrapped__ # type:ignore[attr-defined] + popcon_ufunc_wrapped_call.__signature__ = _make_new_sig(func_signature, input_units, return_units) # type:ignore[attr-defined] + return popcon_ufunc_wrapped_call + + return _wraps_ufunc + + +def _check_units(units_dict: dict[str, Union[str, Unit, None]]) -> dict[str, Union[str, Unit, None]]: + + for key, unit in units_dict.items(): + if unit is None: + pass + elif isinstance(unit, str): + units_dict[key] = ureg(unit).units + elif not isinstance(unit, Unit): + raise TypeError(f"wraps_ufunc units for {key} must by of type str or Unit, not {str(type(unit))[1:-1]} (value was {unit})") + + return units_dict + + +def _return_magnitude_in_specified_units(vals: Any, units_mapping: dict[str, Union[str, Unit, None]]) -> dict[str, Any]: + + if not set(vals.keys()) == set(units_mapping): + raise ValueError(f"Argument keys {vals.keys()} did not match units_mapping keys {units_mapping.keys()}") + + converted_vals = {} + + for key in vals.keys(): + val = vals[key] + unit = units_mapping[key] + + if unit is None or val is None: + converted_vals[key] = val + + elif isinstance(val, Quantity): + converted_vals[key] = magnitude(convert_units(val, unit)) + + elif isinstance(val, xr.DataArray): + converted_vals[key] = convert_units(val, unit).pint.dequantify() + + elif Quantity(1, unit).check(ureg.dimensionless): + converted_vals[key] = val + + else: + raise NotImplementedError(f"Cannot convert {key} of type {str(type(val))[1:-1]} to units {unit}") + + return converted_vals + + +def _convert_return_to_quantities(vals: Any, units_mapping: dict[str, Union[str, Unit, None]]) -> dict[str, Any]: + + if not isinstance(vals, tuple): + vals = (vals,) + + if not len(vals) == len(units_mapping): + raise ValueError(f"Number of returned values ({len(vals)}) did not match length of units_mapping ({len(units_mapping)})") + vals = dict(zip(units_mapping.keys(), vals)) + + converted_vals = {} + + for key in vals.keys(): + val = vals[key] + unit = units_mapping[key] + + if unit is None or val is None: + converted_vals[key] = val + + elif isinstance(val, xr.DataArray): + converted_vals[key] = val.pint.quantify(unit, unit_registry=ureg) + + elif isinstance(val, Quantity): + converted_vals[key] = val.to(unit) + + else: + converted_vals[key] = Quantity(val, unit) + + return converted_vals + + +def _make_new_sig( + sig: Signature, + input_units: Mapping[str, Union[str, Unit, None]], + return_units: Mapping[str, Union[str, Unit, None]], +) -> Signature: + """Create a new signature for a wrapped function that replaces the plain floats/arrays with Quantity/DataArray.""" + parameters = list(sig.parameters.values()) + ret_annotation = sig.return_annotation + + # update parameter annotations + new_parameters: list[Parameter] = [] + for param, unit in zip(parameters, input_units.values()): + if unit is None: + new_parameters.append(param) + else: + new_parameters.append(param.replace(annotation=Union[Quantity, xr.DataArray])) + + # update return annotation + units_list = list(return_units.values()) + + # extract the types from the tuple + if isinstance(ret_annotation, GenericAlias) and ret_annotation.__origin__ == tuple: + old_types: list[Any] = list(ret_annotation.__args__) + elif ret_annotation == Parameter.empty: + old_types = [Any for _ in range(len(units_list))] + else: + old_types = [ret_annotation] + + if len(old_types) != len(units_list): + warnings.warn( + ( + f"Return type annotation {ret_annotation} has {len(old_types)} return values" + f", while the return_units: {return_units} specifies {len(return_units)} values" + ), + stacklevel=3, + ) + ret_types = tuple(xr.DataArray if units_list[i] is not None else old_types[i] for i in range(len(units_list))) + + if len(ret_types) == 0: + new_ret_ann: Union[type, None, GenericAlias] = None + elif len(ret_types) == 1: + new_ret_ann = ret_types[0] + else: + new_ret_ann = GenericAlias(tuple, ret_types) + + return sig.replace(parameters=new_parameters, return_annotation=new_ret_ann) diff --git a/cfspopcon/unit_handling/default_units.py b/cfspopcon/unit_handling/default_units.py new file mode 100644 index 00000000..6219eb58 --- /dev/null +++ b/cfspopcon/unit_handling/default_units.py @@ -0,0 +1,260 @@ +"""Define default units for writing to/from disk.""" +from collections.abc import Iterable +from numbers import Number +from typing import Any, Union, overload + +import numpy as np +import xarray as xr + +from .setup_unit_handling import DimensionalityError, Quantity, convert_units, magnitude + +DEFAULT_UNITS = dict( + areal_elongation="", + average_electron_density="n19", + average_electron_temp="keV", + average_ion_density="n19", + average_ion_temp="keV", + average_total_pressure="Pa", + B_pol_out_mid="T", + B_t_out_mid="T", + beta_poloidal="", + beta_toroidal="", + beta="", + bootstrap_fraction="", + confinement_threshold_scalar="", + confinement_time_scalar="", + core_radiated_power_fraction="", + core_radiator_charge_state="", + core_radiator_concentration="", + core_radiator=None, + current_relaxation_time="s", + dilution_change_from_core_rad="", + dilution="", + effective_collisionality="", + electron_density_peaking_offset="", + electron_density_peaking="", + electron_density_profile="n19", + electron_temp_profile="keV", + elongation_ratio_sep_to_areal="", + energy_confinement_scaling=None, + energy_confinement_time="s", + f_shaping="", + fieldline_pitch_at_omp="", + fraction_of_external_power_coupled="", + fraction_of_P_SOL_to_divertor="", + fuel_average_mass_number="amu", + fuel_ion_density_profile="n19", + fusion_reaction=None, + fusion_triple_product="n20 * keV * s", + greenwald_fraction="", + heavier_fuel_species_fraction="", + impurities="", + impurity_charge_state="", + input_SOL_power_loss_fraction="", + input_target_electron_temp="eV", + input_target_q_parallel="GW / m**2", + inverse_aspect_ratio="", + ion_density_peaking_offset="", + ion_density_peaking="", + ion_temp_profile="keV", + ion_to_electron_temp_ratio="", + kappa_e0="W / (eV**3.5 m)", + lambda_q_factor="", + lambda_q_scaling=None, + lambda_q="mm", + loop_voltage="V", + magnetic_field_on_axis="T", + major_radius="m", + minimum_core_radiated_fraction="", + minor_radius="m", + neoclassical_loop_resistivity="m * ohm", + nesep_over_nebar="", + neutron_power_flux_to_walls="MW / m**2", + neutron_rate="s**-1", + normalized_beta="percent * m * T / MA", + normalized_inverse_temp_scale_length="", + nu_star="", + P_alpha="MW", + P_auxillary="MW", + P_external="MW", + P_fusion="MW", + P_in="MW", + P_launched="MW", + P_LH_thresh="MW", + P_neutron="MW", + P_ohmic="MW", + P_radiated_by_core_radiator="MW", + P_radiation="MW", + P_sol="MW", + parallel_connection_length="m", + PB_over_R="MW * T / m", + PBpRnSq="MW * T / m * n20**-2", + peak_electron_density="n19", + peak_electron_temp="keV", + peak_fuel_ion_density="n19", + peak_ion_temp="keV", + peak_pressure="Pa", + plasma_current="A", + plasma_stored_energy="MJ", + plasma_volume="m**3", + product_of_magnetic_field_and_radius="m * T", + profile_form=None, + q_parallel="GW / m**2", + q_perp="MW / m**2", + q_star="", + Q="", + radiated_power_method=None, + radiated_power_scalar="", + ratio_of_P_SOL_to_P_LH="", + rho_star="", + rho="", + separatrix_elongation="", + separatrix_triangularity="", + SOC_LOC_ratio="", + SOL_momentum_loss_function=None, + SOL_power_loss_fraction="", + spitzer_resistivity="m * ohm", + summed_impurity_density="n19", + surface_area="m**2", + target_electron_density="n19", + target_electron_flux="m**-2 s**-1", + target_electron_temp="eV", + target_q_parallel="GW / m**2", + tau_e_scaling_uses_P_in=None, + temperature_peaking="", + toroidal_flux_expansion="", + trapped_particle_fraction="", + triangularity_psi95="", + triangularity_ratio_sep_to_psi95="", + two_point_model_method=None, + upstream_electron_temp="eV", + vertical_minor_radius="m", + z_effective="", + zeff_change_from_core_rad="", +) + + +def default_unit(var: str) -> Union[str, None]: + """Return cfspopcon's default unit for a given quantity. + + Args: + var: Quantity name + + Returns: Unit + """ + try: + return DEFAULT_UNITS[var] + except KeyError: + raise KeyError( + f"No default unit defined for {var}. Please check configured default units in the unit_handling submodule." + ) from None + + +def magnitude_in_default_units(value: Union[Quantity, xr.DataArray], key: str) -> Union[float, list[float], Any]: + """Convert values to default units and then return the magnitude. + + Args: + value: input value to convert to a float + key: name of field for looking up in DEFAULT_UNITS dictionary + + Returns: + magnitude of value in default units and as basic type + """ + try: + # unit conversion step + unit = default_unit(key) + if unit is None: + return value + + mag = magnitude(convert_units(value, unit)) + + except DimensionalityError as e: + print(f"Unit conversion failed for {key}. Could not convert '{value}' to '{DEFAULT_UNITS[key]}'") + raise e + + # single value arrays -> float + # np,xr array -> list + if isinstance(mag, (np.ndarray, xr.DataArray)): + if mag.size == 1: + return float(mag) + else: + return [float(v) for v in mag] + else: + return float(mag) + + +@overload +def set_default_units(value: Number, key: str) -> Quantity: + ... + + +@overload +def set_default_units(value: xr.DataArray, key: str) -> xr.DataArray: + ... + + +@overload +def set_default_units(value: Any, key: str) -> Any: + ... + + +def set_default_units(value: Any, key: str) -> Any: + """Return value as a quantity with default units. + + Args: + value: magnitude of input value to convert to a Quantity + key: name of field for looking up in DEFAULT_UNITS dictionary + + Returns: + magnitude of value in default units + """ + + def _is_number_not_bool(val: Any) -> bool: + return isinstance(val, Number) and not isinstance(val, bool) + + def _is_iterable_of_number_not_bool(val: Any) -> bool: + if not isinstance(val, Iterable): + return False + + if isinstance(val, (np.ndarray, xr.DataArray)) and val.ndim == 0: + return _is_number_not_bool(val.item()) + + return all(_is_number_not_bool(v) for v in value) + + # None is used to ignore class types + if DEFAULT_UNITS[key] is None: + if _is_number_not_bool(value) or _is_iterable_of_number_not_bool(value): + raise RuntimeError( + f"set_default_units for key {key} and value {value} of type {type(value)}: numeric types should carry units!" + ) + return value + elif isinstance(value, xr.DataArray): + return value.pint.quantify(DEFAULT_UNITS[key]) + else: + return Quantity(value, DEFAULT_UNITS[key]) + + +@overload +def convert_to_default_units(value: float, key: str) -> float: + ... + + +@overload +def convert_to_default_units(value: xr.DataArray, key: str) -> xr.DataArray: + ... + + +@overload +def convert_to_default_units(value: Quantity, key: str) -> Quantity: + ... + + +def convert_to_default_units(value: Union[float, Quantity, xr.DataArray], key: str) -> Union[float, Quantity, xr.DataArray]: + """Convert an array or scalar to default units.""" + unit = DEFAULT_UNITS[key] + if unit is None or unit == "": + return value + elif isinstance(value, (xr.DataArray, Quantity)): + return convert_units(value, unit) + else: + raise NotImplementedError(f"No implementation for 'convert_to_default_units' with an array of type {type(value)} ({value})") diff --git a/cfspopcon/unit_handling/setup_unit_handling.py b/cfspopcon/unit_handling/setup_unit_handling.py new file mode 100644 index 00000000..56727b66 --- /dev/null +++ b/cfspopcon/unit_handling/setup_unit_handling.py @@ -0,0 +1,98 @@ +"""Set up the pint library for unit handling.""" +import warnings +from collections.abc import Callable +from functools import wraps +from typing import Any, TypeVar, Union, overload + +import numpy as np +import numpy.typing as npt +import pint +import pint_xarray # type:ignore[import] +import xarray as xr +from pint.errors import DimensionalityError +from typing_extensions import ParamSpec + +ureg = pint_xarray.setup_registry( + pint.UnitRegistry( + force_ndarray_like=True, + cache_folder=":auto:", + ) +) + +Quantity = ureg.Quantity +Unit = ureg.Unit + +Params = ParamSpec("Params") +Ret = TypeVar("Ret") + +# Define custom units for density as n_19 or n_20 (used in several formulas) +ureg.define("_1e19_per_cubic_metre = 1e19 m^-3 = 1e19 m^-3 = n19") +ureg.define("_1e20_per_cubic_metre = 1e20 m^-3 = 1e10 m^-3 = n20") +ureg.define("percent = 0.01") + +# Needed for serialization/deserialization +pint.set_application_registry(ureg) # type:ignore[no-untyped-call] + + +def suppress_downcast_warning(func: Callable[Params, Ret]) -> Callable[Params, Ret]: + """Suppresses a common warning about downcasting quantities to arrays.""" + + @wraps(func) + def wrapper(*args: Params.args, **kwargs: Params.kwargs) -> Ret: + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", message="The unit of the quantity is stripped when downcasting to ndarray.") + return func(*args, **kwargs) + + return wrapper + + +@overload +def convert_units(array: xr.DataArray, units: Union[str, pint.Unit]) -> xr.DataArray: + ... + + +@overload +def convert_units(array: pint.Quantity, units: Union[str, pint.Unit]) -> pint.Quantity: + ... + + +def convert_units(array: Union[xr.DataArray, pint.Quantity], units: Any) -> Union[xr.DataArray, pint.Quantity]: + """Convert an array to specified units, handling both Quantities and xr.DataArrays.""" + if isinstance(array, xr.DataArray): + if not hasattr(array.pint, "units") or array.pint.units is None: + array = array.pint.quantify(ureg.dimensionless) + + return array.pint.to(units) # type: ignore[no-any-return] + elif isinstance(array, Quantity): + return array.to(units) # type:ignore[no-any-return] + else: + raise NotImplementedError(f"No implementation for 'convert_units' with an array of type {type(array)} ({array})") + + +@suppress_downcast_warning +def magnitude(array: Union[xr.DataArray, pint.Quantity]) -> Union[npt.NDArray[np.float32], float]: + """Return the magnitude of an array, handling both Quantities and xr.DataArrays.""" + if isinstance(array, xr.DataArray): + return array.values + elif isinstance(array, Quantity): + return array.magnitude # type: ignore[no-any-return] + else: + raise NotImplementedError(f"No implementation for 'magnitude' with an array of type {type(array)} ({array})") + + +def dimensionless_magnitude(array: Union[xr.DataArray, pint.Quantity]) -> Union[npt.NDArray[np.float32], float]: + """Converts the array to dimensionless and returns the magnitude.""" + return magnitude(convert_units(array, ureg.dimensionless)) + + +__all__ = [ + "DimensionalityError", + "ureg", + "Quantity", + "Unit", + "suppress_downcast_warning", + "convert_units", + "magnitude", + "suppress_downcast_warning", + "dimensionless_magnitude", +] diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 00000000..d4bb2cbb --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 00000000..8d22e749 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,265 @@ +"""Sphinx configuration for cfspopcon.""" +import warnings +from collections.abc import Mapping +from inspect import Parameter, Signature, signature +from types import GenericAlias +from typing import Any, Union + +import xarray as xr +from sphinx.ext.autodoc import ClassDocumenter, FunctionDocumenter +from sphinx.ext.autodoc.importer import get_class_members +from sphinx.ext.intersphinx import missing_reference +from sphinx.util.inspect import stringify_signature + +import cfspopcon +from cfspopcon.algorithms.algorithm_class import Algorithm +from cfspopcon import formulas +from cfspopcon.unit_handling.setup_unit_handling import Quantity, Unit + +project = "cfspopcon" +copyright = "2023, Commonwealth Fusion Systems" +author = cfspopcon.__author__ +version = cfspopcon.__version__ +release = version + +# -- General configuration + +# warn for missing references. Can be quite loud but at least we then have +# ensured that all links to other classes etc work. +nitpicky = True + +add_module_names = False + +# note that github actions seems to be on openssl 3.0. +# if you aren't locally, that can cause different behaviour. +linkcheck_ignore = [ + # server is incompatible with openssl 3.0 default, see e.g. + # https://github.com/urllib3/urllib3/issues/2653 + r"https://doi.org/10.2172/7297293", + r"https://doi.org/10.2172/1372790", + # these work but linkcheck doesn't like them.. + r"https://doi.org/10.2172/1334107", + r"https://doi.org/10.13182/FST91-A29553", + r"https://doi.org/10.1080/10420150.2018.1462361", + r"https://github.com/cfs-energy/cfspopcon/blob/main/docs/doc_sources/getting_started.ipynb", +] +linkcheck_retries = 5 +linkcheck_timeout = 120 + +source_suffix = ".rst" + +# If docs change signficantly such that navigation depth is more, this setting +# might need to be increased +html_theme_options = { + "navigation_depth": 3, +} + +# The master toctree document. +master_doc = "index" + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = "friendly" +highlight_language = "python3" + +# -- Options for HTML output + +html_static_path = ["static"] +html_theme = "sphinx_rtd_theme" +html_domain_indices = False +html_use_index = False +html_show_sphinx = False +htmlhelp_basename = "cfspopconDoc" +python_maximum_signature_line_length = 90 +# +# -- extensions and their options +# + +extensions = [ + "sphinx.ext.napoleon", + "sphinx.ext.autodoc", + "sphinx.ext.doctest", + "sphinx.ext.intersphinx", + # linkcode to point to github would be nicer + "sphinx.ext.viewcode", + "sphinx.ext.mathjax", + "matplotlib.sphinxext.plot_directive", + "sphinx_copybutton", + "sphinxcontrib.bibtex", + "nbsphinx", +] + +# -- nbsphinx +exclude_patterns = ["_build", "static"] +nbsphinx_execute = "never" + +# -- autodoc +autodoc_default_options = { + "show-inheritance": True, + "members": True, + "undoc-members": True, + "member-order": "bysource", +} +autoclass_content = "both" +autodoc_typehints = "signature" + +# -- doctest +doctest_global_setup = """ +from cfspopcon import * +""" + +# -- intersphinx +intersphinx_mapping = { + "python": ("https://docs.python.org/3", None), + "numpy": ("https://numpy.org/doc/stable/", None), + "matplotlib": ("https://matplotlib.org/stable/", None), + "pandas": ("https://pandas.pydata.org/docs/", None), + "scipy": ("https://docs.scipy.org/doc/scipy/", None), + "pint": ("https://pint.readthedocs.io/en/stable/", None), + "xarray": ("https://docs.xarray.dev/en/stable/", None), +} + +# -- matplotlib plot_directive +# only plot a png +plot_formats = ["png"] +# don't show link to the png +plot_html_show_formats = False + +# -- copybutton +# make copy paste of code blocks nice on copy remove the leading >>> or ... of +# code blocks and remove printed output. Their default is usually good but +# currently a bit broken so we need the below +copybutton_exclude = ".lineos" +copybutton_prompt_text = r">>> |\.\.\. " +copybutton_prompt_is_regexp = True +copybutton_only_copy_prompt_lines = True + +# -- bibtex bibliography +bibtex_bibfiles = ["refs.bib"] + + +# register a resolve function to help sphinx with the resolve references sphinx +# couldn't note: sphinx doesn't stop calling listeners once one with lower +# priority has returned a good result so this function is called pretty much +# for every cross-reference, thus we need to filter out the cases we actually +# want to handle +def resolve(app, env, node, contnode): + """Custom reference resolver.""" + ret_node = None + + if node["refdomain"] == "py" and node["reftype"] == "class": + py = env.domains["py"] + + # type hint links are transformed into something like + # :py:class:`numpy.float64` but `numpy.float64` is actually documented + # as a :py:attr:. We just use the general :py:obj: here which should be + # fine as long as there aren't any name collisions in numpy + if "numpy" in node["reftarget"]: + node["reftype"] = "obj" + ret_node = missing_reference(app, env, node, contnode) + + # This is a similar fix to above. We have cases where we use a generic + # type e.g. cfspopcon.strict_base.T and that is is a :py:attr: so we + # run into the same case as above. Same sledgehammer approach of + # just using :py:obj: for any missing links at this tag + elif "cfspopcon" in node["reftarget"]: + node["reftype"] = "obj" + ret_node = py.resolve_xref(env, node["refdoc"], app.builder, node["reftype"], node["reftarget"], node, contnode) + + # patch Self return types to point to the class the function is defined + # on + elif "typing_ext" in node["reftarget"]: + node["reftarget"] = node["py:class"] + ret_node = py.resolve_xref(env, node["refdoc"], app.builder, node["reftype"], node["reftarget"], node, contnode) + + elif "pint" in node["reftarget"]: + s = node["reftarget"] + if s.startswith("pint") and s.endswith("Quantity"): + node["reftarget"] = "pint.Quantity" + ret_node = missing_reference(app, env, node, contnode) + + return ret_node + + +# the below workaround is adopted from: +# https://github.com/celery/celery/blob/1683008881717d2f8391264cb2b6177d85ff5ea8/celery/contrib/sphinx.py#L42 +# which is BSD3 licensed see: +# https://github.com/celery/celery/blob/1683008881717d2f8391264cb2b6177d85ff5ea8/LICENSE#L1 + +# wraps_ufunc returns a class which leads to sphinx ignoring the function +# This is a custom documenter to ensure automodule correctly lists wrapped functions +# and creates a better signature for them. Setting the signature object on the actual class (like for Algorithms) +# isn't possible because the __call__ function is always a member of the class and setting it on an instance +# does not work. +class FunctionWrapperDocumenter(FunctionDocumenter): + """Document a wraps_ufunc wrapped function""" + + # this means `autowraps_ufunc` is a new autodoc directive + objtype = "wraps_ufunc" + # but document those as functions + directivetype = "function" + member_order = 11 + + @classmethod + def can_document_member(cls, member, membername, isattr, parent): + return super().can_document_member(member, membername, isattr, parent) and hasattr(member, "unitless_func") + + def format_args(self): + fw = self.object + sig = signature(fw) + return stringify_signature(sig, unqualified_typehints=True) + + def document_members(self, all_members=False): + super(FunctionDocumenter, self).document_members(all_members) + + def get_object_members(self, want_all: bool): + members = get_class_members(self.object, self.objpath, self.get_attr, self.config.autodoc_inherit_docstrings) + unitless_func = members.get("unitless_func", None) + if unitless_func is not None: + unitless_func.object.__doc__ = "A scalar and not unit aware version of the above function." + # the unitless function will get documented as a member of the FuncitionWrapper clas + # but sphinx pops the first argument because it thinks that's the "self" so we monkey patch around that + # by prepending a parameter that gets thrown away + tmp_param = Parameter("tmp", kind=Parameter.POSITIONAL_ONLY) + s = signature(unitless_func.object) + new_sig = s.replace(parameters=[tmp_param, *s.parameters.values()], return_annotation=s.return_annotation) + unitless_func.object.__signature__ = new_sig + return False, [unitless_func] + + +class AlgDocumenter(ClassDocumenter): + """Document a Algorithm instance.""" + + objtype = "popcon_alg" + # data so that we don't get the "class" prefix in sphinx + directivetype = "data" + member_order = 21 + + @classmethod + def can_document_member(cls, member, membername, isattr, parent): + return isinstance(member, Algorithm) + + def add_directive_header(self, sig: str) -> None: + super(ClassDocumenter, self).add_directive_header(sig) + + def get_object_members(self, want_all: bool): + members = get_class_members(self.object, self.objpath, self.get_attr, self.config.autodoc_inherit_docstrings) + return False, [m for k, m in members.items() if k in {"run", "update_dataset", "return_keys"}] + + def format_signature(self, **kwargs) -> str: + return "" + + def get_doc(self): + return None + + def import_object(self, raiseerror: bool = False) -> bool: + ret = super().import_object(raiseerror) + self.doc_as_attr = False + return ret + + +def setup(app): + # default is 900, intersphinx is 500 + app.connect("missing-reference", resolve, 1000) + app.add_css_file("theme_overrides.css") + app.add_autodocumenter(FunctionWrapperDocumenter) + app.add_autodocumenter(AlgDocumenter) diff --git a/docs/doc_sources/Usage.rst b/docs/doc_sources/Usage.rst new file mode 100644 index 00000000..ad80ef6d --- /dev/null +++ b/docs/doc_sources/Usage.rst @@ -0,0 +1,38 @@ +.. _gettingstarted: + +Getting Started +=================== + +Installation +^^^^^^^^^^^^^ + +The cfspopcon package is available on the `Python Package Index `, thus installation is as simple as: + +.. code:: + + >>> pip install cfspopcon + +.. warning:: + The :code:`cfspopcon.atomic_data` module requires data files produced by the `radas project `_. Radas produces these files by processing `OpenADAS `_ data. These files are not shipped as part of :code:`cfspopcon`. Follow the below steps after the :code:`pip install cfspopcon` command (we will try to make this smoother in the future. N.b. this only has to be done once). + + .. code:: bash + + >>> export RADAS=$(python -c "from cfspopcon import atomic_data;from pathlib import Path; print(Path(atomic_data.__file__).parent)") + >>> pushd /tmp + >>> git clone https://github.com/cfs-energy/radas.git + >>> pushd radas + >>> poetry install --only main + >>> poetry run fetch_adas + >>> poetry run run_radas + >>> cp ./cases/*/output/*.nc $RADAS + >>> popd && popd + + +Example Notebook +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +The example notebook linked below can be found within the `docs folder `_ of our github repository. + +.. toctree:: + + getting_started diff --git a/docs/doc_sources/api.rst b/docs/doc_sources/api.rst new file mode 100644 index 00000000..d55a0e49 --- /dev/null +++ b/docs/doc_sources/api.rst @@ -0,0 +1,26 @@ +API +********* + + + +Configuration Enums +===================== +.. automodule:: cfspopcon.named_options + +Algorithms +===================== +.. automodule:: cfspopcon.algorithms + +Internals +===================== + +The functions and classes below are listed here for completeness. +But these are internals, so it should usually not be required to interact with any of them directly. + +.. py:currentmodule:: none + +.. autoclass:: cfspopcon.unit_handling.Unitfull +.. automodule:: cfspopcon.algorithms.algorithm_class +.. automodule:: cfspopcon.formulas +.. automodule:: cfspopcon.formulas.scrape_off_layer_model +.. automodule:: cfspopcon.helpers diff --git a/docs/doc_sources/bib.rst b/docs/doc_sources/bib.rst new file mode 100644 index 00000000..816eb3c5 --- /dev/null +++ b/docs/doc_sources/bib.rst @@ -0,0 +1,6 @@ +Bibliography +============= + +.. bibliography:: + :all: + :style: unsrt diff --git a/docs/doc_sources/dev_guide.rst b/docs/doc_sources/dev_guide.rst new file mode 100644 index 00000000..794d0aec --- /dev/null +++ b/docs/doc_sources/dev_guide.rst @@ -0,0 +1,167 @@ +.. _devguide: + +Developer's Guide +******************* + +The cfspopcon team uses `Poetry `_ to develop. +If you are familiar with the usual poetry based development workflow, feel free to skip right ahead to the `Contribution Guidelines`_. + +Development Setup +==================== + +For more information and help installing Poetry, please refer to `their documentation `_. +Once you have Poetry installed we are ready to start developing. First we clone the repository and enter into the folder. + +.. code:: + + >>> git clone https://github.com/cfs-energy/cfspopcon.git + >>> cd cfspopcon + +Setting up a virtual environment and installing all dependencies required to develop, is done in just one command: + +.. code:: + + >>> poetry install + +If you are new to Poetry, we suggest that you at least read their brief introduction on `how to use this virtual environment `_. +You can verify that everything worked as expected by following the :ref:`Getting Started ` guide. + +At this point you are ready to read our `Contribution Guidelines`_ and start making changes to the code. We are looking forward to your contribution! + + +Contribution Guidelines +======================== + +If you have a question or found a bug, please feel free to raise an issue on GitHub. + +If you would like to make changes to the code, we ask that you follow the below guidelines: + +1. Please follow our `Style Guide`_ +2. The `Pre-Commit Checks`_ should all pass +3. Make sure tests in the test suite are still passing, see `Running the Test Suite`_ +4. If adding new functionality, please try to add a unit test for it, if applicable. +5. Please ensure that any changes are correctly reflected in the documentation, see `Building The Documentation`_ + + + +Style Guide +============= + +The set of tools configured to run as pre-commit hooks should cover the simple style decisions. +For everything else, we follow the `Google Python Style Guide `_, but make some exceptions for science / math variables. +The Google style guide and PEP8 encourage long, descriptive, lower case variables names. However, these can make science / math equations hard to read. +There is a case to be made for using well-established mathematical symbols as **local** variable names, e.g. :code:`T` for temperature or :code:`r` for position. +Subscripts can be added, e.g. :code:`r_plasma`. + +To make reading & validating formulas easier, we additionally follow the below guidelines: + +- Add a descriptive comment when using short variable names. +- When local variables are declared, specify their units in a comment next to the declaration, like :code:`x = 1.0 # [m]` +- Use basic SI units, unless you have a good reason not to. (e.g. prefer :code:`[A]` over :code:`[kA]`). +- Explicitly call out dimensionless physical quantities, e.g. :code:`reynolds_number = 1e3 # [~]`. +- Functions that handle dimensional quantities should use :class:`pint.Quantity`. + +Please note, that while we have some checks for docstrings, those checks do not cover all aspects. +So let's look at a basic example, the :func:`~cfspopcon.formulas.calc_plasma_volume` function: + +.. literalinclude:: ../../cfspopcon/formulas/geometry.py + :language: python + :linenos: + :pyobject: calc_plasma_volume + +To summarize the important points of the above example: + +1. Include short descriptive one-liner. +2. If applicable, add a more detailed description. +3. List the arguments with a short description, and include their units. +4. Each return value should come with a brief explanation and unit. +5. Do **not** include any type annotations within the docstring. These will be added automatically by sphinx. + +Aside from the units annotations in the docstring, you'll notice the parameters are annotated with the type :class:`~cfspopcon.unit_handling.Unitfull`. +This is because all calculations in cfspopcon use explicit unit handling to better ensure that calculations are correct and no units handling errors sneak into a formula. +The units handling cfspopcon is powered by the `pint `_ and `pint-xarray `_ python packages. +The type :class:`~cfspopcon.unit_handling.Unitfull`, used in the above function as type annotation, is an alias of :code:`pint.Quantity | xarray.DataArray`. + +In addition to the above example, we also recommend having a look at the :mod:`~cfspopcon.formulas` module, which holds many good examples. + + +Pre-Commit Checks +=================== + +As the name suggests, these are a list of checks that should be run before making a commit. +We use the `pre-commit `_ framework to ensure these checks are run for every commit. +You already installed the :code:`pre-commit` tool as a development dependency during the `Development Setup`_. + +Run all configured checks by executing: + +.. code:: + + >>> poetry run pre-commit run --all-files + +But instead of trying to remember to run this command before every commit, we suggest you follow the `pre-commit documentation `_ and install the git hooks. + +.. code:: + + >>> poetry run pre-commit install + +The installed git hooks will now automatically run the required checks when you try to :code:`git commit` some changes. +An added benefit is that this will usually be faster than running over all files, as :code:`pre-commit` is pretty smart at figuring out which files it needs to check for a given commit. + +If you are curious, you can see all the automatic checks that we have configured to run in the file :code:`.pre-commit-config.yaml`: + +.. literalinclude:: ../../.pre-commit-config.yaml + + + + +Running the Test Suite +======================= + +We use `pytest `_ and the `pytest-cov `_ plugin for our test suite. +All tests can be found in the :code:`tests` subfolder. +The configuration can be found in the :code:`pyproject.toml` file. + +Running the entire test suit can be done via: + +.. code:: + + >>> poetry run pytest + +Adding a new Test +------------------- + +When adding new functionality it is best to also add a test for it. +If the category of the added functionality fits within one of the existing files, please add your test to that file. +Otherwise feel free to create a new test file. The name should follow the convention :code:`test_{description}.py`. + + +Building The Documentation +=============================== + +Our documentation is build and hosted on `Read The Docs `_ and previews are available on each PR. +But when extending the documentation it is most convenient to first build it locally yourself to check that everything is included & rendered correctly. + +.. warning:: + Building the documentation unfortunately requires a non-python dependency: `pandoc `_. + Please ensure that the :code:`pandoc` executable is available before proceeding. + This package can easily be installed via :code:`sudo apt-get install pandoc` (Linux) or :code:`brew install pandoc` (MacOS). + For more details please see `pandoc's installation guide `_. + +Starting from inside the project folder you can trigger the build by running: + +.. code:: + + >>> poetry run make -C docs html + +Once that build is finished, open the file :code:`./docs/_build/html/index.html` to view the documentation. + +As part of our CI we also run the `sphinx-doctest `_ and `sphinx-linkcheck `_ extensions. +The :code:`sphinx-doctest` extension checks that python snippets used in docstrings are actually valid python code and produce the expected output. And :code:`sphinx-linkcheck` is used to ensure that any links used within our documentation are correct and accessible. + +To avoid having failures in the CI it's a good idea to run these locally first as well: + +.. code:: + + poetry run make -C docs doctest + poetry run make -C docs linkcheck + diff --git a/docs/doc_sources/getting_started.ipynb b/docs/doc_sources/getting_started.ipynb new file mode 100644 index 00000000..68dd28ea --- /dev/null +++ b/docs/doc_sources/getting_started.ipynb @@ -0,0 +1,2642 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Creating your first POPCON\n", + "\n", + "Welcome to cfspopcon!\n", + "\n", + "This notebook will work you through how to set up a POPCON run and plot the results.\n", + "\n", + "To start with, execute the cell below to import some additional libraries that we'll frequently use, as well as the cfspopcon library itself. If you can execute this cell without error, that's a great start. If not, make sure that the cfspopcon library is installed correctly." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import xarray as xr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from pathlib import Path\n", + "\n", + "import cfspopcon\n", + "from cfspopcon.unit_handling import ureg" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to configure a POPCON analysis is via a configuration file. For this, we use YAML files (which map neatly to python dictionaries).\n", + "\n", + "In the next cell, we read in the `SPARC_PRD/input.yaml` file, applying a few conversions on the data. This includes\n", + "\n", + "1. The `algorithms` entry is converted into a `cfspopcon.CompositeAlgorithm` which we'll talk about later. This basically gives the list of operations that we want to perform on the input data. \n", + "2. The `points` entry is stored in a separate dictionary. This gives a set of key-value pairs of 'optimal' points (for instance, giving the point with the maximum fusion power gain).\n", + "3. The `grids` entry is converted into an `xr.DataArray` storing a `np.linspace` or `np.logspace` of values which we scan over. We usually scan over `average_electron_density` and `average_electron_temp`, but there's nothing preventing you from scanning over other numerical input variables or having more than 2 dimensions which you scan over (n.b. this can get expensive!).\n", + "4. Each input variable is checked to see if its name matches one of the enumerators in `cfspopcon.named_options`. These are used to store switch values, such as `cfspopcon.named_options.ReactionType.DT` which indicates that we're interested in the DT fusion reaction.\n", + "5. Each input variable is converted into its default units, stored in `cfspopcon.unit_handling.default_units.DEFAULT_UNITS`. This will set, for instance, the `average_electron_temp` values to have units of `keV`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "input_parameters, algorithm, points = cfspopcon.read_case(\"../../example_cases/SPARC_PRD\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first want to make sure that our analysis won't crash due to missing input variables. For this, we use the `validate_inputs` method of the `cfspopcon.CompositeAlgorithm` object, which makes sure that all required input variables are defined by the `input.yaml` file. It will also tell you if the algorithms you're requesting are out of order." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "algorithm.validate_inputs(input_parameters);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since we're looking at the example, it's unsurprisingly well behaved. Let's intentionally drop an input variable to show that it works." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/j9/kfmd11x90hbgylhpfwhtqzyw0000gq/T/ipykernel_64214/170706882.py:4: UserWarning: Missing input parameters [major_radius].\n", + " algorithm.validate_inputs(incomplete_input_parameters, raise_error_on_missing_inputs=False);\n" + ] + } + ], + "source": [ + "incomplete_input_parameters = input_parameters.copy()\n", + "del incomplete_input_parameters[\"major_radius\"]\n", + "\n", + "algorithm.validate_inputs(incomplete_input_parameters, raise_error_on_missing_inputs=False);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we pack all of the (complete) input parameters into an `xarray.Dataset`.\n", + "\n", + "If you're not familiar with `xarray`, a `Dataset` functions like a dictionary which stores labelled `xr.DataArray`s, which in turn function like `np.array`s but with additional annotation to describe the coordinates and units of the array. We'll use a lot of `xarray` features, so it's worth [reading the docs](https://docs.xarray.dev/en/stable/), including their useful [How do I ...](https://docs.xarray.dev/en/stable/howdoi.html) section.\n", + "\n", + "Our starting dataset isn't super interesting: it's exactly what we defined in the `input.yaml` file. In the next cell, we construct a dataset from out input parameters, and then print into the notebook a representation of the notebook (this is the somewhat odd-looking second line)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:                               (dim_species: 3,\n",
+       "                                           dim_average_electron_density: 40,\n",
+       "                                           dim_average_electron_temp: 30)\n",
+       "Coordinates:\n",
+       "  * dim_species                           (dim_species) object Impurity.Tungs...\n",
+       "  * dim_average_electron_density          (dim_average_electron_density) float64 ...\n",
+       "  * dim_average_electron_temp             (dim_average_electron_temp) float64 ...\n",
+       "Data variables: (12/36)\n",
+       "    major_radius                          float64 [m] 1.85\n",
+       "    magnetic_field_on_axis                float64 [T] 12.2\n",
+       "    inverse_aspect_ratio                  float64 [] 0.3081\n",
+       "    areal_elongation                      float64 [] 1.75\n",
+       "    elongation_ratio_sep_to_areal         float64 [] 1.125\n",
+       "    triangularity_psi95                   float64 [] 0.3\n",
+       "    ...                                    ...\n",
+       "    SOL_momentum_loss_function            object MomentumLossFunction.KotovRe...\n",
+       "    fraction_of_P_SOL_to_divertor         float64 [] 0.6\n",
+       "    kappa_e0                              float64 [W/eV³⋅⁵/m] 2.6e+03\n",
+       "    target_electron_temp                  float64 [eV] 25.0\n",
+       "    average_electron_density              (dim_average_electron_density) float64 [1e19 m^-3] ...\n",
+       "    average_electron_temp                 (dim_average_electron_temp) float64 [keV] ...
" + ], + "text/plain": [ + "\n", + "Dimensions: (dim_species: 3,\n", + " dim_average_electron_density: 40,\n", + " dim_average_electron_temp: 30)\n", + "Coordinates:\n", + " * dim_species (dim_species) object Impurity.Tungs...\n", + " * dim_average_electron_density (dim_average_electron_density) float64 ...\n", + " * dim_average_electron_temp (dim_average_electron_temp) float64 ...\n", + "Data variables: (12/36)\n", + " major_radius float64 [m] 1.85\n", + " magnetic_field_on_axis float64 [T] 12.2\n", + " inverse_aspect_ratio float64 [] 0.3081\n", + " areal_elongation float64 [] 1.75\n", + " elongation_ratio_sep_to_areal float64 [] 1.125\n", + " triangularity_psi95 float64 [] 0.3\n", + " ... ...\n", + " SOL_momentum_loss_function object MomentumLossFunction.KotovRe...\n", + " fraction_of_P_SOL_to_divertor float64 [] 0.6\n", + " kappa_e0 float64 [W/eV³⋅⁵/m] 2.6e+03\n", + " target_electron_temp float64 [eV] 25.0\n", + " average_electron_density (dim_average_electron_density) float64 [1e19 m^-3] ...\n", + " average_electron_temp (dim_average_electron_temp) float64 [keV] ..." + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset = xr.Dataset(input_parameters)\n", + "\n", + "dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's run a POPCON!\n", + "\n", + "We'll use the `update_dataset` method of our algorithm and pass in our dataset of input parameters.\n", + "\n", + "The `CompositeAlgorithm` calls the `update_dataset` for each of its `Algorithm`s. These calls check that all of the required inputs are defined in the dataset, and then write the results back into the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:                               (dim_species: 3,\n",
+       "                                           dim_average_electron_density: 40,\n",
+       "                                           dim_average_electron_temp: 30,\n",
+       "                                           dim_rho: 50)\n",
+       "Coordinates:\n",
+       "  * dim_species                           (dim_species) object Impurity.Tungs...\n",
+       "  * dim_average_electron_density          (dim_average_electron_density) float64 ...\n",
+       "  * dim_average_electron_temp             (dim_average_electron_temp) float64 ...\n",
+       "Dimensions without coordinates: dim_rho\n",
+       "Data variables: (12/115)\n",
+       "    major_radius                          float64 [m] 1.85\n",
+       "    magnetic_field_on_axis                float64 [T] 12.2\n",
+       "    inverse_aspect_ratio                  float64 [] 0.3081\n",
+       "    areal_elongation                      float64 [] 1.75\n",
+       "    elongation_ratio_sep_to_areal         float64 [] 1.125\n",
+       "    triangularity_psi95                   float64 [] 0.3\n",
+       "    ...                                    ...\n",
+       "    core_radiated_power_fraction          (dim_average_electron_density, dim_average_electron_temp) float64 [] ...\n",
+       "    nu_star                               (dim_average_electron_density, dim_average_electron_temp) float64 [] ...\n",
+       "    rho_star                              (dim_average_electron_temp) float64 [] ...\n",
+       "    fusion_triple_product                 (dim_average_electron_density, dim_average_electron_temp) float64 [1e10 m^-3·keV·s] ...\n",
+       "    peak_pressure                         (dim_average_electron_temp, dim_average_electron_density) float64 [Pa] ...\n",
+       "    current_relaxation_time               (dim_average_electron_temp, dim_average_electron_density) float64 [s] ...
" + ], + "text/plain": [ + "\n", + "Dimensions: (dim_species: 3,\n", + " dim_average_electron_density: 40,\n", + " dim_average_electron_temp: 30,\n", + " dim_rho: 50)\n", + "Coordinates:\n", + " * dim_species (dim_species) object Impurity.Tungs...\n", + " * dim_average_electron_density (dim_average_electron_density) float64 ...\n", + " * dim_average_electron_temp (dim_average_electron_temp) float64 ...\n", + "Dimensions without coordinates: dim_rho\n", + "Data variables: (12/115)\n", + " major_radius float64 [m] 1.85\n", + " magnetic_field_on_axis float64 [T] 12.2\n", + " inverse_aspect_ratio float64 [] 0.3081\n", + " areal_elongation float64 [] 1.75\n", + " elongation_ratio_sep_to_areal float64 [] 1.125\n", + " triangularity_psi95 float64 [] 0.3\n", + " ... ...\n", + " core_radiated_power_fraction (dim_average_electron_density, dim_average_electron_temp) float64 [] ...\n", + " nu_star (dim_average_electron_density, dim_average_electron_temp) float64 [] ...\n", + " rho_star (dim_average_electron_temp) float64 [] ...\n", + " fusion_triple_product (dim_average_electron_density, dim_average_electron_temp) float64 [1e10 m^-3·keV·s] ...\n", + " peak_pressure (dim_average_electron_temp, dim_average_electron_density) float64 [Pa] ...\n", + " current_relaxation_time (dim_average_electron_temp, dim_average_electron_density) float64 [s] ..." + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "algorithm.update_dataset(dataset, in_place=True)\n", + "\n", + "dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting and interrogating the results\n", + "\n", + "That's it: the only thing left is to look at our results. We can use the built-in plotting functionality, which is configured by dictionaries which we read in from YAML files using `read_plot_style`.\n", + "\n", + "Nothing fancy is happening here: it's just reading in a dictionary from a file and not doing any conversions. You can modify the YAML file, or directly make a dictionary yourself. The structure of the dictionary is\n", + "\n", + "* `type`: what sort of plot do you want to make. Currently we only support `popcon`, but room for growth.\n", + "* `figsize`: the size of the figure in inches, defining both the aspect ratio and text size of the resulting plot. If you want larger overall labels, try reducing `figsize`\n", + "* `show_dpi`: the pixels-per-inch of the resulting figure. Increase this if your figure is blurry. This will also make the figure larger in the Jupyter notebook.\n", + "* `save_as`: a name for the figure when saving it as a `.png`\n", + "* `coords` or `new_coords`: what to use as the x-axis and y-axis. `coords` must be already in the coordinates of the dataset, while `new_coords` can be output variables (see the example below)\n", + "* `fill`: a block for a variable to be plotted as a colormesh. Inside this, we define a section `where` which we use to build a mask (discussed below)\n", + "* `points`: a block for points to be highlighted on the plot. These must correspond to points defined in the `input.yaml` file\n", + "* `contour`: a block for variables which we should plot contours for. We pick a single color per contour and then label the contour lines themselves at specific values, which lets us show multiple variables at once\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'popcon',\n", + " 'figsize': [8, 6],\n", + " 'show_dpi': 150,\n", + " 'save_as': 'SPARC_PRD',\n", + " 'coords': {'x': {'dimension': 'average_electron_temp',\n", + " 'label': '$$ [$keV$]',\n", + " 'units': 'keV'},\n", + " 'y': {'dimension': 'average_electron_density',\n", + " 'label': '$$ [$10^{20} m^{-3}$]',\n", + " 'units': 'n20'}},\n", + " 'fill': {'variable': 'Q',\n", + " 'where': {'Q': {'min': 1.0},\n", + " 'P_auxillary': {'min': 0.0, 'max': 25.0, 'units': 'MW'},\n", + " 'greenwald_fraction': {'max': 0.9},\n", + " 'ratio_of_P_SOL_to_P_LH': {'min': 1.0}}},\n", + " 'points': {'PRD': {'label': 'PRD',\n", + " 'marker': 'x',\n", + " 'color': 'red',\n", + " 'size': 50.0}},\n", + " 'contour': {'Q': {'label': '$Q$',\n", + " 'levels': [0.1, 1.0, 2.0, 5.0, 10.0, 50.0],\n", + " 'color': 'tab:red',\n", + " 'format': '1.2g'},\n", + " 'ratio_of_P_SOL_to_P_LH': {'label': '$P_{SOL}/P_{LH}$',\n", + " 'color': 'tab:blue',\n", + " 'levels': [1.0],\n", + " 'format': '1.2g'},\n", + " 'P_auxillary': {'label': '$P_{aux}$',\n", + " 'levels': [1.0, 5.0, 10.0, 25.0, 50.0],\n", + " 'color': 'tab:gray',\n", + " 'format': '1.2g'},\n", + " 'P_fusion': {'label': '$P_{fusion}$',\n", + " 'color': 'tab:purple',\n", + " 'levels': [50.0, 100.0, 150.0, 200.0],\n", + " 'format': '1.2g'}}}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot_style = cfspopcon.read_plot_style(\"../../example_cases/SPARC_PRD/plot_popcon.yaml\")\n", + "\n", + "plot_style" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once we have our `plot_style`, we call `cfspopcon.plotting.make_plot` to make a figure.\n", + "\n", + "N.b. we've set `output_dir=None` to stop `make_plot` from saving the figure to a `.png` file. If you're using the command-line tool, you can delete the `save_as` key in `plot_style`.\n", + "\n", + "It's pretty easy to make this plot, but not entirely straightforward to interpret it.\n", + "\n", + "Firstly, the axes are for the average density and for the average temperature. These are more often the outputs of a calculation, rather than the independent variables. This is a consequence of the particular 'back to front' algorithm that we're using, which uses the average temperature and density to define the plasma stored energy and the resulting confinement time and input power required to stay at that point.\n", + "\n", + "Next, it's helpful to remember that all of the points shown are completely independent. Each represents a time-independent solution of the given algorithm.\n", + "\n", + "Although we get a solution at all $(\\bar n_e, \\bar T_e)$ points, they don't all make sense as operational points. There are a set of limits that we impose via the `where` block inside the `fill` block. For this example, these are\n", + "\n", + "1. We're looking for high fusion gains, with at least $Q>1$,\n", + "2. Since we're using the ITER98y2 H-mode energy confinement scaling, we require that $P_{SOL} > P_{LH}$,\n", + "3. We can't switch off the Ohmic power, so we neglect points with $P_{RF} <= 0$,\n", + "4. To avoid density-limit disruptions, we require that the volume-averaged density is no more than 90% of the Greenwald density limit,\n", + "5. To avoid damaging the magnets with neutrons, we impose a limit of $P_{fusion} < 140MW$.\n", + "\n", + "We mask points which don't meet these requirements, and then plot a variable over the unmasked region (in this case, we're plotting $Q$).\n", + "\n", + "On top of this, we plot contours of fields of interest such as the divertor heat-flux metric $P_{SOL} B_{pol} / R n^2$ so we can see the trends of these field as we go across the accessible parameter space.\n", + "\n", + "Finally, within the accessible parameter, we select points which minimize or maximize the values of fields, such as the point giving the maximum value of $Q$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cfspopcon.plotting.make_plot(\n", + " dataset,\n", + " plot_style,\n", + " points=points,\n", + " title=\"POPCON example\",\n", + " output_dir=None\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There's lots of functionality which you can explore (and extend!). For example, if you'd prefer to look at the results in terms of the auxillary heating power instead of the average electron temperature, you can use `cfspopcon.transform` to map the results onto new axes.\n", + "\n", + "Some of these features are a bit experimental. For instance, you can see here that by remapping we've shrunk the range of $Q$ in the accessible parameter space, since we apply a transformation on the masked array. Increasing the resolution of the analysis grid should reduce the difference when remapping." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cfspopcon.plotting.make_plot(dataset,\n", + " cfspopcon.read_plot_style(\"../../example_cases/SPARC_PRD/plot_remapped.yaml\"),\n", + " points=points,\n", + " title=\"POPCON example\",\n", + " output_dir=None,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We often want to study individual points in detail.\n", + "\n", + "The simplest way to do this is to use `file_io.write_point_to_file` which writes the values at the points specified in the `points` dictionary to a JSON file." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "for point, point_params in points.items():\n", + " cfspopcon.file_io.write_point_to_file(dataset, point, point_params, output_dir=Path(\"../../example_cases/SPARC_PRD/output\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can dig into the output file `SPARC_PRD/outputs/max_Q.json`, or alternatively we can peek under the hood to understand what is going on. Let's pick the `max_Q` point which we defined in `input.yaml`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'maximize': 'Q',\n", + " 'where': {'P_auxillary': {'min': 0.0, 'max': 25.0, 'units': 'MW'},\n", + " 'greenwald_fraction': {'max': 0.9},\n", + " 'ratio_of_P_SOL_to_P_LH': {'min': 1.0},\n", + " 'P_fusion': {'max': 140.0, 'units': 'MW'}}}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "point_params = points[\"PRD\"]\n", + "\n", + "point_params" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first build a *mask* from the `where` key. This lets us hide parts of operational space which aren't physical (for example, if they have $P_{SOL}$ below the LH transition).\n", + "\n", + "This can be used with the `where` method of an `xarray.DataArray`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mask = cfspopcon.point_selection.build_mask_from_dict(dataset, point_params)\n", + "\n", + "dataset.Q.where(mask).plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, let's find the point here with the highest value of Q. This gives us the indices of the corresponding point." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'dim_average_electron_density': \n", + " array(24),\n", + " 'dim_average_electron_temp': \n", + " array(8)}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "point_indices = cfspopcon.point_selection.find_coords_of_maximum(dataset.Q, mask=mask)\n", + "\n", + "point_indices" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use those indices to select a point of the array, see the coordinates and value at that point." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'Q' ()>\n",
+       "<Quantity(11.40076545330472, 'dimensionless')>\n",
+       "Coordinates:\n",
+       "    dim_average_electron_density  float64 25.0\n",
+       "    dim_average_electron_temp     float64 9.138
" + ], + "text/plain": [ + "\n", + "\n", + "Coordinates:\n", + " dim_average_electron_density float64 25.0\n", + " dim_average_electron_temp float64 9.138" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset.Q.isel(point_indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also select this point for all of the variables defined in our dataset, which lets us look at the values of *all* of the different fields at that point (you might need to click the arrow next to \"data variables\" to see these)." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:                               (dim_species: 3, dim_rho: 50)\n",
+       "Coordinates:\n",
+       "  * dim_species                           (dim_species) object Impurity.Tungs...\n",
+       "    dim_average_electron_density          float64 25.0\n",
+       "    dim_average_electron_temp             float64 9.138\n",
+       "Dimensions without coordinates: dim_rho\n",
+       "Data variables: (12/115)\n",
+       "    major_radius                          float64 [m] 1.85\n",
+       "    magnetic_field_on_axis                float64 [T] 12.2\n",
+       "    inverse_aspect_ratio                  float64 [] 0.3081\n",
+       "    areal_elongation                      float64 [] 1.75\n",
+       "    elongation_ratio_sep_to_areal         float64 [] 1.125\n",
+       "    triangularity_psi95                   float64 [] 0.3\n",
+       "    ...                                    ...\n",
+       "    core_radiated_power_fraction          float64 [] 0.1866\n",
+       "    nu_star                               float64 [] 0.02375\n",
+       "    rho_star                              float64 [] 0.002213\n",
+       "    fusion_triple_product                 float64 [1e10 m^-3·keV·s] 45.28\n",
+       "    peak_pressure                         float64 [Pa] 2.469e+06\n",
+       "    current_relaxation_time               float64 [s] 16.36
" + ], + "text/plain": [ + "\n", + "Dimensions: (dim_species: 3, dim_rho: 50)\n", + "Coordinates:\n", + " * dim_species (dim_species) object Impurity.Tungs...\n", + " dim_average_electron_density float64 25.0\n", + " dim_average_electron_temp float64 9.138\n", + "Dimensions without coordinates: dim_rho\n", + "Data variables: (12/115)\n", + " major_radius float64 [m] 1.85\n", + " magnetic_field_on_axis float64 [T] 12.2\n", + " inverse_aspect_ratio float64 [] 0.3081\n", + " areal_elongation float64 [] 1.75\n", + " elongation_ratio_sep_to_areal float64 [] 1.125\n", + " triangularity_psi95 float64 [] 0.3\n", + " ... ...\n", + " core_radiated_power_fraction float64 [] 0.1866\n", + " nu_star float64 [] 0.02375\n", + " rho_star float64 [] 0.002213\n", + " fusion_triple_product float64 [1e10 m^-3·keV·s] 45.28\n", + " peak_pressure float64 [Pa] 2.469e+06\n", + " current_relaxation_time float64 [s] 16.36" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "point = dataset.isel(point_indices)\n", + "\n", + "point" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we want to look at a particular value, we can pull the single-element `DataArray` out of the `Dataset`.\n", + "\n", + "For instance, we can return how much power is crossing the separatrix. By default, this is stored in megawatts, but we can easily convert it to other compatible units such as watts." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'P_sol' ()>\n",
+       "<Quantity(25591250.26660787, 'watt')>\n",
+       "Coordinates:\n",
+       "    dim_average_electron_density  float64 25.0\n",
+       "    dim_average_electron_temp     float64 9.138
" + ], + "text/plain": [ + "\n", + "\n", + "Coordinates:\n", + " dim_average_electron_density float64 25.0\n", + " dim_average_electron_temp float64 9.138" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "point.P_sol.pint.to(ureg.watt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we selected the point, we selected a single average electron density and temperature, but left the rest of the structure of the data unchanged. If we'd defined more than 2 variables in our `grid` section of our `input.yaml`, we could look at how the point (in this case maximum Q) varies as a function of the third parameter (which could be something like the confinement time scalar $H$). Even for our simple 2D POPCON, there's still some 1D data at our point: namely, the assumed temperature and density profiles." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "point.electron_temp_profile.pint.to(ureg.keV).plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's the basics for using the POPCON library.\n", + "\n", + "You can perform the analysis in this notebook using the command line tool. If you wanted to run this exact case from a terminal at the top-level of this repository, the command would be:\n", + "```\n", + "poetry run popcon example_cases/SPARC_PRD -p example_cases/SPARC_PRD/plot_popcon.yaml -p example_cases/SPARC_PRD/plot_remapped.yaml --debug --show\n", + "```\n", + "where `example_cases/SPARC_PRD` is the path to the `input.yaml` file and `example_cases/SPARC_PRD/plot_popcon.yaml` & `example_cases/SPARC_PRD/plot_remapped.yaml` are the two plotting styles that we used.\n", + "\n", + "Feel free to try things out and change the `input.yaml` file. At some point, you'll probably want to dig into the formulas and algorithms and start implementing your own. For this, see the other notebooks in this folder." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/doc_sources/physics_glossary.rst b/docs/doc_sources/physics_glossary.rst new file mode 100644 index 00000000..4ba0db31 --- /dev/null +++ b/docs/doc_sources/physics_glossary.rst @@ -0,0 +1,373 @@ +.. _physics_glossary: + +Physics Glossary +================== + +.. glossary:: + :sorted: + + Q + Fusion power thermal gain factor. + + P_fusion + Total power generated by fusion integrated over the plasma volume. For DT fusion, this is the sum of the power going to the alpha particles and to the neutrons. + + P_neutron + Fusion power released as neutrons integrated over the plasma volume. + + P_alpha + Fusion power released as alpha particles integrated over the plasma volume. + + P_external + External heating absorbed by the plasma (ohmic plus auxillary) integrated over the plasma volume. + + P_launched + External heating supplied to the plasma (entering the volume, but not necessarily absorbed — ohmic plus auxillary) integrated over the plasma volume. + + fraction_of_external_power_coupled + Fraction of supplied external heating absorbed by the plasma: :math:`f_{coupled}=P_{external} / P_{launched}`. + + P_radiation + Power radiated from the confined region due to Bremmsstrahlung, synchrotron and impurity excitation-relaxation processes. + + P_radiated_by_core_radiator + Power radiated from the confined region due to the injection of an :term:`extrinsic` core radiator. + + extrinsic impurity + An impurity which has intentionally been injected into the plasma to enhance radiative power dissipation. + + intrinsic impurity + An impurity which is assumed to be already in the plasma (without being injected by us). + + P_SOL + power_crossing_separatrix + Power crossing the separatrix and entering the scrape-off-layer. + + SOL_power_loss_fraction + Fraction of power entering a scrape-off-layer flux tube which is lost (radiated or cross-field transported) before reaching the divertor target. + + SOL_momentum_loss_function + Fraction of momentum entering a scrape-off-layer flux tube which is lost before reaching the divertor target. + + kappa_e0 + Electron heat conductivity constant, such that :math:`q_{e,\parallel,cond}=\kappa_{e0}T_{e}^{5/2}\nabla_\parallel T_e`. + + toroidal_flux_expansion + Ratio of the divertor target major radius to the :term:`upstream` major radius for the two point model :math:`R_{target} / R_{upstream}`. + + nesep_over_nebar + Ratio of the separatrix electron density to the volume-averaged electron density :math:`n_{e,sep} / \bar n_e`. + + parallel_connection_length + Length along a field-line from :term:`upstream` to the divertor target. + + upstream + The point where heat enters the flux-tube being considered for the two-point-model. Usually 'upstream' means the outboard-midplane separatrix. + + upstream_electron_temp + The :term:`upstream` electron temperature. + + target_electron_density + The :term:`target` electron density. + + target + The divertor target. Although there are several divertor targets, we usually perform the two-point-model analysis for the low-field-side (outboard) divertor target. + + target_electron_temp + The :term:`target` electron temperature. + + target_electron_flux + The rate of electrons per unit area reaching the :term:`target`. + + target_q_parallel + The parallel heat flux density at the :term:`target`. + + neutron_power_flux_to_walls + Neutron power per unit area to the wall. + + neutron_rate + Number of neutrons produced per second. + + B_t_out_mid + Toroidal magnetic field at outboard midplane separatrix + + B_pol_omp + B_pol_out_mid + Poloidal magnetic field at outboard midplane separatrix + + fieldline_pitch_at_omp + The :term:`upstream` pitch of the magnetic field :math:`B_{tot} / B_{pol}`, used to convert from poloidal to parallel heat flux density. + + lambda_q_scaling + A :class:`~cfspopcon.named_options.LambdaQScaling` indicating which scaling to use for :term:`lambda_q`. + + lambda_q + The :term:`upstream` parallel heat flux density (:math:`q_\parallel`) near-SOL cross-field decay length. + + lambda_q_factor + A scaling factor :math:`C` which can be used to increase or decrease :math:`\lambda_q=C \lambda_{q,scaling}`. + + q_perp + The :term:`upstream` poloidal heat flux density. + + q_parallel + The :term:`upstream` parallel heat flux density. + + PBpRnSq + :math:`P_{SOL}B_{pol}/(R n_{sep}^2)`, a metric used to estimate how challenging heat exhaust will be. This metric is approximately :math:`q_\parallel/n_{e,sep}^2`, which in the Lengyel model gives the impurity concentration required for detachment. + + PB_over_R + :math:`P_{SOL}B_0/R`, a metric used to estimate how challenging heat exhaust will be. + + atomic_data + Dictionary mapping :class:`~cfspopcon.named_options.Impurity` to datasets giving coronal and non-coronal :math:`L_z` radiated power factors and :math:`\langle Z \rangle` mean charge state curves from `radas `_. + + impurities + A :class:`xarray.DataArray` giving the concentration of non-fuel species relative to the electron density. + This array must have a dimension `dim_species` with :class:`~cfspopcon.named_options.Impurity` coordinates. + There are several functions in the :mod:`cfspopcon.helpers` module to help you make and extend the `impurities` array. + + impurity_species + An :class:`~cfspopcon.named_options.Impurity` indicating which non-fuel atomic species we are performing a calculation for. + + impurity_concentration + Concentration of a non-fuel atomic species relative to the electron density :math:`c_Z = n_Z / n_e`. + + impurity_charge_state + The mean charge state of a non-fuel species. + + greenwald_fraction + Ratio of the average electron density to the Greenwald density limit :math:`f_{G}=\bar n_e / n_G`. + + tau_i + Impurity residence/recycling time, which leads to a non-coronal enhancement of radiated power. + + radiated_power_method + A :class:`~cfspopcon.named_options.RadiationMethod` indicating how we should calculate the power radiated from the confined region. + + dilution + Fuel-species concentration as a fraction of the electron density :math:`n_{DT}/n_e`. + + core_radiator + An :class:`~cfspopcon.named_options.Impurity` indicating which :term:`extrinsic` core radiator species should be injected into the confined region to enhance the core radiated power. + + core_radiator_charge_state + Charge state of the :term:`extrinsic` core radiator. + + core_radiator_concentration + Concentration of the :term:`extrinsic` core radiator required to achieve the desired core radiated power fraction, relative to the electron density :math:`c_{core} = n_{core}/n_e`. + + electron_density_profile + A 1D profile of the electron density as a function of :math:`\rho_{pol}`. + + electron_temp_profile + A 1D profile of the electron temperature as a function of :math:`\rho_{pol}`. + + ion_temp_profile + A 1D profile of the ion temperature as a function of :math:`\rho_{pol}`. + + profile_form + A :class:`~cfspopcon.named_options.ProfileForm` indicating which sort of assumed profile shape we should use. + + z_effective + The "effective charge" of the ions, defined as :math:`\sum_j Z_j^2 n_j / n_e`. + + rho + The square-root of the normalized poloidal flux :math:`\rho_{pol}=\sqrt{\psi_N}`, used as a flux surface label. + + plasma_volume + Plasma volume inside the last-closed-flux-surface. + + normalized_inverse_temp_scale_length + Inverse normalized electron temperature gradient scale length :math:`a / ( T_e / \nabla T_e )`, which defines the shape of the :class:`~cfspopcon.named_options.ProfileForm.prf` profiles. + + inverse_aspect_ratio + Ratio of minor to major radius :math:`\epsilon= a / R_0`. + + confinement_time_scalar + Usually denoted :math:`H`, scalar applied to the energy confinement time calculated from a scaling such that :math:`\tau_e = H \tau_{e,scaling}`. + + plasma_current + Current carried by the plasma :math:`I_p`. + + magnetic_field_on_axis + Magnetic field at the geometric magnetic axis :math:`B_0 = BR / R0`. + + average_electron_density + Volume-averaged electron density in the confined region :math:`\bar n_e`. + + average_electron_temp + Volume-averaged electron temperature in the confined region :math:`\bar T_e`. + + summed_impurity_density + Density of non-fuel ions. + + average_ion_density + Volume-averaged ion density in the confined region :math:`\bar n_i`. + + average_ion_temp + Volume-averaged ion temperature in the confined region :math:`\bar T_i`. + + average_total_pressure + Sum of electron and ion pressures. + + areal_elongation + Elongation of the confined region computed using the poloidal area inside the last-closed-flux-surface :math:`\kappa_A = S_{pol} / (\pi a^2)`. + + beta_toroidal + Ratio of plasma pressure to magnetic pressure provided by the toroidal magnetic field. + + beta_poloidal + Ratio of plasma pressure to magnetic pressure provided by the poloidal magnetic field. + + beta_total + Ratio of plasma pressure to magnetic pressure provided by the total magnetic field. + + beta_N + Ratio of plasma pressure to magnetic pressure provided by the total magnetic field, normalized to :math:`I_MA / a B_0`. + + separatrix_elongation + Elongation of the last-closed-flux-surface :math:`(Z_{max,LCFS} - Z_{min,LCFS}) / (R_{max,LCFS} - R_{min,LCFS})`. + + elongation_ratio_sep_to_areal + Ratio of separatrix elongation to areal elongation :math:`\kappa_{sep}/\kappa_A`. + + triangularity_ratio_sep_to_psi95 + Ratio of separatrix triangularity to triangularity at the :math:`psi_N=0.95` surface :math:`\delta_{sep}/\delta_{95}.` + + f_shaping + Shaping factor used to compute :math:`q_*`. + + fuel_average_mass_number + Average mass of fuel ions, with the average weighted by the relative concentration of each species. + + surface_area + Area of the last-closed-flux-surface, i.e. the surface defined by toroidally revolving the poloidal last-closed-flux-surface. + + triangularity_psi95 + Usually denoted :math:`\delta_{95}`, average of upper and lower triangularity at the :math:`\psi_N=0.95` surface. + + spitzer_resistivity + Plasma loop collisional resistivity. + + neoclassical_loop_resistivity + Plasma loop neoclassical resistivity. + + inductive_plasma_current + Plasma current driven by the central solenoid (i.e. excluding the contribution of the bootstrap current). + + electron_density_peaking_offset + Scalar offset of the electron density peaking relative to the density peaking scaling. + + ion_density_peaking_offset + Scalar offset of the ion density peaking relative to the density peaking scaling. + + ion_density_peaking + Ratio of the peak ion density to the volume-averaged ion density. + + electron_density_peaking + Ratio of the peak ion density to the volume-averaged electron density. + + temperature_peaking + Ratio of the peak (electron or ion) temperature to the volume-averaged temperature. + + bootstrap_fraction + Fraction of the plasma current due to the bootstrap current. + + effective_collisionality + Estimate of collisionality used for computing the expected density peaking. + + nu_n + Either the :term:`ion_density_peaking` or the :term:`electron_density_peaking` + + peak_ion_temp + Peak ion temperature + + peak_fuel_ion_density + Peak fuel ion density (i.e. product of fuel dilution, ion peaking factor and average electron density). + + peak_electron_temp + Peak electron temperature + + peak_electron_density + Peak electron density + + current_relaxation_time + Time constant for the radial current diffusion. + + trapped_particle_fraction + Global average of the fraction of trapped electrons used in the calculation of global plasma resistivity. + + minimum_core_radiated_fraction + Minimum fraction of :math:`P_{in}` which should be radiated from the confined region, below which + we will inject an additional :term:`extrinsic` core radiator to increase + the radiated power up to this value. + + radiated_power_scalar + An enhancement factor :math:`C` to modify the radiated power :math:`P_{rad} = C P_{rad,calculated}`. + + zeff_change_from_core_rad + Change in :term:`z_effective` due to the injection of a core radiator. + + dilution_change_from_core_rad + Change in :term:`dilution` due to the injection of a core radiator. + + fuel_ion_density_profile + A 1D profile of the fuel ion density as a function of :math:`\rho_{pol}`. + + separatrix_triangularity + Separatrix triangularity (average of upper and lower triangularity). + + plasma_stored_energy + Thermal energy in the plasma. + + q_star + Analytical approximation of safety factor at :math:`\rho=0.95`. + + loop_voltage + inductive loop voltage + + energy_confinement_scaling + tau_e_scaling + A :class:`~cfspopcon.named_options.ConfinementScaling` indicating which :math:`\tau_e` energy confinement scaling should be used. + + energy_confinement_time + A characteristic time which gives the rate at which the plasma loses energy. In steady-state, :math:`\tau_e=W_p / P_in`. + + P_in + Total input power to the plasma. Sum of ohmic, auxillary and alpha power. + + fraction_of_P_SOL_to_divertor + fraction of the total power going towards the :term:`target`. + + P_LH_thresh + Power required to cross the L-H transition. + + SOC_LOC_ratio + Ratio of the energy confinement time from the chosen saturated ohmic confinement (SOC) scaling and the chosen linear ohmic confinement (LOC) scaling. + + P_LI_thresh + Power required to cross the L-I transition. + + P_ohmic + P_Ohmic + Power deposited in the plasma due to resistive ohmic heating. + + major_radius + The major radius of the geometric magnetic axis. + + minor_radius + Horizontal minor radius of the plasma :math:`(R_{max,LCFS}-R_{min,LCFS})/2` + + vertical_minor_radius + Vertical minor radius of the plasma :math:`(Z_{max,LCFS}-Z_{min,LCFS})/2` + + product_of_magnetic_field_and_radius + Product of the major radius and the (vacuum) magnetic field :math:`B \times R`. + + fusion_reaction + A :class:`~cfspopcon.named_options.ReactionType` indicating which fusion reaction should be used. + + heavier_fuel_species_fraction + Fraction of fuel ions which are the heavier species. i.e. for DT fusion, this is :math:`f_T = n_T/(n_T+n_D)`. + diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 00000000..dab35578 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,27 @@ +.. cfspopcon documentation master file, created by + sphinx-quickstart on Mon Nov 14 16:09:52 2022. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +##################################### +Welcome to cfspopcon's documentation! +##################################### + +POPCONs (Plasma OPerating CONtours) is a tool developed to explore the performance and constraints of tokamak designs based on 0D scaling laws, model plasma kinetic profiles, and physics assumptions on the properties and behavior of the core plasma. + +POPCONs was initially described in :cite:`prd` where it was applied to the design of the SPARC tokamak. + +To start generating your fist plasma operating contours with cfspopcon, head over to the :ref:`Getting Started ` guide. + +A usefull resource is our :ref:`Physics Glossary ` which lists all input and output variables, including definitions and citations for formulas where relevant. + +If you are interested in how to setup a development environment to make changes to cfspopcon, we suggest you checkout the :ref:`Developer's Guide `. + +.. toctree:: + :maxdepth: 1 + + doc_sources/Usage + doc_sources/physics_glossary + doc_sources/dev_guide + doc_sources/api + doc_sources/bib diff --git a/docs/refs.bib b/docs/refs.bib new file mode 100644 index 00000000..b9723c26 --- /dev/null +++ b/docs/refs.bib @@ -0,0 +1,438 @@ +@article{eich_scaling_2013, + title = {Scaling of the tokamak near the scrape-off layer {H}-mode power width and implications for {ITER}}, + volume = {53}, + issn = {0029-5515}, + doi = {10.1088/0029-5515/53/9/093031}, + language = {en}, + number = {9}, + journal = {Nuclear Fusion}, + author = {Eich, T. and Leonard, A. W. and Pitts, R. A. and Fundamenski, W. and Goldston, R. J. and Gray, T. K. and Herrmann, A. and Kirk, A. and Kallenbach, A. and Kardaun, O. and Kukushkin, A. S. and LaBombard, B. and Maingi, R. and Makowski, M. A. and Scarabosio, A. and Sieglin, B. and Terry, J. and Thornton, A. and Team, ASDEX Upgrade and Contributors, JET EFDA}, + month = aug, + year = {2013}, + note = {Publisher: IOP Publishing and International Atomic Energy Agency}, + pages = {093031}, +} + +@article{Bonoli, + title = {Observation of Efficient Lower Hybrid Current Drive at High Density in Diverted Plasmas on the Alcator C-Mod Tokamak}, + author = {Baek, S. G. and Wallace, G. M. and Bonoli, P. T. and Brunner, D. and Faust, I. C. and Hubbard, A. E. and Hughes, J. W. and LaBombard, B. and Parker, R. R. and Porkolab, M. and Shiraiwa, S. and Wukitch, S.}, + journal = {Phys. Rev. Lett.}, + volume = {121}, + issue = {5}, + pages = {055001}, + numpages = {6}, + year = {2018}, + month = {Aug}, + publisher = {American Physical Society}, + doi = {10.1103/PhysRevLett.121.055001}, +} + +@article{prd, + title={Overview of the SPARC tokamak}, + volume={86}, + DOI={10.1017/S0022377820001257}, + number={5}, + journal={Journal of Plasma Physics}, + publisher={Cambridge University Press}, + author={Creely, A. J. and Greenwald, M. J. and Ballinger, S. B. and Brunner, D. and Canik, J. and Doody, J. and Fülöp, T. and Garnier, D. T. and Granetz, R. and Gray, T. K. and et al.}, + year={2020}, + pages={865860502} +} + +@article{suckewer_radiation_1981, + title = {Radiation losses in {PLT} during neutral-beam and {ICRF} heating experiments}, + volume = {21}, + issn = {0029-5515}, + doi = {10.1088/0029-5515/21/8/007}, + abstract = {Radiation and charge-exchange losses in the PLT tokamak are compared for discharges with Ohmic heating only (OH), and with additional heating by neutral beams (NB) or RF in the ion cyclotron frequency range (ICRF). Spectroscopic, bolometric and soft-X-ray diagnostics were used. The effects of discharge cleaning, vacuum wall gettering, and rate of gas inlet on radiation losses from OH plasmas and the correlation between radiation from plasma core and edge temperatures are discussed. – For discharges with neutral-beam injection the radiation dependence on type of injection (e.g. co-injection versus counter- and co- plus counter-injection) was investigated. Radial profiles of radiation loss were compared with profiles of power deposition. Although total radiation was in the range of 30–60\% of total input power into relatively clean plasma, nevertheless only 10–20\% of the total central input power to ions and electrons was radiated from the plasma core. The radiated power was increased mainly by increased influx of impurities, however, a fraction of this radiation was due to the change in charge-state distribution associated with charge-exchange recombination. – During ICRF heating radiation losses were higher than or comparable to those experienced during co- plus counter-injection at similar power levels. At these low power levels of ICRF heating the total radiated power was ∼ 80\% of auxiliary-heating power. Radiation losses changed somewhat less rapidly than linearly with ICRF power input up to the maximum available at the time of these measurements (0.65 MW).}, + language = {en}, + number = {8}, + journal = {Nuclear Fusion}, + author = {Suckewer, S. and Hinnov, E. and Hwang, D. and Schivell, J. and Schmidt, G. L. and Bol, K. and Bretz, N. and Colestock, P. L. and Dimock, D. and Eubank, H. P. and Goldston, R. J. and Hawryluk, R. J. and Hosea, J. C. and Hsuan, H. and Johnson, D. W. and Meservey, E. and McNeill, D.}, + month = aug, + year = {1981}, + pages = {981}, +} + +@article{brunner_2018_heat_flux, + title = {High-resolution heat flux width measurements at reactor-level magnetic fields and observation of a unified width scaling across confinement regimes in the Alcator C-Mod tokamak}, + volume = {58}, + pages = {094002}, + doi = {10.1088/1741-4326/aad0d6}, + journal = {Nuclear Fusion}, + year = {2018}, + author = {Brunner, D. and LaBombard, B. and Kuang, A. Q. and Terry, J. L.} +} + +@article{stangeby_2018, + title = {Basic physical processes and reduced models for plasma detachment}, + volume = {60}, + doi = {10.1088/1361-6587/aaacf6}, + journal = {Plasma Physics and Controlled Fusion}, + author = {Stangeby, P.}, + year = {2018}, + pages = {044022}, +} + +@article{bosch_improved_1992, + title = {Improved formulas for fusion cross-sections and thermal reactivities}, + volume = {32}, + issn = {0029-5515}, + doi = {10.1088/0029-5515/32/4/I07}, + language = {en}, + number = {4}, + journal = {Nuclear Fusion}, + author = {Bosch, H.-S. and Hale, G. M.}, + month = apr, + year = {1992}, + pages = {611}, +} + + +@techreport{langenbrunner_temperature_2016, + title = {Temperature derivatives for fusion reactivity of {D}-{D} and {D}-{T}}, + abstract = {Deuterium-tritium (D-T) and deuterium-deuterium (D-D) fusion reaction rates are observable using leakage gamma flux. A direct measurement of γ-rays with equipment that exhibits fast temporal response could be used to infer temperature, if the detector signal is amenable for taking the logarithmic time-derivative, alpha. We consider the temperature dependence for fusion cross section reactivity.}, + language = {English}, + number = {LA-UR-16-29065}, + institution = {Los Alamos National Lab. (LANL), Los Alamos, NM (United States)}, + author = {Langenbrunner, James R. and Makaruk, Hanna Ewa}, + month = nov, + year = {2016}, + doi = {10.2172/1334107}, +} + +@article{nevins_thermonuclear_2000, + title = {The thermonuclear fusion rate coefficient for p-¹¹{B} reactions}, + volume = {40}, + issn = {0029-5515}, + doi = {10.1088/0029-5515/40/4/310}, + language = {en}, + number = {4}, + journal = {Nuclear Fusion}, + author = {Nevins, W.M and Swain, R}, + month = apr, + year = {2000}, + pages = {865--872}, +} + +@article{sikora_new_2016, + title = {A {New} {Evaluation} of the ¹¹{B}(p,α)αα {Reaction} {Rates}}, + volume = {35}, + issn = {1572-9591}, + doi = {10.1007/s10894-016-0069-y}, + language = {en}, + number = {3}, + journal = {Journal of Fusion Energy}, + author = {Sikora, M. H. and Weller, H. R.}, + month = jun, + year = {2016}, + pages = {538--543}, +} + +@book{richardson_nrl_2019, + title = {{NRL} {Plasma} {Formulary}}, + language = {en}, + publisher = {Naval Research Lab.}, + author = {Richardson, A S}, + year = {2019}, + url = {https://www.nrl.navy.mil/Portals/38/PDF%20Files/NRL_Plasma_Formulary_2019.pdf} +} + +@article{putvinski_fusion_2019, + title = {Fusion reactivity of the {pB11} plasma revisited}, + volume = {59}, + issn = {0029-5515}, + doi = {10.1088/1741-4326/ab1a60}, + language = {en}, + number = {7}, + journal = {Nuclear Fusion}, + author = {Putvinski, S. V. and Ryutov, D. D. and Yushmanov, P. N.}, + month = jun, + year = {2019}, + note = {Publisher: IOP Publishing}, + pages = {076018}, +} + +@techreport{macfarlane_bucky-1_1995, + title = {{BUCKY}-1 - {A} 1-{D} {Radiation} {Hydrodynamics} {Code} for {Simulating} {Inertial} {Confinement} {Fusion} {High} {Energy} {Density} {Plasmas}}, + url = {https://fti.neep.wisc.edu/fti.neep.wisc.edu/pdf/fdm984.pdf}, + number = {UWFDM-984}, + institution = {University of Wisconsin Fusion Technology Institute}, + author = {MacFarlane, J.J. and Moses, G.A. and Peterson, R.R.}, + month = aug, + year = {1995}, +} + +@article{gibson_impurity_1978, + title = {Impurity behaviour in real and simulated tokamak plasmas}, + volume = {76-77}, + issn = {0022-3115}, + doi = {10.1016/0022-3115(78)90122-8}, + language = {en}, + journal = {Journal of Nuclear Materials}, + author = {Gibson, A.}, + month = sep, + year = {1978}, + pages = {92--102}, +} + +@techreport{post_steady_1977, + title = {Steady state radiative cooling rates for low-density high-temperature plasmas}, + language = {English}, + number = {PPPL-1352}, + institution = {Princeton Univ., NJ (USA). Plasma Physics Lab.}, + author = {Post, D. E. and Jensen, R. V. and Tarter, C. B. and Grasberger, W. H. and Lokke, W. A.}, + month = jul, + year = {1977}, + doi = {10.2172/7297293}, +} + +@article{uckan_iter_1991, + title = {{ITER} {Confinement} {Capability}}, + volume = {19}, + issn = {0748-1896}, + doi = {10.13182/FST91-A29553}, + number = {3P2B}, + journal = {Fusion Technology}, + author = {Uckan, N. A. and Hogan, J. T.}, + month = may, + year = {1991}, + pages = {1499--1503}, +} + +@article{editors_iter_1999, + title = {The {ITER} {Physics} {Basis} - {Chapter} 1: {Overview} and summary}, + volume = {39}, + issn = {0029-5515}, + shorttitle = {Chapter 1}, + doi = {10.1088/0029-5515/39/12/301}, + language = {en}, + number = {12}, + journal = {Nuclear Fusion}, + author = {Editors, ITER Physics Basis and Chairs, ITER Physics Expert Group and {Co-Chairs} and Team, ITER Joint Central and Unit, Physics Integration}, + month = dec, + year = {1999}, + pages = {2137}, +} + +@article{angioni_particle_2009, + title = {Particle transport in tokamak plasmas, theory and experiment}, + volume = {51}, + issn = {0741-3335}, + doi = {10.1088/0741-3335/51/12/124017}, + language = {en}, + number = {12}, + journal = {Plasma Physics and Controlled Fusion}, + author = {Angioni, C. and Fable, E. and Greenwald, M. and Maslov, M. and Peeters, A. G. and Takenaga, H. and Weisen, H.}, + month = nov, + year = {2009}, + pages = {124017}, +} + +@article{martin_power_2008, + title = {Power requirement for accessing the {H}-mode in {ITER}}, + volume = {123}, + issn = {1742-6596}, + doi = {10.1088/1742-6596/123/1/012033}, + language = {en}, + number = {1}, + journal = {Journal of Physics: Conference Series}, + author = {Martin, Y. R. and Takizuka, T. and Group), (andthe ITPA CDBM H.-mode Threshold Database Working}, + month = jul, + year = {2008}, + pages = {012033}, +} + +@article{ryter_i-mode_2016, + title = {I-mode studies at {ASDEX} {Upgrade}: {L}-{I} and {I}-{H} transitions, pedestal and confinement properties}, + volume = {57}, + issn = {0029-5515}, + shorttitle = {I-mode studies at {ASDEX} {Upgrade}}, + doi = {10.1088/0029-5515/57/1/016004}, + language = {en}, + number = {1}, + journal = {Nuclear Fusion}, + author = {Ryter, F. and Fischer, R. and Fuchs, J. C. and Happel, T. and McDermott, R. M. and Viezzer, E. and Wolfrum, E. and Orte, L. Barrera and Bernert, M. and Burckhart, A. and Graça, S. da and Kurzan, B. and McCarthy, P. and Pütterich, T. and Suttrop, W. and Willensdorfer, M. and Team, the ASDEX Upgrade}, + month = sep, + year = {2016}, + note = {Publisher: IOP Publishing}, + pages = {016004}, +} + +@article{Ryter_2014, +doi = {10.1088/0029-5515/54/8/083003}, +url = {https://dx.doi.org/10.1088/0029-5515/54/8/083003}, +year = {2014}, +month = {may}, +publisher = {IOP Publishing}, +volume = {54}, +number = {8}, +pages = {083003}, +author = {F. Ryter and L. Barrera Orte and B. Kurzan and R.M. McDermott and G. Tardini and E. Viezzer and M. Bernert and R. Fischer and The ASDEX Upgrade Team}, +title = {Experimental evidence for the key role of the ion heat channel in the physics of the L–H transition}, +journal = {Nuclear Fusion}, +} + +@article{hubbard_threshold_2012, + title = {Threshold conditions for transitions to {I}-mode and {H}-mode with unfavourable ion grad {B} drift direction}, + volume = {52}, + issn = {0029-5515}, + doi = {10.1088/0029-5515/52/11/114009}, + language = {en}, + number = {11}, + journal = {Nuclear Fusion}, + author = {Hubbard, A. E. and Whyte, D. G. and Churchill, R. M. and Dominguez, A. and Hughes, J. W. and Ma, Y. and Marmar, E. S. and Lin, Y. and Reinke, M. L. and White, A. E.}, + month = oct, + year = {2012}, + note = {Publisher: IOP Publishing and International Atomic Energy Agency}, + pages = {114009}, +} + +@article{angioni_scaling_2007, + title = {Scaling of density peaking in {H}-mode plasmas based on a combined database of {AUG} and {JET} observations}, + volume = {47}, + issn = {0029-5515}, + doi = {10.1088/0029-5515/47/9/033}, + language = {en}, + number = {9}, + journal = {Nuclear Fusion}, + author = {Angioni, C. and Weisen, H. and Kardaun, O. J. W. F. and Maslov, M. and Zabolotsky, A. and Fuchs, C. and Garzotti, L. and Giroud, C. and Kurzan, B. and Mantica, P. and Peeters, A. G. and Stober, J. and Team, the ASDEX Upgrade and Workprogramme, contributors to the EFDA-JET}, + month = aug, + year = {2007}, + pages = {1326}, +} + +@book{wesson_tokamaks_2004, + address = {Oxford, New York}, + edition = {3rd}, + series = {International {Series} of {Monographs} on {Physics}}, + title = {Tokamaks}, + isbn = {9780198509226}, + publisher = {Oxford University Press}, + author = {Wesson, John}, + year = {2004}, +} + +@book{wesson_tokamaks_2011, + address = {Oxford, New York}, + edition = {4th}, + series = {International {Series} of {Monographs} on {Physics}}, + title = {Tokamaks}, + isbn = {978-0-19-959223-4}, + publisher = {Oxford University Press}, + author = {Wesson, John}, + month = dec, + year = {2011}, +} + +@article{gi_bootstrap_2014, + title = {Bootstrap current fraction scaling for a tokamak reactor design study}, + volume = {89}, + issn = {0920-3796}, + doi = {10.1016/j.fusengdes.2014.07.009}, + language = {en}, + number = {11}, + journal = {Fusion Engineering and Design}, + author = {Gi, Keii and Nakamura, Makoto and Tobita, Kenji and Ono, Yasushi}, + month = nov, + year = {2014}, + keywords = {Bootstrap current fraction, Reactor design, Scaling, Spherical tokamak, Systems codes, Tokamak}, + pages = {2709--2715}, +} + +@book{freidberg_plasma_2007, + address = {Cambridge}, + title = {Plasma {Physics} and {Fusion} {Energy}}, + isbn = {978-0-521-73317-5}, + publisher = {Cambridge University Press}, + author = {Freidberg, Jeffrey P.}, + year = {2007}, + doi = {10.1017/CBO9780511755705}, +} +@article{hively_convenient_1977, + title = {Convenient computational forms for maxwellian reactivities}, + volume = {17}, + issn = {0029-5515}, + doi = {10.1088/0029-5515/17/4/019}, + language = {en}, + number = {4}, + journal = {Nuclear Fusion}, + author = {Hively, L. M.}, + month = aug, + year = {1977}, + pages = {873}, +} + +@techreport{langenbrunner_analytic_2017, + title = {Analytic, empirical and delta method temperature derivatives of {D}-{D} and {D}-{T} fusion reactivity formulations, as a means of verification}, + language = {en}, + institution = {Los Alamos National Lab. (LANL), Los Alamos, NM (United States)}, + number = {LA-UR--17-26143, 1372790}, + author = {Langenbrunner, James R. and Booker, Jane M.}, + month = jul, + year = {2017}, + doi = {10.2172/1372790}, +} + +@article{mavrin_improved_2018, + title = {Improved fits of coronal radiative cooling rates for high-temperature plasmas}, + volume = {173}, + issn = {10294953}, + url = {https://doi.org/10.1080/10420150.2018.1462361}, + doi = {10.1080/10420150.2018.1462361}, + pages = {388--398}, + number = {5}, + journal = {Radiation Effects and Defects in Solids}, + author = {Mavrin, A. A.}, + year = {2018}, +} + +@article{mavrin_radiative_2017, + title = {Radiative Cooling Rates for Low-Z Impurities in Non-coronal Equilibrium State}, + volume = {36}, + issn = {01640313}, + url = {https://doi.org/10.1007/s10894-017-0136-z}, + doi = {10.1007/s10894-017-0136-z}, + pages = {161--172}, + number = {4}, + journal = {Journal of Fusion Energy}, + author = {Mavrin, A. A.}, + year = {2017}, +} + +@article{stott_feasibility_2005, + title = {The feasibility of using D-3He and D-D fusion fuels}, + volume = {47}, + issn = {07413335}, + url = {https://doi.org/10.1088/0741-3335/47/8/011}, + doi = {10.1088/0741-3335/47/8/011}, + pages = {1305}, + journal = {Plasma Physics and Controlled Fusion}, + author = {Stott, P. E.}, + year = {2005}, +} + +@article{zohm_use_2019, + title = {On the Use of High Magnetic Field in Reactor Grade Tokamaks}, + volume = {38}, + url = {https://doi.org/10.1007/s10894-018-0177-y}, + doi = {10.1007/s10894-018-0177-y}, + pages = {3-10}, + journal = {Journal of Fusion Energy}, + author = {Zohm, H.}, + year = {2019}, +} + +@article{Verdoolaege_2021, +doi = {10.1088/1741-4326/abdb91}, +url = {https://dx.doi.org/10.1088/1741-4326/abdb91}, +year = {2021}, +month = {may}, +publisher = {IOP Publishing}, +volume = {61}, +number = {7}, +pages = {076006}, +author = {G. Verdoolaege and S.M. Kaye and C. Angioni and O.J.W.F. Kardaun and M. Maslov and M. Romanelli and F. Ryter and K. Thomsen and the ASDEX Upgrade Team and the EUROfusion MST1 Team and JET Contributors}, +title = {The updated ITPA global H-mode confinement database: description and analysis}, +journal = {Nuclear Fusion}, +} \ No newline at end of file diff --git a/docs/static/theme_overrides.css b/docs/static/theme_overrides.css new file mode 100644 index 00000000..94af5f01 --- /dev/null +++ b/docs/static/theme_overrides.css @@ -0,0 +1,29 @@ +/* Fix for: https://github.com/readthedocs/sphinx_rtd_theme/issues/301 +/* Fix taken from: https://github.com/readthedocs/sphinx_rtd_theme/pull/383/ */ +span.eqno { + margin-left: 5px; + float: right; + /* position the number above the equation so that :hover is activated */ + z-index: 1; + position: relative; +} + +span.eqno .headerlink { + display: none; + visibility: hidden; +} + +span.eqno:hover .headerlink { + display: inline-block; + visibility: visible; +} + + +.sig.sig-object.py dl{ + margin: 0 0 0 0; +} + +.sig.sig-object.py * dd{ + margin: 0 0 0px 24px; +} + diff --git a/example_cases/SPARC_PRD/input.yaml b/example_cases/SPARC_PRD/input.yaml new file mode 100644 index 00000000..a34044ab --- /dev/null +++ b/example_cases/SPARC_PRD/input.yaml @@ -0,0 +1,168 @@ +# Primary Reference Discharge, see https://doi.org/10.1017/S0022377820001257 +algorithms: + # The POPCON algorithm starts by selecting an average density + # and temperature, which defines a stored energy stored_energy. From this, + # we can compute P_in from stored_energy and a tau_e scaling. + - calc_geometry + - calc_q_star_from_plasma_current + - calc_fuel_average_mass_number + - calc_average_ion_temp + - calc_zeff_and_dilution_from_impurities + - calc_plasma_stored_energy + - calc_power_balance_from_tau_e + # Once we have P_in (=P_loss in steady-state), we want to split + # it into components. For this, we need to estimate 1D plasma + # profiles in the confined region. + - calc_beta + - calc_peaked_profiles + # Once we have the profiles, we can then estimate the power + # radiated from the confined region. + - calc_core_radiated_power + - require_P_rad_less_than_P_in + # To control the power crossing the separatrix, we can inject + # a core radiator (high-Z species like Xenon) to intentionally + # increase the power radiated from the core. This increases + # the fuel dilution and Zeff (computed), as well as degrading + # core confinement (not yet computed). + - calc_extrinsic_core_radiator + # We then recompute the profiles with the dilution due to the + # core radiator, and use this to determine the fusion power rate. + - calc_peaked_profiles + - calc_fusion_gain + # We compute the ohmic heating power from the inductive current and + # loop voltage, and then set P_auxillary = P_in - P_ohmic + - calc_bootstrap_fraction + - calc_ohmic_power + - calc_auxillary_power + # Once we have the power input into and radiated from the confined + # region, we can determine the power crossing the separatrix. We use + # a scaling for lambda_q to calculate a corresponding q_parallel, and + # then use the two-point-model to determine how much edge seeding we + # require to protect the divertor. + - calc_P_SOL + - calc_average_total_pressure + - calc_heat_exhaust + - two_point_model_fixed_tet + # Finally, we calculate several parameters which aren't used in other + # calculations, but which are useful for characterizing operational + # points. These can be used later when masking inaccessible operational + # space, such as regions with f_Greenwald >~ 1.0 or where P_SOL < P_LH. + - calc_greenwald_fraction + - calc_confinement_transition_threshold_power + - calc_ratio_P_LH + - calc_f_rad_core + - calc_normalised_collisionality + - calc_rho_star + - calc_triple_product + - calc_peak_pressure + - calc_current_relaxation_time + +grid: + # input variables in the 'grid' block will be replaced by + # a corresponding linspace or logspace of values + + average_electron_density: + # Average electron density in 1e19 particles / m^3 + min: 1.0 + max: 40.0 + num: 40 + spacing: linear + + average_electron_temp: + # Average electron temperature in keV + min: 5.0 + max: 20.0 + num: 30 + spacing: linear + +points: + PRD: + maximize: Q + where: + P_auxillary: + min: 0.0 + max: 25.0 + units: MW + greenwald_fraction: + max: 0.9 + ratio_of_P_SOL_to_P_LH: + min: 1.0 + P_fusion: + max: 140.0 + units: MW + +# Major radius in metres +major_radius: 1.85 +# Toroidal field on-axis in Tesla +magnetic_field_on_axis: 12.2 +# Inverse aspect ratio +inverse_aspect_ratio: 0.3081 +# Areal elongation +areal_elongation: 1.75 +# Ratio of separatrix_elongation to kappa_A +elongation_ratio_sep_to_areal: 1.125 +# Triangularity at rho_pol = 0.95 +triangularity_psi95: 0.3 +# Ratio of separatrix_triangularity to delta_95 +triangularity_ratio_sep_to_psi95: 1.8 +# Plasma current in Ampere +plasma_current: 8.7e+6 +# Fraction of launched power absorbed by the plasma. Affects Q=P_fusion / (P_external / f_coupled). +fraction_of_external_power_coupled: 0.9 + +# What fusion reaction are we using? +fusion_reaction: DT +# Fraction of fuel ions which are the heavier species +heavier_fuel_species_fraction: 0.5 + +# What sort of 1D profiles should be assumed? +profile_form: prf +# Inverse normalized electron temp scale length a / L_Te = a / (Te / grad(Te)) +normalized_inverse_temp_scale_length: 2.5 +# Offset for the electron density peaking factor +electron_density_peaking_offset: -0.1 +# Offset for the ion density peaking factor +ion_density_peaking_offset: -0.2 +# Temperature peaking factor +temperature_peaking: 2.5 +# Ratio of volume-averaged temperatures (Ti / Te) +ion_to_electron_temp_ratio: 1.0 + +# Ratio of confinement-mode threshold power to scaling +confinement_threshold_scalar: 1.0 +# Confinement enhancement factor +confinement_time_scalar: 1.0 +# Name of the tau_e scaling used +energy_confinement_scaling: ITER98y2 + +radiated_power_method: Radas +radiated_power_scalar: 1.0 +minimum_core_radiated_fraction: 0.0 + +impurities: + # Impurity concentration relative to electron density. + Tungsten: 1.5e-5 + Helium: 6.0e-2 + Oxygen: 3.1e-3 + +core_radiator: Xenon + +# Inputs for two-point-model +# Ratio of separatrix to average density +nesep_over_nebar: 0.3 +# R_t/R_u = major radius at target / major radius upstream (outboard midplane) +toroidal_flux_expansion: 0.6974 +# Length along field-line from upstream (outboard midplane) to target in m +parallel_connection_length: 30.0 +# Lambda_q scaling (matching a LambdaQScaling in named_options) +lambda_q_scaling: EichRegression15 +# Scaling factor for lambda_q relative to selected scaling +lambda_q_factor: 1.0 +# Function used to calculate the momentum loss as a function of target Te in the SOL (matching a MomentumLossFunction in named_options) +SOL_momentum_loss_function: KotovReiter +# Fraction of P_SOL going to the outer divertor +fraction_of_P_SOL_to_divertor: 0.6 +# Electron thermal conductivity in W / (eV**3.5 m) +kappa_e0: 2600.0 +# Calculate P_rad_SOL such that the target electron temperature in eV reaches this value (for FixedTargetElectronTemp) +target_electron_temp: 25.0 diff --git a/example_cases/SPARC_PRD/plot_popcon.yaml b/example_cases/SPARC_PRD/plot_popcon.yaml new file mode 100644 index 00000000..5dfff0e7 --- /dev/null +++ b/example_cases/SPARC_PRD/plot_popcon.yaml @@ -0,0 +1,65 @@ +type: popcon + +figsize: [8, 6] +show_dpi: 150 +save_as: "SPARC_PRD" + +coords: + x: + dimension: average_electron_temp + label: "$$ [$keV$]" + units: keV + y: + dimension: average_electron_density + label: "$$ [$10^{20} m^{-3}$]" + units: n20 + +fill: + variable: Q + where: + Q: + min: 1.0 + P_auxillary: + min: 0.0 + max: 25.0 + units: MW + greenwald_fraction: + max: 0.9 + ratio_of_P_SOL_to_P_LH: + min: 1.0 + +points: + PRD: + label: "PRD" + marker: "x" + color: "red" + size: 50.0 + +# Suggested colors are "tab:red", "tab:blue", "tab:orange", "tab:green", "tab:purple", +# "tab:brown", "tab:pink", "tab:gray", "tab:olive", "tab:cyan" +contour: + + Q: + label: $Q$ + levels: [0.1, 1.0, 2.0, 5.0, 10.0, 50.0] + color: "tab:red" + format: "1.2g" + + ratio_of_P_SOL_to_P_LH: + label: "$P_{SOL}/P_{LH}$" + color: "tab:blue" + levels: [1.0] + format: "1.2g" + + P_auxillary: + label: "$P_{aux}$" + levels: [1.0, 5.0, 10.0, 25.0, 50.0] + color: "tab:gray" + format: "1.2g" + + P_fusion: + label: "$P_{fusion}$" + color: "tab:purple" + levels: [50.0, 100.0, 150.0, 200.0] + format: "1.2g" + \ No newline at end of file diff --git a/example_cases/SPARC_PRD/plot_remapped.yaml b/example_cases/SPARC_PRD/plot_remapped.yaml new file mode 100644 index 00000000..8aeb2ee6 --- /dev/null +++ b/example_cases/SPARC_PRD/plot_remapped.yaml @@ -0,0 +1,65 @@ +type: popcon + +figsize: [8, 6] +show_dpi: 150 + +new_coords: + x: + dimension: P_auxillary + label: "$P_{RF}$ [$MW$]" + units: MW + max: 25.0 + y: + dimension: average_electron_density + label: "$$ [$10^{20} m^{-3}$]" + units: n20 + +fill: + variable: Q + where: + Q: + min: 1.0 + P_auxillary: + min: 0.0 + max: 25.0 + units: MW + greenwald_fraction: + max: 0.9 + ratio_of_P_SOL_to_P_LH: + min: 1.0 + +points: + PRD: + label: "PRD" + marker: "x" + color: "red" + size: 50.0 + +# Suggested colors are "tab:red", "tab:blue", "tab:orange", "tab:green", "tab:purple", +# "tab:brown", "tab:pink", "tab:gray", "tab:olive", "tab:cyan" +contour: + + Q: + label: $Q$ + levels: [0.1, 1.0, 2.0, 5.0, 10.0, 50.0] + color: "tab:red" + format: "1.2g" + + ratio_of_P_SOL_to_P_LH: + label: "$P_{SOL}/P_{LH}$" + color: "tab:blue" + levels: [1.0] + format: "1.2g" + + P_auxillary: + label: "$P_{aux}$" + levels: [1.0, 5.0, 10.0, 25.0, 50.0] + color: "tab:gray" + format: "1.2g" + + P_fusion: + label: "$P_{fusion}$" + color: "tab:purple" + levels: [50.0, 100.0, 150.0, 200.0] + format: "1.2g" + \ No newline at end of file diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 00000000..fa9d915d --- /dev/null +++ b/poetry.lock @@ -0,0 +1,2929 @@ +# This file is automatically @generated by Poetry 1.6.1 and should not be changed by hand. + +[[package]] +name = "alabaster" +version = "0.7.13" +description = "A configurable sidebar-enabled Sphinx theme" +optional = false +python-versions = ">=3.6" +files = [ + {file = "alabaster-0.7.13-py3-none-any.whl", hash = "sha256:1ee19aca801bbabb5ba3f5f258e4422dfa86f82f3e9cefb0859b283cdd7f62a3"}, + {file = "alabaster-0.7.13.tar.gz", hash = "sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2"}, +] + +[[package]] +name = "appnope" +version = "0.1.3" +description = "Disable App Nap on macOS >= 10.9" +optional = false +python-versions = "*" +files = [ + {file = "appnope-0.1.3-py2.py3-none-any.whl", hash = "sha256:265a455292d0bd8a72453494fa24df5a11eb18373a60c7c0430889f22548605e"}, + {file = "appnope-0.1.3.tar.gz", hash = "sha256:02bd91c4de869fbb1e1c50aafc4098827a7a54ab2f39d9dcba6c9547ed920e24"}, +] + +[[package]] +name = "asttokens" +version = "2.4.0" +description = "Annotate AST trees with source code positions" +optional = false +python-versions = "*" +files = [ + {file = "asttokens-2.4.0-py2.py3-none-any.whl", hash = "sha256:cf8fc9e61a86461aa9fb161a14a0841a03c405fa829ac6b202670b3495d2ce69"}, + {file = "asttokens-2.4.0.tar.gz", hash = "sha256:2e0171b991b2c959acc6c49318049236844a5da1d65ba2672c4880c1c894834e"}, +] + +[package.dependencies] +six = ">=1.12.0" + +[package.extras] +test = ["astroid", "pytest"] + +[[package]] +name = "attrs" +version = "23.1.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.1.0-py3-none-any.whl", hash = "sha256:1f28b4522cdc2fb4256ac1a020c78acf9cba2c6b461ccd2c126f3aa8e8335d04"}, + {file = "attrs-23.1.0.tar.gz", hash = "sha256:6279836d581513a26f1bf235f9acd333bc9115683f14f7e8fae46c98fc50e015"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[docs,tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-no-zope = ["cloudpickle", "hypothesis", "mypy (>=1.1.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] + +[[package]] +name = "babel" +version = "2.12.1" +description = "Internationalization utilities" +optional = false +python-versions = ">=3.7" +files = [ + {file = "Babel-2.12.1-py3-none-any.whl", hash = "sha256:b4246fb7677d3b98f501a39d43396d3cafdc8eadb045f4a31be01863f655c610"}, + {file = "Babel-2.12.1.tar.gz", hash = "sha256:cc2d99999cd01d44420ae725a21c9e3711b3aadc7976d6147f622d8581963455"}, +] + +[[package]] +name = "backcall" +version = "0.2.0" +description = "Specifications for callback functions passed in to an API" +optional = false +python-versions = "*" +files = [ + {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, + {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.2" +description = "Screen-scraping library" +optional = false +python-versions = ">=3.6.0" +files = [ + {file = "beautifulsoup4-4.12.2-py3-none-any.whl", hash = "sha256:bd2520ca0d9d7d12694a53d44ac482d181b4ec1888909b035a3dbf40d0f57d4a"}, + {file = "beautifulsoup4-4.12.2.tar.gz", hash = "sha256:492bbc69dca35d12daac71c4db1bfff0c876c00ef4a2ffacce226d4638eb72da"}, +] + +[package.dependencies] +soupsieve = ">1.2" + +[package.extras] +html5lib = ["html5lib"] +lxml = ["lxml"] + +[[package]] +name = "black" +version = "22.12.0" +description = "The uncompromising code formatter." +optional = false +python-versions = ">=3.7" +files = [ + {file = "black-22.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eedd20838bd5d75b80c9f5487dbcb06836a43833a37846cf1d8c1cc01cef59d"}, + {file = "black-22.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:159a46a4947f73387b4d83e87ea006dbb2337eab6c879620a3ba52699b1f4351"}, + {file = "black-22.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d30b212bffeb1e252b31dd269dfae69dd17e06d92b87ad26e23890f3efea366f"}, + {file = "black-22.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:7412e75863aa5c5411886804678b7d083c7c28421210180d67dfd8cf1221e1f4"}, + {file = "black-22.12.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c116eed0efb9ff870ded8b62fe9f28dd61ef6e9ddd28d83d7d264a38417dcee2"}, + {file = "black-22.12.0-cp37-cp37m-win_amd64.whl", hash = "sha256:1f58cbe16dfe8c12b7434e50ff889fa479072096d79f0a7f25e4ab8e94cd8350"}, + {file = "black-22.12.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77d86c9f3db9b1bf6761244bc0b3572a546f5fe37917a044e02f3166d5aafa7d"}, + {file = "black-22.12.0-cp38-cp38-win_amd64.whl", hash = "sha256:82d9fe8fee3401e02e79767016b4907820a7dc28d70d137eb397b92ef3cc5bfc"}, + {file = "black-22.12.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:101c69b23df9b44247bd88e1d7e90154336ac4992502d4197bdac35dd7ee3320"}, + {file = "black-22.12.0-cp39-cp39-win_amd64.whl", hash = "sha256:559c7a1ba9a006226f09e4916060982fd27334ae1998e7a38b3f33a37f7a2148"}, + {file = "black-22.12.0-py3-none-any.whl", hash = "sha256:436cc9167dd28040ad90d3b404aec22cedf24a6e4d7de221bec2730ec0c97bcf"}, + {file = "black-22.12.0.tar.gz", hash = "sha256:229351e5a18ca30f447bf724d007f890f97e13af070bb6ad4c0a441cd7596a2f"}, +] + +[package.dependencies] +click = ">=8.0.0" +mypy-extensions = ">=0.4.3" +pathspec = ">=0.9.0" +platformdirs = ">=2" +tomli = {version = ">=1.1.0", markers = "python_full_version < \"3.11.0a7\""} +typing-extensions = {version = ">=3.10.0.0", markers = "python_version < \"3.10\""} + +[package.extras] +colorama = ["colorama (>=0.4.3)"] +d = ["aiohttp (>=3.7.4)"] +jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] +uvloop = ["uvloop (>=0.15.2)"] + +[[package]] +name = "bleach" +version = "6.0.0" +description = "An easy safelist-based HTML-sanitizing tool." +optional = false +python-versions = ">=3.7" +files = [ + {file = "bleach-6.0.0-py3-none-any.whl", hash = "sha256:33c16e3353dbd13028ab4799a0f89a83f113405c766e9c122df8a06f5b85b3f4"}, + {file = "bleach-6.0.0.tar.gz", hash = "sha256:1a1a85c1595e07d8db14c5f09f09e6433502c51c595970edc090551f0db99414"}, +] + +[package.dependencies] +six = ">=1.9.0" +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.2)"] + +[[package]] +name = "certifi" +version = "2023.7.22" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2023.7.22-py3-none-any.whl", hash = "sha256:92d6037539857d8206b8f6ae472e8b77db8058fec5937a1ef3f54304089edbb9"}, + {file = "certifi-2023.7.22.tar.gz", hash = "sha256:539cc1d13202e33ca466e88b2807e29f4c13049d6d87031a3c110744495cb082"}, +] + +[[package]] +name = "cffi" +version = "1.16.0" +description = "Foreign Function Interface for Python calling C code." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, + {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, + {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, + {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, + {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, + {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, + {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, + {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, + {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, + {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, + {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, + {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, + {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, + {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, +] + +[package.dependencies] +pycparser = "*" + +[[package]] +name = "cfgv" +version = "3.4.0" +description = "Validate configuration and produce human readable error messages." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.2.0" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.2.0.tar.gz", hash = "sha256:3bb3d25a8e6c0aedd251753a79ae98a093c7e7b471faa3aa9a93a81431987ace"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0b87549028f680ca955556e3bd57013ab47474c3124dc069faa0b6545b6c9710"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7c70087bfee18a42b4040bb9ec1ca15a08242cf5867c58726530bdf3945672ed"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a103b3a7069b62f5d4890ae1b8f0597618f628b286b03d4bc9195230b154bfa9"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94aea8eff76ee6d1cdacb07dd2123a68283cb5569e0250feab1240058f53b623"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:db901e2ac34c931d73054d9797383d0f8009991e723dab15109740a63e7f902a"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b0dac0ff919ba34d4df1b6131f59ce95b08b9065233446be7e459f95554c0dc8"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:193cbc708ea3aca45e7221ae58f0fd63f933753a9bfb498a3b474878f12caaad"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09393e1b2a9461950b1c9a45d5fd251dc7c6f228acab64da1c9c0165d9c7765c"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:baacc6aee0b2ef6f3d308e197b5d7a81c0e70b06beae1f1fcacffdbd124fe0e3"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:bf420121d4c8dce6b889f0e8e4ec0ca34b7f40186203f06a946fa0276ba54029"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:c04a46716adde8d927adb9457bbe39cf473e1e2c2f5d0a16ceb837e5d841ad4f"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:aaf63899c94de41fe3cf934601b0f7ccb6b428c6e4eeb80da72c58eab077b19a"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d62e51710986674142526ab9f78663ca2b0726066ae26b78b22e0f5e571238dd"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-win32.whl", hash = "sha256:04e57ab9fbf9607b77f7d057974694b4f6b142da9ed4a199859d9d4d5c63fe96"}, + {file = "charset_normalizer-3.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:48021783bdf96e3d6de03a6e39a1171ed5bd7e8bb93fc84cc649d11490f87cea"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4957669ef390f0e6719db3613ab3a7631e68424604a7b448f079bee145da6e09"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:46fb8c61d794b78ec7134a715a3e564aafc8f6b5e338417cb19fe9f57a5a9bf2"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f779d3ad205f108d14e99bb3859aa7dd8e9c68874617c72354d7ecaec2a054ac"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f25c229a6ba38a35ae6e25ca1264621cc25d4d38dca2942a7fce0b67a4efe918"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2efb1bd13885392adfda4614c33d3b68dee4921fd0ac1d3988f8cbb7d589e72a"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f30b48dd7fa1474554b0b0f3fdfdd4c13b5c737a3c6284d3cdc424ec0ffff3a"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:246de67b99b6851627d945db38147d1b209a899311b1305dd84916f2b88526c6"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bd9b3b31adcb054116447ea22caa61a285d92e94d710aa5ec97992ff5eb7cf3"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8c2f5e83493748286002f9369f3e6607c565a6a90425a3a1fef5ae32a36d749d"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3170c9399da12c9dc66366e9d14da8bf7147e1e9d9ea566067bbce7bb74bd9c2"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7a4826ad2bd6b07ca615c74ab91f32f6c96d08f6fcc3902ceeedaec8cdc3bcd6"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:3b1613dd5aee995ec6d4c69f00378bbd07614702a315a2cf6c1d21461fe17c23"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9e608aafdb55eb9f255034709e20d5a83b6d60c054df0802fa9c9883d0a937aa"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-win32.whl", hash = "sha256:f2a1d0fd4242bd8643ce6f98927cf9c04540af6efa92323e9d3124f57727bfc1"}, + {file = "charset_normalizer-3.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:681eb3d7e02e3c3655d1b16059fbfb605ac464c834a0c629048a30fad2b27489"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c57921cda3a80d0f2b8aec7e25c8aa14479ea92b5b51b6876d975d925a2ea346"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41b25eaa7d15909cf3ac4c96088c1f266a9a93ec44f87f1d13d4a0e86c81b982"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f058f6963fd82eb143c692cecdc89e075fa0828db2e5b291070485390b2f1c9c"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7647ebdfb9682b7bb97e2a5e7cb6ae735b1c25008a70b906aecca294ee96cf4"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eef9df1eefada2c09a5e7a40991b9fc6ac6ef20b1372abd48d2794a316dc0449"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e03b8895a6990c9ab2cdcd0f2fe44088ca1c65ae592b8f795c3294af00a461c3"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:ee4006268ed33370957f55bf2e6f4d263eaf4dc3cfc473d1d90baff6ed36ce4a"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:c4983bf937209c57240cff65906b18bb35e64ae872da6a0db937d7b4af845dd7"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:3bb7fda7260735efe66d5107fb7e6af6a7c04c7fce9b2514e04b7a74b06bf5dd"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:72814c01533f51d68702802d74f77ea026b5ec52793c791e2da806a3844a46c3"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:70c610f6cbe4b9fce272c407dd9d07e33e6bf7b4aa1b7ffb6f6ded8e634e3592"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-win32.whl", hash = "sha256:a401b4598e5d3f4a9a811f3daf42ee2291790c7f9d74b18d75d6e21dda98a1a1"}, + {file = "charset_normalizer-3.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:c0b21078a4b56965e2b12f247467b234734491897e99c1d51cee628da9786959"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:95eb302ff792e12aba9a8b8f8474ab229a83c103d74a750ec0bd1c1eea32e669"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1a100c6d595a7f316f1b6f01d20815d916e75ff98c27a01ae817439ea7726329"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6339d047dab2780cc6220f46306628e04d9750f02f983ddb37439ca47ced7149"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4b749b9cc6ee664a3300bb3a273c1ca8068c46be705b6c31cf5d276f8628a94"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a38856a971c602f98472050165cea2cdc97709240373041b69030be15047691f"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f87f746ee241d30d6ed93969de31e5ffd09a2961a051e60ae6bddde9ec3583aa"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89f1b185a01fe560bc8ae5f619e924407efca2191b56ce749ec84982fc59a32a"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1c8a2f4c69e08e89632defbfabec2feb8a8d99edc9f89ce33c4b9e36ab63037"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2f4ac36d8e2b4cc1aa71df3dd84ff8efbe3bfb97ac41242fbcfc053c67434f46"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a386ebe437176aab38c041de1260cd3ea459c6ce5263594399880bbc398225b2"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:ccd16eb18a849fd8dcb23e23380e2f0a354e8daa0c984b8a732d9cfaba3a776d"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:e6a5bf2cba5ae1bb80b154ed68a3cfa2fa00fde979a7f50d6598d3e17d9ac20c"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:45de3f87179c1823e6d9e32156fb14c1927fcc9aba21433f088fdfb555b77c10"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-win32.whl", hash = "sha256:1000fba1057b92a65daec275aec30586c3de2401ccdcd41f8a5c1e2c87078706"}, + {file = "charset_normalizer-3.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:8b2c760cfc7042b27ebdb4a43a4453bd829a5742503599144d54a032c5dc7e9e"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:855eafa5d5a2034b4621c74925d89c5efef61418570e5ef9b37717d9c796419c"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:203f0c8871d5a7987be20c72442488a0b8cfd0f43b7973771640fc593f56321f"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e857a2232ba53ae940d3456f7533ce6ca98b81917d47adc3c7fd55dad8fab858"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e86d77b090dbddbe78867a0275cb4df08ea195e660f1f7f13435a4649e954e5"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4fb39a81950ec280984b3a44f5bd12819953dc5fa3a7e6fa7a80db5ee853952"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2dee8e57f052ef5353cf608e0b4c871aee320dd1b87d351c28764fc0ca55f9f4"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8700f06d0ce6f128de3ccdbc1acaea1ee264d2caa9ca05daaf492fde7c2a7200"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1920d4ff15ce893210c1f0c0e9d19bfbecb7983c76b33f046c13a8ffbd570252"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c1c76a1743432b4b60ab3358c937a3fe1341c828ae6194108a94c69028247f22"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f7560358a6811e52e9c4d142d497f1a6e10103d3a6881f18d04dbce3729c0e2c"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:c8063cf17b19661471ecbdb3df1c84f24ad2e389e326ccaf89e3fb2484d8dd7e"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:cd6dbe0238f7743d0efe563ab46294f54f9bc8f4b9bcf57c3c666cc5bc9d1299"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:1249cbbf3d3b04902ff081ffbb33ce3377fa6e4c7356f759f3cd076cc138d020"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-win32.whl", hash = "sha256:6c409c0deba34f147f77efaa67b8e4bb83d2f11c8806405f76397ae5b8c0d1c9"}, + {file = "charset_normalizer-3.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:7095f6fbfaa55defb6b733cfeb14efaae7a29f0b59d8cf213be4e7ca0b857b80"}, + {file = "charset_normalizer-3.2.0-py3-none-any.whl", hash = "sha256:8e098148dd37b4ce3baca71fb394c81dc5d9c7728c95df695d2dca218edf40e6"}, +] + +[[package]] +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "comm" +version = "0.1.4" +description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +optional = false +python-versions = ">=3.6" +files = [ + {file = "comm-0.1.4-py3-none-any.whl", hash = "sha256:6d52794cba11b36ed9860999cd10fd02d6b2eac177068fdd585e1e2f8a96e67a"}, + {file = "comm-0.1.4.tar.gz", hash = "sha256:354e40a59c9dd6db50c5cc6b4acc887d82e9603787f83b68c01a80a923984d15"}, +] + +[package.dependencies] +traitlets = ">=4" + +[package.extras] +lint = ["black (>=22.6.0)", "mdformat (>0.7)", "mdformat-gfm (>=0.3.5)", "ruff (>=0.0.156)"] +test = ["pytest"] +typing = ["mypy (>=0.990)"] + +[[package]] +name = "contourpy" +version = "1.1.0" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = false +python-versions = ">=3.8" +files = [ + {file = "contourpy-1.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:89f06eff3ce2f4b3eb24c1055a26981bffe4e7264acd86f15b97e40530b794bc"}, + {file = "contourpy-1.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dffcc2ddec1782dd2f2ce1ef16f070861af4fb78c69862ce0aab801495dda6a3"}, + {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25ae46595e22f93592d39a7eac3d638cda552c3e1160255258b695f7b58e5655"}, + {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:17cfaf5ec9862bc93af1ec1f302457371c34e688fbd381f4035a06cd47324f48"}, + {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18a64814ae7bce73925131381603fff0116e2df25230dfc80d6d690aa6e20b37"}, + {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90c81f22b4f572f8a2110b0b741bb64e5a6427e0a198b2cdc1fbaf85f352a3aa"}, + {file = "contourpy-1.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:53cc3a40635abedbec7f1bde60f8c189c49e84ac180c665f2cd7c162cc454baa"}, + {file = "contourpy-1.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:1f795597073b09d631782e7245016a4323cf1cf0b4e06eef7ea6627e06a37ff2"}, + {file = "contourpy-1.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0b7b04ed0961647691cfe5d82115dd072af7ce8846d31a5fac6c142dcce8b882"}, + {file = "contourpy-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27bc79200c742f9746d7dd51a734ee326a292d77e7d94c8af6e08d1e6c15d545"}, + {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:052cc634bf903c604ef1a00a5aa093c54f81a2612faedaa43295809ffdde885e"}, + {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9382a1c0bc46230fb881c36229bfa23d8c303b889b788b939365578d762b5c18"}, + {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5cec36c5090e75a9ac9dbd0ff4a8cf7cecd60f1b6dc23a374c7d980a1cd710e"}, + {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f0cbd657e9bde94cd0e33aa7df94fb73c1ab7799378d3b3f902eb8eb2e04a3a"}, + {file = "contourpy-1.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:181cbace49874f4358e2929aaf7ba84006acb76694102e88dd15af861996c16e"}, + {file = "contourpy-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fb3b7d9e6243bfa1efb93ccfe64ec610d85cfe5aec2c25f97fbbd2e58b531256"}, + {file = "contourpy-1.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bcb41692aa09aeb19c7c213411854402f29f6613845ad2453d30bf421fe68fed"}, + {file = "contourpy-1.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5d123a5bc63cd34c27ff9c7ac1cd978909e9c71da12e05be0231c608048bb2ae"}, + {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62013a2cf68abc80dadfd2307299bfa8f5aa0dcaec5b2954caeb5fa094171103"}, + {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0b6616375d7de55797d7a66ee7d087efe27f03d336c27cf1f32c02b8c1a5ac70"}, + {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:317267d915490d1e84577924bd61ba71bf8681a30e0d6c545f577363157e5e94"}, + {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d551f3a442655f3dcc1285723f9acd646ca5858834efeab4598d706206b09c9f"}, + {file = "contourpy-1.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e7a117ce7df5a938fe035cad481b0189049e8d92433b4b33aa7fc609344aafa1"}, + {file = "contourpy-1.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:d4f26b25b4f86087e7d75e63212756c38546e70f2a92d2be44f80114826e1cd4"}, + {file = "contourpy-1.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc00bb4225d57bff7ebb634646c0ee2a1298402ec10a5fe7af79df9a51c1bfd9"}, + {file = "contourpy-1.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:189ceb1525eb0655ab8487a9a9c41f42a73ba52d6789754788d1883fb06b2d8a"}, + {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f2931ed4741f98f74b410b16e5213f71dcccee67518970c42f64153ea9313b9"}, + {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:30f511c05fab7f12e0b1b7730ebdc2ec8deedcfb505bc27eb570ff47c51a8f15"}, + {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:143dde50520a9f90e4a2703f367cf8ec96a73042b72e68fcd184e1279962eb6f"}, + {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e94bef2580e25b5fdb183bf98a2faa2adc5b638736b2c0a4da98691da641316a"}, + {file = "contourpy-1.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ed614aea8462735e7d70141374bd7650afd1c3f3cb0c2dbbcbe44e14331bf002"}, + {file = "contourpy-1.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:438ba416d02f82b692e371858143970ed2eb6337d9cdbbede0d8ad9f3d7dd17d"}, + {file = "contourpy-1.1.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a698c6a7a432789e587168573a864a7ea374c6be8d4f31f9d87c001d5a843493"}, + {file = "contourpy-1.1.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:397b0ac8a12880412da3551a8cb5a187d3298a72802b45a3bd1805e204ad8439"}, + {file = "contourpy-1.1.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:a67259c2b493b00e5a4d0f7bfae51fb4b3371395e47d079a4446e9b0f4d70e76"}, + {file = "contourpy-1.1.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2b836d22bd2c7bb2700348e4521b25e077255ebb6ab68e351ab5aa91ca27e027"}, + {file = "contourpy-1.1.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:084eaa568400cfaf7179b847ac871582199b1b44d5699198e9602ecbbb5f6104"}, + {file = "contourpy-1.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:911ff4fd53e26b019f898f32db0d4956c9d227d51338fb3b03ec72ff0084ee5f"}, + {file = "contourpy-1.1.0.tar.gz", hash = "sha256:e53046c3863828d21d531cc3b53786e6580eb1ba02477e8681009b6aa0870b21"}, +] + +[package.dependencies] +numpy = ">=1.16" + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.2.0)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "wurlitzer"] + +[[package]] +name = "coverage" +version = "6.5.0" +description = "Code coverage measurement for Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "coverage-6.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ef8674b0ee8cc11e2d574e3e2998aea5df5ab242e012286824ea3c6970580e53"}, + {file = "coverage-6.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:784f53ebc9f3fd0e2a3f6a78b2be1bd1f5575d7863e10c6e12504f240fd06660"}, + {file = "coverage-6.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b4a5be1748d538a710f87542f22c2cad22f80545a847ad91ce45e77417293eb4"}, + {file = "coverage-6.5.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:83516205e254a0cb77d2d7bb3632ee019d93d9f4005de31dca0a8c3667d5bc04"}, + {file = "coverage-6.5.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af4fffaffc4067232253715065e30c5a7ec6faac36f8fc8d6f64263b15f74db0"}, + {file = "coverage-6.5.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:97117225cdd992a9c2a5515db1f66b59db634f59d0679ca1fa3fe8da32749cae"}, + {file = "coverage-6.5.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:a1170fa54185845505fbfa672f1c1ab175446c887cce8212c44149581cf2d466"}, + {file = "coverage-6.5.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:11b990d520ea75e7ee8dcab5bc908072aaada194a794db9f6d7d5cfd19661e5a"}, + {file = "coverage-6.5.0-cp310-cp310-win32.whl", hash = "sha256:5dbec3b9095749390c09ab7c89d314727f18800060d8d24e87f01fb9cfb40b32"}, + {file = "coverage-6.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:59f53f1dc5b656cafb1badd0feb428c1e7bc19b867479ff72f7a9dd9b479f10e"}, + {file = "coverage-6.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4a5375e28c5191ac38cca59b38edd33ef4cc914732c916f2929029b4bfb50795"}, + {file = "coverage-6.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4ed2820d919351f4167e52425e096af41bfabacb1857186c1ea32ff9983ed75"}, + {file = "coverage-6.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:33a7da4376d5977fbf0a8ed91c4dffaaa8dbf0ddbf4c8eea500a2486d8bc4d7b"}, + {file = "coverage-6.5.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8fb6cf131ac4070c9c5a3e21de0f7dc5a0fbe8bc77c9456ced896c12fcdad91"}, + {file = "coverage-6.5.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a6b7d95969b8845250586f269e81e5dfdd8ff828ddeb8567a4a2eaa7313460c4"}, + {file = "coverage-6.5.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:1ef221513e6f68b69ee9e159506d583d31aa3567e0ae84eaad9d6ec1107dddaa"}, + {file = "coverage-6.5.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cca4435eebea7962a52bdb216dec27215d0df64cf27fc1dd538415f5d2b9da6b"}, + {file = "coverage-6.5.0-cp311-cp311-win32.whl", hash = "sha256:98e8a10b7a314f454d9eff4216a9a94d143a7ee65018dd12442e898ee2310578"}, + {file = "coverage-6.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:bc8ef5e043a2af066fa8cbfc6e708d58017024dc4345a1f9757b329a249f041b"}, + {file = "coverage-6.5.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:4433b90fae13f86fafff0b326453dd42fc9a639a0d9e4eec4d366436d1a41b6d"}, + {file = "coverage-6.5.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4f05d88d9a80ad3cac6244d36dd89a3c00abc16371769f1340101d3cb899fc3"}, + {file = "coverage-6.5.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:94e2565443291bd778421856bc975d351738963071e9b8839ca1fc08b42d4bef"}, + {file = "coverage-6.5.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:027018943386e7b942fa832372ebc120155fd970837489896099f5cfa2890f79"}, + {file = "coverage-6.5.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:255758a1e3b61db372ec2736c8e2a1fdfaf563977eedbdf131de003ca5779b7d"}, + {file = "coverage-6.5.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:851cf4ff24062c6aec510a454b2584f6e998cada52d4cb58c5e233d07172e50c"}, + {file = "coverage-6.5.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:12adf310e4aafddc58afdb04d686795f33f4d7a6fa67a7a9d4ce7d6ae24d949f"}, + {file = "coverage-6.5.0-cp37-cp37m-win32.whl", hash = "sha256:b5604380f3415ba69de87a289a2b56687faa4fe04dbee0754bfcae433489316b"}, + {file = "coverage-6.5.0-cp37-cp37m-win_amd64.whl", hash = "sha256:4a8dbc1f0fbb2ae3de73eb0bdbb914180c7abfbf258e90b311dcd4f585d44bd2"}, + {file = "coverage-6.5.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d900bb429fdfd7f511f868cedd03a6bbb142f3f9118c09b99ef8dc9bf9643c3c"}, + {file = "coverage-6.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:2198ea6fc548de52adc826f62cb18554caedfb1d26548c1b7c88d8f7faa8f6ba"}, + {file = "coverage-6.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c4459b3de97b75e3bd6b7d4b7f0db13f17f504f3d13e2a7c623786289dd670e"}, + {file = "coverage-6.5.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:20c8ac5386253717e5ccc827caad43ed66fea0efe255727b1053a8154d952398"}, + {file = "coverage-6.5.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b07130585d54fe8dff3d97b93b0e20290de974dc8177c320aeaf23459219c0b"}, + {file = "coverage-6.5.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:dbdb91cd8c048c2b09eb17713b0c12a54fbd587d79adcebad543bc0cd9a3410b"}, + {file = "coverage-6.5.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:de3001a203182842a4630e7b8d1a2c7c07ec1b45d3084a83d5d227a3806f530f"}, + {file = "coverage-6.5.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e07f4a4a9b41583d6eabec04f8b68076ab3cd44c20bd29332c6572dda36f372e"}, + {file = "coverage-6.5.0-cp38-cp38-win32.whl", hash = "sha256:6d4817234349a80dbf03640cec6109cd90cba068330703fa65ddf56b60223a6d"}, + {file = "coverage-6.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:7ccf362abd726b0410bf8911c31fbf97f09f8f1061f8c1cf03dfc4b6372848f6"}, + {file = "coverage-6.5.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:633713d70ad6bfc49b34ead4060531658dc6dfc9b3eb7d8a716d5873377ab745"}, + {file = "coverage-6.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:95203854f974e07af96358c0b261f1048d8e1083f2de9b1c565e1be4a3a48cfc"}, + {file = "coverage-6.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9023e237f4c02ff739581ef35969c3739445fb059b060ca51771e69101efffe"}, + {file = "coverage-6.5.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:265de0fa6778d07de30bcf4d9dc471c3dc4314a23a3c6603d356a3c9abc2dfcf"}, + {file = "coverage-6.5.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f830ed581b45b82451a40faabb89c84e1a998124ee4212d440e9c6cf70083e5"}, + {file = "coverage-6.5.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7b6be138d61e458e18d8e6ddcddd36dd96215edfe5f1168de0b1b32635839b62"}, + {file = "coverage-6.5.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:42eafe6778551cf006a7c43153af1211c3aaab658d4d66fa5fcc021613d02518"}, + {file = "coverage-6.5.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:723e8130d4ecc8f56e9a611e73b31219595baa3bb252d539206f7bbbab6ffc1f"}, + {file = "coverage-6.5.0-cp39-cp39-win32.whl", hash = "sha256:d9ecf0829c6a62b9b573c7bb6d4dcd6ba8b6f80be9ba4fc7ed50bf4ac9aecd72"}, + {file = "coverage-6.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:fc2af30ed0d5ae0b1abdb4ebdce598eafd5b35397d4d75deb341a614d333d987"}, + {file = "coverage-6.5.0-pp36.pp37.pp38-none-any.whl", hash = "sha256:1431986dac3923c5945271f169f59c45b8802a114c8f548d611f2015133df77a"}, + {file = "coverage-6.5.0.tar.gz", hash = "sha256:f642e90754ee3e06b0e7e51bce3379590e76b7f76b708e1a71ff043f87025c84"}, +] + +[package.dependencies] +tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""} + +[package.extras] +toml = ["tomli"] + +[[package]] +name = "cycler" +version = "0.11.0" +description = "Composable style cycles" +optional = false +python-versions = ">=3.6" +files = [ + {file = "cycler-0.11.0-py3-none-any.whl", hash = "sha256:3a27e95f763a428a739d2add979fa7494c912a32c17c4c38c4d5f082cad165a3"}, + {file = "cycler-0.11.0.tar.gz", hash = "sha256:9c87405839a19696e837b3b818fed3f5f69f16f1eec1a1ad77e043dcea9c772f"}, +] + +[[package]] +name = "debugpy" +version = "1.8.0" +description = "An implementation of the Debug Adapter Protocol for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "debugpy-1.8.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:7fb95ca78f7ac43393cd0e0f2b6deda438ec7c5e47fa5d38553340897d2fbdfb"}, + {file = "debugpy-1.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef9ab7df0b9a42ed9c878afd3eaaff471fce3fa73df96022e1f5c9f8f8c87ada"}, + {file = "debugpy-1.8.0-cp310-cp310-win32.whl", hash = "sha256:a8b7a2fd27cd9f3553ac112f356ad4ca93338feadd8910277aff71ab24d8775f"}, + {file = "debugpy-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:5d9de202f5d42e62f932507ee8b21e30d49aae7e46d5b1dd5c908db1d7068637"}, + {file = "debugpy-1.8.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:ef54404365fae8d45cf450d0544ee40cefbcb9cb85ea7afe89a963c27028261e"}, + {file = "debugpy-1.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60009b132c91951354f54363f8ebdf7457aeb150e84abba5ae251b8e9f29a8a6"}, + {file = "debugpy-1.8.0-cp311-cp311-win32.whl", hash = "sha256:8cd0197141eb9e8a4566794550cfdcdb8b3db0818bdf8c49a8e8f8053e56e38b"}, + {file = "debugpy-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:a64093656c4c64dc6a438e11d59369875d200bd5abb8f9b26c1f5f723622e153"}, + {file = "debugpy-1.8.0-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:b05a6b503ed520ad58c8dc682749113d2fd9f41ffd45daec16e558ca884008cd"}, + {file = "debugpy-1.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c6fb41c98ec51dd010d7ed650accfd07a87fe5e93eca9d5f584d0578f28f35f"}, + {file = "debugpy-1.8.0-cp38-cp38-win32.whl", hash = "sha256:46ab6780159eeabb43c1495d9c84cf85d62975e48b6ec21ee10c95767c0590aa"}, + {file = "debugpy-1.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:bdc5ef99d14b9c0fcb35351b4fbfc06ac0ee576aeab6b2511702e5a648a2e595"}, + {file = "debugpy-1.8.0-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:61eab4a4c8b6125d41a34bad4e5fe3d2cc145caecd63c3fe953be4cc53e65bf8"}, + {file = "debugpy-1.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:125b9a637e013f9faac0a3d6a82bd17c8b5d2c875fb6b7e2772c5aba6d082332"}, + {file = "debugpy-1.8.0-cp39-cp39-win32.whl", hash = "sha256:57161629133113c97b387382045649a2b985a348f0c9366e22217c87b68b73c6"}, + {file = "debugpy-1.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:e3412f9faa9ade82aa64a50b602544efcba848c91384e9f93497a458767e6926"}, + {file = "debugpy-1.8.0-py2.py3-none-any.whl", hash = "sha256:9c9b0ac1ce2a42888199df1a1906e45e6f3c9555497643a85e0bf2406e3ffbc4"}, + {file = "debugpy-1.8.0.zip", hash = "sha256:12af2c55b419521e33d5fb21bd022df0b5eb267c3e178f1d374a63a2a6bdccd0"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +description = "Decorators for Humans" +optional = false +python-versions = ">=3.5" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +description = "XML bomb protection for Python stdlib modules" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "distlib" +version = "0.3.7" +description = "Distribution utilities" +optional = false +python-versions = "*" +files = [ + {file = "distlib-0.3.7-py2.py3-none-any.whl", hash = "sha256:2e24928bc811348f0feb63014e97aaae3037f2cf48712d51ae61df7fd6075057"}, + {file = "distlib-0.3.7.tar.gz", hash = "sha256:9dafe54b34a028eafd95039d5e5d4851a13734540f1331060d31c9916e7147a8"}, +] + +[[package]] +name = "docutils" +version = "0.20.1" +description = "Docutils -- Python Documentation Utilities" +optional = false +python-versions = ">=3.7" +files = [ + {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"}, + {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.1.3" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.1.3-py3-none-any.whl", hash = "sha256:343280667a4585d195ca1cf9cef84a4e178c4b6cf2274caef9859782b567d5e3"}, + {file = "exceptiongroup-1.1.3.tar.gz", hash = "sha256:097acd85d473d75af5bb98e41b61ff7fe35efe6675e4f9370ec6ec5126d160e9"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "executing" +version = "1.2.0" +description = "Get the currently executing AST node of a frame, and other information" +optional = false +python-versions = "*" +files = [ + {file = "executing-1.2.0-py2.py3-none-any.whl", hash = "sha256:0314a69e37426e3608aada02473b4161d4caf5a4b244d1d0c48072b8fee7bacc"}, + {file = "executing-1.2.0.tar.gz", hash = "sha256:19da64c18d2d851112f09c287f8d3dbbdf725ab0e569077efb6cdcbd3497c107"}, +] + +[package.extras] +tests = ["asttokens", "littleutils", "pytest", "rich"] + +[[package]] +name = "fastjsonschema" +version = "2.18.1" +description = "Fastest Python implementation of JSON schema" +optional = false +python-versions = "*" +files = [ + {file = "fastjsonschema-2.18.1-py3-none-any.whl", hash = "sha256:aec6a19e9f66e9810ab371cc913ad5f4e9e479b63a7072a2cd060a9369e329a8"}, + {file = "fastjsonschema-2.18.1.tar.gz", hash = "sha256:06dc8680d937628e993fa0cd278f196d20449a1adc087640710846b324d422ea"}, +] + +[package.extras] +devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] + +[[package]] +name = "filelock" +version = "3.12.3" +description = "A platform independent file lock." +optional = false +python-versions = ">=3.8" +files = [ + {file = "filelock-3.12.3-py3-none-any.whl", hash = "sha256:f067e40ccc40f2b48395a80fcbd4728262fab54e232e090a4063ab804179efeb"}, + {file = "filelock-3.12.3.tar.gz", hash = "sha256:0ecc1dd2ec4672a10c8550a8182f1bd0c0a5088470ecd5a125e45f49472fac3d"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.7.1", markers = "python_version < \"3.11\""} + +[package.extras] +docs = ["furo (>=2023.7.26)", "sphinx (>=7.1.2)", "sphinx-autodoc-typehints (>=1.24)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.3)", "diff-cover (>=7.7)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)", "pytest-timeout (>=2.1)"] + +[[package]] +name = "fonttools" +version = "4.42.1" +description = "Tools to manipulate font files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fonttools-4.42.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ed1a13a27f59d1fc1920394a7f596792e9d546c9ca5a044419dca70c37815d7c"}, + {file = "fonttools-4.42.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c9b1ce7a45978b821a06d375b83763b27a3a5e8a2e4570b3065abad240a18760"}, + {file = "fonttools-4.42.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f720fa82a11c0f9042376fd509b5ed88dab7e3cd602eee63a1af08883b37342b"}, + {file = "fonttools-4.42.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db55cbaea02a20b49fefbd8e9d62bd481aaabe1f2301dabc575acc6b358874fa"}, + {file = "fonttools-4.42.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3a35981d90feebeaef05e46e33e6b9e5b5e618504672ca9cd0ff96b171e4bfff"}, + {file = "fonttools-4.42.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:68a02bbe020dc22ee0540e040117535f06df9358106d3775e8817d826047f3fd"}, + {file = "fonttools-4.42.1-cp310-cp310-win32.whl", hash = "sha256:12a7c247d1b946829bfa2f331107a629ea77dc5391dfd34fdcd78efa61f354ca"}, + {file = "fonttools-4.42.1-cp310-cp310-win_amd64.whl", hash = "sha256:a398bdadb055f8de69f62b0fc70625f7cbdab436bbb31eef5816e28cab083ee8"}, + {file = "fonttools-4.42.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:689508b918332fb40ce117131633647731d098b1b10d092234aa959b4251add5"}, + {file = "fonttools-4.42.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9e36344e48af3e3bde867a1ca54f97c308735dd8697005c2d24a86054a114a71"}, + {file = "fonttools-4.42.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19b7db825c8adee96fac0692e6e1ecd858cae9affb3b4812cdb9d934a898b29e"}, + {file = "fonttools-4.42.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:113337c2d29665839b7d90b39f99b3cac731f72a0eda9306165a305c7c31d341"}, + {file = "fonttools-4.42.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:37983b6bdab42c501202500a2be3a572f50d4efe3237e0686ee9d5f794d76b35"}, + {file = "fonttools-4.42.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:6ed2662a3d9c832afa36405f8748c250be94ae5dfc5283d668308391f2102861"}, + {file = "fonttools-4.42.1-cp311-cp311-win32.whl", hash = "sha256:179737095eb98332a2744e8f12037b2977f22948cf23ff96656928923ddf560a"}, + {file = "fonttools-4.42.1-cp311-cp311-win_amd64.whl", hash = "sha256:f2b82f46917d8722e6b5eafeefb4fb585d23babd15d8246c664cd88a5bddd19c"}, + {file = "fonttools-4.42.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:62f481ac772fd68901573956231aea3e4b1ad87b9b1089a61613a91e2b50bb9b"}, + {file = "fonttools-4.42.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f2f806990160d1ce42d287aa419df3ffc42dfefe60d473695fb048355fe0c6a0"}, + {file = "fonttools-4.42.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:db372213d39fa33af667c2aa586a0c1235e88e9c850f5dd5c8e1f17515861868"}, + {file = "fonttools-4.42.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d18fc642fd0ac29236ff88ecfccff229ec0386090a839dd3f1162e9a7944a40"}, + {file = "fonttools-4.42.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:8708b98c278012ad267ee8a7433baeb809948855e81922878118464b274c909d"}, + {file = "fonttools-4.42.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c95b0724a6deea2c8c5d3222191783ced0a2f09bd6d33f93e563f6f1a4b3b3a4"}, + {file = "fonttools-4.42.1-cp38-cp38-win32.whl", hash = "sha256:4aa79366e442dbca6e2c8595645a3a605d9eeabdb7a094d745ed6106816bef5d"}, + {file = "fonttools-4.42.1-cp38-cp38-win_amd64.whl", hash = "sha256:acb47f6f8680de24c1ab65ebde39dd035768e2a9b571a07c7b8da95f6c8815fd"}, + {file = "fonttools-4.42.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5fb289b7a815638a7613d46bcf324c9106804725b2bb8ad913c12b6958ffc4ec"}, + {file = "fonttools-4.42.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:53eb5091ddc8b1199330bb7b4a8a2e7995ad5d43376cadce84523d8223ef3136"}, + {file = "fonttools-4.42.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46a0ec8adbc6ff13494eb0c9c2e643b6f009ce7320cf640de106fb614e4d4360"}, + {file = "fonttools-4.42.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7cc7d685b8eeca7ae69dc6416833fbfea61660684b7089bca666067cb2937dcf"}, + {file = "fonttools-4.42.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:be24fcb80493b2c94eae21df70017351851652a37de514de553435b256b2f249"}, + {file = "fonttools-4.42.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:515607ec756d7865f23070682622c49d922901943697871fc292277cf1e71967"}, + {file = "fonttools-4.42.1-cp39-cp39-win32.whl", hash = "sha256:0eb79a2da5eb6457a6f8ab904838454accc7d4cccdaff1fd2bd3a0679ea33d64"}, + {file = "fonttools-4.42.1-cp39-cp39-win_amd64.whl", hash = "sha256:7286aed4ea271df9eab8d7a9b29e507094b51397812f7ce051ecd77915a6e26b"}, + {file = "fonttools-4.42.1-py3-none-any.whl", hash = "sha256:9398f244e28e0596e2ee6024f808b06060109e33ed38dcc9bded452fd9bbb853"}, + {file = "fonttools-4.42.1.tar.gz", hash = "sha256:c391cd5af88aacaf41dd7cfb96eeedfad297b5899a39e12f4c2c3706d0a3329d"}, +] + +[package.extras] +all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0,<5)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.0.0)", "xattr", "zopfli (>=0.1.4)"] +graphite = ["lz4 (>=1.7.4.2)"] +interpolatable = ["munkres", "scipy"] +lxml = ["lxml (>=4.0,<5)"] +pathops = ["skia-pathops (>=0.5.0)"] +plot = ["matplotlib"] +repacker = ["uharfbuzz (>=0.23.0)"] +symfont = ["sympy"] +type1 = ["xattr"] +ufo = ["fs (>=2.2.0,<3)"] +unicode = ["unicodedata2 (>=15.0.0)"] +woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] + +[[package]] +name = "identify" +version = "2.5.28" +description = "File identification library for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "identify-2.5.28-py2.py3-none-any.whl", hash = "sha256:87816de144bf46d161bd5b3e8f5596b16cade3b80be537087334b26bc5c177f3"}, + {file = "identify-2.5.28.tar.gz", hash = "sha256:94bb59643083ebd60dc996d043497479ee554381fbc5307763915cda49b0e78f"}, +] + +[package.extras] +license = ["ukkonen"] + +[[package]] +name = "idna" +version = "3.4" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.5" +files = [ + {file = "idna-3.4-py3-none-any.whl", hash = "sha256:90b77e79eaa3eba6de819a0c442c0b4ceefc341a7a2ab77d7562bf49f425c5c2"}, + {file = "idna-3.4.tar.gz", hash = "sha256:814f528e8dead7d329833b91c5faa87d60bf71824cd12a7530b5526063d02cb4"}, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +description = "Getting image size from png/jpeg/jpeg2000/gif file" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"}, + {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, +] + +[[package]] +name = "importlib-metadata" +version = "6.8.0" +description = "Read metadata from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_metadata-6.8.0-py3-none-any.whl", hash = "sha256:3ebb78df84a805d7698245025b975d9d67053cd94c79245ba4b3eb694abe68bb"}, + {file = "importlib_metadata-6.8.0.tar.gz", hash = "sha256:dbace7892d8c0c4ac1ad096662232f831d4e64f4c4545bd53016a3e9d4654743"}, +] + +[package.dependencies] +zipp = ">=0.5" + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +perf = ["ipython"] +testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"] + +[[package]] +name = "importlib-resources" +version = "6.0.1" +description = "Read resources from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_resources-6.0.1-py3-none-any.whl", hash = "sha256:134832a506243891221b88b4ae1213327eea96ceb4e407a00d790bb0626f45cf"}, + {file = "importlib_resources-6.0.1.tar.gz", hash = "sha256:4359457e42708462b9626a04657c6208ad799ceb41e5c58c57ffa0e6a098a5d4"}, +] + +[package.dependencies] +zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-ruff"] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipdb" +version = "0.13.13" +description = "IPython-enabled pdb" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4"}, + {file = "ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726"}, +] + +[package.dependencies] +decorator = {version = "*", markers = "python_version > \"3.6\""} +ipython = {version = ">=7.31.1", markers = "python_version > \"3.6\""} +tomli = {version = "*", markers = "python_version > \"3.6\" and python_version < \"3.11\""} + +[[package]] +name = "ipykernel" +version = "6.25.2" +description = "IPython Kernel for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "ipykernel-6.25.2-py3-none-any.whl", hash = "sha256:2e2ee359baba19f10251b99415bb39de1e97d04e1fab385646f24f0596510b77"}, + {file = "ipykernel-6.25.2.tar.gz", hash = "sha256:f468ddd1f17acb48c8ce67fcfa49ba6d46d4f9ac0438c1f441be7c3d1372230b"}, +] + +[package.dependencies] +appnope = {version = "*", markers = "platform_system == \"Darwin\""} +comm = ">=0.1.1" +debugpy = ">=1.6.5" +ipython = ">=7.23.1" +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +matplotlib-inline = ">=0.1" +nest-asyncio = "*" +packaging = "*" +psutil = "*" +pyzmq = ">=20" +tornado = ">=6.1" +traitlets = ">=5.4.0" + +[package.extras] +cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"] +pyqt5 = ["pyqt5"] +pyside6 = ["pyside6"] +test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "ipython" +version = "8.15.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.9" +files = [ + {file = "ipython-8.15.0-py3-none-any.whl", hash = "sha256:45a2c3a529296870a97b7de34eda4a31bee16bc7bf954e07d39abe49caf8f887"}, + {file = "ipython-8.15.0.tar.gz", hash = "sha256:2baeb5be6949eeebf532150f81746f8333e2ccce02de1c7eedde3f23ed5e9f1e"}, +] + +[package.dependencies] +appnope = {version = "*", markers = "sys_platform == \"darwin\""} +backcall = "*" +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +exceptiongroup = {version = "*", markers = "python_version < \"3.11\""} +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""} +pickleshare = "*" +prompt-toolkit = ">=3.0.30,<3.0.37 || >3.0.37,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5" +typing-extensions = {version = "*", markers = "python_version < \"3.10\""} + +[package.extras] +all = ["black", "curio", "docrepr", "exceptiongroup", "ipykernel", "ipyparallel", "ipywidgets", "matplotlib", "matplotlib (!=3.2.0)", "nbconvert", "nbformat", "notebook", "numpy (>=1.21)", "pandas", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "qtconsole", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "trio", "typing-extensions"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "ipykernel", "matplotlib", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "typing-extensions"] +kernel = ["ipykernel"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["pytest (<7.1)", "pytest-asyncio", "testpath"] +test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.21)", "pandas", "pytest (<7.1)", "pytest-asyncio", "testpath", "trio"] + +[[package]] +name = "jedi" +version = "0.19.0" +description = "An autocompletion tool for Python that can be used for text editors." +optional = false +python-versions = ">=3.6" +files = [ + {file = "jedi-0.19.0-py2.py3-none-any.whl", hash = "sha256:cb8ce23fbccff0025e9386b5cf85e892f94c9b822378f8da49970471335ac64e"}, + {file = "jedi-0.19.0.tar.gz", hash = "sha256:bcf9894f1753969cbac8022a8c2eaee06bfa3724e4192470aaffe7eb6272b0c4"}, +] + +[package.dependencies] +parso = ">=0.8.3,<0.9.0" + +[package.extras] +docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["Django (<3.1)", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] + +[[package]] +name = "jinja2" +version = "3.1.2" +description = "A very fast and expressive template engine." +optional = false +python-versions = ">=3.7" +files = [ + {file = "Jinja2-3.1.2-py3-none-any.whl", hash = "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"}, + {file = "Jinja2-3.1.2.tar.gz", hash = "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852"}, +] + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + +[[package]] +name = "jsonschema" +version = "4.19.1" +description = "An implementation of JSON Schema validation for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema-4.19.1-py3-none-any.whl", hash = "sha256:cd5f1f9ed9444e554b38ba003af06c0a8c2868131e56bfbef0550fb450c0330e"}, + {file = "jsonschema-4.19.1.tar.gz", hash = "sha256:ec84cc37cfa703ef7cd4928db24f9cb31428a5d0fa77747b8b51a847458e0bbf"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +jsonschema-specifications = ">=2023.03.6" +referencing = ">=0.28.4" +rpds-py = ">=0.7.1" + +[package.extras] +format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] + +[[package]] +name = "jsonschema-specifications" +version = "2023.7.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema_specifications-2023.7.1-py3-none-any.whl", hash = "sha256:05adf340b659828a004220a9613be00fa3f223f2b82002e273dee62fd50524b1"}, + {file = "jsonschema_specifications-2023.7.1.tar.gz", hash = "sha256:c91a50404e88a1f6ba40636778e2ee08f6e24c5613fe4c53ac24578a5a7f72bb"}, +] + +[package.dependencies] +referencing = ">=0.28.0" + +[[package]] +name = "jupyter-client" +version = "8.3.1" +description = "Jupyter protocol implementation and client libraries" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_client-8.3.1-py3-none-any.whl", hash = "sha256:5eb9f55eb0650e81de6b7e34308d8b92d04fe4ec41cd8193a913979e33d8e1a5"}, + {file = "jupyter_client-8.3.1.tar.gz", hash = "sha256:60294b2d5b869356c893f57b1a877ea6510d60d45cf4b38057f1672d85699ac9"}, +] + +[package.dependencies] +importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +python-dateutil = ">=2.8.2" +pyzmq = ">=23.0" +tornado = ">=6.2" +traitlets = ">=5.3" + +[package.extras] +docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] + +[[package]] +name = "jupyter-core" +version = "5.3.2" +description = "Jupyter core package. A base package on which Jupyter projects rely." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_core-5.3.2-py3-none-any.whl", hash = "sha256:a4af53c3fa3f6330cebb0d9f658e148725d15652811d1c32dc0f63bb96f2e6d6"}, + {file = "jupyter_core-5.3.2.tar.gz", hash = "sha256:0c28db6cbe2c37b5b398e1a1a5b22f84fd64cd10afc1f6c05b02fb09481ba45f"}, +] + +[package.dependencies] +platformdirs = ">=2.5" +pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} +traitlets = ">=5.3" + +[package.extras] +docs = ["myst-parser", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] +test = ["ipykernel", "pre-commit", "pytest", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "jupyterlab-pygments" +version = "0.2.2" +description = "Pygments theme using JupyterLab CSS variables" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab_pygments-0.2.2-py2.py3-none-any.whl", hash = "sha256:2405800db07c9f770863bcf8049a529c3dd4d3e28536638bd7c1c01d2748309f"}, + {file = "jupyterlab_pygments-0.2.2.tar.gz", hash = "sha256:7405d7fde60819d905a9fa8ce89e4cd830e318cdad22a0030f7a901da705585d"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.5" +description = "A fast implementation of the Cassowary constraint solver" +optional = false +python-versions = ">=3.7" +files = [ + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"}, + {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, +] + +[[package]] +name = "latexcodec" +version = "2.0.1" +description = "A lexer and codec to work with LaTeX code in Python." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "latexcodec-2.0.1-py2.py3-none-any.whl", hash = "sha256:c277a193638dc7683c4c30f6684e3db728a06efb0dc9cf346db8bd0aa6c5d271"}, + {file = "latexcodec-2.0.1.tar.gz", hash = "sha256:2aa2551c373261cefe2ad3a8953a6d6533e68238d180eb4bb91d7964adb3fe9a"}, +] + +[package.dependencies] +six = ">=1.4.1" + +[[package]] +name = "markupsafe" +version = "2.1.3" +description = "Safely add untrusted strings to HTML/XML markup." +optional = false +python-versions = ">=3.7" +files = [ + {file = "MarkupSafe-2.1.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cd0f502fe016460680cd20aaa5a76d241d6f35a1c3350c474bac1273803893fa"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e09031c87a1e51556fdcb46e5bd4f59dfb743061cf93c4d6831bf894f125eb57"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68e78619a61ecf91e76aa3e6e8e33fc4894a2bebe93410754bd28fce0a8a4f9f"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:65c1a9bcdadc6c28eecee2c119465aebff8f7a584dd719facdd9e825ec61ab52"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:525808b8019e36eb524b8c68acdd63a37e75714eac50e988180b169d64480a00"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:962f82a3086483f5e5f64dbad880d31038b698494799b097bc59c2edf392fce6"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:aa7bd130efab1c280bed0f45501b7c8795f9fdbeb02e965371bbef3523627779"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c9c804664ebe8f83a211cace637506669e7890fec1b4195b505c214e50dd4eb7"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-win32.whl", hash = "sha256:10bbfe99883db80bdbaff2dcf681dfc6533a614f700da1287707e8a5d78a8431"}, + {file = "MarkupSafe-2.1.3-cp310-cp310-win_amd64.whl", hash = "sha256:1577735524cdad32f9f694208aa75e422adba74f1baee7551620e43a3141f559"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ad9e82fb8f09ade1c3e1b996a6337afac2b8b9e365f926f5a61aacc71adc5b3c"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c0fae6c3be832a0a0473ac912810b2877c8cb9d76ca48de1ed31e1c68386575"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b076b6226fb84157e3f7c971a47ff3a679d837cf338547532ab866c57930dbee"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bfce63a9e7834b12b87c64d6b155fdd9b3b96191b6bd334bf37db7ff1fe457f2"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:338ae27d6b8745585f87218a3f23f1512dbf52c26c28e322dbe54bcede54ccb9"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e4dd52d80b8c83fdce44e12478ad2e85c64ea965e75d66dbeafb0a3e77308fcc"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:df0be2b576a7abbf737b1575f048c23fb1d769f267ec4358296f31c2479db8f9"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5bbe06f8eeafd38e5d0a4894ffec89378b6c6a625ff57e3028921f8ff59318ac"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-win32.whl", hash = "sha256:dd15ff04ffd7e05ffcb7fe79f1b98041b8ea30ae9234aed2a9168b5797c3effb"}, + {file = "MarkupSafe-2.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:134da1eca9ec0ae528110ccc9e48041e0828d79f24121a1a146161103c76e686"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:f698de3fd0c4e6972b92290a45bd9b1536bffe8c6759c62471efaa8acb4c37bc"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:aa57bd9cf8ae831a362185ee444e15a93ecb2e344c8e52e4d721ea3ab6ef1823"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffcc3f7c66b5f5b7931a5aa68fc9cecc51e685ef90282f4a82f0f5e9b704ad11"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47d4f1c5f80fc62fdd7777d0d40a2e9dda0a05883ab11374334f6c4de38adffd"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1f67c7038d560d92149c060157d623c542173016c4babc0c1913cca0564b9939"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:9aad3c1755095ce347e26488214ef77e0485a3c34a50c5a5e2471dff60b9dd9c"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:14ff806850827afd6b07a5f32bd917fb7f45b046ba40c57abdb636674a8b559c"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8f9293864fe09b8149f0cc42ce56e3f0e54de883a9de90cd427f191c346eb2e1"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-win32.whl", hash = "sha256:715d3562f79d540f251b99ebd6d8baa547118974341db04f5ad06d5ea3eb8007"}, + {file = "MarkupSafe-2.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:1b8dd8c3fd14349433c79fa8abeb573a55fc0fdd769133baac1f5e07abf54aeb"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:8e254ae696c88d98da6555f5ace2279cf7cd5b3f52be2b5cf97feafe883b58d2"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb0932dc158471523c9637e807d9bfb93e06a95cbf010f1a38b98623b929ef2b"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9402b03f1a1b4dc4c19845e5c749e3ab82d5078d16a2a4c2cd2df62d57bb0707"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca379055a47383d02a5400cb0d110cef0a776fc644cda797db0c5696cfd7e18e"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:b7ff0f54cb4ff66dd38bebd335a38e2c22c41a8ee45aa608efc890ac3e3931bc"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:c011a4149cfbcf9f03994ec2edffcb8b1dc2d2aede7ca243746df97a5d41ce48"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:56d9f2ecac662ca1611d183feb03a3fa4406469dafe241673d521dd5ae92a155"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-win32.whl", hash = "sha256:8758846a7e80910096950b67071243da3e5a20ed2546e6392603c096778d48e0"}, + {file = "MarkupSafe-2.1.3-cp37-cp37m-win_amd64.whl", hash = "sha256:787003c0ddb00500e49a10f2844fac87aa6ce977b90b0feaaf9de23c22508b24"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:2ef12179d3a291be237280175b542c07a36e7f60718296278d8593d21ca937d4"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2c1b19b3aaacc6e57b7e25710ff571c24d6c3613a45e905b1fde04d691b98ee0"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8afafd99945ead6e075b973fefa56379c5b5c53fd8937dad92c662da5d8fd5ee"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c41976a29d078bb235fea9b2ecd3da465df42a562910f9022f1a03107bd02be"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d080e0a5eb2529460b30190fcfcc4199bd7f827663f858a226a81bc27beaa97e"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:69c0f17e9f5a7afdf2cc9fb2d1ce6aabdb3bafb7f38017c0b77862bcec2bbad8"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:504b320cd4b7eff6f968eddf81127112db685e81f7e36e75f9f84f0df46041c3"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:42de32b22b6b804f42c5d98be4f7e5e977ecdd9ee9b660fda1a3edf03b11792d"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-win32.whl", hash = "sha256:ceb01949af7121f9fc39f7d27f91be8546f3fb112c608bc4029aef0bab86a2a5"}, + {file = "MarkupSafe-2.1.3-cp38-cp38-win_amd64.whl", hash = "sha256:1b40069d487e7edb2676d3fbdb2b0829ffa2cd63a2ec26c4938b2d34391b4ecc"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8023faf4e01efadfa183e863fefde0046de576c6f14659e8782065bcece22198"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6b2b56950d93e41f33b4223ead100ea0fe11f8e6ee5f641eb753ce4b77a7042b"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9dcdfd0eaf283af041973bff14a2e143b8bd64e069f4c383416ecd79a81aab58"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05fb21170423db021895e1ea1e1f3ab3adb85d1c2333cbc2310f2a26bc77272e"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:282c2cb35b5b673bbcadb33a585408104df04f14b2d9b01d4c345a3b92861c2c"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ab4a0df41e7c16a1392727727e7998a467472d0ad65f3ad5e6e765015df08636"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7ef3cb2ebbf91e330e3bb937efada0edd9003683db6b57bb108c4001f37a02ea"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0a4e4a1aff6c7ac4cd55792abf96c915634c2b97e3cc1c7129578aa68ebd754e"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-win32.whl", hash = "sha256:fec21693218efe39aa7f8599346e90c705afa52c5b31ae019b2e57e8f6542bb2"}, + {file = "MarkupSafe-2.1.3-cp39-cp39-win_amd64.whl", hash = "sha256:3fd4abcb888d15a94f32b75d8fd18ee162ca0c064f35b11134be77050296d6ba"}, + {file = "MarkupSafe-2.1.3.tar.gz", hash = "sha256:af598ed32d6ae86f1b747b82783958b1a4ab8f617b06fe68795c7f026abbdcad"}, +] + +[[package]] +name = "matplotlib" +version = "3.7.3" +description = "Python plotting package" +optional = false +python-versions = ">=3.8" +files = [ + {file = "matplotlib-3.7.3-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:085c33b27561d9c04386789d5aa5eb4a932ddef43cfcdd0e01735f9a6e85ce0c"}, + {file = "matplotlib-3.7.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c568e80e1c17f68a727f30f591926751b97b98314d8e59804f54f86ae6fa6a22"}, + {file = "matplotlib-3.7.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7baf98c5ad59c5c4743ea884bb025cbffa52dacdfdac0da3e6021a285a90377e"}, + {file = "matplotlib-3.7.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:236024f582e40dac39bca592258888b38ae47a9fed7b8de652d68d3d02d47d2b"}, + {file = "matplotlib-3.7.3-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12b4f6795efea037ce2d41e7c417ad8bd02d5719c6ad4a8450a0708f4a1cfb89"}, + {file = "matplotlib-3.7.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78b2136cc6c5415b78977e0e8c608647d597204b05b1d9089ccf513c7d913733"}, + {file = "matplotlib-3.7.3-cp310-cp310-win32.whl", hash = "sha256:122dcbf9be0086e2a95d9e5e0632dbf3bd5b65eaa68c369363310a6c87753059"}, + {file = "matplotlib-3.7.3-cp310-cp310-win_amd64.whl", hash = "sha256:4aab27d9e33293389e3c1d7c881d414a72bdfda0fedc3a6bf46c6fa88d9b8015"}, + {file = "matplotlib-3.7.3-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:d5adc743de91e8e0b13df60deb1b1c285b8effea3d66223afceb14b63c9b05de"}, + {file = "matplotlib-3.7.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:55de4cf7cd0071b8ebf203981b53ab64f988a0a1f897a2dff300a1124e8bcd8b"}, + {file = "matplotlib-3.7.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ac03377fd908aaee2312d0b11735753e907adb6f4d1d102de5e2425249693f6c"}, + {file = "matplotlib-3.7.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:755bafc10a46918ce9a39980009b54b02dd249594e5adf52f9c56acfddb5d0b7"}, + {file = "matplotlib-3.7.3-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1a6094c6f8e8d18db631754df4fe9a34dec3caf074f6869a7db09f18f9b1d6b2"}, + {file = "matplotlib-3.7.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:272dba2f1b107790ed78ebf5385b8d14b27ad9e90419de340364b49fe549a993"}, + {file = "matplotlib-3.7.3-cp311-cp311-win32.whl", hash = "sha256:591c123bed1cb4b9996fb60b41a6d89c2ec4943244540776c5f1283fb6960a53"}, + {file = "matplotlib-3.7.3-cp311-cp311-win_amd64.whl", hash = "sha256:3bf3a178c6504694cee8b88b353df0051583f2f6f8faa146f67115c27c856881"}, + {file = "matplotlib-3.7.3-cp312-cp312-macosx_10_12_universal2.whl", hash = "sha256:edf54cac8ee3603f3093616b40a931e8c063969756a4d78a86e82c2fea9659f7"}, + {file = "matplotlib-3.7.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:91e36a85ea639a1ba9f91427041eac064b04829945fe331a92617b6cb21d27e5"}, + {file = "matplotlib-3.7.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:caf5eaaf7c68f8d7df269dfbcaf46f48a70ff482bfcebdcc97519671023f2a7d"}, + {file = "matplotlib-3.7.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:74bf57f505efea376097e948b7cdd87191a7ce8180616390aef496639edf601f"}, + {file = "matplotlib-3.7.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ee152a88a0da527840a426535514b6ed8ac4240eb856b1da92cf48124320e346"}, + {file = "matplotlib-3.7.3-cp312-cp312-win_amd64.whl", hash = "sha256:67a410a9c9e07cbc83581eeea144bbe298870bf0ac0ee2f2e10a015ab7efee19"}, + {file = "matplotlib-3.7.3-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:259999c05285cb993d7f2a419cea547863fa215379eda81f7254c9e932963729"}, + {file = "matplotlib-3.7.3-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:3f4e7fd5a6157e1d018ce2166ec8e531a481dd4a36f035b5c23edfe05a25419a"}, + {file = "matplotlib-3.7.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:faa3d12d8811d08d14080a8b7b9caea9a457dc495350166b56df0db4b9909ef5"}, + {file = "matplotlib-3.7.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:336e88900c11441e458da01c8414fc57e04e17f9d3bb94958a76faa2652bcf6b"}, + {file = "matplotlib-3.7.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:12f4c0dd8aa280d796c8772ea8265a14f11a04319baa3a16daa5556065e8baea"}, + {file = "matplotlib-3.7.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1990955b11e7918d256cf3b956b10997f405b7917a3f1c7d8e69c1d15c7b1930"}, + {file = "matplotlib-3.7.3-cp38-cp38-win32.whl", hash = "sha256:e78707b751260b42b721507ad7aa60fe4026d7f51c74cca6b9cd8b123ebb633a"}, + {file = "matplotlib-3.7.3-cp38-cp38-win_amd64.whl", hash = "sha256:e594ee43c59ea39ca5c6244667cac9d017a3527febc31f5532ad9135cf7469ec"}, + {file = "matplotlib-3.7.3-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:6eaa1cf0e94c936a26b78f6d756c5fbc12e0a58c8a68b7248a2a31456ce4e234"}, + {file = "matplotlib-3.7.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:0a97af9d22e8ebedc9f00b043d9bbd29a375e9e10b656982012dded44c10fd77"}, + {file = "matplotlib-3.7.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1f9c6c16597af660433ab330b59ee2934b832ee1fabcaf5cbde7b2add840f31e"}, + {file = "matplotlib-3.7.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a7240259b4b9cbc62381f6378cff4d57af539162a18e832c1e48042fabc40b6b"}, + {file = "matplotlib-3.7.3-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:747c6191d2e88ae854809e69aa358dbf852ff1a5738401b85c1cc9012309897a"}, + {file = "matplotlib-3.7.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec726b08a5275d827aa91bb951e68234a4423adb91cf65bc0fcdc0f2777663f7"}, + {file = "matplotlib-3.7.3-cp39-cp39-win32.whl", hash = "sha256:40e3b9b450c6534f07278310c4e34caff41c2a42377e4b9d47b0f8d3ac1083a2"}, + {file = "matplotlib-3.7.3-cp39-cp39-win_amd64.whl", hash = "sha256:dfc118642903a23e309b1da32886bb39a4314147d013e820c86b5fb4cb2e36d0"}, + {file = "matplotlib-3.7.3-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:165c8082bf8fc0360c24aa4724a22eaadbfd8c28bf1ccf7e94d685cad48261e4"}, + {file = "matplotlib-3.7.3-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ebd8470cc2a3594746ff0513aecbfa2c55ff6f58e6cef2efb1a54eb87c88ffa2"}, + {file = "matplotlib-3.7.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7153453669c9672b52095119fd21dd032d19225d48413a2871519b17db4b0fde"}, + {file = "matplotlib-3.7.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:498a08267dc69dd8f24c4b5d7423fa584d7ce0027ba71f7881df05fc09b89bb7"}, + {file = "matplotlib-3.7.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:d48999c4b19b5a0c058c9cd828ff6fc7748390679f6cf9a2ad653a3e802c87d3"}, + {file = "matplotlib-3.7.3-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22d65d18b4ee8070a5fea5761d59293f1f9e2fac37ec9ce090463b0e629432fd"}, + {file = "matplotlib-3.7.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c40cde976c36693cc0767e27cf5f443f91c23520060bd9496678364adfafe9c"}, + {file = "matplotlib-3.7.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:39018a2b17592448fbfdf4b8352955e6c3905359939791d4ff429296494d1a0c"}, + {file = "matplotlib-3.7.3.tar.gz", hash = "sha256:f09b3dd6bdeb588de91f853bbb2d6f0ff8ab693485b0c49035eaa510cb4f142e"}, +] + +[package.dependencies] +contourpy = ">=1.0.1" +cycler = ">=0.10" +fonttools = ">=4.22.0" +importlib-resources = {version = ">=3.2.0", markers = "python_version < \"3.10\""} +kiwisolver = ">=1.0.1" +numpy = ">=1.20,<2" +packaging = ">=20.0" +pillow = ">=6.2.0" +pyparsing = ">=2.3.1" +python-dateutil = ">=2.7" +setuptools_scm = ">=7" + +[[package]] +name = "matplotlib-inline" +version = "0.1.6" +description = "Inline Matplotlib backend for Jupyter" +optional = false +python-versions = ">=3.5" +files = [ + {file = "matplotlib-inline-0.1.6.tar.gz", hash = "sha256:f887e5f10ba98e8d2b150ddcf4702c1e5f8b3a20005eb0f74bfdbd360ee6f304"}, + {file = "matplotlib_inline-0.1.6-py3-none-any.whl", hash = "sha256:f1f41aab5328aa5aaea9b16d083b128102f8712542f819fe7e6a420ff581b311"}, +] + +[package.dependencies] +traitlets = "*" + +[[package]] +name = "mistune" +version = "3.0.2" +description = "A sane and fast Markdown parser with useful plugins and renderers" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "mypy" +version = "1.5.1" +description = "Optional static typing for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "mypy-1.5.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f33592ddf9655a4894aef22d134de7393e95fcbdc2d15c1ab65828eee5c66c70"}, + {file = "mypy-1.5.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:258b22210a4a258ccd077426c7a181d789d1121aca6db73a83f79372f5569ae0"}, + {file = "mypy-1.5.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9ec1f695f0c25986e6f7f8778e5ce61659063268836a38c951200c57479cc12"}, + {file = "mypy-1.5.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:abed92d9c8f08643c7d831300b739562b0a6c9fcb028d211134fc9ab20ccad5d"}, + {file = "mypy-1.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:a156e6390944c265eb56afa67c74c0636f10283429171018446b732f1a05af25"}, + {file = "mypy-1.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6ac9c21bfe7bc9f7f1b6fae441746e6a106e48fc9de530dea29e8cd37a2c0cc4"}, + {file = "mypy-1.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:51cb1323064b1099e177098cb939eab2da42fea5d818d40113957ec954fc85f4"}, + {file = "mypy-1.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:596fae69f2bfcb7305808c75c00f81fe2829b6236eadda536f00610ac5ec2243"}, + {file = "mypy-1.5.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:32cb59609b0534f0bd67faebb6e022fe534bdb0e2ecab4290d683d248be1b275"}, + {file = "mypy-1.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:159aa9acb16086b79bbb0016145034a1a05360626046a929f84579ce1666b315"}, + {file = "mypy-1.5.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f6b0e77db9ff4fda74de7df13f30016a0a663928d669c9f2c057048ba44f09bb"}, + {file = "mypy-1.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:26f71b535dfc158a71264e6dc805a9f8d2e60b67215ca0bfa26e2e1aa4d4d373"}, + {file = "mypy-1.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fc3a600f749b1008cc75e02b6fb3d4db8dbcca2d733030fe7a3b3502902f161"}, + {file = "mypy-1.5.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:26fb32e4d4afa205b24bf645eddfbb36a1e17e995c5c99d6d00edb24b693406a"}, + {file = "mypy-1.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:82cb6193de9bbb3844bab4c7cf80e6227d5225cc7625b068a06d005d861ad5f1"}, + {file = "mypy-1.5.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4a465ea2ca12804d5b34bb056be3a29dc47aea5973b892d0417c6a10a40b2d65"}, + {file = "mypy-1.5.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9fece120dbb041771a63eb95e4896791386fe287fefb2837258925b8326d6160"}, + {file = "mypy-1.5.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d28ddc3e3dfeab553e743e532fb95b4e6afad51d4706dd22f28e1e5e664828d2"}, + {file = "mypy-1.5.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:57b10c56016adce71fba6bc6e9fd45d8083f74361f629390c556738565af8eeb"}, + {file = "mypy-1.5.1-cp38-cp38-win_amd64.whl", hash = "sha256:ff0cedc84184115202475bbb46dd99f8dcb87fe24d5d0ddfc0fe6b8575c88d2f"}, + {file = "mypy-1.5.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8f772942d372c8cbac575be99f9cc9d9fb3bd95c8bc2de6c01411e2c84ebca8a"}, + {file = "mypy-1.5.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5d627124700b92b6bbaa99f27cbe615c8ea7b3402960f6372ea7d65faf376c14"}, + {file = "mypy-1.5.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:361da43c4f5a96173220eb53340ace68cda81845cd88218f8862dfb0adc8cddb"}, + {file = "mypy-1.5.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:330857f9507c24de5c5724235e66858f8364a0693894342485e543f5b07c8693"}, + {file = "mypy-1.5.1-cp39-cp39-win_amd64.whl", hash = "sha256:c543214ffdd422623e9fedd0869166c2f16affe4ba37463975043ef7d2ea8770"}, + {file = "mypy-1.5.1-py3-none-any.whl", hash = "sha256:f757063a83970d67c444f6e01d9550a7402322af3557ce7630d3c957386fa8f5"}, + {file = "mypy-1.5.1.tar.gz", hash = "sha256:b031b9601f1060bf1281feab89697324726ba0c0bae9d7cd7ab4b690940f0b92"}, +] + +[package.dependencies] +mypy-extensions = ">=1.0.0" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = ">=4.1.0" + +[package.extras] +dmypy = ["psutil (>=4.0)"] +install-types = ["pip"] +reports = ["lxml"] + +[[package]] +name = "mypy-extensions" +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." +optional = false +python-versions = ">=3.5" +files = [ + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, +] + +[[package]] +name = "nbclient" +version = "0.6.8" +description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "nbclient-0.6.8-py3-none-any.whl", hash = "sha256:7cce8b415888539180535953f80ea2385cdbb444944cdeb73ffac1556fdbc228"}, + {file = "nbclient-0.6.8.tar.gz", hash = "sha256:268fde3457cafe1539e32eb1c6d796bbedb90b9e92bacd3e43d83413734bb0e8"}, +] + +[package.dependencies] +jupyter-client = ">=6.1.5" +nbformat = ">=5.0" +nest-asyncio = "*" +traitlets = ">=5.2.2" + +[package.extras] +sphinx = ["Sphinx (>=1.7)", "autodoc-traits", "mock", "moto", "myst-parser", "sphinx-book-theme"] +test = ["black", "check-manifest", "flake8", "ipykernel", "ipython", "ipywidgets", "mypy", "nbconvert", "pip (>=18.1)", "pre-commit", "pytest (>=4.1)", "pytest-asyncio", "pytest-cov (>=2.6.1)", "setuptools (>=60.0)", "testpath", "twine (>=1.11.0)", "xmltodict"] + +[[package]] +name = "nbconvert" +version = "7.9.2" +description = "Converting Jupyter Notebooks" +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbconvert-7.9.2-py3-none-any.whl", hash = "sha256:39fe4b8bdd1b0104fdd86fc8a43a9077ba64c720bda4c6132690d917a0a154ee"}, + {file = "nbconvert-7.9.2.tar.gz", hash = "sha256:e56cc7588acc4f93e2bb5a34ec69028e4941797b2bfaf6462f18a41d1cc258c9"}, +] + +[package.dependencies] +beautifulsoup4 = "*" +bleach = "!=5.0.0" +defusedxml = "*" +importlib-metadata = {version = ">=3.6", markers = "python_version < \"3.10\""} +jinja2 = ">=3.0" +jupyter-core = ">=4.7" +jupyterlab-pygments = "*" +markupsafe = ">=2.0" +mistune = ">=2.0.3,<4" +nbclient = ">=0.5.0" +nbformat = ">=5.7" +packaging = "*" +pandocfilters = ">=1.4.1" +pygments = ">=2.4.1" +tinycss2 = "*" +traitlets = ">=5.1" + +[package.extras] +all = ["nbconvert[docs,qtpdf,serve,test,webpdf]"] +docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"] +qtpdf = ["nbconvert[qtpng]"] +qtpng = ["pyqtwebengine (>=5.15)"] +serve = ["tornado (>=6.1)"] +test = ["flaky", "ipykernel", "ipywidgets (>=7)", "pytest", "pytest-dependency"] +webpdf = ["playwright"] + +[[package]] +name = "nbformat" +version = "5.9.2" +description = "The Jupyter Notebook format" +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbformat-5.9.2-py3-none-any.whl", hash = "sha256:1c5172d786a41b82bcfd0c23f9e6b6f072e8fb49c39250219e4acfff1efe89e9"}, + {file = "nbformat-5.9.2.tar.gz", hash = "sha256:5f98b5ba1997dff175e77e0c17d5c10a96eaed2cbd1de3533d1fc35d5e111192"}, +] + +[package.dependencies] +fastjsonschema = "*" +jsonschema = ">=2.6" +jupyter-core = "*" +traitlets = ">=5.1" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["pep440", "pre-commit", "pytest", "testpath"] + +[[package]] +name = "nbmake" +version = "1.4.3" +description = "Pytest plugin for testing notebooks" +optional = false +python-versions = ">=3.7.0,<4.0.0" +files = [ + {file = "nbmake-1.4.3-py3-none-any.whl", hash = "sha256:0318dd5dd30066e83717bf38888b2bec1b4744ad669a9801b41858e589493330"}, + {file = "nbmake-1.4.3.tar.gz", hash = "sha256:9afc46ba05cc22f5a78047a758dca32386c95eaaa41501b25ce108cf733d9622"}, +] + +[package.dependencies] +ipykernel = ">=5.4.0" +nbclient = ">=0.6.6,<0.7.0" +nbformat = ">=5.0.8,<6.0.0" +Pygments = ">=2.7.3,<3.0.0" +pytest = ">=6.1.0" + +[[package]] +name = "nbsphinx" +version = "0.9.3" +description = "Jupyter Notebook Tools for Sphinx" +optional = false +python-versions = ">=3.6" +files = [ + {file = "nbsphinx-0.9.3-py3-none-any.whl", hash = "sha256:6e805e9627f4a358bd5720d5cbf8bf48853989c79af557afd91a5f22e163029f"}, + {file = "nbsphinx-0.9.3.tar.gz", hash = "sha256:ec339c8691b688f8676104a367a4b8cf3ea01fd089dc28d24dec22d563b11562"}, +] + +[package.dependencies] +docutils = "*" +jinja2 = "*" +nbconvert = "!=5.4" +nbformat = "*" +sphinx = ">=1.8" +traitlets = ">=5" + +[[package]] +name = "nest-asyncio" +version = "1.5.8" +description = "Patch asyncio to allow nested event loops" +optional = false +python-versions = ">=3.5" +files = [ + {file = "nest_asyncio-1.5.8-py3-none-any.whl", hash = "sha256:accda7a339a70599cb08f9dd09a67e0c2ef8d8d6f4c07f96ab203f2ae254e48d"}, + {file = "nest_asyncio-1.5.8.tar.gz", hash = "sha256:25aa2ca0d2a5b5531956b9e273b45cf664cae2b145101d73b86b199978d48fdb"}, +] + +[[package]] +name = "nodeenv" +version = "1.8.0" +description = "Node.js virtual environment builder" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*" +files = [ + {file = "nodeenv-1.8.0-py2.py3-none-any.whl", hash = "sha256:df865724bb3c3adc86b3876fa209771517b0cfe596beff01a92700e0e8be4cec"}, + {file = "nodeenv-1.8.0.tar.gz", hash = "sha256:d51e0c37e64fbf47d017feac3145cdbb58836d7eee8c6f6d3b6880c5456227d2"}, +] + +[package.dependencies] +setuptools = "*" + +[[package]] +name = "numpy" +version = "1.25.2" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "numpy-1.25.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:db3ccc4e37a6873045580d413fe79b68e47a681af8db2e046f1dacfa11f86eb3"}, + {file = "numpy-1.25.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:90319e4f002795ccfc9050110bbbaa16c944b1c37c0baeea43c5fb881693ae1f"}, + {file = "numpy-1.25.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfe4a913e29b418d096e696ddd422d8a5d13ffba4ea91f9f60440a3b759b0187"}, + {file = "numpy-1.25.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f08f2e037bba04e707eebf4bc934f1972a315c883a9e0ebfa8a7756eabf9e357"}, + {file = "numpy-1.25.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bec1e7213c7cb00d67093247f8c4db156fd03075f49876957dca4711306d39c9"}, + {file = "numpy-1.25.2-cp310-cp310-win32.whl", hash = "sha256:7dc869c0c75988e1c693d0e2d5b26034644399dd929bc049db55395b1379e044"}, + {file = "numpy-1.25.2-cp310-cp310-win_amd64.whl", hash = "sha256:834b386f2b8210dca38c71a6e0f4fd6922f7d3fcff935dbe3a570945acb1b545"}, + {file = "numpy-1.25.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c5462d19336db4560041517dbb7759c21d181a67cb01b36ca109b2ae37d32418"}, + {file = "numpy-1.25.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c5652ea24d33585ea39eb6a6a15dac87a1206a692719ff45d53c5282e66d4a8f"}, + {file = "numpy-1.25.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d60fbae8e0019865fc4784745814cff1c421df5afee233db6d88ab4f14655a2"}, + {file = "numpy-1.25.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60e7f0f7f6d0eee8364b9a6304c2845b9c491ac706048c7e8cf47b83123b8dbf"}, + {file = "numpy-1.25.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:bb33d5a1cf360304754913a350edda36d5b8c5331a8237268c48f91253c3a364"}, + {file = "numpy-1.25.2-cp311-cp311-win32.whl", hash = "sha256:5883c06bb92f2e6c8181df7b39971a5fb436288db58b5a1c3967702d4278691d"}, + {file = "numpy-1.25.2-cp311-cp311-win_amd64.whl", hash = "sha256:5c97325a0ba6f9d041feb9390924614b60b99209a71a69c876f71052521d42a4"}, + {file = "numpy-1.25.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b79e513d7aac42ae918db3ad1341a015488530d0bb2a6abcbdd10a3a829ccfd3"}, + {file = "numpy-1.25.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:eb942bfb6f84df5ce05dbf4b46673ffed0d3da59f13635ea9b926af3deb76926"}, + {file = "numpy-1.25.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e0746410e73384e70d286f93abf2520035250aad8c5714240b0492a7302fdca"}, + {file = "numpy-1.25.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7806500e4f5bdd04095e849265e55de20d8cc4b661b038957354327f6d9b295"}, + {file = "numpy-1.25.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8b77775f4b7df768967a7c8b3567e309f617dd5e99aeb886fa14dc1a0791141f"}, + {file = "numpy-1.25.2-cp39-cp39-win32.whl", hash = "sha256:2792d23d62ec51e50ce4d4b7d73de8f67a2fd3ea710dcbc8563a51a03fb07b01"}, + {file = "numpy-1.25.2-cp39-cp39-win_amd64.whl", hash = "sha256:76b4115d42a7dfc5d485d358728cdd8719be33cc5ec6ec08632a5d6fca2ed380"}, + {file = "numpy-1.25.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:1a1329e26f46230bf77b02cc19e900db9b52f398d6722ca853349a782d4cff55"}, + {file = "numpy-1.25.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c3abc71e8b6edba80a01a52e66d83c5d14433cbcd26a40c329ec7ed09f37901"}, + {file = "numpy-1.25.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:1b9735c27cea5d995496f46a8b1cd7b408b3f34b6d50459d9ac8fe3a20cc17bf"}, + {file = "numpy-1.25.2.tar.gz", hash = "sha256:fd608e19c8d7c55021dffd43bfe5492fab8cc105cc8986f813f8c3c048b38760"}, +] + +[[package]] +name = "packaging" +version = "23.1" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "packaging-23.1-py3-none-any.whl", hash = "sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61"}, + {file = "packaging-23.1.tar.gz", hash = "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"}, +] + +[[package]] +name = "pandas" +version = "1.5.3" +description = "Powerful data structures for data analysis, time series, and statistics" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pandas-1.5.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3749077d86e3a2f0ed51367f30bf5b82e131cc0f14260c4d3e499186fccc4406"}, + {file = "pandas-1.5.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:972d8a45395f2a2d26733eb8d0f629b2f90bebe8e8eddbb8829b180c09639572"}, + {file = "pandas-1.5.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:50869a35cbb0f2e0cd5ec04b191e7b12ed688874bd05dd777c19b28cbea90996"}, + {file = "pandas-1.5.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3ac844a0fe00bfaeb2c9b51ab1424e5c8744f89860b138434a363b1f620f354"}, + {file = "pandas-1.5.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a0a56cef15fd1586726dace5616db75ebcfec9179a3a55e78f72c5639fa2a23"}, + {file = "pandas-1.5.3-cp310-cp310-win_amd64.whl", hash = "sha256:478ff646ca42b20376e4ed3fa2e8d7341e8a63105586efe54fa2508ee087f328"}, + {file = "pandas-1.5.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6973549c01ca91ec96199e940495219c887ea815b2083722821f1d7abfa2b4dc"}, + {file = "pandas-1.5.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c39a8da13cede5adcd3be1182883aea1c925476f4e84b2807a46e2775306305d"}, + {file = "pandas-1.5.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f76d097d12c82a535fda9dfe5e8dd4127952b45fea9b0276cb30cca5ea313fbc"}, + {file = "pandas-1.5.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e474390e60ed609cec869b0da796ad94f420bb057d86784191eefc62b65819ae"}, + {file = "pandas-1.5.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f2b952406a1588ad4cad5b3f55f520e82e902388a6d5a4a91baa8d38d23c7f6"}, + {file = "pandas-1.5.3-cp311-cp311-win_amd64.whl", hash = "sha256:bc4c368f42b551bf72fac35c5128963a171b40dce866fb066540eeaf46faa003"}, + {file = "pandas-1.5.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:14e45300521902689a81f3f41386dc86f19b8ba8dd5ac5a3c7010ef8d2932813"}, + {file = "pandas-1.5.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9842b6f4b8479e41968eced654487258ed81df7d1c9b7b870ceea24ed9459b31"}, + {file = "pandas-1.5.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:26d9c71772c7afb9d5046e6e9cf42d83dd147b5cf5bcb9d97252077118543792"}, + {file = "pandas-1.5.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5fbcb19d6fceb9e946b3e23258757c7b225ba450990d9ed63ccceeb8cae609f7"}, + {file = "pandas-1.5.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:565fa34a5434d38e9d250af3c12ff931abaf88050551d9fbcdfafca50d62babf"}, + {file = "pandas-1.5.3-cp38-cp38-win32.whl", hash = "sha256:87bd9c03da1ac870a6d2c8902a0e1fd4267ca00f13bc494c9e5a9020920e1d51"}, + {file = "pandas-1.5.3-cp38-cp38-win_amd64.whl", hash = "sha256:41179ce559943d83a9b4bbacb736b04c928b095b5f25dd2b7389eda08f46f373"}, + {file = "pandas-1.5.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c74a62747864ed568f5a82a49a23a8d7fe171d0c69038b38cedf0976831296fa"}, + {file = "pandas-1.5.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c4c00e0b0597c8e4f59e8d461f797e5d70b4d025880516a8261b2817c47759ee"}, + {file = "pandas-1.5.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a50d9a4336a9621cab7b8eb3fb11adb82de58f9b91d84c2cd526576b881a0c5a"}, + {file = "pandas-1.5.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd05f7783b3274aa206a1af06f0ceed3f9b412cf665b7247eacd83be41cf7bf0"}, + {file = "pandas-1.5.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f69c4029613de47816b1bb30ff5ac778686688751a5e9c99ad8c7031f6508e5"}, + {file = "pandas-1.5.3-cp39-cp39-win32.whl", hash = "sha256:7cec0bee9f294e5de5bbfc14d0573f65526071029d036b753ee6507d2a21480a"}, + {file = "pandas-1.5.3-cp39-cp39-win_amd64.whl", hash = "sha256:dfd681c5dc216037e0b0a2c821f5ed99ba9f03ebcf119c7dac0e9a7b960b9ec9"}, + {file = "pandas-1.5.3.tar.gz", hash = "sha256:74a3fd7e5a7ec052f183273dc7b0acd3a863edf7520f5d3a1765c04ffdb3b0b1"}, +] + +[package.dependencies] +numpy = [ + {version = ">=1.20.3", markers = "python_version < \"3.10\""}, + {version = ">=1.23.2", markers = "python_version >= \"3.11\""}, + {version = ">=1.21.0", markers = "python_version >= \"3.10\" and python_version < \"3.11\""}, +] +python-dateutil = ">=2.8.1" +pytz = ">=2020.1" + +[package.extras] +test = ["hypothesis (>=5.5.3)", "pytest (>=6.0)", "pytest-xdist (>=1.31)"] + +[[package]] +name = "pandas-stubs" +version = "1.5.3.230321" +description = "Type annotations for pandas" +optional = false +python-versions = ">=3.8,<3.12" +files = [ + {file = "pandas_stubs-1.5.3.230321-py3-none-any.whl", hash = "sha256:4bf36b3071dd55f0e558ac8efe07676a120f2ed89e7a3df0fb78ddf2733bf247"}, + {file = "pandas_stubs-1.5.3.230321.tar.gz", hash = "sha256:2fa860df9e6058e9f0d2c09bc711c09abb8f0516eee7f0b9f9950d29b835fc6f"}, +] + +[package.dependencies] +types-pytz = ">=2022.1.1" + +[[package]] +name = "pandocfilters" +version = "1.5.0" +description = "Utilities for writing pandoc filters in python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pandocfilters-1.5.0-py2.py3-none-any.whl", hash = "sha256:33aae3f25fd1a026079f5d27bdd52496f0e0803b3469282162bafdcbdf6ef14f"}, + {file = "pandocfilters-1.5.0.tar.gz", hash = "sha256:0b679503337d233b4339a817bfc8c50064e2eff681314376a47cb582305a7a38"}, +] + +[[package]] +name = "parso" +version = "0.8.3" +description = "A Python Parser" +optional = false +python-versions = ">=3.6" +files = [ + {file = "parso-0.8.3-py2.py3-none-any.whl", hash = "sha256:c001d4636cd3aecdaf33cbb40aebb59b094be2a74c556778ef5576c175e19e75"}, + {file = "parso-0.8.3.tar.gz", hash = "sha256:8c07be290bb59f03588915921e29e8a50002acaf2cdc5fa0e0114f91709fafa0"}, +] + +[package.extras] +qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] +testing = ["docopt", "pytest (<6.0.0)"] + +[[package]] +name = "pathspec" +version = "0.11.2" +description = "Utility library for gitignore style pattern matching of file paths." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pathspec-0.11.2-py3-none-any.whl", hash = "sha256:1d6ed233af05e679efb96b1851550ea95bbb64b7c490b0f5aa52996c11e92a20"}, + {file = "pathspec-0.11.2.tar.gz", hash = "sha256:e0d8d0ac2f12da61956eb2306b69f9469b42f4deb0f3cb6ed47b9cce9996ced3"}, +] + +[[package]] +name = "pexpect" +version = "4.8.0" +description = "Pexpect allows easy control of interactive console applications." +optional = false +python-versions = "*" +files = [ + {file = "pexpect-4.8.0-py2.py3-none-any.whl", hash = "sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937"}, + {file = "pexpect-4.8.0.tar.gz", hash = "sha256:fc65a43959d153d0114afe13997d439c22823a27cefceb5ff35c2178c6784c0c"}, +] + +[package.dependencies] +ptyprocess = ">=0.5" + +[[package]] +name = "pickleshare" +version = "0.7.5" +description = "Tiny 'shelve'-like database with concurrency support" +optional = false +python-versions = "*" +files = [ + {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, + {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, +] + +[[package]] +name = "pillow" +version = "10.0.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "Pillow-10.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1f62406a884ae75fb2f818694469519fb685cc7eaff05d3451a9ebe55c646891"}, + {file = "Pillow-10.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d5db32e2a6ccbb3d34d87c87b432959e0db29755727afb37290e10f6e8e62614"}, + {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edf4392b77bdc81f36e92d3a07a5cd072f90253197f4a52a55a8cec48a12483b"}, + {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:520f2a520dc040512699f20fa1c363eed506e94248d71f85412b625026f6142c"}, + {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:8c11160913e3dd06c8ffdb5f233a4f254cb449f4dfc0f8f4549eda9e542c93d1"}, + {file = "Pillow-10.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a74ba0c356aaa3bb8e3eb79606a87669e7ec6444be352870623025d75a14a2bf"}, + {file = "Pillow-10.0.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d5d0dae4cfd56969d23d94dc8e89fb6a217be461c69090768227beb8ed28c0a3"}, + {file = "Pillow-10.0.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22c10cc517668d44b211717fd9775799ccec4124b9a7f7b3635fc5386e584992"}, + {file = "Pillow-10.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:dffe31a7f47b603318c609f378ebcd57f1554a3a6a8effbc59c3c69f804296de"}, + {file = "Pillow-10.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:9fb218c8a12e51d7ead2a7c9e101a04982237d4855716af2e9499306728fb485"}, + {file = "Pillow-10.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d35e3c8d9b1268cbf5d3670285feb3528f6680420eafe35cccc686b73c1e330f"}, + {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ed64f9ca2f0a95411e88a4efbd7a29e5ce2cea36072c53dd9d26d9c76f753b3"}, + {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b6eb5502f45a60a3f411c63187db83a3d3107887ad0d036c13ce836f8a36f1d"}, + {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:c1fbe7621c167ecaa38ad29643d77a9ce7311583761abf7836e1510c580bf3dd"}, + {file = "Pillow-10.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:cd25d2a9d2b36fcb318882481367956d2cf91329f6892fe5d385c346c0649629"}, + {file = "Pillow-10.0.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:3b08d4cc24f471b2c8ca24ec060abf4bebc6b144cb89cba638c720546b1cf538"}, + {file = "Pillow-10.0.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d737a602fbd82afd892ca746392401b634e278cb65d55c4b7a8f48e9ef8d008d"}, + {file = "Pillow-10.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:3a82c40d706d9aa9734289740ce26460a11aeec2d9c79b7af87bb35f0073c12f"}, + {file = "Pillow-10.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:bc2ec7c7b5d66b8ec9ce9f720dbb5fa4bace0f545acd34870eff4a369b44bf37"}, + {file = "Pillow-10.0.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:d80cf684b541685fccdd84c485b31ce73fc5c9b5d7523bf1394ce134a60c6883"}, + {file = "Pillow-10.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76de421f9c326da8f43d690110f0e79fe3ad1e54be811545d7d91898b4c8493e"}, + {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81ff539a12457809666fef6624684c008e00ff6bf455b4b89fd00a140eecd640"}, + {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce543ed15570eedbb85df19b0a1a7314a9c8141a36ce089c0a894adbfccb4568"}, + {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:685ac03cc4ed5ebc15ad5c23bc555d68a87777586d970c2c3e216619a5476223"}, + {file = "Pillow-10.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:d72e2ecc68a942e8cf9739619b7f408cc7b272b279b56b2c83c6123fcfa5cdff"}, + {file = "Pillow-10.0.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d50b6aec14bc737742ca96e85d6d0a5f9bfbded018264b3b70ff9d8c33485551"}, + {file = "Pillow-10.0.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:00e65f5e822decd501e374b0650146063fbb30a7264b4d2744bdd7b913e0cab5"}, + {file = "Pillow-10.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:f31f9fdbfecb042d046f9d91270a0ba28368a723302786c0009ee9b9f1f60199"}, + {file = "Pillow-10.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:1ce91b6ec08d866b14413d3f0bbdea7e24dfdc8e59f562bb77bc3fe60b6144ca"}, + {file = "Pillow-10.0.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:349930d6e9c685c089284b013478d6f76e3a534e36ddfa912cde493f235372f3"}, + {file = "Pillow-10.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3a684105f7c32488f7153905a4e3015a3b6c7182e106fe3c37fbb5ef3e6994c3"}, + {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b4f69b3700201b80bb82c3a97d5e9254084f6dd5fb5b16fc1a7b974260f89f43"}, + {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f07ea8d2f827d7d2a49ecf1639ec02d75ffd1b88dcc5b3a61bbb37a8759ad8d"}, + {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:040586f7d37b34547153fa383f7f9aed68b738992380ac911447bb78f2abe530"}, + {file = "Pillow-10.0.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:f88a0b92277de8e3ca715a0d79d68dc82807457dae3ab8699c758f07c20b3c51"}, + {file = "Pillow-10.0.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:c7cf14a27b0d6adfaebb3ae4153f1e516df54e47e42dcc073d7b3d76111a8d86"}, + {file = "Pillow-10.0.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:3400aae60685b06bb96f99a21e1ada7bc7a413d5f49bce739828ecd9391bb8f7"}, + {file = "Pillow-10.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:dbc02381779d412145331789b40cc7b11fdf449e5d94f6bc0b080db0a56ea3f0"}, + {file = "Pillow-10.0.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:9211e7ad69d7c9401cfc0e23d49b69ca65ddd898976d660a2fa5904e3d7a9baa"}, + {file = "Pillow-10.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:faaf07ea35355b01a35cb442dd950d8f1bb5b040a7787791a535de13db15ed90"}, + {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9f72a021fbb792ce98306ffb0c348b3c9cb967dce0f12a49aa4c3d3fdefa967"}, + {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f7c16705f44e0504a3a2a14197c1f0b32a95731d251777dcb060aa83022cb2d"}, + {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:76edb0a1fa2b4745fb0c99fb9fb98f8b180a1bbceb8be49b087e0b21867e77d3"}, + {file = "Pillow-10.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:368ab3dfb5f49e312231b6f27b8820c823652b7cd29cfbd34090565a015e99ba"}, + {file = "Pillow-10.0.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:608bfdee0d57cf297d32bcbb3c728dc1da0907519d1784962c5f0c68bb93e5a3"}, + {file = "Pillow-10.0.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5c6e3df6bdd396749bafd45314871b3d0af81ff935b2d188385e970052091017"}, + {file = "Pillow-10.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:7be600823e4c8631b74e4a0d38384c73f680e6105a7d3c6824fcf226c178c7e6"}, + {file = "Pillow-10.0.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:92be919bbc9f7d09f7ae343c38f5bb21c973d2576c1d45600fce4b74bafa7ac0"}, + {file = "Pillow-10.0.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8182b523b2289f7c415f589118228d30ac8c355baa2f3194ced084dac2dbba"}, + {file = "Pillow-10.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:38250a349b6b390ee6047a62c086d3817ac69022c127f8a5dc058c31ccef17f3"}, + {file = "Pillow-10.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:88af2003543cc40c80f6fca01411892ec52b11021b3dc22ec3bc9d5afd1c5334"}, + {file = "Pillow-10.0.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:c189af0545965fa8d3b9613cfdb0cd37f9d71349e0f7750e1fd704648d475ed2"}, + {file = "Pillow-10.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce7b031a6fc11365970e6a5686d7ba8c63e4c1cf1ea143811acbb524295eabed"}, + {file = "Pillow-10.0.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:db24668940f82321e746773a4bc617bfac06ec831e5c88b643f91f122a785684"}, + {file = "Pillow-10.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:efe8c0681042536e0d06c11f48cebe759707c9e9abf880ee213541c5b46c5bf3"}, + {file = "Pillow-10.0.0.tar.gz", hash = "sha256:9c82b5b3e043c7af0d95792d0d20ccf68f61a1fec6b3530e718b688422727396"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] +tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "pint" +version = "0.22" +description = "Physical quantities module" +optional = false +python-versions = ">=3.9" +files = [ + {file = "Pint-0.22-py3-none-any.whl", hash = "sha256:6e2b3c5c2b4d9b516608bc860a417a39d66eb99c958f36540cf931d2c2e9f80f"}, + {file = "Pint-0.22.tar.gz", hash = "sha256:2d139f6abbcf3016cad7d3cec05707fe908ac4f99cf59aedfd6ee667b7a64433"}, +] + +[package.dependencies] +typing-extensions = "*" + +[package.extras] +babel = ["babel (<=2.8)"] +dask = ["dask"] +mip = ["mip (>=1.13)"] +numpy = ["numpy (>=1.19.5)"] +pandas = ["pint-pandas (>=0.3)"] +test = ["pytest", "pytest-cov", "pytest-mpl", "pytest-subtests"] +uncertainties = ["uncertainties (>=3.1.6)"] +xarray = ["xarray"] + +[[package]] +name = "pint-xarray" +version = "0.3" +description = "Physical units interface to xarray using Pint" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pint-xarray-0.3.tar.gz", hash = "sha256:3545dfa78bee3f98eba29b8bd17500e3b5cb7c7b03a2c2781c4d4d59b6a82841"}, + {file = "pint_xarray-0.3-py3-none-any.whl", hash = "sha256:a7d87c792a2e981cbff464bd1c875e872ef7a0c882a9395cfbc34512b3dcb1ab"}, +] + +[package.dependencies] +numpy = ">=1.17" +pint = ">=0.16" +xarray = ">=0.16.1" + +[[package]] +name = "platformdirs" +version = "3.10.0" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." +optional = false +python-versions = ">=3.7" +files = [ + {file = "platformdirs-3.10.0-py3-none-any.whl", hash = "sha256:d7c24979f292f916dc9cbf8648319032f551ea8c49a4c9bf2fb556a02070ec1d"}, + {file = "platformdirs-3.10.0.tar.gz", hash = "sha256:b45696dab2d7cc691a3226759c0d3b00c47c8b6e293d96f6436f733303f77f6d"}, +] + +[package.extras] +docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.1)", "sphinx-autodoc-typehints (>=1.24)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)"] + +[[package]] +name = "pluggy" +version = "1.3.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.3.0-py3-none-any.whl", hash = "sha256:d89c696a773f8bd377d18e5ecda92b7a3793cbe66c87060a6fb58c7b6e1061f7"}, + {file = "pluggy-1.3.0.tar.gz", hash = "sha256:cf61ae8f126ac6f7c451172cf30e3e43d3ca77615509771b3a984a0730651e12"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "pre-commit" +version = "2.21.0" +description = "A framework for managing and maintaining multi-language pre-commit hooks." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pre_commit-2.21.0-py2.py3-none-any.whl", hash = "sha256:e2f91727039fc39a92f58a588a25b87f936de6567eed4f0e673e0507edc75bad"}, + {file = "pre_commit-2.21.0.tar.gz", hash = "sha256:31ef31af7e474a8d8995027fefdfcf509b5c913ff31f2015b4ec4beb26a6f658"}, +] + +[package.dependencies] +cfgv = ">=2.0.0" +identify = ">=1.0.0" +nodeenv = ">=0.11.1" +pyyaml = ">=5.1" +virtualenv = ">=20.10.0" + +[[package]] +name = "prompt-toolkit" +version = "3.0.39" +description = "Library for building powerful interactive command lines in Python" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.39-py3-none-any.whl", hash = "sha256:9dffbe1d8acf91e3de75f3b544e4842382fc06c6babe903ac9acb74dc6e08d88"}, + {file = "prompt_toolkit-3.0.39.tar.gz", hash = "sha256:04505ade687dc26dc4284b1ad19a83be2f2afe83e7a828ace0c72f3a1df72aac"}, +] + +[package.dependencies] +wcwidth = "*" + +[[package]] +name = "psutil" +version = "5.9.5" +description = "Cross-platform lib for process and system monitoring in Python." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "psutil-5.9.5-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:be8929ce4313f9f8146caad4272f6abb8bf99fc6cf59344a3167ecd74f4f203f"}, + {file = "psutil-5.9.5-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:ab8ed1a1d77c95453db1ae00a3f9c50227ebd955437bcf2a574ba8adbf6a74d5"}, + {file = "psutil-5.9.5-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:4aef137f3345082a3d3232187aeb4ac4ef959ba3d7c10c33dd73763fbc063da4"}, + {file = "psutil-5.9.5-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:ea8518d152174e1249c4f2a1c89e3e6065941df2fa13a1ab45327716a23c2b48"}, + {file = "psutil-5.9.5-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:acf2aef9391710afded549ff602b5887d7a2349831ae4c26be7c807c0a39fac4"}, + {file = "psutil-5.9.5-cp27-none-win32.whl", hash = "sha256:5b9b8cb93f507e8dbaf22af6a2fd0ccbe8244bf30b1baad6b3954e935157ae3f"}, + {file = "psutil-5.9.5-cp27-none-win_amd64.whl", hash = "sha256:8c5f7c5a052d1d567db4ddd231a9d27a74e8e4a9c3f44b1032762bd7b9fdcd42"}, + {file = "psutil-5.9.5-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:3c6f686f4225553615612f6d9bc21f1c0e305f75d7d8454f9b46e901778e7217"}, + {file = "psutil-5.9.5-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7a7dd9997128a0d928ed4fb2c2d57e5102bb6089027939f3b722f3a210f9a8da"}, + {file = "psutil-5.9.5-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89518112647f1276b03ca97b65cc7f64ca587b1eb0278383017c2a0dcc26cbe4"}, + {file = "psutil-5.9.5-cp36-abi3-win32.whl", hash = "sha256:104a5cc0e31baa2bcf67900be36acde157756b9c44017b86b2c049f11957887d"}, + {file = "psutil-5.9.5-cp36-abi3-win_amd64.whl", hash = "sha256:b258c0c1c9d145a1d5ceffab1134441c4c5113b2417fafff7315a917a026c3c9"}, + {file = "psutil-5.9.5-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:c607bb3b57dc779d55e1554846352b4e358c10fff3abf3514a7a6601beebdb30"}, + {file = "psutil-5.9.5.tar.gz", hash = "sha256:5410638e4df39c54d957fc51ce03048acd8e6d60abc0f5107af51e5fb566eb3c"}, +] + +[package.extras] +test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +optional = false +python-versions = "*" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.2" +description = "Safely evaluate AST nodes without side effects" +optional = false +python-versions = "*" +files = [ + {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, + {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, +] + +[package.extras] +tests = ["pytest"] + +[[package]] +name = "pybtex" +version = "0.24.0" +description = "A BibTeX-compatible bibliography processor in Python" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*" +files = [ + {file = "pybtex-0.24.0-py2.py3-none-any.whl", hash = "sha256:e1e0c8c69998452fea90e9179aa2a98ab103f3eed894405b7264e517cc2fcc0f"}, + {file = "pybtex-0.24.0.tar.gz", hash = "sha256:818eae35b61733e5c007c3fcd2cfb75ed1bc8b4173c1f70b56cc4c0802d34755"}, +] + +[package.dependencies] +latexcodec = ">=1.0.4" +PyYAML = ">=3.01" +six = "*" + +[package.extras] +test = ["pytest"] + +[[package]] +name = "pybtex-docutils" +version = "1.0.3" +description = "A docutils backend for pybtex." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pybtex-docutils-1.0.3.tar.gz", hash = "sha256:3a7ebdf92b593e00e8c1c538aa9a20bca5d92d84231124715acc964d51d93c6b"}, + {file = "pybtex_docutils-1.0.3-py3-none-any.whl", hash = "sha256:8fd290d2ae48e32fcb54d86b0efb8d573198653c7e2447d5bec5847095f430b9"}, +] + +[package.dependencies] +docutils = ">=0.14" +pybtex = ">=0.16" + +[[package]] +name = "pycparser" +version = "2.21" +description = "C parser in Python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"}, + {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"}, +] + +[[package]] +name = "pygments" +version = "2.16.1" +description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=3.7" +files = [ + {file = "Pygments-2.16.1-py3-none-any.whl", hash = "sha256:13fc09fa63bc8d8671a6d247e1eb303c4b343eaee81d861f3404db2935653692"}, + {file = "Pygments-2.16.1.tar.gz", hash = "sha256:1daff0494820c69bc8941e407aa20f577374ee88364ee10a98fdbe0aece96e29"}, +] + +[package.extras] +plugins = ["importlib-metadata"] + +[[package]] +name = "pyparsing" +version = "3.1.1" +description = "pyparsing module - Classes and methods to define and execute parsing grammars" +optional = false +python-versions = ">=3.6.8" +files = [ + {file = "pyparsing-3.1.1-py3-none-any.whl", hash = "sha256:32c7c0b711493c72ff18a981d24f28aaf9c1fb7ed5e9667c9e84e3db623bdbfb"}, + {file = "pyparsing-3.1.1.tar.gz", hash = "sha256:ede28a1a32462f5a9705e07aea48001a08f7cf81a021585011deba701581a0db"}, +] + +[package.extras] +diagrams = ["jinja2", "railroad-diagrams"] + +[[package]] +name = "pytest" +version = "7.4.2" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-7.4.2-py3-none-any.whl", hash = "sha256:1d881c6124e08ff0a1bb75ba3ec0bfd8b5354a01c194ddd5a0a870a48d99b002"}, + {file = "pytest-7.4.2.tar.gz", hash = "sha256:a766259cfab564a2ad52cb1aae1b881a75c3eb7e34ca3779697c23ed47c47069"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=0.12,<2.0" +tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""} + +[package.extras] +testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "pytest-cov" +version = "4.1.0" +description = "Pytest plugin for measuring coverage." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-cov-4.1.0.tar.gz", hash = "sha256:3904b13dfbfec47f003b8e77fd5b589cd11904a21ddf1ab38a64f204d6a10ef6"}, + {file = "pytest_cov-4.1.0-py3-none-any.whl", hash = "sha256:6ba70b9e97e69fcc3fb45bfeab2d0a138fb65c4d0d6a41ef33983ad114be8c3a"}, +] + +[package.dependencies] +coverage = {version = ">=5.2.1", extras = ["toml"]} +pytest = ">=4.6" + +[package.extras] +testing = ["fields", "hunter", "process-tests", "pytest-xdist", "six", "virtualenv"] + +[[package]] +name = "python-dateutil" +version = "2.8.2" +description = "Extensions to the standard Python datetime module" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, + {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "pytz" +version = "2023.3.post1" +description = "World timezone definitions, modern and historical" +optional = false +python-versions = "*" +files = [ + {file = "pytz-2023.3.post1-py2.py3-none-any.whl", hash = "sha256:ce42d816b81b68506614c11e8937d3aa9e41007ceb50bfdcb0749b921bf646c7"}, + {file = "pytz-2023.3.post1.tar.gz", hash = "sha256:7b4fddbeb94a1eba4b557da24f19fdf9db575192544270a9101d8509f9f43d7b"}, +] + +[[package]] +name = "pywin32" +version = "306" +description = "Python for Window Extensions" +optional = false +python-versions = "*" +files = [ + {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, + {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, + {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"}, + {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, + {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"}, + {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"}, + {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, + {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"}, + {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"}, + {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"}, + {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"}, + {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, + {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"}, + {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.1" +description = "YAML parser and emitter for Python" +optional = false +python-versions = ">=3.6" +files = [ + {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, + {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, + {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, + {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, + {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, + {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, + {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, + {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, + {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, + {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, + {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, + {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"}, + {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"}, + {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, + {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, + {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, + {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, + {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, + {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, + {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, + {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, +] + +[[package]] +name = "pyzmq" +version = "25.1.1" +description = "Python bindings for 0MQ" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pyzmq-25.1.1-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:381469297409c5adf9a0e884c5eb5186ed33137badcbbb0560b86e910a2f1e76"}, + {file = "pyzmq-25.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:955215ed0604dac5b01907424dfa28b40f2b2292d6493445dd34d0dfa72586a8"}, + {file = "pyzmq-25.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:985bbb1316192b98f32e25e7b9958088431d853ac63aca1d2c236f40afb17c83"}, + {file = "pyzmq-25.1.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:afea96f64efa98df4da6958bae37f1cbea7932c35878b185e5982821bc883369"}, + {file = "pyzmq-25.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76705c9325d72a81155bb6ab48d4312e0032bf045fb0754889133200f7a0d849"}, + {file = "pyzmq-25.1.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:77a41c26205d2353a4c94d02be51d6cbdf63c06fbc1295ea57dad7e2d3381b71"}, + {file = "pyzmq-25.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:12720a53e61c3b99d87262294e2b375c915fea93c31fc2336898c26d7aed34cd"}, + {file = "pyzmq-25.1.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:57459b68e5cd85b0be8184382cefd91959cafe79ae019e6b1ae6e2ba8a12cda7"}, + {file = "pyzmq-25.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:292fe3fc5ad4a75bc8df0dfaee7d0babe8b1f4ceb596437213821f761b4589f9"}, + {file = "pyzmq-25.1.1-cp310-cp310-win32.whl", hash = "sha256:35b5ab8c28978fbbb86ea54958cd89f5176ce747c1fb3d87356cf698048a7790"}, + {file = "pyzmq-25.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:11baebdd5fc5b475d484195e49bae2dc64b94a5208f7c89954e9e354fc609d8f"}, + {file = "pyzmq-25.1.1-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:d20a0ddb3e989e8807d83225a27e5c2eb2260eaa851532086e9e0fa0d5287d83"}, + {file = "pyzmq-25.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e1c1be77bc5fb77d923850f82e55a928f8638f64a61f00ff18a67c7404faf008"}, + {file = "pyzmq-25.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d89528b4943d27029a2818f847c10c2cecc79fa9590f3cb1860459a5be7933eb"}, + {file = "pyzmq-25.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:90f26dc6d5f241ba358bef79be9ce06de58d477ca8485e3291675436d3827cf8"}, + {file = "pyzmq-25.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c2b92812bd214018e50b6380ea3ac0c8bb01ac07fcc14c5f86a5bb25e74026e9"}, + {file = "pyzmq-25.1.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:2f957ce63d13c28730f7fd6b72333814221c84ca2421298f66e5143f81c9f91f"}, + {file = "pyzmq-25.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:047a640f5c9c6ade7b1cc6680a0e28c9dd5a0825135acbd3569cc96ea00b2505"}, + {file = "pyzmq-25.1.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7f7e58effd14b641c5e4dec8c7dab02fb67a13df90329e61c869b9cc607ef752"}, + {file = "pyzmq-25.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c2910967e6ab16bf6fbeb1f771c89a7050947221ae12a5b0b60f3bca2ee19bca"}, + {file = "pyzmq-25.1.1-cp311-cp311-win32.whl", hash = "sha256:76c1c8efb3ca3a1818b837aea423ff8a07bbf7aafe9f2f6582b61a0458b1a329"}, + {file = "pyzmq-25.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:44e58a0554b21fc662f2712814a746635ed668d0fbc98b7cb9d74cb798d202e6"}, + {file = "pyzmq-25.1.1-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:e1ffa1c924e8c72778b9ccd386a7067cddf626884fd8277f503c48bb5f51c762"}, + {file = "pyzmq-25.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1af379b33ef33757224da93e9da62e6471cf4a66d10078cf32bae8127d3d0d4a"}, + {file = "pyzmq-25.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cff084c6933680d1f8b2f3b4ff5bbb88538a4aac00d199ac13f49d0698727ecb"}, + {file = "pyzmq-25.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e2400a94f7dd9cb20cd012951a0cbf8249e3d554c63a9c0cdfd5cbb6c01d2dec"}, + {file = "pyzmq-25.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d81f1ddae3858b8299d1da72dd7d19dd36aab654c19671aa8a7e7fb02f6638a"}, + {file = "pyzmq-25.1.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:255ca2b219f9e5a3a9ef3081512e1358bd4760ce77828e1028b818ff5610b87b"}, + {file = "pyzmq-25.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a882ac0a351288dd18ecae3326b8a49d10c61a68b01419f3a0b9a306190baf69"}, + {file = "pyzmq-25.1.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:724c292bb26365659fc434e9567b3f1adbdb5e8d640c936ed901f49e03e5d32e"}, + {file = "pyzmq-25.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ca1ed0bb2d850aa8471387882247c68f1e62a4af0ce9c8a1dbe0d2bf69e41fb"}, + {file = "pyzmq-25.1.1-cp312-cp312-win32.whl", hash = "sha256:b3451108ab861040754fa5208bca4a5496c65875710f76789a9ad27c801a0075"}, + {file = "pyzmq-25.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:eadbefd5e92ef8a345f0525b5cfd01cf4e4cc651a2cffb8f23c0dd184975d787"}, + {file = "pyzmq-25.1.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:db0b2af416ba735c6304c47f75d348f498b92952f5e3e8bff449336d2728795d"}, + {file = "pyzmq-25.1.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7c133e93b405eb0d36fa430c94185bdd13c36204a8635470cccc200723c13bb"}, + {file = "pyzmq-25.1.1-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:273bc3959bcbff3f48606b28229b4721716598d76b5aaea2b4a9d0ab454ec062"}, + {file = "pyzmq-25.1.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:cbc8df5c6a88ba5ae385d8930da02201165408dde8d8322072e3e5ddd4f68e22"}, + {file = "pyzmq-25.1.1-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:18d43df3f2302d836f2a56f17e5663e398416e9dd74b205b179065e61f1a6edf"}, + {file = "pyzmq-25.1.1-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:73461eed88a88c866656e08f89299720a38cb4e9d34ae6bf5df6f71102570f2e"}, + {file = "pyzmq-25.1.1-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:34c850ce7976d19ebe7b9d4b9bb8c9dfc7aac336c0958e2651b88cbd46682123"}, + {file = "pyzmq-25.1.1-cp36-cp36m-win32.whl", hash = "sha256:d2045d6d9439a0078f2a34b57c7b18c4a6aef0bee37f22e4ec9f32456c852c71"}, + {file = "pyzmq-25.1.1-cp36-cp36m-win_amd64.whl", hash = "sha256:458dea649f2f02a0b244ae6aef8dc29325a2810aa26b07af8374dc2a9faf57e3"}, + {file = "pyzmq-25.1.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7cff25c5b315e63b07a36f0c2bab32c58eafbe57d0dce61b614ef4c76058c115"}, + {file = "pyzmq-25.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1579413ae492b05de5a6174574f8c44c2b9b122a42015c5292afa4be2507f28"}, + {file = "pyzmq-25.1.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3d0a409d3b28607cc427aa5c30a6f1e4452cc44e311f843e05edb28ab5e36da0"}, + {file = "pyzmq-25.1.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:21eb4e609a154a57c520e3d5bfa0d97e49b6872ea057b7c85257b11e78068222"}, + {file = "pyzmq-25.1.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:034239843541ef7a1aee0c7b2cb7f6aafffb005ede965ae9cbd49d5ff4ff73cf"}, + {file = "pyzmq-25.1.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:f8115e303280ba09f3898194791a153862cbf9eef722ad8f7f741987ee2a97c7"}, + {file = "pyzmq-25.1.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:1a5d26fe8f32f137e784f768143728438877d69a586ddeaad898558dc971a5ae"}, + {file = "pyzmq-25.1.1-cp37-cp37m-win32.whl", hash = "sha256:f32260e556a983bc5c7ed588d04c942c9a8f9c2e99213fec11a031e316874c7e"}, + {file = "pyzmq-25.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:abf34e43c531bbb510ae7e8f5b2b1f2a8ab93219510e2b287a944432fad135f3"}, + {file = "pyzmq-25.1.1-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:87e34f31ca8f168c56d6fbf99692cc8d3b445abb5bfd08c229ae992d7547a92a"}, + {file = "pyzmq-25.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c9c6c9b2c2f80747a98f34ef491c4d7b1a8d4853937bb1492774992a120f475d"}, + {file = "pyzmq-25.1.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5619f3f5a4db5dbb572b095ea3cb5cc035335159d9da950830c9c4db2fbb6995"}, + {file = "pyzmq-25.1.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5a34d2395073ef862b4032343cf0c32a712f3ab49d7ec4f42c9661e0294d106f"}, + {file = "pyzmq-25.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25f0e6b78220aba09815cd1f3a32b9c7cb3e02cb846d1cfc526b6595f6046618"}, + {file = "pyzmq-25.1.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:3669cf8ee3520c2f13b2e0351c41fea919852b220988d2049249db10046a7afb"}, + {file = "pyzmq-25.1.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:2d163a18819277e49911f7461567bda923461c50b19d169a062536fffe7cd9d2"}, + {file = "pyzmq-25.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:df27ffddff4190667d40de7beba4a950b5ce78fe28a7dcc41d6f8a700a80a3c0"}, + {file = "pyzmq-25.1.1-cp38-cp38-win32.whl", hash = "sha256:a382372898a07479bd34bda781008e4a954ed8750f17891e794521c3e21c2e1c"}, + {file = "pyzmq-25.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:52533489f28d62eb1258a965f2aba28a82aa747202c8fa5a1c7a43b5db0e85c1"}, + {file = "pyzmq-25.1.1-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:03b3f49b57264909aacd0741892f2aecf2f51fb053e7d8ac6767f6c700832f45"}, + {file = "pyzmq-25.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:330f9e188d0d89080cde66dc7470f57d1926ff2fb5576227f14d5be7ab30b9fa"}, + {file = "pyzmq-25.1.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:2ca57a5be0389f2a65e6d3bb2962a971688cbdd30b4c0bd188c99e39c234f414"}, + {file = "pyzmq-25.1.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:d457aed310f2670f59cc5b57dcfced452aeeed77f9da2b9763616bd57e4dbaae"}, + {file = "pyzmq-25.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c56d748ea50215abef7030c72b60dd723ed5b5c7e65e7bc2504e77843631c1a6"}, + {file = "pyzmq-25.1.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:8f03d3f0d01cb5a018debeb412441996a517b11c5c17ab2001aa0597c6d6882c"}, + {file = "pyzmq-25.1.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:820c4a08195a681252f46926de10e29b6bbf3e17b30037bd4250d72dd3ddaab8"}, + {file = "pyzmq-25.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:17ef5f01d25b67ca8f98120d5fa1d21efe9611604e8eb03a5147360f517dd1e2"}, + {file = "pyzmq-25.1.1-cp39-cp39-win32.whl", hash = "sha256:04ccbed567171579ec2cebb9c8a3e30801723c575601f9a990ab25bcac6b51e2"}, + {file = "pyzmq-25.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:e61f091c3ba0c3578411ef505992d356a812fb200643eab27f4f70eed34a29ef"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ade6d25bb29c4555d718ac6d1443a7386595528c33d6b133b258f65f963bb0f6"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e0c95ddd4f6e9fca4e9e3afaa4f9df8552f0ba5d1004e89ef0a68e1f1f9807c7"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:48e466162a24daf86f6b5ca72444d2bf39a5e58da5f96370078be67c67adc978"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:abc719161780932c4e11aaebb203be3d6acc6b38d2f26c0f523b5b59d2fc1996"}, + {file = "pyzmq-25.1.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ccf825981640b8c34ae54231b7ed00271822ea1c6d8ba1090ebd4943759abf5"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:c2f20ce161ebdb0091a10c9ca0372e023ce24980d0e1f810f519da6f79c60800"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:deee9ca4727f53464daf089536e68b13e6104e84a37820a88b0a057b97bba2d2"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:aa8d6cdc8b8aa19ceb319aaa2b660cdaccc533ec477eeb1309e2a291eaacc43a"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:019e59ef5c5256a2c7378f2fb8560fc2a9ff1d315755204295b2eab96b254d0a"}, + {file = "pyzmq-25.1.1-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:b9af3757495c1ee3b5c4e945c1df7be95562277c6e5bccc20a39aec50f826cd0"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:548d6482dc8aadbe7e79d1b5806585c8120bafa1ef841167bc9090522b610fa6"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:057e824b2aae50accc0f9a0570998adc021b372478a921506fddd6c02e60308e"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2243700cc5548cff20963f0ca92d3e5e436394375ab8a354bbea2b12911b20b0"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79986f3b4af059777111409ee517da24a529bdbd46da578b33f25580adcff728"}, + {file = "pyzmq-25.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:11d58723d44d6ed4dd677c5615b2ffb19d5c426636345567d6af82be4dff8a55"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:49d238cf4b69652257db66d0c623cd3e09b5d2e9576b56bc067a396133a00d4a"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fedbdc753827cf014c01dbbee9c3be17e5a208dcd1bf8641ce2cd29580d1f0d4"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bc16ac425cc927d0a57d242589f87ee093884ea4804c05a13834d07c20db203c"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11c1d2aed9079c6b0c9550a7257a836b4a637feb334904610f06d70eb44c56d2"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e8a701123029cc240cea61dd2d16ad57cab4691804143ce80ecd9286b464d180"}, + {file = "pyzmq-25.1.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:61706a6b6c24bdece85ff177fec393545a3191eeda35b07aaa1458a027ad1304"}, + {file = "pyzmq-25.1.1.tar.gz", hash = "sha256:259c22485b71abacdfa8bf79720cd7bcf4b9d128b30ea554f01ae71fdbfdaa23"}, +] + +[package.dependencies] +cffi = {version = "*", markers = "implementation_name == \"pypy\""} + +[[package]] +name = "referencing" +version = "0.30.2" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "referencing-0.30.2-py3-none-any.whl", hash = "sha256:449b6669b6121a9e96a7f9e410b245d471e8d48964c67113ce9afe50c8dd7bdf"}, + {file = "referencing-0.30.2.tar.gz", hash = "sha256:794ad8003c65938edcdbc027f1933215e0d0ccc0291e3ce20a4d87432b59efc0"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + +[[package]] +name = "requests" +version = "2.31.0" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.7" +files = [ + {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, + {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "rpds-py" +version = "0.10.3" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rpds_py-0.10.3-cp310-cp310-macosx_10_7_x86_64.whl", hash = "sha256:485747ee62da83366a44fbba963c5fe017860ad408ccd6cd99aa66ea80d32b2e"}, + {file = "rpds_py-0.10.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c55f9821f88e8bee4b7a72c82cfb5ecd22b6aad04033334f33c329b29bfa4da0"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3b52a67ac66a3a64a7e710ba629f62d1e26ca0504c29ee8cbd99b97df7079a8"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3aed39db2f0ace76faa94f465d4234aac72e2f32b009f15da6492a561b3bbebd"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:271c360fdc464fe6a75f13ea0c08ddf71a321f4c55fc20a3fe62ea3ef09df7d9"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ef5fddfb264e89c435be4adb3953cef5d2936fdeb4463b4161a6ba2f22e7b740"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a771417c9c06c56c9d53d11a5b084d1de75de82978e23c544270ab25e7c066ff"}, + {file = "rpds_py-0.10.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:52b5cbc0469328e58180021138207e6ec91d7ca2e037d3549cc9e34e2187330a"}, + {file = "rpds_py-0.10.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6ac3fefb0d168c7c6cab24fdfc80ec62cd2b4dfd9e65b84bdceb1cb01d385c33"}, + {file = "rpds_py-0.10.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:8d54bbdf5d56e2c8cf81a1857250f3ea132de77af543d0ba5dce667183b61fec"}, + {file = "rpds_py-0.10.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cd2163f42868865597d89399a01aa33b7594ce8e2c4a28503127c81a2f17784e"}, + {file = "rpds_py-0.10.3-cp310-none-win32.whl", hash = "sha256:ea93163472db26ac6043e8f7f93a05d9b59e0505c760da2a3cd22c7dd7111391"}, + {file = "rpds_py-0.10.3-cp310-none-win_amd64.whl", hash = "sha256:7cd020b1fb41e3ab7716d4d2c3972d4588fdfbab9bfbbb64acc7078eccef8860"}, + {file = "rpds_py-0.10.3-cp311-cp311-macosx_10_7_x86_64.whl", hash = "sha256:1d9b5ee46dcb498fa3e46d4dfabcb531e1f2e76b477e0d99ef114f17bbd38453"}, + {file = "rpds_py-0.10.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:563646d74a4b4456d0cf3b714ca522e725243c603e8254ad85c3b59b7c0c4bf0"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e626b864725680cd3904414d72e7b0bd81c0e5b2b53a5b30b4273034253bb41f"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:485301ee56ce87a51ccb182a4b180d852c5cb2b3cb3a82f7d4714b4141119d8c"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:42f712b4668831c0cd85e0a5b5a308700fe068e37dcd24c0062904c4e372b093"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6c9141af27a4e5819d74d67d227d5047a20fa3c7d4d9df43037a955b4c748ec5"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef750a20de1b65657a1425f77c525b0183eac63fe7b8f5ac0dd16f3668d3e64f"}, + {file = "rpds_py-0.10.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e1a0ffc39f51aa5f5c22114a8f1906b3c17eba68c5babb86c5f77d8b1bba14d1"}, + {file = "rpds_py-0.10.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f4c179a7aeae10ddf44c6bac87938134c1379c49c884529f090f9bf05566c836"}, + {file = "rpds_py-0.10.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:176287bb998fd1e9846a9b666e240e58f8d3373e3bf87e7642f15af5405187b8"}, + {file = "rpds_py-0.10.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6446002739ca29249f0beaaf067fcbc2b5aab4bc7ee8fb941bd194947ce19aff"}, + {file = "rpds_py-0.10.3-cp311-none-win32.whl", hash = "sha256:c7aed97f2e676561416c927b063802c8a6285e9b55e1b83213dfd99a8f4f9e48"}, + {file = "rpds_py-0.10.3-cp311-none-win_amd64.whl", hash = "sha256:8bd01ff4032abaed03f2db702fa9a61078bee37add0bd884a6190b05e63b028c"}, + {file = "rpds_py-0.10.3-cp312-cp312-macosx_10_7_x86_64.whl", hash = "sha256:4cf0855a842c5b5c391dd32ca273b09e86abf8367572073bd1edfc52bc44446b"}, + {file = "rpds_py-0.10.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:69b857a7d8bd4f5d6e0db4086da8c46309a26e8cefdfc778c0c5cc17d4b11e08"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:975382d9aa90dc59253d6a83a5ca72e07f4ada3ae3d6c0575ced513db322b8ec"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:35fbd23c1c8732cde7a94abe7fb071ec173c2f58c0bd0d7e5b669fdfc80a2c7b"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:106af1653007cc569d5fbb5f08c6648a49fe4de74c2df814e234e282ebc06957"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce5e7504db95b76fc89055c7f41e367eaadef5b1d059e27e1d6eabf2b55ca314"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5aca759ada6b1967fcfd4336dcf460d02a8a23e6abe06e90ea7881e5c22c4de6"}, + {file = "rpds_py-0.10.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b5d4bdd697195f3876d134101c40c7d06d46c6ab25159ed5cbd44105c715278a"}, + {file = "rpds_py-0.10.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a657250807b6efd19b28f5922520ae002a54cb43c2401e6f3d0230c352564d25"}, + {file = "rpds_py-0.10.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:177c9dd834cdf4dc39c27436ade6fdf9fe81484758885f2d616d5d03c0a83bd2"}, + {file = "rpds_py-0.10.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e22491d25f97199fc3581ad8dd8ce198d8c8fdb8dae80dea3512e1ce6d5fa99f"}, + {file = "rpds_py-0.10.3-cp38-cp38-macosx_10_7_x86_64.whl", hash = "sha256:2f3e1867dd574014253b4b8f01ba443b9c914e61d45f3674e452a915d6e929a3"}, + {file = "rpds_py-0.10.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c22211c165166de6683de8136229721f3d5c8606cc2c3d1562da9a3a5058049c"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40bc802a696887b14c002edd43c18082cb7b6f9ee8b838239b03b56574d97f71"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5e271dd97c7bb8eefda5cca38cd0b0373a1fea50f71e8071376b46968582af9b"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:95cde244e7195b2c07ec9b73fa4c5026d4a27233451485caa1cd0c1b55f26dbd"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08a80cf4884920863623a9ee9a285ee04cef57ebedc1cc87b3e3e0f24c8acfe5"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:763ad59e105fca09705d9f9b29ecffb95ecdc3b0363be3bb56081b2c6de7977a"}, + {file = "rpds_py-0.10.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:187700668c018a7e76e89424b7c1042f317c8df9161f00c0c903c82b0a8cac5c"}, + {file = "rpds_py-0.10.3-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:5267cfda873ad62591b9332fd9472d2409f7cf02a34a9c9cb367e2c0255994bf"}, + {file = "rpds_py-0.10.3-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:2ed83d53a8c5902ec48b90b2ac045e28e1698c0bea9441af9409fc844dc79496"}, + {file = "rpds_py-0.10.3-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:255f1a10ae39b52122cce26ce0781f7a616f502feecce9e616976f6a87992d6b"}, + {file = "rpds_py-0.10.3-cp38-none-win32.whl", hash = "sha256:a019a344312d0b1f429c00d49c3be62fa273d4a1094e1b224f403716b6d03be1"}, + {file = "rpds_py-0.10.3-cp38-none-win_amd64.whl", hash = "sha256:efb9ece97e696bb56e31166a9dd7919f8f0c6b31967b454718c6509f29ef6fee"}, + {file = "rpds_py-0.10.3-cp39-cp39-macosx_10_7_x86_64.whl", hash = "sha256:570cc326e78ff23dec7f41487aa9c3dffd02e5ee9ab43a8f6ccc3df8f9327623"}, + {file = "rpds_py-0.10.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cff7351c251c7546407827b6a37bcef6416304fc54d12d44dbfecbb717064717"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:177914f81f66c86c012311f8c7f46887ec375cfcfd2a2f28233a3053ac93a569"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:448a66b8266de0b581246ca7cd6a73b8d98d15100fb7165974535fa3b577340e"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3bbac1953c17252f9cc675bb19372444aadf0179b5df575ac4b56faaec9f6294"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9dd9d9d9e898b9d30683bdd2b6c1849449158647d1049a125879cb397ee9cd12"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e8c71ea77536149e36c4c784f6d420ffd20bea041e3ba21ed021cb40ce58e2c9"}, + {file = "rpds_py-0.10.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16a472300bc6c83fe4c2072cc22b3972f90d718d56f241adabc7ae509f53f154"}, + {file = "rpds_py-0.10.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:b9255e7165083de7c1d605e818025e8860636348f34a79d84ec533546064f07e"}, + {file = "rpds_py-0.10.3-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:53d7a3cd46cdc1689296348cb05ffd4f4280035770aee0c8ead3bbd4d6529acc"}, + {file = "rpds_py-0.10.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:22da15b902f9f8e267020d1c8bcfc4831ca646fecb60254f7bc71763569f56b1"}, + {file = "rpds_py-0.10.3-cp39-none-win32.whl", hash = "sha256:850c272e0e0d1a5c5d73b1b7871b0a7c2446b304cec55ccdb3eaac0d792bb065"}, + {file = "rpds_py-0.10.3-cp39-none-win_amd64.whl", hash = "sha256:de61e424062173b4f70eec07e12469edde7e17fa180019a2a0d75c13a5c5dc57"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-macosx_10_7_x86_64.whl", hash = "sha256:af247fd4f12cca4129c1b82090244ea5a9d5bb089e9a82feb5a2f7c6a9fe181d"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:3ad59efe24a4d54c2742929001f2d02803aafc15d6d781c21379e3f7f66ec842"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:642ed0a209ced4be3a46f8cb094f2d76f1f479e2a1ceca6de6346a096cd3409d"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:37d0c59548ae56fae01c14998918d04ee0d5d3277363c10208eef8c4e2b68ed6"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aad6ed9e70ddfb34d849b761fb243be58c735be6a9265b9060d6ddb77751e3e8"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8f94fdd756ba1f79f988855d948ae0bad9ddf44df296770d9a58c774cfbcca72"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77076bdc8776a2b029e1e6ffbe6d7056e35f56f5e80d9dc0bad26ad4a024a762"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:87d9b206b1bd7a0523375dc2020a6ce88bca5330682ae2fe25e86fd5d45cea9c"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:8efaeb08ede95066da3a3e3c420fcc0a21693fcd0c4396d0585b019613d28515"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a4d9bfda3f84fc563868fe25ca160c8ff0e69bc4443c5647f960d59400ce6557"}, + {file = "rpds_py-0.10.3-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:d27aa6bbc1f33be920bb7adbb95581452cdf23005d5611b29a12bb6a3468cc95"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-macosx_10_7_x86_64.whl", hash = "sha256:ed8313809571a5463fd7db43aaca68ecb43ca7a58f5b23b6e6c6c5d02bdc7882"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:e10e6a1ed2b8661201e79dff5531f8ad4cdd83548a0f81c95cf79b3184b20c33"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:015de2ce2af1586ff5dc873e804434185199a15f7d96920ce67e50604592cae9"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ae87137951bb3dc08c7d8bfb8988d8c119f3230731b08a71146e84aaa919a7a9"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0bb4f48bd0dd18eebe826395e6a48b7331291078a879295bae4e5d053be50d4c"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:09362f86ec201288d5687d1dc476b07bf39c08478cde837cb710b302864e7ec9"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:821392559d37759caa67d622d0d2994c7a3f2fb29274948ac799d496d92bca73"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7170cbde4070dc3c77dec82abf86f3b210633d4f89550fa0ad2d4b549a05572a"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:5de11c041486681ce854c814844f4ce3282b6ea1656faae19208ebe09d31c5b8"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:4ed172d0c79f156c1b954e99c03bc2e3033c17efce8dd1a7c781bc4d5793dfac"}, + {file = "rpds_py-0.10.3-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:11fdd1192240dda8d6c5d18a06146e9045cb7e3ba7c06de6973000ff035df7c6"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-macosx_10_7_x86_64.whl", hash = "sha256:f602881d80ee4228a2355c68da6b296a296cd22bbb91e5418d54577bbf17fa7c"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:691d50c99a937709ac4c4cd570d959a006bd6a6d970a484c84cc99543d4a5bbb"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:24cd91a03543a0f8d09cb18d1cb27df80a84b5553d2bd94cba5979ef6af5c6e7"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fc2200e79d75b5238c8d69f6a30f8284290c777039d331e7340b6c17cad24a5a"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ea65b59882d5fa8c74a23f8960db579e5e341534934f43f3b18ec1839b893e41"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:829e91f3a8574888b73e7a3feb3b1af698e717513597e23136ff4eba0bc8387a"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eab75a8569a095f2ad470b342f2751d9902f7944704f0571c8af46bede438475"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:061c3ff1f51ecec256e916cf71cc01f9975af8fb3af9b94d3c0cc8702cfea637"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:39d05e65f23a0fe897b6ac395f2a8d48c56ac0f583f5d663e0afec1da89b95da"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:4eca20917a06d2fca7628ef3c8b94a8c358f6b43f1a621c9815243462dcccf97"}, + {file = "rpds_py-0.10.3-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e8d0f0eca087630d58b8c662085529781fd5dc80f0a54eda42d5c9029f812599"}, + {file = "rpds_py-0.10.3.tar.gz", hash = "sha256:fcc1ebb7561a3e24a6588f7c6ded15d80aec22c66a070c757559b57b17ffd1cb"}, +] + +[[package]] +name = "ruff" +version = "0.0.292" +description = "An extremely fast Python linter, written in Rust." +optional = false +python-versions = ">=3.7" +files = [ + {file = "ruff-0.0.292-py3-none-macosx_10_7_x86_64.whl", hash = "sha256:02f29db018c9d474270c704e6c6b13b18ed0ecac82761e4fcf0faa3728430c96"}, + {file = "ruff-0.0.292-py3-none-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:69654e564342f507edfa09ee6897883ca76e331d4bbc3676d8a8403838e9fade"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c3c91859a9b845c33778f11902e7b26440d64b9d5110edd4e4fa1726c41e0a4"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4476f1243af2d8c29da5f235c13dca52177117935e1f9393f9d90f9833f69e4"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:be8eb50eaf8648070b8e58ece8e69c9322d34afe367eec4210fdee9a555e4ca7"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:9889bac18a0c07018aac75ef6c1e6511d8411724d67cb879103b01758e110a81"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6bdfabd4334684a4418b99b3118793f2c13bb67bf1540a769d7816410402a205"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aa7c77c53bfcd75dbcd4d1f42d6cabf2485d2e1ee0678da850f08e1ab13081a8"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e087b24d0d849c5c81516ec740bf4fd48bf363cfb104545464e0fca749b6af9"}, + {file = "ruff-0.0.292-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f160b5ec26be32362d0774964e218f3fcf0a7da299f7e220ef45ae9e3e67101a"}, + {file = "ruff-0.0.292-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ac153eee6dd4444501c4bb92bff866491d4bfb01ce26dd2fff7ca472c8df9ad0"}, + {file = "ruff-0.0.292-py3-none-musllinux_1_2_i686.whl", hash = "sha256:87616771e72820800b8faea82edd858324b29bb99a920d6aa3d3949dd3f88fb0"}, + {file = "ruff-0.0.292-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b76deb3bdbea2ef97db286cf953488745dd6424c122d275f05836c53f62d4016"}, + {file = "ruff-0.0.292-py3-none-win32.whl", hash = "sha256:e854b05408f7a8033a027e4b1c7f9889563dd2aca545d13d06711e5c39c3d003"}, + {file = "ruff-0.0.292-py3-none-win_amd64.whl", hash = "sha256:f27282bedfd04d4c3492e5c3398360c9d86a295be00eccc63914438b4ac8a83c"}, + {file = "ruff-0.0.292-py3-none-win_arm64.whl", hash = "sha256:7f67a69c8f12fbc8daf6ae6d36705037bde315abf8b82b6e1f4c9e74eb750f68"}, + {file = "ruff-0.0.292.tar.gz", hash = "sha256:1093449e37dd1e9b813798f6ad70932b57cf614e5c2b5c51005bf67d55db33ac"}, +] + +[[package]] +name = "scipy" +version = "1.11.2" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = "<3.13,>=3.9" +files = [ + {file = "scipy-1.11.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2b997a5369e2d30c97995dcb29d638701f8000d04df01b8e947f206e5d0ac788"}, + {file = "scipy-1.11.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:95763fbda1206bec41157582bea482f50eb3702c85fffcf6d24394b071c0e87a"}, + {file = "scipy-1.11.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e367904a0fec76433bf3fbf3e85bf60dae8e9e585ffd21898ab1085a29a04d16"}, + {file = "scipy-1.11.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d690e1ca993c8f7ede6d22e5637541217fc6a4d3f78b3672a6fe454dbb7eb9a7"}, + {file = "scipy-1.11.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d2b813bfbe8dec6a75164523de650bad41f4405d35b0fa24c2c28ae07fcefb20"}, + {file = "scipy-1.11.2-cp310-cp310-win_amd64.whl", hash = "sha256:afdb0d983f6135d50770dd979df50bf1c7f58b5b33e0eb8cf5c73c70600eae1d"}, + {file = "scipy-1.11.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8d9886f44ef8c9e776cb7527fb01455bf4f4a46c455c4682edc2c2cc8cd78562"}, + {file = "scipy-1.11.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:1342ca385c673208f32472830c10110a9dcd053cf0c4b7d4cd7026d0335a6c1d"}, + {file = "scipy-1.11.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b133f237bd8ba73bad51bc12eb4f2d84cbec999753bf25ba58235e9fc2096d80"}, + {file = "scipy-1.11.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3aeb87661de987f8ec56fa6950863994cd427209158255a389fc5aea51fa7055"}, + {file = "scipy-1.11.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:90d3b1364e751d8214e325c371f0ee0dd38419268bf4888b2ae1040a6b266b2a"}, + {file = "scipy-1.11.2-cp311-cp311-win_amd64.whl", hash = "sha256:f73102f769ee06041a3aa26b5841359b1a93cc364ce45609657751795e8f4a4a"}, + {file = "scipy-1.11.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa4909c6c20c3d91480533cddbc0e7c6d849e7d9ded692918c76ce5964997898"}, + {file = "scipy-1.11.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:ac74b1512d38718fb6a491c439aa7b3605b96b1ed3be6599c17d49d6c60fca18"}, + {file = "scipy-1.11.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b8425fa963a32936c9773ee3ce44a765d8ff67eed5f4ac81dc1e4a819a238ee9"}, + {file = "scipy-1.11.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:542a757e2a6ec409e71df3d8fd20127afbbacb1c07990cb23c5870c13953d899"}, + {file = "scipy-1.11.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ea932570b1c2a30edafca922345854ff2cd20d43cd9123b6dacfdecebfc1a80b"}, + {file = "scipy-1.11.2-cp312-cp312-win_amd64.whl", hash = "sha256:4447ad057d7597476f9862ecbd9285bbf13ba9d73ce25acfa4e4b11c6801b4c9"}, + {file = "scipy-1.11.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b0620240ef445b5ddde52460e6bc3483b7c9c750275369379e5f609a1050911c"}, + {file = "scipy-1.11.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:f28f1f6cfeb48339c192efc6275749b2a25a7e49c4d8369a28b6591da02fbc9a"}, + {file = "scipy-1.11.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:214cdf04bbae7a54784f8431f976704ed607c4bc69ba0d5d5d6a9df84374df76"}, + {file = "scipy-1.11.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10eb6af2f751aa3424762948e5352f707b0dece77288206f227864ddf675aca0"}, + {file = "scipy-1.11.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0f3261f14b767b316d7137c66cc4f33a80ea05841b9c87ad83a726205b901423"}, + {file = "scipy-1.11.2-cp39-cp39-win_amd64.whl", hash = "sha256:2c91cf049ffb5575917f2a01da1da082fd24ed48120d08a6e7297dfcac771dcd"}, + {file = "scipy-1.11.2.tar.gz", hash = "sha256:b29318a5e39bd200ca4381d80b065cdf3076c7d7281c5e36569e99273867f61d"}, +] + +[package.dependencies] +numpy = ">=1.21.6,<1.28.0" + +[package.extras] +dev = ["click", "cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] +doc = ["jupytext", "matplotlib (>2)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"] +test = ["asv", "gmpy2", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + +[[package]] +name = "seaborn" +version = "0.12.2" +description = "Statistical data visualization" +optional = false +python-versions = ">=3.7" +files = [ + {file = "seaborn-0.12.2-py3-none-any.whl", hash = "sha256:ebf15355a4dba46037dfd65b7350f014ceb1f13c05e814eda2c9f5fd731afc08"}, + {file = "seaborn-0.12.2.tar.gz", hash = "sha256:374645f36509d0dcab895cba5b47daf0586f77bfe3b36c97c607db7da5be0139"}, +] + +[package.dependencies] +matplotlib = ">=3.1,<3.6.1 || >3.6.1" +numpy = ">=1.17,<1.24.0 || >1.24.0" +pandas = ">=0.25" + +[package.extras] +dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"] +docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx-copybutton", "sphinx-design", "sphinx-issues"] +stats = ["scipy (>=1.3)", "statsmodels (>=0.10)"] + +[[package]] +name = "setuptools" +version = "68.2.1" +description = "Easily download, build, install, upgrade, and uninstall Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "setuptools-68.2.1-py3-none-any.whl", hash = "sha256:eff96148eb336377ab11beee0c73ed84f1709a40c0b870298b0d058828761bae"}, + {file = "setuptools-68.2.1.tar.gz", hash = "sha256:56ee14884fd8d0cd015411f4a13f40b4356775a0aefd9ebc1d3bfb9a1acb32f1"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-hoverxref (<2)", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] +testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pip (>=19.1)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] +testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.1)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] + +[[package]] +name = "setuptools-scm" +version = "7.1.0" +description = "the blessed package to manage your versions by scm tags" +optional = false +python-versions = ">=3.7" +files = [ + {file = "setuptools_scm-7.1.0-py3-none-any.whl", hash = "sha256:73988b6d848709e2af142aa48c986ea29592bbcfca5375678064708205253d8e"}, + {file = "setuptools_scm-7.1.0.tar.gz", hash = "sha256:6c508345a771aad7d56ebff0e70628bf2b0ec7573762be9960214730de278f27"}, +] + +[package.dependencies] +packaging = ">=20.0" +setuptools = "*" +tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""} +typing-extensions = "*" + +[package.extras] +test = ["pytest (>=6.2)", "virtualenv (>20)"] +toml = ["setuptools (>=42)"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +description = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms." +optional = false +python-versions = "*" +files = [ + {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"}, + {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"}, +] + +[[package]] +name = "soupsieve" +version = "2.5" +description = "A modern CSS selector implementation for Beautiful Soup." +optional = false +python-versions = ">=3.8" +files = [ + {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, + {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, +] + +[[package]] +name = "sphinx" +version = "7.2.6" +description = "Python documentation generator" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinx-7.2.6-py3-none-any.whl", hash = "sha256:1e09160a40b956dc623c910118fa636da93bd3ca0b9876a7b3df90f07d691560"}, + {file = "sphinx-7.2.6.tar.gz", hash = "sha256:9a5160e1ea90688d5963ba09a2dcd8bdd526620edbb65c328728f1b2228d5ab5"}, +] + +[package.dependencies] +alabaster = ">=0.7,<0.8" +babel = ">=2.9" +colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""} +docutils = ">=0.18.1,<0.21" +imagesize = ">=1.3" +importlib-metadata = {version = ">=4.8", markers = "python_version < \"3.10\""} +Jinja2 = ">=3.0" +packaging = ">=21.0" +Pygments = ">=2.14" +requests = ">=2.25.0" +snowballstemmer = ">=2.0" +sphinxcontrib-applehelp = "*" +sphinxcontrib-devhelp = "*" +sphinxcontrib-htmlhelp = ">=2.0.0" +sphinxcontrib-jsmath = "*" +sphinxcontrib-qthelp = "*" +sphinxcontrib-serializinghtml = ">=1.1.9" + +[package.extras] +docs = ["sphinxcontrib-websupport"] +lint = ["docutils-stubs", "flake8 (>=3.5.0)", "flake8-simplify", "isort", "mypy (>=0.990)", "ruff", "sphinx-lint", "types-requests"] +test = ["cython (>=3.0)", "filelock", "html5lib", "pytest (>=4.6)", "setuptools (>=67.0)"] + +[[package]] +name = "sphinx-copybutton" +version = "0.5.2" +description = "Add a copy button to each of your code cells." +optional = false +python-versions = ">=3.7" +files = [ + {file = "sphinx-copybutton-0.5.2.tar.gz", hash = "sha256:4cf17c82fb9646d1bc9ca92ac280813a3b605d8c421225fd9913154103ee1fbd"}, + {file = "sphinx_copybutton-0.5.2-py3-none-any.whl", hash = "sha256:fb543fd386d917746c9a2c50360c7905b605726b9355cd26e9974857afeae06e"}, +] + +[package.dependencies] +sphinx = ">=1.8" + +[package.extras] +code-style = ["pre-commit (==2.12.1)"] +rtd = ["ipython", "myst-nb", "sphinx", "sphinx-book-theme", "sphinx-examples"] + +[[package]] +name = "sphinx-rtd-theme" +version = "2.0.0rc2" +description = "Read the Docs theme for Sphinx" +optional = false +python-versions = ">=3.6" +files = [ + {file = "sphinx_rtd_theme-2.0.0rc2-py2.py3-none-any.whl", hash = "sha256:f04df9213acf421c3b42f4f39005c8bc68fc4696c5b4ed4ef13d1678369713f7"}, + {file = "sphinx_rtd_theme-2.0.0rc2.tar.gz", hash = "sha256:d1270effe620df9164b1cd2d617909472a63531e21a716fd22d0fbcedf9d24ff"}, +] + +[package.dependencies] +docutils = "<0.21" +sphinx = ">=5,<8" +sphinxcontrib-jquery = ">=4,<5" + +[package.extras] +dev = ["bump2version", "sphinxcontrib-httpdomain", "transifex-client", "wheel"] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "1.0.7" +description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_applehelp-1.0.7-py3-none-any.whl", hash = "sha256:094c4d56209d1734e7d252f6e0b3ccc090bd52ee56807a5d9315b19c122ab15d"}, + {file = "sphinxcontrib_applehelp-1.0.7.tar.gz", hash = "sha256:39fdc8d762d33b01a7d8f026a3b7d71563ea3b72787d5f00ad8465bd9d6dfbfa"}, +] + +[package.dependencies] +Sphinx = ">=5" + +[package.extras] +lint = ["docutils-stubs", "flake8", "mypy"] +test = ["pytest"] + +[[package]] +name = "sphinxcontrib-bibtex" +version = "2.6.1" +description = "Sphinx extension for BibTeX style citations." +optional = false +python-versions = ">=3.7" +files = [ + {file = "sphinxcontrib-bibtex-2.6.1.tar.gz", hash = "sha256:046b49f070ae5276af34c1b8ddb9bc9562ef6de2f7a52d37a91cb8e53f54b863"}, + {file = "sphinxcontrib_bibtex-2.6.1-py3-none-any.whl", hash = "sha256:094c772098fe6b030cda8618c45722b2957cad0c04f328ba2b154aa08dfe720a"}, +] + +[package.dependencies] +docutils = ">=0.8,<0.18.dev0 || >=0.20.dev0" +importlib-metadata = {version = ">=3.6", markers = "python_version < \"3.10\""} +pybtex = ">=0.24" +pybtex-docutils = ">=1.0.0" +Sphinx = ">=3.5" + +[[package]] +name = "sphinxcontrib-devhelp" +version = "1.0.5" +description = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_devhelp-1.0.5-py3-none-any.whl", hash = "sha256:fe8009aed765188f08fcaadbb3ea0d90ce8ae2d76710b7e29ea7d047177dae2f"}, + {file = "sphinxcontrib_devhelp-1.0.5.tar.gz", hash = "sha256:63b41e0d38207ca40ebbeabcf4d8e51f76c03e78cd61abe118cf4435c73d4212"}, +] + +[package.dependencies] +Sphinx = ">=5" + +[package.extras] +lint = ["docutils-stubs", "flake8", "mypy"] +test = ["pytest"] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.0.4" +description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_htmlhelp-2.0.4-py3-none-any.whl", hash = "sha256:8001661c077a73c29beaf4a79968d0726103c5605e27db92b9ebed8bab1359e9"}, + {file = "sphinxcontrib_htmlhelp-2.0.4.tar.gz", hash = "sha256:6c26a118a05b76000738429b724a0568dbde5b72391a688577da08f11891092a"}, +] + +[package.dependencies] +Sphinx = ">=5" + +[package.extras] +lint = ["docutils-stubs", "flake8", "mypy"] +test = ["html5lib", "pytest"] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +description = "Extension to include jQuery on newer Sphinx releases" +optional = false +python-versions = ">=2.7" +files = [ + {file = "sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a"}, + {file = "sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae"}, +] + +[package.dependencies] +Sphinx = ">=1.8" + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +description = "A sphinx extension which renders display math in HTML via JavaScript" +optional = false +python-versions = ">=3.5" +files = [ + {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"}, + {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"}, +] + +[package.extras] +test = ["flake8", "mypy", "pytest"] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "1.0.6" +description = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_qthelp-1.0.6-py3-none-any.whl", hash = "sha256:bf76886ee7470b934e363da7a954ea2825650013d367728588732c7350f49ea4"}, + {file = "sphinxcontrib_qthelp-1.0.6.tar.gz", hash = "sha256:62b9d1a186ab7f5ee3356d906f648cacb7a6bdb94d201ee7adf26db55092982d"}, +] + +[package.dependencies] +Sphinx = ">=5" + +[package.extras] +lint = ["docutils-stubs", "flake8", "mypy"] +test = ["pytest"] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "1.1.9" +description = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)" +optional = false +python-versions = ">=3.9" +files = [ + {file = "sphinxcontrib_serializinghtml-1.1.9-py3-none-any.whl", hash = "sha256:9b36e503703ff04f20e9675771df105e58aa029cfcbc23b8ed716019b7416ae1"}, + {file = "sphinxcontrib_serializinghtml-1.1.9.tar.gz", hash = "sha256:0c64ff898339e1fac29abd2bf5f11078f3ec413cfe9c046d3120d7ca65530b54"}, +] + +[package.dependencies] +Sphinx = ">=5" + +[package.extras] +lint = ["docutils-stubs", "flake8", "mypy"] +test = ["pytest"] + +[[package]] +name = "stack-data" +version = "0.6.2" +description = "Extract data from python stack frames and tracebacks for informative displays" +optional = false +python-versions = "*" +files = [ + {file = "stack_data-0.6.2-py3-none-any.whl", hash = "sha256:cbb2a53eb64e5785878201a97ed7c7b94883f48b87bfb0bbe8b623c74679e4a8"}, + {file = "stack_data-0.6.2.tar.gz", hash = "sha256:32d2dd0376772d01b6cb9fc996f3c8b57a357089dec328ed4b6553d037eaf815"}, +] + +[package.dependencies] +asttokens = ">=2.1.0" +executing = ">=1.2.0" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] + +[[package]] +name = "tinycss2" +version = "1.2.1" +description = "A tiny CSS parser" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, + {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, +] + +[package.dependencies] +webencodings = ">=0.4" + +[package.extras] +doc = ["sphinx", "sphinx_rtd_theme"] +test = ["flake8", "isort", "pytest"] + +[[package]] +name = "toml" +version = "0.10.2" +description = "Python Library for Tom's Obvious, Minimal Language" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, + {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, +] + +[[package]] +name = "tomli" +version = "2.0.1" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, + {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, +] + +[[package]] +name = "tornado" +version = "6.3.3" +description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +optional = false +python-versions = ">= 3.8" +files = [ + {file = "tornado-6.3.3-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:502fba735c84450974fec147340016ad928d29f1e91f49be168c0a4c18181e1d"}, + {file = "tornado-6.3.3-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:805d507b1f588320c26f7f097108eb4023bbaa984d63176d1652e184ba24270a"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1bd19ca6c16882e4d37368e0152f99c099bad93e0950ce55e71daed74045908f"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ac51f42808cca9b3613f51ffe2a965c8525cb1b00b7b2d56828b8045354f76a"}, + {file = "tornado-6.3.3-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:71a8db65160a3c55d61839b7302a9a400074c9c753040455494e2af74e2501f2"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:ceb917a50cd35882b57600709dd5421a418c29ddc852da8bcdab1f0db33406b0"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:7d01abc57ea0dbb51ddfed477dfe22719d376119844e33c661d873bf9c0e4a16"}, + {file = "tornado-6.3.3-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:9dc4444c0defcd3929d5c1eb5706cbe1b116e762ff3e0deca8b715d14bf6ec17"}, + {file = "tornado-6.3.3-cp38-abi3-win32.whl", hash = "sha256:65ceca9500383fbdf33a98c0087cb975b2ef3bfb874cb35b8de8740cf7f41bd3"}, + {file = "tornado-6.3.3-cp38-abi3-win_amd64.whl", hash = "sha256:22d3c2fa10b5793da13c807e6fc38ff49a4f6e1e3868b0a6f4164768bb8e20f5"}, + {file = "tornado-6.3.3.tar.gz", hash = "sha256:e7d8db41c0181c80d76c982aacc442c0783a2c54d6400fe028954201a2e032fe"}, +] + +[[package]] +name = "traitlets" +version = "5.9.0" +description = "Traitlets Python configuration system" +optional = false +python-versions = ">=3.7" +files = [ + {file = "traitlets-5.9.0-py3-none-any.whl", hash = "sha256:9e6ec080259b9a5940c797d58b613b5e31441c2257b87c2e795c5228ae80d2d8"}, + {file = "traitlets-5.9.0.tar.gz", hash = "sha256:f6cde21a9c68cf756af02035f72d5a723bf607e862e7be33ece505abf4a3bad9"}, +] + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["argcomplete (>=2.0)", "pre-commit", "pytest", "pytest-mock"] + +[[package]] +name = "types-pytz" +version = "2023.3.0.1" +description = "Typing stubs for pytz" +optional = false +python-versions = "*" +files = [ + {file = "types-pytz-2023.3.0.1.tar.gz", hash = "sha256:1a7b8d4aac70981cfa24478a41eadfcd96a087c986d6f150d77e3ceb3c2bdfab"}, + {file = "types_pytz-2023.3.0.1-py3-none-any.whl", hash = "sha256:65152e872137926bb67a8fe6cc9cfd794365df86650c5d5fdc7b167b0f38892e"}, +] + +[[package]] +name = "types-pyyaml" +version = "6.0.12.11" +description = "Typing stubs for PyYAML" +optional = false +python-versions = "*" +files = [ + {file = "types-PyYAML-6.0.12.11.tar.gz", hash = "sha256:7d340b19ca28cddfdba438ee638cd4084bde213e501a3978738543e27094775b"}, + {file = "types_PyYAML-6.0.12.11-py3-none-any.whl", hash = "sha256:a461508f3096d1d5810ec5ab95d7eeecb651f3a15b71959999988942063bf01d"}, +] + +[[package]] +name = "typing-extensions" +version = "4.7.1" +description = "Backported and Experimental Type Hints for Python 3.7+" +optional = false +python-versions = ">=3.7" +files = [ + {file = "typing_extensions-4.7.1-py3-none-any.whl", hash = "sha256:440d5dd3af93b060174bf433bccd69b0babc3b15b1a8dca43789fd7f61514b36"}, + {file = "typing_extensions-4.7.1.tar.gz", hash = "sha256:b75ddc264f0ba5615db7ba217daeb99701ad295353c45f9e95963337ceeeffb2"}, +] + +[[package]] +name = "urllib3" +version = "2.0.4" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.7" +files = [ + {file = "urllib3-2.0.4-py3-none-any.whl", hash = "sha256:de7df1803967d2c2a98e4b11bb7d6bd9210474c46e8a0401514e3a42a75ebde4"}, + {file = "urllib3-2.0.4.tar.gz", hash = "sha256:8d22f86aae8ef5e410d4f539fde9ce6b2113a001bb4d189e0aed70642d602b11"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +secure = ["certifi", "cryptography (>=1.9)", "idna (>=2.0.0)", "pyopenssl (>=17.1.0)", "urllib3-secure-extra"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[[package]] +name = "virtualenv" +version = "20.24.5" +description = "Virtual Python Environment builder" +optional = false +python-versions = ">=3.7" +files = [ + {file = "virtualenv-20.24.5-py3-none-any.whl", hash = "sha256:b80039f280f4919c77b30f1c23294ae357c4c8701042086e3fc005963e4e537b"}, + {file = "virtualenv-20.24.5.tar.gz", hash = "sha256:e8361967f6da6fbdf1426483bfe9fca8287c242ac0bc30429905721cefbff752"}, +] + +[package.dependencies] +distlib = ">=0.3.7,<1" +filelock = ">=3.12.2,<4" +platformdirs = ">=3.9.1,<4" + +[package.extras] +docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] +test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"] + +[[package]] +name = "wcwidth" +version = "0.2.6" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.6-py2.py3-none-any.whl", hash = "sha256:795b138f6875577cd91bba52baf9e445cd5118fd32723b460e30a0af30ea230e"}, + {file = "wcwidth-0.2.6.tar.gz", hash = "sha256:a5220780a404dbe3353789870978e472cfe477761f06ee55077256e509b156d0"}, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +description = "Character encoding aliases for legacy web content" +optional = false +python-versions = "*" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "xarray" +version = "2023.8.0" +description = "N-D labeled arrays and datasets in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "xarray-2023.8.0-py3-none-any.whl", hash = "sha256:eb42b56aea2c7d5db2a7d0c33fb005b78eb5c4421eb747f2ced138c70b5c204e"}, + {file = "xarray-2023.8.0.tar.gz", hash = "sha256:825c6d64202a731a4e49321edd1e9dfabf4be06802f1b8c8a3c00a3ebfc8cedf"}, +] + +[package.dependencies] +numpy = ">=1.21" +packaging = ">=21.3" +pandas = ">=1.4" + +[package.extras] +accel = ["bottleneck", "flox", "numbagg", "scipy"] +complete = ["bottleneck", "cftime", "dask[complete]", "flox", "fsspec", "h5netcdf", "matplotlib", "nc-time-axis", "netCDF4", "numbagg", "pooch", "pydap", "scipy", "seaborn", "zarr"] +docs = ["bottleneck", "cftime", "dask[complete]", "flox", "fsspec", "h5netcdf", "ipykernel", "ipython", "jupyter-client", "matplotlib", "nbsphinx", "nc-time-axis", "netCDF4", "numbagg", "pooch", "pydap", "scanpydoc", "scipy", "seaborn", "sphinx-autosummary-accessors", "sphinx-rtd-theme", "zarr"] +io = ["cftime", "fsspec", "h5netcdf", "netCDF4", "pooch", "pydap", "scipy", "zarr"] +parallel = ["dask[complete]"] +viz = ["matplotlib", "nc-time-axis", "seaborn"] + +[[package]] +name = "zipp" +version = "3.16.2" +description = "Backport of pathlib-compatible object wrapper for zip files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "zipp-3.16.2-py3-none-any.whl", hash = "sha256:679e51dd4403591b2d6838a48de3d283f3d188412a9782faadf845f298736ba0"}, + {file = "zipp-3.16.2.tar.gz", hash = "sha256:ebc15946aa78bd63458992fc81ec3b6f7b1e92d51c35e6de1c3804e73b799147"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy (>=0.9.1)", "pytest-ruff"] + +[metadata] +lock-version = "2.0" +python-versions = ">=3.9,<3.12" +content-hash = "8e793db7290f8a86f60f35a23a53854f72aabc094d4ecde0ddbc2a9214165f2e" diff --git a/poetry.toml b/poetry.toml new file mode 100644 index 00000000..dcd755d1 --- /dev/null +++ b/poetry.toml @@ -0,0 +1,6 @@ +# This tells poetry to build the cfspopcon virtual environment +# in a .venv folder inside the cfspopcon repository. This makes +# it easier to clean up afterwards (just delete the folder) +# and to find the virtual environment to use with the Jupyter +# notebooks. +virtualenvs.in-project = true \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..dad822fc --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,114 @@ +[tool.black] +line-length = 140 +target-version = ['py39', 'py310', 'py311'] + +[tool.poetry] +name = "cfspopcon" +version = "4.0.0" +description = "Empirically-derived scoping of tokamak operational space." +authors = ["Commonwealth Fusion Systems"] +classifiers = [ +"Development Status :: 5 - Production/Stable", +"Intended Audience :: Science/Research", +"Programming Language :: Python :: 3", +"Programming Language :: Python :: 3.9", +"Programming Language :: Python :: 3.10", +"Programming Language :: Python :: 3.11", +"Programming Language :: Python :: 3 :: Only", +"Topic :: Scientific/Engineering :: Physics", +"License :: OSI Approved :: MIT License", +] + + +[tool.poetry.scripts] +popcon = 'cfspopcon.cli:run_popcon_cli' + +[tool.poetry.dependencies] +python = ">=3.9,<3.12" +numpy = "^1.22.4" +pandas = "^1.4" +scipy = "^1.8" +seaborn = "^0.12" +pyyaml = "^6.0" +toml = "^0.10.2" +typing-extensions = "^4.0.1" +pint = "^0.22" +xarray = "^2023.4.1" +pint-xarray = "^0.3" +ipdb = "^0.13.13" +click = "^8.1.0" + +[tool.poetry.group.dev.dependencies] +pre-commit = "^2.20.0" +black = "^22.10.0" +pytest = "^7.2.0" +coverage = "^6.5.0" +pytest-cov = "^4.0.0" +types-pyyaml = "^6.0.12.2" +pandas-stubs = "^1.5.1.221024" +mypy = "^1.4.1" +sphinx = "^7.2.6" +sphinx-rtd-theme = "^2.0.0rc2" +sphinxcontrib-bibtex = "^2.6.1" +sphinx-copybutton = "^0.5.2" +ruff = "^0.0.292" +nbmake = "^1.4.3" +nbsphinx = "^0.9.3" + +[tool.coverage.report] +fail_under = 82 + +[tool.pytest.ini_options] +addopts = "--cov=cfspopcon --cov-report term-missing --cov-report xml:coverage.xml --verbose -s --nbmake" +testpaths = [ + "tests", + "docs/doc_sources" +] + +[build-system] +requires = ["poetry-core>=1.0.0"] +build-backend = "poetry.core.masonry.api" + +[tool.mypy] +plugins = "numpy.typing.mypy_plugin" +strict = true +disallow_any_generics=false +exclude = [ + '^cfspopcon/plotting/.*\.py$', # these need to fixed +] + +[tool.ruff] +select = [ + "A", # avoid shadowing + "B", # flake8-bugbear + "C4", # comprehensions + "D", #docstrings + "E", # pycodestyle Errors + "ERA", # no commented out code + "F", # pyflakes + "FLY", # flynt + "I001", # isort + "ISC", # implicit string concatenation + "PERF", # Perflint + "PIE", # flake8-pie + "PGH", # pygrep-hooks + "PL", # pylint + "Q", # flake8-quotes + "RUF", # ruff builtins e.g. noqa checking + "T10", # flake8-debugger (no breakpoint etc) + "TCH",# type-checking imports + "UP", # pyupgrade + "W", # pycodestyle warnings + ] + +ignore = [ + "E501", # Never enforce line length violations, we have black for that. + "PLR0913", #ignore limit on number of args + "PLR2004", #ignore magic values warning, at least for now + "C408", # use {} instead of dict(), but we use dict heavily, for now leave it +] +pyupgrade.keep-runtime-typing=true +pydocstyle.convention = "google" +target-version = "py39" +line-length = 140 + diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 00000000..9e4a7b42 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,40 @@ +from pathlib import Path + +import pytest +import yaml + + +@pytest.fixture(scope="session") +def test_directory() -> Path: + path = Path(__file__).parent + assert path.exists() + return path + + +@pytest.fixture(scope="session") +def repository_directory(test_directory) -> Path: + path = test_directory.parent + assert path.exists() + return path + + +@pytest.fixture(scope="session") +def module_directory(repository_directory) -> Path: + path = repository_directory / "cfspopcon" + assert path.exists() + return path + + +@pytest.fixture(scope="session") +def cases_directory(repository_directory) -> Path: + path = repository_directory / "example_cases" + assert path.exists() + return path + + +@pytest.fixture(scope="session") +def example_inputs(cases_directory) -> dict: + filepath = cases_directory / "SPARC_PRD" / "input.yaml" + assert filepath.exists() + + return yaml.safe_load(filepath) diff --git a/tests/regression_results/PRD.json b/tests/regression_results/PRD.json new file mode 100644 index 00000000..e32ad68e --- /dev/null +++ b/tests/regression_results/PRD.json @@ -0,0 +1,1101 @@ +{ + "coords": { + "dim_species": { + "dims": [ + "dim_0" + ], + "attrs": {}, + "data": [ + "Tungsten", + "Helium", + "Oxygen" + ] + }, + "dim_average_electron_density": { + "dims": [], + "attrs": {}, + "data": 25.0 + }, + "dim_average_electron_temp": { + "dims": [], + "attrs": {}, + "data": 9.137931034482758 + } + }, + "attrs": {}, + "dims": { + "dim_0": 3, + "dim_species": 3, + "dim_rho": 50 + }, + "data_vars": { + "major_radius": { + "dims": [], + "attrs": { + "units": "meter" + }, + "data": 1.85 + }, + "magnetic_field_on_axis": { + "dims": [], + "attrs": { + "units": "tesla" + }, + "data": 12.2 + }, + "inverse_aspect_ratio": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.3081 + }, + "areal_elongation": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.75 + }, + "elongation_ratio_sep_to_areal": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.125 + }, + "triangularity_psi95": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.3 + }, + "triangularity_ratio_sep_to_psi95": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.8 + }, + "plasma_current": { + "dims": [], + "attrs": { + "units": "ampere" + }, + "data": 8700000.0 + }, + "fraction_of_external_power_coupled": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.9 + }, + "fusion_reaction": { + "dims": [], + "attrs": {}, + "data": "DT" + }, + "heavier_fuel_species_fraction": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.5 + }, + "profile_form": { + "dims": [], + "attrs": {}, + "data": "prf" + }, + "normalized_inverse_temp_scale_length": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 2.5 + }, + "electron_density_peaking_offset": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": -0.1 + }, + "ion_density_peaking_offset": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": -0.2 + }, + "temperature_peaking": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 2.5 + }, + "ion_to_electron_temp_ratio": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.0 + }, + "confinement_threshold_scalar": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.0 + }, + "confinement_time_scalar": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.0 + }, + "energy_confinement_scaling": { + "dims": [], + "attrs": {}, + "data": "ITER98y2" + }, + "radiated_power_method": { + "dims": [], + "attrs": {}, + "data": "Radas" + }, + "radiated_power_scalar": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.0 + }, + "minimum_core_radiated_fraction": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.0 + }, + "impurities": { + "dims": [ + "dim_species" + ], + "attrs": { + "units": "dimensionless" + }, + "data": [ + 1.5e-05, + 0.06, + 0.0031 + ] + }, + "core_radiator": { + "dims": [], + "attrs": {}, + "data": "Xenon" + }, + "nesep_over_nebar": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.3 + }, + "toroidal_flux_expansion": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.6974 + }, + "parallel_connection_length": { + "dims": [], + "attrs": { + "units": "meter" + }, + "data": 30.0 + }, + "lambda_q_scaling": { + "dims": [], + "attrs": {}, + "data": "EichRegression15" + }, + "lambda_q_factor": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.0 + }, + "SOL_momentum_loss_function": { + "dims": [], + "attrs": {}, + "data": "KotovReiter" + }, + "fraction_of_P_SOL_to_divertor": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.6 + }, + "kappa_e0": { + "dims": [], + "attrs": { + "units": "watt / electron_volt ** 3.5 / meter" + }, + "data": 2600.0 + }, + "target_electron_temp": { + "dims": [], + "attrs": { + "units": "electron_volt" + }, + "data": 25.0 + }, + "average_electron_density": { + "dims": [], + "attrs": { + "units": "_1e19_per_cubic_metre" + }, + "data": 25.0 + }, + "average_electron_temp": { + "dims": [], + "attrs": { + "units": "kiloelectron_volt" + }, + "data": 9.137931034482758 + }, + "separatrix_elongation": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.96875 + }, + "separatrix_triangularity": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.54 + }, + "minor_radius": { + "dims": [], + "attrs": { + "units": "meter" + }, + "data": 0.569985 + }, + "vertical_minor_radius": { + "dims": [], + "attrs": { + "units": "meter" + }, + "data": 1.1221579687499998 + }, + "plasma_volume": { + "dims": [], + "attrs": { + "units": "meter ** 3" + }, + "data": 19.79484837055445 + }, + "surface_area": { + "dims": [], + "attrs": { + "units": "meter ** 2" + }, + "data": 55.536257947812175 + }, + "f_shaping": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 2.6721853873123846 + }, + "q_star": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 3.2902757162288694 + }, + "fuel_average_mass_number": { + "dims": [], + "attrs": { + "units": "unified_atomic_mass_unit" + }, + "data": 2.5 + }, + "average_ion_temp": { + "dims": [], + "attrs": { + "units": "kiloelectron_volt" + }, + "data": 9.137931034482758 + }, + "impurity_charge_state": { + "dims": [ + "dim_species" + ], + "attrs": { + "units": "dimensionless" + }, + "data": [ + 58.37812639204965, + 1.9999999473503665, + 7.999453250480196 + ] + }, + "z_effective": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.343818980316905 + }, + "dilution": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.8543260261866087 + }, + "summed_impurity_density": { + "dims": [], + "attrs": { + "units": "_1e19_per_cubic_metre" + }, + "data": 1.5778750000000001 + }, + "average_ion_density": { + "dims": [], + "attrs": { + "units": "_1e19_per_cubic_metre" + }, + "data": 21.358150654665216 + }, + "plasma_stored_energy": { + "dims": [], + "attrs": { + "units": "megajoule" + }, + "data": 20.838369393350952 + }, + "energy_confinement_time": { + "dims": [], + "attrs": { + "units": "second" + }, + "data": 0.6623168189838371 + }, + "P_in": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 31.462841945222415 + }, + "beta_toroidal": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.012360853882996833 + }, + "beta_poloidal": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.19742242875250135 + }, + "beta": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.011632527455851185 + }, + "normalized_beta": { + "dims": [], + "attrs": { + "units": "meter * percent * tesla / megaampere" + }, + "data": 0.9297754847754564 + }, + "effective_collisionality": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.07443149734873825 + }, + "ion_density_peaking": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.4011372596580545 + }, + "electron_density_peaking": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.5011372596580543 + }, + "peak_electron_density": { + "dims": [], + "attrs": { + "units": "_1e19_per_cubic_metre" + }, + "data": 37.52843149145136 + }, + "peak_fuel_ion_density": { + "dims": [], + "attrs": { + "units": "_1e19_per_cubic_metre" + }, + "data": 29.925700679641505 + }, + "peak_electron_temp": { + "dims": [], + "attrs": { + "units": "kiloelectron_volt" + }, + "data": 22.844827586206897 + }, + "peak_ion_temp": { + "dims": [], + "attrs": { + "units": "kiloelectron_volt" + }, + "data": 22.844827586206897 + }, + "rho": { + "dims": [ + "dim_rho" + ], + "attrs": { + "units": "dimensionless" + }, + "data": [ + 0.0, + 0.02, + 0.04, + 0.06, + 0.08, + 0.1, + 0.12, + 0.14, + 0.16, + 0.18, + 0.2, + 0.22, + 0.24, + 0.26, + 0.28, + 0.3, + 0.32, + 0.34, + 0.36, + 0.38, + 0.4, + 0.42, + 0.44, + 0.46, + 0.48, + 0.5, + 0.52, + 0.54, + 0.56, + 0.58, + 0.6, + 0.62, + 0.64, + 0.66, + 0.68, + 0.7000000000000001, + 0.72, + 0.74, + 0.76, + 0.78, + 0.8, + 0.8200000000000001, + 0.84, + 0.86, + 0.88, + 0.9, + 0.92, + 0.9400000000000001, + 0.96, + 0.98 + ] + }, + "electron_density_profile": { + "dims": [ + "dim_rho" + ], + "attrs": { + "units": "_1e19_per_cubic_metre" + }, + "data": [ + 37.53973991173976, + 37.525773878667486, + 37.48390694669497, + 37.414232501660116, + 37.31690580091254, + 37.19214339685033, + 37.04022233407129, + 36.86147912430463, + 36.65630850443169, + 36.425161984011304, + 36.16854618978988, + 35.88702101569157, + 35.58119758774254, + 35.2517360542804, + 34.899343212629205, + 34.524769984176736, + 34.12880875047038, + 33.712290563546276, + 33.27608224422068, + 32.821083382500014, + 32.34822325460498, + 31.858457671353335, + 31.35276577280437, + 30.832146784137247, + 30.29761674771379, + 29.75020524616831, + 29.191315206719494, + 28.635808239756525, + 28.090872498795516, + 27.55630681476778, + 27.031913846826107, + 26.51750000949417, + 26.012875401202333, + 25.517853734183333, + 25.032252265702123, + 24.55589173059437, + 24.088596275088708, + 23.63019339188838, + 23.18051385648825, + 22.739391664703735, + 22.306663971388474, + 21.882171030318258, + 21.46575613521895, + 21.057265561916612, + 20.65654851158853, + 20.263457055094147, + 19.877846078365405, + 19.313144858739772, + 18.306469509218292, + 11.626327009971213 + ] + }, + "fuel_ion_density_profile": { + "dims": [ + "dim_rho" + ], + "attrs": { + "units": "_1e19_per_cubic_metre" + }, + "data": [ + 29.93008777129205, + 29.921121867704638, + 29.89424026876438, + 29.84949126169168, + 29.786955164570898, + 29.70674408613263, + 29.60900159085816, + 29.493902270806633, + 29.36165122595213, + 29.21248345519584, + 29.04666316058415, + 28.86448296761599, + 28.66626306486003, + 28.452350266421917, + 28.22311700110349, + 27.97896023237639, + 27.720300313552418, + 27.44757978276909, + 27.161262102621862, + 26.86183034946199, + 26.549785857541163, + 26.225646823319906, + 25.88994687536565, + 25.5432336153486, + 25.186067135698064, + 24.819018519509868, + 24.442913113607805, + 24.067691512122792, + 23.69822991352968, + 23.334439896391167, + 22.976234396621773, + 22.623527686651272, + 22.276235354907886, + 21.93427428561651, + 21.597562638906986, + 21.266019831227815, + 20.939566516060445, + 20.618124564929666, + 20.301617048705527, + 19.989968219192242, + 19.683103490999756, + 19.380949423693576, + 19.083433704218645, + 18.790485129592994, + 18.50203358986711, + 18.21801005134483, + 17.93834654006188, + 17.52688019511696, + 16.61331182624222, + 10.551012903566784 + ] + }, + "electron_temp_profile": { + "dims": [ + "dim_rho" + ], + "attrs": { + "units": "kiloelectron_volt" + }, + "data": [ + 22.81700031005393, + 22.794916213858393, + 22.72879209094119, + 22.61901119942156, + 22.46620818995649, + 22.271262994778876, + 22.035292388010884, + 21.759639330503582, + 21.44586024142759, + 21.095710365374412, + 20.71112742738783, + 20.294213788755364, + 19.84721733324049, + 19.372511326493818, + 18.872573500483547, + 18.349964619853683, + 17.807306788148814, + 17.247261748912724, + 16.672509429922524, + 16.085726968478994, + 15.489568442015889, + 14.886645511652285, + 14.279509167072204, + 13.67063273969366, + 13.06239632792736, + 12.457072753886544, + 11.857198932297228, + 11.278916509472818, + 10.728837253556305, + 10.205585679849829, + 9.707853386836657, + 9.234395784495796, + 8.784028982178587, + 8.355626828265335, + 7.948118094199611, + 7.560483795858814, + 7.1917546455630434, + 6.841008628350937, + 6.50736869646198, + 6.190000576260198, + 5.888110682115468, + 5.600944132026026, + 5.327782860020225, + 5.067943820617523, + 4.820777280858972, + 4.585665195636339, + 4.36201966225737, + 4.046835325082298, + 3.835898711955329, + 2.4361558507970544 + ] + }, + "ion_temp_profile": { + "dims": [ + "dim_rho" + ], + "attrs": { + "units": "kiloelectron_volt" + }, + "data": [ + 22.81700031005393, + 22.794916213858393, + 22.72879209094119, + 22.61901119942156, + 22.46620818995649, + 22.271262994778876, + 22.035292388010884, + 21.759639330503582, + 21.44586024142759, + 21.095710365374412, + 20.71112742738783, + 20.294213788755364, + 19.84721733324049, + 19.372511326493818, + 18.872573500483547, + 18.349964619853683, + 17.807306788148814, + 17.247261748912724, + 16.672509429922524, + 16.085726968478994, + 15.489568442015889, + 14.886645511652285, + 14.279509167072204, + 13.67063273969366, + 13.06239632792736, + 12.457072753886544, + 11.857198932297228, + 11.278916509472818, + 10.728837253556305, + 10.205585679849829, + 9.707853386836657, + 9.234395784495796, + 8.784028982178587, + 8.355626828265335, + 7.948118094199611, + 7.560483795858814, + 7.1917546455630434, + 6.841008628350937, + 6.50736869646198, + 6.190000576260198, + 5.888110682115468, + 5.600944132026026, + 5.327782860020225, + 5.067943820617523, + 4.820777280858972, + 4.585665195636339, + 4.36201966225737, + 4.046835325082298, + 3.835898711955329, + 2.4361558507970544 + ] + }, + "P_radiation": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 5.871591678614546 + }, + "core_radiator_concentration": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.0 + }, + "P_radiated_by_core_radiator": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 0.0 + }, + "core_radiator_charge_state": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 45.77499167746534 + }, + "zeff_change_from_core_rad": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.0 + }, + "dilution_change_from_core_rad": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.0 + }, + "P_fusion": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 112.79346348616448 + }, + "P_neutron": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 90.23477078893161 + }, + "P_alpha": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 22.558692697232903 + }, + "P_external": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 8.904149247989512 + }, + "P_launched": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 9.893499164432791 + }, + "Q": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 11.40076545330472 + }, + "neutron_power_flux_to_walls": { + "dims": [], + "attrs": { + "units": "megawatt / meter ** 2" + }, + "data": 1.624790256371358 + }, + "neutron_rate": { + "dims": [], + "attrs": { + "units": "1 / second" + }, + "data": 4.00000810164065e+19 + }, + "bootstrap_fraction": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.08515117576845077 + }, + "spitzer_resistivity": { + "dims": [], + "attrs": { + "units": "meter * ohm" + }, + "data": 1.0136457814443183e-09 + }, + "trapped_particle_fraction": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 2.377505168672477 + }, + "neoclassical_loop_resistivity": { + "dims": [], + "attrs": { + "units": "meter * ohm" + }, + "data": 2.9146805798816443e-09 + }, + "loop_voltage": { + "dims": [], + "attrs": { + "units": "volt" + }, + "data": 0.1509719887879264 + }, + "P_ohmic": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 1.2016139539804378 + }, + "P_auxillary": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 7.702535294009074 + }, + "P_sol": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 25.59125026660787 + }, + "average_total_pressure": { + "dims": [], + "attrs": { + "units": "pascal" + }, + "data": 732028.9793275861 + }, + "PB_over_R": { + "dims": [], + "attrs": { + "units": "megawatt * tesla / meter" + }, + "data": 168.76392067708971 + }, + "PBpRnSq": { + "dims": [], + "attrs": { + "units": "megawatt * tesla / _1e20_per_cubic_metre ** 2 / meter" + }, + "data": 8.206676168550032 + }, + "B_pol_out_mid": { + "dims": [], + "attrs": { + "units": "tesla" + }, + "data": 3.0527119151332296 + }, + "B_t_out_mid": { + "dims": [], + "attrs": { + "units": "tesla" + }, + "data": 9.326504089901384 + }, + "fieldline_pitch_at_omp": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 3.214648364176006 + }, + "lambda_q": { + "dims": [], + "attrs": { + "units": "millimeter" + }, + "data": 0.28326855346030794 + }, + "q_parallel": { + "dims": [], + "attrs": { + "units": "gigawatt / meter ** 2" + }, + "data": 11.460018573149283 + }, + "q_perp": { + "dims": [], + "attrs": { + "units": "megawatt / meter ** 2" + }, + "data": 5941.561499571544 + }, + "upstream_electron_temp": { + "dims": [], + "attrs": { + "units": "electron_volt" + }, + "data": 299.12304931555707 + }, + "target_electron_density": { + "dims": [], + "attrs": { + "units": "_1e19_per_cubic_metre" + }, + "data": 44.86845739733103 + }, + "SOL_power_loss_fraction": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.9639674438709462 + }, + "target_electron_flux": { + "dims": [], + "attrs": { + "units": "1 / meter ** 2 / second" + }, + "data": 1.971000727006153e+25 + }, + "target_q_parallel": { + "dims": [], + "attrs": { + "units": "gigawatt / meter ** 2" + }, + "data": 0.41293376247700014 + }, + "greenwald_fraction": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.2932901530528177 + }, + "P_LH_thresh": { + "dims": [], + "attrs": { + "units": "megawatt" + }, + "data": 24.59383938922551 + }, + "ratio_of_P_SOL_to_P_LH": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 1.0405553139384702 + }, + "core_radiated_power_fraction": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.18661987651456066 + }, + "nu_star": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.023749179486475976 + }, + "rho_star": { + "dims": [], + "attrs": { + "units": "dimensionless" + }, + "data": 0.0022127891680210022 + }, + "fusion_triple_product": { + "dims": [], + "attrs": { + "units": "_1e20_per_cubic_metre * kiloelectron_volt * second" + }, + "data": 45.2791219241439 + }, + "peak_pressure": { + "dims": [], + "attrs": { + "units": "pascal" + }, + "data": 2468918.97623166 + }, + "current_relaxation_time": { + "dims": [], + "attrs": { + "units": "second" + }, + "data": 16.361532562672082 + } + } +} \ No newline at end of file diff --git a/tests/regression_results/SPARC_PRD_result.nc b/tests/regression_results/SPARC_PRD_result.nc new file mode 100644 index 0000000000000000000000000000000000000000..c00afd126bb0b98cb54caeee15726601060bbacb GIT binary patch literal 2946296 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

CF_ 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

VVF7m!V>H1ZZ=c7n|9y0_}ZtQ}t22 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 z%0A45O3KJ;kQq{GA)-)1}WwK!lh+NM*m1BDjL^vbn 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�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≈S^pn&?yKPf61zM2B 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 z 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
kD_5g!cXPrxI6sp{f0Ssr&7w-8P-+6 z|6KNGQF^%d1>hTs|56oBV9uB?`g+J$c!L%t&v!Lg7cH4PC1owvfK* z57xGSK@IXI7|#k1PE5ylvUd7Zks0vUe)!TclAJ{b0oDiAMNW|Zgj9>{a^(3P<22^} z#@$r;hMQUT;M4cr%NJgkO1ittg9C>D(ZaCIJgXpaysP4ck+&=w`C{2-V)y*P!Rpz>TKrwMqIe2X@AA;Oex2~Kxhm-`15Urfk$=$d zA6bmw;JRx8KXG7PW%e&6^THCp*&5(S1VWE!@ZdY~uFUtn<3y%SZalnIab&8w)>1GE zbx1iGWB);sOn7E!J2v%^abTvfb~$oKJB=-K;QuyS^U`Nd>UHQ9eYx#((MOiGO8?+T z9&E!bzp97m=UkE5nQ&q8>= zVNNcPRgIbwL!9VcngTyHh~qqc$#LMnoP|9yuNDKh98>E}8}q^*KbHD%73SbWTLdhw z17BHwxozbc0pP-K7|UM+f4{5zA~g!Q{r%Mz zImQD|G`}CJ`QQdItNXVntsNnz(bG4~AEnqk_JpMTI01e2vz7cCuxH%8-!khle736` zFPBV*ZuHHjkLmZ|U-SR`JnKy-=}o+vCa~lS^oo}YRQy38T2uU%w)9pz95v@~iwP zc-zxwZN9?icHDEJ)By05HGMtT7lUV!So7QzdOg;Yr#`Of&|e)r=(k4}{0S@V`DIrR zqH)~<`Hgl&7o#8jISf3-rTnF=R|fnC1EUdFH^UFow5Kl+K9GQV*lq~dMsD?=zG*?8*a!V;dU7UzlF^Ggm4^?3 z?^=CuIqD1l!7bq}`eL}-!qmCcF)&2Ta;h=TDM9|I`q{QNiIV!2|3nQdWvPr#iVQbD*gB| z8Cqz#LR@GG^jCW|kA_ceN|X8M=7&UZ@geKW=PGV(s* zSN4CpAnhHIg6RAEG+y2`B+kIk>CfuX&+ogQywG!+qaOui?88^_ zZ_y(%dfs+7OG1{6xX;+rlAj}2rtjRUPu*m=g!l1Y87}U2ich-pUPQjnjE8xwebDo^ zYgeq1BZj(P=!F?ei|gJyJLN-rt6}2d4e2dJo-ISnJ9V-d^JR z>FA8bM&UhM*khT4@5iJuWbdg1(4EL$ivUlh$er5Jb!w5k#RM%_%(uTf~=h)R?dJy_i zzsF5O{qUi?s$TNPysN0#Q4_>N250k^jGsnchQ`aM6W9y%E6OT#G=7slOMZUuI&ac@ zB62Hq?#@grZB<}IfxZm=R zh#QlrGgZUl_x8(oesOFjsPF z8=GqPW1mS{Z9lNP2=f+CNjnqsulk5V!c*Y#L)LC_yW^0@p`Nn?`J3#}s@1AJ(8=jZ z?_{QI#=ah!$9ES#_59z>xmjw+adD=R9)DSl+>`z9oj>pB^S}RD6v~1SVlRiG{YV!tSi;CH0wzM>R*MX{Ip$EV^Rwb?Qf9XKtRAK-`r5gJso{#EpDid}9Rjl~0Y(19dCnTIp5{ zpV&p*g%0|;O}xbA)q69i!5zMlZw13m*xxT^>)i=MAKB>^!O-I)4h(?l{2uU0XH6)X zy#_Dr;jDWN-%D&`c-e_pz!^s_SGxi4os_sX8vBx16%Jh$QFh3idwWj%6m)Vj@8c(H zE3l`>&eTf01l(kry~LCOB88)Zj1RrYkvp8!?kGa$Z@T6lAL=A?&E6d@&bXVizjbv* z19a6LC)c|Dg8oN;ZfRt!6zZ}3XU`Pyv*SXxi#N_BV^>?wd_55|YW(}2*S3?4^rmHg zx-db8XC2)g`xAldzKA*%B}L5mJ$134pI? zaLX|C3POgT%QNSY{t2U+U_0c($@jJJTO#-B@{$iFrpCyH>;16Bqnvc7X-Mly-y_wY zSECn^&%kY(T4Z+1o45_dzx&V4ByMfV&bk;!;+6}($cj6R@8#a`pe_D?+-QY#3iNUz z*|TKCG%$ZX9-nUMMqIsoQ=?hhs4GmC-u45MUBG@~wJa_3+#=IM)YPV(kT<~4_ zzbcnwUzxStcg^SB;1{plh}aICJ~@d$LmKn&$|W)?&ftgnZ*DM%+7Eq-Pf1mfHgZm! z7BsEWAeKV)NB0k>h#ocw9!y?Gv@6%%^5S*eKR7V6trh;xRK2%ps}7NQ*NSEQa)aOr zXaBtF0{-JbTfzmdDw)38ZTcuz1oik>{mmBm?g>%KZwVmd(bniB?Cr+uR7>`KLw;iY z_kf~IyjR-t9jf`_WOzC&Tt*!}9Wf^->vi$Oj4^p~dMTIKI9U1W6t6VhO4Zde{yXS(a%WU8DmI_t^%!@M9^&E%p{+_@O=- znx70&zW?6AMU$xE78pOSeGBD3j`01^o^NXvUM$BmJ4b#4nl`@{8?30)F(0?DNwn(QUp3U z8E$;L2N~U-?rNO9l#CYnXdTEzE^ns%fQYIr84AlSz3R*hT-Vk{uwXhde&rszg1g*| z&?#NQip$Ah#OqqcuMRTUQPO053-8p=7mM#pTqOO-=HTy9(DlsNx!vF0gY;5c0{;dT z;x35JmIb^er1L%hWZ5~qSIr0CikJiwx04xItp|U>+ZWvj=e;Fvdv&M!i3-%E*Q}ua zA#tnS1ueV|5%-+le!T|+#67m{m+rs<;s&U_6XPsJe-ApLyA1tgzN_bjO-aQ0Im1nJ zWg+y|CoI(+u*av$27VkI0Nz-eh}+V@wa#AJ)sMc>J@l^sp#|`hCze}|vY_|!YnrtP z^Y84w4?V14=uyHF&Syn|H?*1_`BIr!>PK?~7oi^QTaSGzvn7gByw3F7PNd$J^{-ik zEOPhrs9!=K|7!7IZDSmn8`hr_`~e>1h_k)VOMNnZ+ox~(2YFZw7yaEUEm4oOJJZdg z$awhJvxg(NyXK_aeo5JZjA}VI(AabI?|S&|rmY7EXXFEaQt?m42cn+&#IV`WBpk^Xnr@+V!bq`&jocGKGd z*j$Xkov)F1qR98s?W$RBBOgsVeK&aSFq}xW=39QjP4tT|A7*$uH4yhx_?P&{*e|;5 z4a#q6qAuP~9{XXwZM@Zcp??s4Wy|xh^S}S=^YeM8?Zw4hf*v~1927!cdc0Ynb==GJKn73A@(JQ zsp8k6NAU_?EtvR%*mHt8ulfav)v|xB)GFwLA|E;AYhMR$5-Y<05;*Ux4@wNQ5G9KE!uw2ofjMuPjO*)X*P@VIr7^r z0xo&Jhfiv!<02wk4BSp!p{?=z;OpbOw$|n21>SW*>aBG>aFoEYIeicC{pihTc2$Xl z4`J_62j*dR>5fyKf~b$b!ex`~-o#cqf7-|F7_nN7L+XX#w>>l?=-E9(=-oL3&8j0r z@8{~}gti0ctz$}T1CFx9Z)bVMd-w@sVpDX3$b3vA%d9$$%q?B{nCB`>MSx>S`Rm6XvqvX{p35_^9vM z9glZw;;>pV{2_ja-9r*ffJf$Z>Di+XN%+jZwFPrk_sGq)Nv`lC_}kV0himQpS}7*9 zmpH~b`XVFR;HwJR7J;{kebspFD4}m`3w?Ab5;(l-u?)$9FVLM9=*_ly58Q-z{jCJ( z8<}-qr|&pU)GdE@GKBRE;qY*2z+zQt$|A;O5Kqw6L3-^_#QFVXZ-5POCy69ofX03 z$mw&|j%;&k1RuB~^6p0X4>p`;FdCT$vTNSf<3Kw>SqD$4PPcgraB@orlsVW z#C#cIm58ppxfXh!_yyXzM&QZ){;e?wuE=5+pLGmZfM1Z+P`z#=a{HR+6+NCqbjR^s z5 zCH9^o^QET_%QGK>NB{A1ksS1KoBJ}d40genzKK`w1M=Nd{5P}%4>4UdDy4h=JDD_0 zoY}n*ItTZ?G2)~8z)=DN)}#SPIr(@Rv)YG@nI~n%O^ktWHSD*`o=!%)?bH`7#T+K5 zH+xGR?jzjZvRdJnH16PzOmlX_ePZE8zt7_Eja0n7y_gqw4L2}1-FORq@AOBvwS}Rt zKKg^A?VtnNpsph~HIEi8P%a7Bc9+@=3q4pKjrz!1 z-;J+8pZF|Pl6sYo=-R_MH?6RD9Lh=3;)Tw7)oI2*trtYHukPN-!JJ#)F|^gMk1TAT z52Y>rj(zZBgzGZQSDwc88xn9Y@~dNEp{4?v?bh{JoQ%6I0{7<_N}M3mlTx}0t7d=? znI+RMx|mFA%UqJmmLunVBxSu!4;g=Y5>xxz?J_UQkg>z%fy5mPyV;Zy~E z*1h=k&Qj3%E{#hqFMLD>a;^`bov$E`CkZNi)??5g%&=NIiuYv3(LTun><|32wgsPS zgpM?O%83n_M@Mv&)~&*O(%V`Pe-?FVi|d^sCrRvj&#f;H4M8`$UT@}#n#NQc#fzZPZbYwGQjDV{fN61Me5GzanSI_62 z#0q$AcXJ?>SmvzrJwD)}gu^E*pMv-3IIFn2a0hgX_m5Qny+E`@(D(Eu;8!|(_B2hX zk;PXZnM?_4tu-hWV*q3TO0Zz zB$!Myhc{o_iGH&1Pfg7w=;Nx|W@X+_#{I7y3$lTC7{7ehwgmbk&OPW~w;8hX$lIcqg?<2=fzspiFcvT%~9KQReED3#=ec)8#-&*X? z!@OH%7eSY3_PrOmxt=h`*UzjipF}>Xn^_K#-`sP=_#he>m zreiGXK(y>+#Qa(EMAK^z^)2Tii{qh#ufR`Q%nI03S&BOd3D3q(S?(b7nU3ng;_hUY z{AHPm0QB!taXHOw=o(HfDVNB@eyH+T>QWc-m`dFfBsJs6#PsFwRg&->JYcx%{FEl+ z^;S1Xz*Nhjs#Sh=ToNZY^E$RR1Y%D3@a7E* z{&FApC{m=AwuBPX#YF6Ygf{k+Ed8w$2jM>`61NrIN(}AIZkgrSA9GHWZ0QxjzWCSd z_0Sj6m@yE?QjjH1-oM|+@)W^a*lbpmI|Ce0H{HxKjyNYO7p>%AzmDmM4_q}LIShH- z7o`@UPIAIo^8<*pYURmmJQmQCuDvnxdO60v!&1iE*vK;Mtxk*?o}+>A%+iPD%jv*L(8z1!oU2R`t!P0VA=Ipp8$@$tlWBDL+;58c~D7WW=SZ&J7mUBekp z=>9A+zao?q7wQC?!n=}aV{PQjh%}ciJpx~0LRfiwCz<9rZHxC7CR640C;N&Qkx70E zpOMQrnW&F_7L{%#mQO~&y=C%c2Q&) znx*vV{WQE&ac)3jwr{{dgw zVR`5azI%Nq$ec=_l6q?fLv|dz_ao~MqZZ&X9>f~Pz8Z$!ilv!Zh4-p8XIHpe%TcM2D&V|bi=rDD{+*}FSX9g1CD!X z|AVV_=r@0Es?EUrRcPa}?LXf_WKr8L)r;_pFhBB4;=57cE8L)k{qNJlt#faE#dmT$ z>Cr3jwqc(Vk%R#HHq_?tnf{Rb;GYFYZ$0ZZ)kbeL|*+ zs#5|rXOhX8C5g>q(~%bt<&qMLJdN|BQ)6wU$XN5?<`A=+n1joYZQ5)LUZg6k1G!{| zk6M0ygSgGmbyzdG7rK)HsV@!Tp1@P|B_DWVUy-6Kp@+cd7U_+TZFb!4N8l}b zrj9QtL|=K~_DW+7bcszWbJs5+;DlaB=5j^x9nF7Hs&Ef@;r6t&F$LmyZBSu|?T7Aq z{M?V%O5mSX4!+Od1KvC=qQI&Kd04TY2^&M;OGsBM+f)V~>c&&QWDffM%rdt&F20i@ zkFr1DIqsF7Wu)P|h-a*N^<0ctcCKc=?0#a+WGSATfqD1Q)LkNL{IL(-4O7sPB4S_Y z4!#Hf!Ptp^{)vKQv9WU1Kjb#6lc{_cxp zv^aG&72Y7j>+3D5vDX?dWB1(ofIiX2cKCt*&-Af-JkKi=_?Bm*zmp?!dIO(DTxmic zP(bb7@n|x*>9{-n^bzE{>*{@XTLFE;U_f=bC#i?sFU(Gq01kNcL&9(D-BLxu!+vXt zD<+ZQB$$VsnTGtp`WeLeUGEy((286piHT~(v&3m@tkYG6{<`-4$KuF4c<;95D7|x-PMWZxieiV`!}%^Z@*bR{|V9S51W8Z z5vBfW9C8XHvendXdC^ZaHEYGE*8!NbzAZ1t9AN%-PothvKbc#%Y)e1?gv_d6%T0?z z{*Ts)7k1$*QI9W!wJ&imWKR3Q=*d1ZNnM`tcrSc9;`)PD7u4WCNLsi#AdHM>+m`E? zV$MzXW~3&2!Pj{&IqW_9#`%EO^VY!Qb*z_mY9*m>IJmtxeM-!g5l!AUz){}SZ?HYq zMvUzei!UyLZ%V*F1mtI#c^$~qobh3{OT|Cd7x^b4g%!m2xv2auYnzU1up^ZuLRPpFV)US|=9=g|GGHJ{**)2Win zU5fAInJBBZnbxx|5kGT(twcRAB;2i3tJ#8>a zV+Q(2E-QccAm(4KRq}fkh+JAuIe9^sC2~pi99NGlqTWbs`JGDUpX`LsW#GMX$j{5^ zgCFE}%R9A|@ZB!CEqH0OIGLXHul#l}mP}>piaQ)C;a|HpRTH`DCPJ(!&hZk^yRTx> z!XPphcGH_YSUyuJL+u0V<-7da*h=E6_02nNg+Dht zwf08Y7koF-_VQ}os7tkejk*`UmzB*gZ=%0s*oAIu!rT`8{7Bo(Z_r_V*H2?(ev_%) ze5)0Hk^VK0lBJ>ZDSw)MKLq`K@2V5U-XAaz4?b_l9K)W{a_>*I4Y3+Th2L#-Csx#B zYp1usugnY-Uv)!YJ?_ODx(<9)(Y`rbcn%P4ytw${5b7f}BV4&(mn;%5m^f}0L~b0z zrf%&dnXj+^b}%pixhCdbT8nW9OfS>q`CIU}XYbim8flZMRCQ^q6z;afc{SzMe#1SA zD!sy9IovbKf9b5$M@E0=y-li0C!>Ay^D{3(SN$*ZNlWKuGCUa03S0+XM5snARHurV zskUi5f}xXBR&x(NzMmK+=6Vkzkn3l0NL=N=Jin*I+G}2Ul7Y{jv2_;Vq~EM!-^qc# z;YxFi|CwS^pO$bU)ExMFm`DdtGVs|@5r-2;z~2T5j|f}eB(C=?lY_Q+$DHM-O^Q84 zZi7igaZUkrayw_wm_3WQk}reP-tGauzGGLx9XIqD7qx%N;Lpp`Qym2Th;!8PiJT?o zwGELkd_J6j{@o?w@AP%(^Iu&?16_#SIYr_3Poycp@e0^Y=9rnid_)Esn zH9T*B+ii?KpS0@Kn`H2W*1qXmyz$-eQNWyC8?m?Z>{&ncCicTeR}Ov#t|H%Z=z$7! z?%4r-0{&~seA3!KI|}+AFLNQM|Ma{MjOPyeGmFZSd_(GThwDj_D#qOcQOk8A4S(4PX+tME3(QaEmAf~8TaDi zp1UM7D|;kDB}G;uBQ%VnL_%bjt%%5sl95zGcFOJ*sVKkm`>T)i{_)=DKF>MlyN=FB zPkeV(7dMjk1xR6EMR2MVFazSBf$m-boHxS09CPpr0V1dNU+qcE|4ClnVt5z%T;FtBJ`y;X~Ihj!Vc@H?P%&-i?7wHHWFDu3+Xa18Ye@vY|uwSj)~ z>XtL3r9i*#&UNodJJ3Vae9qbN0{#5DA!{?@@(xWLyJWW`PaEf3XpcH9h4ZD3H;~um z4cHY!=m6S6rJn3N><3={hWd>6+m?+#788kqYt5W`UmR8C}Z*C_G&nfq<(Vo8!-dQv8NV?&5*a{ zG`eUc83fSKu4~IhL*Dl2pu`>IrzBWwz7326IZyXeyL&&7Su^z4Dyu;2l$4)k=5x^O zdh>Q=+!HiaL$9oEs>AajuuX48ogCkQ#O{!6AYC~=FXQNq`i7cjhkf@!-Lv0>=7sOn zRPl|Sn1`ZvQa;}oeM+id4$HT1M!n+6`On-DzCfH2dSPEgMBMj@NR}W65dKt07*w|d zA#ztOb3X2u;(ya|X6rZ9oizNJEP97IiwiAIImj2@(cVDW8WS7KjDTEj`rp1MX4P$TI9^!dxW{UZz`ZxKEB0QrK}uP7nD)Exm}_ zhfyDwvv0OJ2lb;LDy0^2?yzZiIx4dtR6kkmJTZv;lvUimeGJq!3?4J59xcSZQW+tN zTZVuzb)uYRnF$2%n-s%#+%L6ZXPsT_LDakd{AayK9#lkk@V9m!2IZjThm1a~=Vu~z zX>N@I>Bnp}PfsAf)SM-0P?`_)#>mo*NpV1bu8=Y|iS@lSv*o`kI?yvG)BJ-D;Qe71 z37v=qdH~Cdx0k?=*m0PTK! z>&znd$)`qE%1T2~XVTa?Z-Bn(zZME5Ywu zsjQ(LC{L|!yV-YPF3KM<&!I;^*{eU{%Kr-B-9@*<$vpt!kNUg~c@g*J=y~}VbM|Y~ z2)dJdfxO+ZL2$p>O^s-A`Cm8jJS@2$nj#L*tzrI{kprY4 z=|TO%yP!VL`RP;-71WOpeArore0pE_qs2ovac}3(aF@SV5wDWyIq(DhYX(eKm7}3R z>RWL=e*T*&CvkgsR18(^Dk0B|70ZkUE>+hdxnf29!37VO|rb! zbSvsl4onR_LtZ3jgX{r))cwTfXpJp3p{_x}|KR8(&`lqwKGNL+^n(XKD^#%no$YO< zx6&1?^EuP{BZyNLy|x@|U;)}Ci~mYQP%o$Lk-+-A9B~%exsz54*l(3O-`t9L@-49i z@oDU{40Dz@&9Y;zxa0o&qIf?VeEmEv_uzcUTl;o;1SqoBuhnkmVc#1lu5yeDaQ*%a z{g^8Nak{h$?-99Gz2fKuE0Fhm+x5J^9&@o+B6zED|MNij+lZxk+@E7esVYgt^Dy(S zITH^WoDs(*a32{dpxaJ4K^Jjd3BHA)vxr-Hhude`qdx92Q^N*9%>Q{o>RrWr-ljBh zaZ$`Gqo^}m?_mRC!*!s4JEK?j`%Q~v+%FX>FMTXi5;TVf+V>&+rAeL^ z)0e}1fGll|CDf~EY#9n~iX8=#Z$|yJ7Vfv5xV%GoV;iWOpWGsh`4Vccw9l*z;$BLAU-iH`b|WiEm6ue-DfxAhUr>Uu6;nD=3SZ|I|V9l zR8IV)ID(3$Y67p#ZtQcjzI)}I#bkw&r@WSU9*XB{Id#WD+KKLDvN8mW&BUh#>(anr z+W6`E$&)}|JDw}J8+r5pZ1j^Ob|P=PT;p82gy*835fHZ#=uZg_9=jK@zO1bJrpV#@ zb&L09H1=cWf{mo}c+d9VPlTSzFSlx+x!I3oJVdmk2wNO zmhao){y5~(*JQR$=OVvSKj&bE{nyE;BLf1c2ioKNSR@B?gWgwGG_nQ&<=O?Fk9RNQ zKGqK=OA^%B;|5j$WzHjh#x@Rx>m&6wjTL5 z&>UUSD-PmCf9HwMhiZ`b$WqWVa>VoCI2_=nf<7tldyf@_H-h?zP*nP!zo2eZxOLSH z`KLzRr2dUqM~K6tY9iR@me~GC%k#o~#WE$zx4SrZbX$-)#W0^Y&#l+`H4uvA8uEH^ zuavSr$8K>2P2n>QHj~1W@lvZ!_OF zXNr97qw1djc09s#J*VL-(Qn)GobVE2X^{BK);)*)J|bz^dk&R z#+k^YkE)|&mlxt?L|xbSC3p_Md}=3h@x6NL!!hn>i+PuxvcE(`QO_G~(XsFrC__It z=1I&W9{(Y?Ve=&NiB=`DZeal5ACaAnodNFu;{M#5fjMO!M-m#5pBjnDD_O*SMoPuE zQrU^1b^YQT%@OloCkBS+OwbQPt^0ku7kvj=yh``|>7c>(Vm_fO07&PmzO!PUgZjX< zqr)A{&CsQ`H3eCMT1_c0ueLYtQ56sB$InwWH@fI_6({D$eY!W%fj+6U)p(OB8`SfT zs}9iWfshdzF{jB21j*LM;BpbvSLa3lIk3F` zQhddnAgy|QZTFRCV90vxmfv3w3~3q8(*6cu?6p7kENubLhu2hWA2Tpmj!>@FjRAd; zhZKGdu+DhPPRiit|2(v2Jr(a!ilP1=JDlHr=K9ZFNddaP-;{Bu9_p=G&XQ(tAs+Um z%-tR5^{Om_eQXT+rWfObhx33&Ycj8L#(tPteeA+HIAvEq7J_rS{i=I466tztLOx9BfBw3< zX{P)rkk$NsmzPf=4^rYnJc|C#ud(imU1ZRt{fk*@&&7FgPOoJ0323k$j__dW0+Pp{ z$Y-qB?|xj`=*^3{0E~TG?#{kK9MM~NkG~wKNq^v+c#b%3x;lTdAD+wh*cZ)Xh#%f= z`rC0_5{Ue-dAF{fK%ecc`0oa`K-jtE{GP@xP|1*p>j3CI3mM3F4R0cFH2@SYM28Y;jxv4m55{9ciR9sO>Y4dT>7{ zHNqoe!TuUhHCUs0c$Cq{Hc`^^v;rs@2mdHzE)nJE4vUky9sq0YzSisLlgjl;)=?`( z9#{K}DeBqC^D6|>>o>Yy$9Jq~qo#n%h>{X<>W-noP7oC~0O*Y@JG zN&!&iZms#UE`j@nMJ`vxuK~wArl=HWU3iftjzT(bOsQ?-%E@_V{L>&WZeuGF;%PC;!mAY1tz5?Tj>dm?y|IgL-$`qr|5;50VO+Lr`StinKT z*9nc%cO{@2H!E~@U^nXH0&_ETqj4_ZDEy^Q8wl%X*wn_PFzflT(NYcWGul)}e50m~ z`MhVXCUmHv!t*wJii~(}N{54TqdO@5x7pBX9P<<>=T4_xR0QcwmQRYqJ%M4fvF6?F z_rS1xwBZNl>N1S;tgt&7S-(aS_bLh4A z0{&@hvB&2C6Hr+1h`L%K&Rf#v#R$ND*K)6@Jzpr0SDz0|lk?Eu*%M${i+Ypf?nToT z+>bt=>Bg}K^(Kc8`EE3SkLTg8aGLA|8cZs?qmn-Z3Dc7VPi2F8huUlp`h(Po`uuG3 z+Mt$|H7`qj0cwJZvi<_vpn7$*|5+*S_gc^N`IjyV!~m!F9?3X&{Nz*IgYPiG=YbfT z56&4YYxllNVBTer(4_WqIH)j>*XQTCL@l5f#w_+@UOYX_O>9u-7tST3=3XCHu#WV0k)Gkb_?DwA z>yG!Nu+m`(BrwNDp6W(GoJ;;d)i-|3Ir%zqlB6*S)O7!=%hEV6nr-VY_<9DYn`af3 zbzT7FiDZpRk{sgi%PtCPeyDed`gRoeh`Gi0&8Nx8gKS(Trai9$lCxHgFV27JuQwdK z&5b!fN|GVGmrxg%o+ixx_X?fZ<2mYrl;3nhg}@BJZ^As&YPZ{;Jy$D@dw_@`=}*@*oXL7=~_<~vZolPm*X9YK1D6uq5_e25LD zE~piG-mQTl`!Q#XQX>@jcXAN@2aF@O$SYHLRkTR$h?hLuPT5_9esqUDDLQwH0GOgT z(7WW3CrlUI=|Tmq2ePiGO3#4i;zJc1Q_Qc{`Jq`KiTep3GS^1wdT)(yx_})gvVK8psqk@Z|R5zwR@k6+s;X1u1t$+WpE{^22QrScpm}cfBOl%=Pfb+ zD!hny4)qEX10B)-_uHNjyQRKZi2708V;U;EK*f#xaWM~l&+|+2bFFW1U#G>Z;TcCz zYB$Rh(fAIEO-f~a|L}hFuFU*aivq?Ky)}o+g}?~?LfvXd0LI0#qJ;Mqz&QJiuP|-} z81@^^P7T-tLnmRnt^GURlh8IZZ@|8Iz|8pa0ie%Tyc21y0(y(YspHOAHaV@qKKWGw zwdnSEgB{{1P8=<=yBvYaS2Fzf^#jzQJiRa%iG9`?z0$sS!9Wqr2wPjEAb&gMEJyf< zxVyO`T?ZQj7D>Ge;-f$|&kcaGk3Fd85FB-2mcil0IAlCtU|TePuEEG zXBW=z?_TN5sUex4?$Q#}&mtJ^?dM%vdA8@07j#I!o%pE8@y2}Eu zEdkU=_<5v6V1At4n;6V_0k)Jf!^fB>Zsoo0RsBuS%5I-9V#j>spR($59`2y2>$laX z?G2ts$~%jbUodYp?5dDt5s>T!GgaacCusnIWXvT|mzvXk({mrx;@KsSc%Xl9{qpMj z4T$TW)4DkuA^^k*#T{C*zkq0?qpZk91;YEY(;>x}*I;t{(Z?v{$9wYhum97)JzvR8 z=BfFhJaEiaTs{r=r*@y2KbsCpPa@|RBSt~7=;~B+m^?^TS7v(N!@l;u({>)}MqniW z_h<33IxylN9+{C;!*jX#lUHjKFnmH)N-a`>;m{DsmHrXyysm5HUkB{FtxIT?LZ)KORFhCDnZZPXXBl=Ga!Jq6U~VjOIHO@Mkf=9~668Pq%MoA9)}g}4ddv7HYvkJKk7 zeCO{Fpa{S8l#>%gUFpK3$GLxSpOJ=CMHMpu$9yo`Gt?{EvA4Qv#(-9ygJza2@=+@- z?t@RTuIq`9O89@r^Emm!Ukh=>zZbF!{#yr#Q-* zD(H|ljYhovw~nk-E9$TGUN)?_U`|8kq4LXH6@j$orL$`P2}ssnM@7yNLH+q|p>1zG zKz*;Zdu|oxT3+8CYeGTY;ZG_pwqY~sbDL_nVV^+kyOyDGy#jMHLRlh_>v>g=hv-gzQ zuYlA;wF3r6@jjGs>(jar$0|;&*fW|8jJyLWqscD7NEzglz}zOr_1s`WvI5ro`-!36 zG+NuV353?x1fi znJtQ!od*;XBC8I&>;5iPpi#T`E zcxat77c3FiP;)%Wk9gB^^bwZCe4tKHi+l6!5HCN`m2z(YsLxgw4MVUW%3wRKfOUcz zk$%(C^b_h5+scy`ZUgo3&7F@B1rS@PX z=D_FtGlN8+SRBh%Y26GIX+GgwUWgz5ocUf~xCh^-6|IB8o&a%&ix?3#vU2>J_J27W5MSn*r^06f1$1xl9d#S&FwdC#p z81sOH86=-vP#1hNxCi$Kt5v@1@#aNcsg1m;QYhk$>%I3{3{Qhr<1XIPZM+d<`St5`|vG8E4WPnT)@q{)ATC$+(0#m+io`y)CG=eW}|}c@67L z-&oZj%qQhKIOATHfq5I>VqW#){n{TsVqwgIbEB@L(?d3po6My7eLDoSN3j(<5Wl4r zuyZ^GAE0IXH+jtA-=_|*SvK(kErCkfSM?QW5m~29MsdFO+4??2cQ4S6hl~54djd2) z9&_6(cwUFEgQ zJng2N_X4QO*Ju(BQRqux_@-?1MSQ)&NOcZ?k~zI}7yU{Uk9BKSjwbZuupMZ9hCJ=R z-5p~uQ7_tLE?;yFb=8rtx_B?x0q7(=PT*0({^~<(!wGz^;;;NwLf(TcXqI+Y_#5V8 z31poo3xSqst$mPQ0%+zRR{yby8}%jyFFC6a&w4SEf5!rGMuXAE?#hNh`kYg?wG?yr zJ*BHvN*aK)$#KNC1#|cB>ev|VQO6wXzDterj-d9EqvYFc1E@Ll1#=8}gX${j%I-AW zBa$S4$(kSiJcK;eF%=pRKV)Z_*@^?ve@}zwF3jtl9joN4Ip=qlK72l z8Fh#y6K?YOJs%ee&kI(-d>DPnw=o}q_Q6;3FX>jCif}fgAO&k=J->b=sc~XoofCzOb0!{b~OaxOy3LWWugCwl85G?D-S6 zTYm$!qJYRHhWz<8^4v;z8qR&%Hx|Q9fhzlMk7{@f;#I39Wh|1ALOnJbnEyK=O)IhB&@kRy^^}lHXAGbKkgJQWlP!Ae3wm7Gl zc_4M>u1zhy#lA~2b0*pp)MqZe;TF0F>X$Ods!2ki&VB1#Oltz-DHP!^dtyONy`a>h zhznGETDdh&CSkr`oSFio330A9gQV9KAZD{h5mA3jq!nlsG5xsc|bMsXq5`;gv zo&dRHhuXRsQ>af&T%DTcOE4g`=Zv9X+dV2k&o>dHaQ%Q_lPgbzUda~NvMiMQB|OsoL*q$b|N0~KqX4) z3;IgFe^5N-4Ag;h^OkjZPl}X3-tzbi)L;{#7lki@syBR;WuF63w=K#32}PcEIA3@F zcbqeFwkrwg_T%0P8`9Nb;`-6Pk?;dx->jco z_+=nJ4<~lLp8~Rq&+H~8R@{@GYj$Bf&g%y_$FIh`LOt&TKGOR1L+TU02VJ=+ik(V#R@EyA- zJ5k{G9%!bk!?{}c?`6B5CpKce_*Xr0^(xL8T|MhxPhlUGrm(e$GYRwJzKT^wq+neU z2%wlFFZlZ{z2e(vpwy{8>Jr9xE97LMCN~#Qz@MWf8Rx)%*Oi1^u%D`~ku%j!#{CpB z{--_)0m!e9^2*p^t|Ik`ATJZ{Z&?hAyvGY#)y$Vf&x?VU(pli&&kUNy5|O$&Bd8x0 zRn4yW02+m69)~nPVIEVJ%gLIJK&qg|oZaLNB=xC4Co}ZlHa(obm$Dty4c$7Iy3S%w zmcoAV3lr!+nAc<$L4Ea~RQst#Lr{%T7Fgeg`o+BktoK-FaNp_*Q%XY;5RdZx?kYmx z!PN3ULn}TYm~l01S;IZ6vce87%7Y*~wt2pzC)A#zs2J|x;&QIkF zfqvpJoA3B@%qwf0Yqjgb^Lm^}IBHUOcCeCWa|^0~5sKTk;6gUY5SChK0YAY1&47{zRY{9eethHQPropRD= z7Ll*Gy`$*!+FRsd2V1tZhvA&PG(bAE0sa4Oqg?J$I8RWXc5d{*dvskQpcC^Y*I}CvNgAS(7YsQy_z&h zH`GC2x|unfR0C+18tAu8q3%Sw;wdfa=L3_%K-JVN@5TYtkB(nV z9Pme;$|tke2zC5K_Ga-d$I-Wz{@(j>BhK;6LB9_auY&SWnQpj2AjpQPAJs-Z1HC@? z^jG|x=ymmMAuNbPJ>!_ZjQPy;;u|VSY8z31rM-_&2z}1CsJ~c~b%B2A23w6WE6|-~ za)jaq5f9nF-BGOwb#WQ-;$nE;HmB?hN+BX|E|*220SZtr%9%8Y+`(MMe%;y&s1se~a(V9<4V21n z+>6VPQD1%aD%;Zp{MdP$UkPD7AI-56-i!EEqPu0FGQML+Zfs^riv#kX{c>lEP^ak3 zBm5~*7X1emmBss!p8`(KoiWRxS+@1;{9~LGC3D=bB_O_-+S&Ac0&}v20)lFMv3?}n z>)!Gcd38Q1*^p4|a})TLlz0$_-)7npS>S^{!q5N7Q?S1h%lWM+xgB$vvP{|55N}j# z&(7HK6NqhmZ9!V-1F`gM?7IF22-AJ9lk=UCucFi5a{mUE(K~)^v&f^@rrcE$ItQ|r ziu3dP5dRxjykb)BhdL6ig!VUx#}1t6Pre-w^tag$KKs4|dNaF?>-J8dmnG)hpGTf4 z)q?EY@(1Wwj{OmgAfVpoVP(*_S*$|_mR!LU%*}8qB%&UOwzk2YlZJKUt4rj{^txZN73~1V1txv>zLUY=`;{)bsls#x59x}kUiw_@yGt-$YZ!z=3^WoW1~xEkc~gkS6v@2v4^7G=WOe2KlWMUA$+w*Y){=VibQ^_3m0hz|H5<73=xhyG#TVKL@Gt_$Z558+;aUPkrSnSvOZm_nd z18s)y&Zmd?j@3+CJ@3GG>smm?I_?*snGTADT*h~8*MaQ16%OPF<8tb~*>Qdp8Tsn9 z3{;1|lo2}O@VoUpT9R%6<-@_y2lP|u(|M!fGJ)?FjUIGQVIJr9y6C5`y8-eX1%mdW zZqd@#=f4w)IEVDweBl2HWS_K)T2G8Ihv`O8;TLAm(mrmQK}9^PocG-?X?D=u7q{yI zFY117w_kU^5CIzO&zgMy!}%{%zkvGkJo?c6oU~3hU|zDk!8z`)ptj<)g?a@2IRWf` zRtk2Y`d28=!wGq+@Q{W5cZ1M(uJ(RU%x56pCGNW8iSL!TNA+zF6(E%N40m0wM4z+G zTm~$lo;Pv#rCeoD4*M9EczOwBIb%i1TaZ`U>wktSJOPY79=Tf)KVa-IjP&C`y$`oY zV(5k#U~CwFUYvwF-T53v`zQDw^_{!)-gXY(H=`3W<}Jw68jr4rBkmr2O;`>2Q@RzK zQD*uG>a8cLo+#S_ok`{D4L(z#z2kqqV=K-z>G$+H2l0H|zC_kAE2Hk6|B6Y+MW8Oy znl|i4eRbL09Z7ObnAf0?Jgkp(MDC!MRx$E{q{(K%c|4zfvC`GosaN2^%+PgH`|5y4_%`Zhcd zm)iLZLC_RU&dfo5o5szD0?D7wf(FwC-pWlYK=S|hSvu+l=9{SeUFWd@^)p*FM_WTs zUwt9BMg2GSRZfw4_pp7KdF5<{^+fetDjVqs>f%=3`U>y+h`u%Jxy@ymU&bjvxh(?q zKPhB>cfDmG$c5Yg{EmK{sQ(rmD456OmL)gbX$ms4+Be=Sz5#~jeHD%ksKX*fv9)_3 z?yjO!n>%z1bwCsA$|1tQ*nRx#X$ky$_SRpepRoV^u}|=NH0rYYf_#3;1Y^CKx|dvt z@7rB}&8L~z7oXRpZt=l)@UUTe*-ONAcQhOA@^|KPil z2S7{jYRuV}x_BNLfgy=qxW}`C_u?N4XhfGfTMS7d{(k-4kbFOo&MUIZHk||YuSv^L ziny<1Y1f0gKcF_~De(2@B<3YIMfiw3#{B9`ae+S)plbh5`H6}j@*?dd;rF(ftFiXG zbSu`4m8f%vEH?w;ihX}fZ7}NH{fa9D2SDYl*3`&B%t=0~!#D9H0%SVOqyG6IKWnji zxk3r?Tl2vv^I^nqjY3ApPFn$kK5NDG`x`I_5~>5aNx%?OK4SLkC*tekEn^!+@I7NT zku&&?@7UOE{^A>;7xfJNNBV#|(r=I2vheqI>Z=FhzXAQg*cAsc)L*UrUS4aX;~bef zcySefj-8F1qsQXAwRzh9VZ3^OB|g za)>R6Z_S%DS)K&S@vt)wYt@jq<#aJ#K^&{D%JPvH^600k%Va62TNFAv@w2cE$Tx(0 zq|6V3)^uNix;N%A88q~MB3{GucqJXIZwZ>ahdLTRrGUoOADXrF4M1910XJeEklY7m zc)QV;GZdfJQ-MC)W1Os1Uak^6P$0%-2qvA*HbN6?6HNpTb#0McSP z(en|`gHAuJYcNMf{lm7w;}QCxuFo}kQ405RH@_LU@)L1Gphk{#$AW6z@hRO~_d%5` zeDp*`3J@Dzk3ux&W#}k2{6#+>q1&s`p7#Of&g?8XQ~elJzKQIYJ&3t8LgaD9 zUC)1UoVbZpb(b;dxA1m!Cr4)DD*iVh5u@ zBW!c=sf0T~ntP_CvW)k`_MDuIAnHatcTP(nE}%{=5V&hmj`>(zX>TKO4pdfacdz{j zs-?m*4@1g9^tD~Jy9@+|ox|S&)cX=S_ct1HP;s+|d*O(4h zqYg-pyYXs{ASm-ByRHn`g3Ki^fyGN$zf;FPr9Va8LP~zId-EM&++L5H!F}wEYv1n5 zFpnUQemeOze(xD4<3)D;YsCBFW}=6_3dW(e^`(1`z~DU|#7@S!a5n!Q5%ZnsO*63{ zD-yAukjJ9#;Jk9O!R%&30MHeq8%Wo2j{noJSvk@hb??E$`{i_j7V@pDpY{T1(Z*Tmw0B6;ri zrLlZ~?hkt{Y~}z0ZaMFi%t9P%`MJV>f#_eO*6Z)Wdj3;zZsWoV`a4YuKN{g&UjCKu zlpX4p#xV_54gA<2>Gd?P&}0gQ5Cd-6g;%0gLY!!hw+= zJkEWD42(3&z7wB%fe{-kz&g~7=i=%2^RqkZfc|S)vB&p{Aud{T49`V;ySDCe#Jm2D z1-(&2U&#C9u#PMrpywSsD|{O3yPxuXrxQ5OQ;p+egGh*fy%{ktbpTpN+lC(De^^IO zs)bA;Ua$AYuf?q$dGx*Vd&>|nsg0I3TX_#uFG9erJ@?SZrc3-Ci+$F+#j~kbE}+lT zdPdYF9P!1H?G#7!8+;J?;G?Gw5H$9W)&By39pBO`Nsx3`iW8iCE_u1$M^G!d7!z!wapqd}ShL#X?CacQb28Rw2e z!4{&;J3%eyd>sGB0Z6W_j@5NwJnuQNUmtnfQqS*yOYrl~xK<~qQc6>J&Jlrh#4{#owq~=!P_n%&M&P^TjkLZyV>O;6sg>Jl`VPkRwdGue6Og3Yf zA4eMY#@snt%8sMk=03vGI{Tkl^?Dvy= zS=|fd0-1D1jXr3t3m)|A#`)YLl|KaYI5f)(U%I>E{K2n$Fumd}X!r_0sMCB7q(O_< z_Il`-VstnCG}?hUq91b;?u}F5r{+{Ifcd<4Sa~wYi0^WArA(MC;T#w?J+6ql(RE(+ zC66~i3_2}x2lFTh|3U*(3oU>U#<&*rdOPMT<#k2S1VH6hs+dxyD=3fGS{Yni2BkOu zO5-InKt?jb@QyIPPg7|g?ir|`{;G3DtnC0WMs&3AUQ_}`Z>IcTqAM_(?ec3emxWOr zA#~Le=afW=Dl?TPVE7wlnv$^}J|* z{a^2E5>TUu4ltSYq24_}{Z9_&G)$$%61dwC@4aOH8u@ODCdGQf1?$Dc?vIWujsVvT zj^E#i@0J2ttf0~#$VG&LIY*|7HD_} zKfQ^2gc~snR-+H3 zH!SwqWz6rZi`!%5_ZVaZG&NfM@%#V#?^2yN&V4Hxtp(Yr_xT>%lJ@IAU`)KabahS> z&&4YE5I^?CFOFD>RK=q%DCer-Hmn~}p=V#s;d|vgr=i7*bw+dj^ZgG+z~Fm3v7ChS z;droTS}NjPC1UJ-=27U+9lptb0sXp~AGla@4ghUkHl@i0&!v`0b&aJ3Xns*S#adWL z4vdmL_m}~7T)i`p9dk8q*Sk#2piiBauJq>*&VS!GTPp0e1j@a=l~1f>(4QmL!yAD* zhi{}iZ<2l@&YO2SP6GSgLjxa|ZbbvRY}4o-9`s8w3-i$CN> z1DZU(AKF^BfyVg_zR4pmfz-RSI^c#lq6Q`BH>u^AKa!&=VLHhEezH7l3hRC~7uu6&PMiuR5;Qpl>1f zZu^zD_-=8}S|~}OFY$EQ*SKR-XpX@vaBmHg>9T3BC>2ypHjHpaT%yF`@Ti1Q)8 zx*{8%OUMdv+RLJE>Jjq_=Dkv9tk$A_@5Wq>gX1d%tS7p5i5WvhK>5iv#+>y6DCrlh zyqo4R=dVtt#Xkgb#ocoRGTNin0Ir2ojw)eC?wy|F3WyQa=% zskdDL^@_nKZrie>Zsfn~N(JVqk8`d5H{pePtdTFW^$+pgvi+q~Cn^ktfeD7VUnb^{ zCA)C`(*u<;HhK`>Mf7#O@)7-Q0$HY+{XmcF61i(yin{j-a)T=3 zl>Ac^A$u;Mb>A`i9`O)y#!;8TL98F-Um^?z#NU5xj!9J83e<;0{+Ai3k2qR$aAe6C z@%ILc#X0nMW(72SJz)nFJwdQ=@&j0C;fdL<01*FLRI>jfAkom?%a43*)$GPy#;7}C z3s*fv%EA1Mg$p{K>3ANyT*fVgL6dV)ndKJZiDw)FvS%HTH#ef~d87j*rJ^k@@6b

t?+5_1&U&Sa_G7zQ=J+{^1R*`PYjde)>w3RE2~E=rqnV_xF-g{Pm&ai6Vaf#v&W zKzN(c82FzR>PMd|rC7{?%7-KqhHVSx!Aic~zxOLBKbk&3y-5P4BmvLt@JNszw__GL z#0T0EzptNBx(wQ4(Oy|?^Ps(3yXmB}GHCP2)6}|Ax4V9LbXd#`>r6&*h8o_7E}gfu zWSk3249}%Xr2r%PW&Vl;&h5@^zWQx=k5oP4qYcx6!P;};-xn^-BNy!7@R9-adsYU7 z>Ys?C)Z3oV!22V7uGPC}56&D35%);`9Lv}4{{z42KYg2F96hO-MJflURD!RI7Q*EUcG`BYINldQ>jZ+_#JVg8av(9vv^t0mR&lCojGtt~)m8eY_g^4vV5E0{VA=*cHep zgEAzdE+yRR4iD-T|8vZVD8o7Mq60M+eT40A;;w#c1Qp{x>vdx*#Mvj_$O_egQgpG8 zX7??S?j8TSwDBuwD+z`76#9bp!E9^UA$ic2IU2|ka~iaTh3kZlcYyX*L4{;uIWT@w zSpytU$2d@y%DQy~`(l3!GUhBXl5&%~PhSGYIg6r68^m2`nT1OWyRnXBJ0$FsMBnsf zkyP}n(zA@8wxREt?n;4Ag@=(>^j@ocP>p&;KACHpa=8DKF}Tmw3Vm$q@0Ky2nYK~H z@bwxQbwVNoeox*4)%J{BKl(4JEQHBp4QGK;SmMX)h&frN9HVkxhY@%8zp18r3?PZr zZMMy~d6gsbdEE)Y#t?I8lLYG0C99AyjDg)Y@TdKDpZ>g=4=f&>ei05M0w0~#^ zzGq6k1NVIJ{UR`TlEttO^XiW@$2#A-x?+TRVT^~9o4(p?07jtB?Xih-IKOM{TzC41 zxbXP%i?}D7{?$r7>+&bmS=V=d?Ct^jIWo)EAnbz={JEzdg}mYP?jtY74g)Qtv+yAH zx3ptgTl74Tr(#XozyBcCji+1X_O@sO_4w<<(`{JSw=h+n)kEEA>GTES9%1yam2&-O zW()B9`eo_!jR5zam94Ut0}9;6%}aQJ+|Z>{7JdfET%u<>0!={6{*-D-5AKO9OH}4} z+6kH*u`Zo8+fkROY0TZh2c(vm#k;!?*|Uw9FzssBgcp}g~mX9F{`E_SBHDPZallLs0xIqV%M&te}|xwIbch}_p0(Y zD7ItnlIFG?(u=#e_uzeU$GQKubvozHfIzeAd~=%#rPj>da1zZ8H>B~(hwL$*B679GjJ|> z`1i9=5Y`c$^N$X+qyGI)mjzg2U4N|BS&Tf^(;|~mC7jRw8@8!jL!67arHsXR7tsEz zv>UZSol4$UoD3HZh|0ZxgES0J_nlY5lbu6exTv(ELp;y1f<3}&o4ZPn@DV3;<79S_3K3j+D z&H$q-?Zp;Doaf`bw${8teE9gQl#WjwIFB^Z?tRC1>i6X<9OuV@{$j6_>vajt4eF%T zP3Qn!tFU>k8T|*prf#uvbYiY}p$ab>>K{)?{BYm%0%-hUcQ)oBZ(ILEZ6&J^sHgK~ ztX({D|G|d`ey+8M^A=^yK`&73oSR!K?gOmLGks~UMBY{}fDm*A0F2(l@m3(e{4(CR z8U4?^#wW6~i}5^O2i(kD!t+pDyFX_Snrzo}B)+YKhEt~Mw30vSt~_O>brHYX+rQZU z6!DVC?y&+xeo$M`c=6Ta0;al}p6YJzuSF2Mcm zinxcHkVCQ&+$8}7@h(nnt8!4u(bl)}#asZ{n~ApB=v(uZj({U?K*>dPn{-M%NM~kg zZO+B+B?mkZkaPBhyEAHu#^ zpkeble77e5@HIrf#(qm?=U@jD){$!3ypt6A651w*4H1`A_1@oCrH4H5r+J;42%OhN z;|`+liGKA=-}j+Dpfe`l_6Q<=wO$n;?5%`(KwLY@+fk?LE+}$}7x9zrYa?Zqe}US9 z1HT{kz2_8Vr9NXHEHojj##;=OTC#81XdO@-{YAGiB7m~7F&Xq;0A!qqEZR2=K$&Oz zV2Sw|uT+C@Eowk@KGyQwtVKm^Y9aE;+TNQ$8bBmeTIO<7I{2%iU=Z{CJ z!lr~YAd1z!bx89?+-la%$6W&m!U89m#xZ9oD_cu@XUU>BlbNN0Pubt^6jS$d8;-XadqrZHE z;`qf4hf*sUCFBo}4=yIp0%_B?m+9fSH}AolXP>MPcQoNKs^gQB?u&7V05j1A&^Tb5IR z!JQxKCgTi@wM?%>gF58%7CW`?TmbrPZPx*Of9azIb;|ZR0QK|q(Mi+?QwyK2?I}au zyZ3cH+f(RECnd@bV!j@AO&4iC6YF{XneY-D66&jcTKT6@_oJU$?0F{=fTv)~>K7(Z zGPL&iqo0Mcr?2{fG?tf#q{EXL8JIt6bXH1&1myNDg?=s3K(-C2`Lo^}bY>%hNurxU z=dx1MI<6O>BjS8>_4zX(m1(mbOhUc&{#b?moOpjm9L*Ij;~XFSvg=8s1Q129ZJt;? zf;`EG%N6Hmk=KoUozCb&opp9dAQ$FertdtZw0H=#1zZMScO`@7d(qoL&ox0|`J=s~ z3hF`(_GUKmj^f;$x2PL0iSGzoiP1;I1ol@f4lQUK?;$6FL5 zcHleHakq;319|aZdP~cLKyOnzAVCU7JSyD0Rm%bB*SU?%{7}d1-e4$l>>%RlEw_K= z`2$@_KI^;WF`)hVHL$n=@5dX;2ZJH3+v&nQB?BHnbGh}?uGto7+MO@0s*z7;|D3bs z922O`oo5@8k&lXRyzA>;iTC84m*1yMpbBjauSfn1y07ty4Wm9WDJgDv8^A1^2hO7f&=F!n}93(>||TQ15>Iz2h2ZV<5?lZ*N)Wi8q z-f~JVX~BEb)?YK&2y|l_*HLdgH!1ch;g>(q-?RI z=SKt3|3TZikG_S4y7#X|`$Z3Z!8vf{+qHYhLpdKKPjlhF%k?eA*y8;6E!C{yE)HZl zbp(aKMF1y6cReLzofnJzFXO5A3BQHGJv-9Pr{;%BV;u?{;G_ks3&K$>mDGHA!~yw&vIjk!SD#;H7+ zpq1?LW$%CQ5l^}KC*{&ZP;k6Kb05R+x$?kLv>EDjp5D6I&UqOa4?`$JHvkw#96r6> zh?8f^IA-MFxy8?ndD0%EuIJ2Ym9Q7UaJ;ohUU~%#qiB*O6X(3W`%ervM&kV$72VV7 zg?;Rq1UV7p16zI`x)eu2J=}T2=`*_MJC~_v*RTQlejcSSyB5)hMbJ^~bp_gJQw7_J zr$Bqq;R_$|9DH4jGz1dQ4>JF%a7S^TK!Q#Me8Z*O+`jJX*)Sy_BN zm}9ay=x^n?4WRTw=aV|*L7b1iRxtBIUdqawE9Egz8rYWSU*cXoO1QD`4CW<2CtSRI z2lwfa1Z@+(?gjGmP5q3we}PPq*jP3ufcv@0YRAl4K*zwkDEgi!){Q{+1{r=J*<2lz zs+a@f_!ZtadKy3sa11p?Uo7#zUHWPXaX?5fO;T&+1;SpQ>ThX2p#54-Q~IzI-V4q+ z_vc43|1#;qrLi}lWiL=TK21ga&qC0}#d%PWjm(J-LY(jC40U6388Ch*G%piX(UF#37Vdph8I)mB+oeflT%tCOeC>L12)Dn5QO2XVn9PP0zV@4yIHDW4g^I%It} zAbq1T_OZN1QwcG^5T>7${iOo*ISU7~XD@;N+BUeP0rA3Acj9ai&KWLgUdb7HKqsu~ zDKwz2bZs$P;U`oHwAO9dal{{J*DT(;Sg%|ivX}N7=I-y?i?fvgsT=k%(-sfHeXFy|B?UYZ!A&{TG@3A2k`HXE*wUt?@ z@7enJ5;yO0ybbo=T&pM>W%n%hWX~` z>p;J%9V8>91$6V-oe|}zi+#fmd%a=l}|{lW#@K)#{IIgT5A9T+rtcqP5^teJfAh< z9*XX>p7hErpzPn~tfh`Q;x9C+FDEEtzI$bK)c<{+B^f(MO^bo7@L|n8*AdVuJkoV# z6m<>?0)gxQiUR4ux}`GQ`$JOSeO0d%bwHJ;qSuGN1tO#R(&V~Vr~{Ig|GKFH2*(pn zNcy2pas02`aW3QygUlXFokuurOS+|eO%G`0HC;=kenx%u%K4SHD~K~D*gY6r0r@IE zb=$9fz@+Ap*6pr01B5HNV= z6Js}aqMv7%R7DZilY7kB(FH%;bKz6x|6>jI$?ZAcf1Co^s#~wXi5#HSc+`G4fVnau z^K}ES_5e+Ho8oue6HfiTBz46Gb4E*R!a~&XzBpca{izmpi#vQ4erG&KUBeS%8}iqH z`r^utJ=pge7jly$fHJ77mywkY6hprps5hkG$;fBLT8iudv>Wa*+Me7jktlWT^{r_e0P1B`*{JU9fF@@7qwI zeIUsA$0{NpB~(M5s0NzRRWI+cS3u)_()K(?8mKQ`NRbgXq#79=OgC;q zf2X_PfaZ48$4$zmEjWQr;`d(?;UiP{yFrx*e&ocj_zGv%8-EsWBFNqh7ulEGzd9}Tg zSE7OGeE7pW;;qc1S1HYUj)>omk`5h2{8sKvS?C`XU~ZI4zxOj8&qaNyR1x((jkl}A zn=^rt;rXnq@BlEp+HOl3F9L({y2(`H6EOJvk5rcA;XV2HV@O8~=s9N!7g2XlcO2PC zn#Y_nxriMGnb_}s_qvlBYX`L4<|c*jI7iwPrzH^Ze1vGc!Ps9=Tk{+KbRs_$vTlp! z_0K?64Xt(AE{FaD1Lx%ZcpeGiw-Xw61JJdb`JU^bALKdv?^YSiHRVP81d@^8!btBpT{i-qQPL$T&uJ%G5(43kO9|N>X2Xb$Z zlM(+N);$zei+j48+TE&fFSpxj&i8BeAWwWfHB;^k%p#8D7y-lw@BP(CZl6HBc2MoE zBEDm{9Zc8F`VnkwFg9Y3gKQCgX1Q`7Kra^DAhQ4VSYw7zxU0bK$Ci^8=`>c(UY2U ze?QKNQJw=s$WK#=C%N1-kf;5YPM8-*ocHG8{+i2c0rcXHW@-(AGMjv!{#G7yP1byJ zXUA((YjEH58}5x%a^~K*IRMCMCWlk@pe~DdM#Jv{zEhXTH+K8T0qL*ojW27Qf#j8+ z@(BIL#HnJYF+1w3&nmeM;yy^i)DGpjQzRgGp6xu9mjv3sg+}x*z6R}(jXT=S6j66V zKWEB;dk>OI1n7;(=Su5a$c+)u2O{$(Isti+LyKlIbu%C@`2Av&KkDI{U-XJ%-@TBNOuM*cSBh@<+q%lN)Md~_al`b<43 zs;C(1grpuFoJvI;cO`(hxdQJ&XS7Q#uM#lwmTBH28NfLAeNm+U4*IHGVu$sx?yt|P za+P)k`rErLB?+O3!=wkM^|c}YkvDzs(-6>kh9m6}zoj+!zS2oUKW<>8a+)MN&{TM$R6!;6t6F3c4_S=VA(fO#6)ymH&7ai7=Rv&Ds<>w!5I zAS_P7-~Z^bFE@2i@AhfcH{Uc8n4M11qI&tL&&s6km*q#@T#@{4I`ZeYlgY~(I(RM~ zO`{%ok51^HUa-S{OjmKi=s5DXLYjU;z76<(`E7Apt_DW+hB4?J%8+av3F+b;rL#8N&w8hOF@#nEO7i0fYQ zZC8rR!g-`W@{%6nh?8r%8Qt|jP1~v$0EjQ{C%t?VmjSR)Xwxo;czaf^z}3U=5ay-u zhd;asl%+4JSGy6vvOfJhyr~e+V}*MU+gs3;OFDSwD9#;;J9Dp|oB=X>f>)M{9_V;> z+eudU18H>hROGlDkdEDdG`<=AYMqjA3O=Fl*+|QEn{7W3T0bSKkkNl|kSD_A>{`U( zOY2q%sE;#kSfB531oOlRhrM0Ya8C<+&(?h0BRRX3`>xS#YJSv*zyHB+r+8(0f!TU{vUlJ; zFdvDQKlky%_sq}j??xVc$6n}4`l4RWj3e?)ls4vL9sM=XY>c@-ACH~SkV3vTCH3II zX`Cyc+TcNvvUM?G$wrmG4sv235mS+7H#d!72cyI~FJ?y1)dB1qx>HOu$> z`Zqvl>3d?bff?vHpGa)=+KPIthnlRddr+_VUh?n!M<6zq7_|*xjvSS|s2qXqTh-a* z{75Ur3)L5|Y2g05s<7=(js$@=)rhq*Bn5fHC=Pq>1@zbM5mGdKi#mrLVU**@Qz>`9 zHu$y^G}gV&DdV^Ua*v${TF%S>OC;sqpUGRm+U_WxtXB*yzK*t!8q$cX_ub8ss{`im ztBS7nfxsLY_wSw21Lhm-0)I55c^X znS;41=+jv<@#pxuN0_H^=|{|VUc|9FxLjgU*UR3TxOLzK?lbBa9JhDG^RV1hABp-O z8TO(G=070EG<5pZl!4CT^_ukU-;tlPT2Za>#krjCz{hS1AO+%bJNHwd8Ex4Dn zq4?u3Df zaiU4U%1>Zzx*t$q`4X7_UL0P3t_7IG0j)y6@E*LHarPph9xG2(v-g-kFhdPpc_<6QoG_MF=$5ug=XCQYM1g?7yF)&&)Ozqo&oTUXfu z^m5e!?sS~fmoL3G&qVw^h);r+1Yq&f((V!B?`tcM{C5WZg!Zi_zlHYT zdAJ|hLE8(u(k72iJV4(;lugURz&FHoqx3Q(G3WAljXYO1>PB1Uo0qW9A&~`J2fy71 zVyU3iZ^3%>*^UT&d4TU!mbcv6zDu~rs6vN}`y*(lW;h>Wg@Lx1xOk2Z?mf68%av4! zy52n{d}R72&@8>{TmKk+wj2qcPGY{a`oOy&q8iqZP_h4v-B#(2w$>Z03=*LZWH`qkb!g-NXEOZj} zS(0kM3B4?!4~j9k9 z$mWiVe}YiQTWPBOkv{{dc3&98Xda+$s5tO;+XjHLy&kF_*#O4^Or0;|oX8b^=laV^ zpq#qq?wGI*&%>XV`U?4vU8O3G?dT_r*v-S^`xA5~8vnjMVgfqmmqW%Cz5%J;#A~Xs z4d?Q0D@Ux~p+4?SYIn&+#MNy@>t1vM;YLl0*^oQ>I){U$(u+~gTM-h@C5-to%IQ3k zSU(bUB{*Dg&)3$j#J~I#$Wwjm(*L#u8dC}RuAm9(%>!~h-nAg-wBD&&&JcOQ0M9pH zkvF$e?mH@S6j(oGSsm`xaZN&>2(@u!1kYp4GI%fM3^DFkwS+yN zLtR6R)2^3S&}TS4;u?Dk@f0>+kGD7%=FEKEcR?QLmR~K6mZpHt%dO*GBKWZKYZ`Ym%s*`@5Sg;jPH%Z>A-E7`Am=iB=rweAiblOS%F&CV496 zhM1R8CGK}P9P@eQv!AC(A-L=TaABnZ6}`oi1|t}7Q821VsP(4*VA6jBv5}UqE#QH2y%x4 z)P+jjf#s<#6L^;kSZ+gNZ@*Rp%kjI9t*!yEj+=yrPBj4QpoDvE0RFqS?f&3aWqikW ze2#l40W3Dhx{YPX%MKn^vHkZ6`{P;mgsM{XCs?I$A63RVzo?;e7|%&ztsQYnV(djy_=Y;kAx45NXVLi}GbR{iBErIS}Sv2sz80bP7 zd*8Do57MZ$Q5U~Inz!M_c|)8N#rX;}-v|M#4VnlASpSS_Jc;>OPNhkUpAko_^N@&%F#uhO%&R7!@_-zwcrSFQ3Uo%f z?q<62fzAP80l!?-n>;q_mHQb2q+La1h92f#-B{l{*usT-zHIV3zMcibg|zPjXW1}6 z?h$2HcoS&j`akc(Y?wc~S1wkF3$#1~BO+g;uKJgKxN_wTXa)|jNSMo{(ZbL)7AXMr zeD9r4o?ZnxvZ?+}tMkALYmPZ}1@$8r-2>EAp93qvuBz4t^(JolF9gHFfMvt#vWZ4s zeZM}*;Y>NORGxA62>rvlUnKZa6Z@}eRql;hUBG;8EqU_Ef51#PAZtmb1JjMK(Bt+o z^tpA2-#(WM%(c0(oySLk@w#-&0|hf+L~pIzRgZX>{=c+(QN-;zE}PpIBJcZbkaT9- zbL_KJIHoTB2D(Ic>7PtZptYT{|Cx-s-hf{S4Q*XH=q|2oiTOS_lHDn?n8#)GOKttv#YF37TWsZfEhG({!~X z2P-3P_3V}CPHGIOC%+TsyhR2%S-*M371Sdp9Xi9qmIkcrGY_u3xDBkU9c#|~dkn0Q z`Tl+TvCne1uOhrP1J*J5O*3ifs0TW-r<)%?CFe9ZNy%ZKyiMu05Z;fTkJTAg?7+Nl ztTHWJgYQ<7+1fp*&)WCe(en)Iv-r5Db`lX6{@{~#$PjU_o0=+5yixaK>U!|ihd03B zrCT~bKwhMN$lPfV@pwOvCzsD5-X$wRdMP*twC?RMUJat|=i=4vKO098@6G*LO(_KG zyClEZXw+Hz#sqBej{vH0v;9TBG4yx7@|Tk=2Cy%UXEO~4_%D>Q+vpHbT+B+3X2;@r z7&Hx;W1ioRx0Fvp6d(sQ|26o9ImrXcw7Ji??~D5FH7!mYNcToFi>;iqNFjiDe7)Q{dImUv;lqPc0|=5;r4 zZ%+Nzs5ay~tUoN9KNV);Gid)tBWC3OFJS;Xn@WOv-m z2nU9ZX8DiqC17kju`=RRgY&wPO-Zm55>7Ypaqo z|FI58y!M%sehtV!)jK+&&xGunpSe^E+D3PkjTTX-*fMrl z;UORDM`ygl{#1Zw>tmm_x6uD=B6Ahay#R@sie5j~q;LW&vm`V=3V;7`EwuQY_rUU(s_og_g6~)J8?!`F?8DxQ z=h20LwS#7HSPT2$1@aeJOPnK{KKAEjpF#bP8r#Ffvxs-uN4A*+ApUr5UA=K7FeU~} zG!~KHy6a6MAdzIEnjspG4i6zecjzHJWW7Tk?Pij=j z$U1yC(Bfo`CZ>~trrBtu{%;Ye{o3>Pewd3D{J?V76>*fE&T&4)@c?x*Ru$bZ0UXa! z?CEzgA7I=o~j(0RQrRtH$M%~G%Tsnj*-R&2!41?+vWSVha$;xOny@GQ-jdRirS_hpiR2Hg}jJ<=f`2TY`-!8N?kwgp%dy9ANGhWTLgfn_O6TBSHMpzyw!IDnS)-l!xVVyvWzrsFGFZ5MK=3uyD7k3i)^ElI7>3=wl0-uHZ&p zT(ZZLZT0y;XL;K6c?1J(ro?Ic&VN8lu`+sedoR%7uGIxK^c#%S`DzxRZ|d@w-@`}I zhajVG<5`Tl(Wa0O*HRb&&h@Jzw%-7@tdI6+-UJl)%RK`f>3AM(nY=vRm~YubnfikdZIHF?3mr<0}xC0$i;U9f5e-#@_z~^5k6sx;@-o zKwwp=%TmyPP|5%4)yiuyQ(hs7HS zRP^Qi@c*}^4%E$K_E)>jf$WEb%qNEhf%VzqdcGIFQv-eBsv!};`rz=#-C%WpSXEFA{!g6M+c9=Ilo*yWf zYJqd&Yop#4oKwPzEG`~Go@Kw+^_>|w=l@4HI+Az-c}3d#ILRHTYe}ZN^?Lw=0N;5QBbR7 z^bd4}o>yAkb5R(+et)eGkm3)GH&0aoad8jJx9}_wPZ(Fz zJw<@<_GxeN71X;^Od`KX?+5L2F5z>NrJybQicXzH+$uX%Nax-u(305AZQqM~Av1DD zDg-c3eCI@`Qn(suobfiCRKR^X2TC@b=^O>wruykQ2mJkyw``5l-U_TA`$)ajF2MTI zU_5}ir>qYQ+Fxk^R{dMrRqc3S6`y@Nk9)vb*VU=ia!g_#v~LF5 zKG%;y#!rAcew2NiY6VbZSV7E)jX+iK7rGyj4A6STLXU9<;A}~J)EfZc8{swlcoZm} zDm9^vzwkW5?oXR6gYMS*%R5!^ew@9@xGnbvbeiQ8B6IpcN7n3=$UeLuS2-T9P~?C( zEB@_6K{oEeyZPqbjzAzZS!B~n5l7TE-lQLZzMMiAu}IV(Xz#pDooFP1R!ZxE3pWnq zTt4Zc^#6LEI0Iel&!Nw@KA(>_12k;%5=<%+K%M3pux_aqWGm}7%wfJB>vwDp``+!q z`o*oQO_B%Jq))|vQdlR326-s*%lMA%3(J=y0PAT@sc2j#))TWM%~JKi3fgWXFnJVM zN5$W489WOt<-x<~~W`(;*JCoZEdvVeWL0QGi7Yjzt>DgoWX(q6Y3`E|DMBSNXD zcgX+Ty#3f2pdIvFXFa+Hs8b!XHT*aa#;eIMobCsz(nt5W={bP6wiZqD5B{H@G3pVB zdK3OijmtQPP&}uOoc>~g=W)EPcKsyi3KnLBRoVdArH8=DhMMHwbOk#2iasY5Fl$P}go=%y}mcvJZl5 zYS?%{kE5u_$K)L7vF-fhDzph$e=fz@`6}SO`Eb7ctuL_pb_u(ydE-4fw^O+d=h*AE2+zc+uLa1?TqVMvHi1rq zpx&=VFVK-}nUW752h2m}j1Ke#;Be$zO3ACcR)Z+gj|HQ@pbhnr-=KIK6yhneTCg<*W9%;-?H0W=lkiLVu za!K`p-(et|JvC)0a}o4-701$NpMV}uhNRq%O?W=@;UVJK&o1tj>vQ!3)~H>ynHbKA zZxej3NMhex*2)5XYV1B-xTk;wR>;*rWS4qmFp+?f~)>=K-4OTUhVr2h?8*+{De{KuwGqU%qr0 zsC!k;%&X!Y*ztVkc{2sT)8jUMJNnrKY0BW!2NZASIn(?hJdaJHhv$Pqm%sTuVQ>h@ zPAB$~8Y@7jw#r?;`ab3;zV0YgV(2hfLZ@aaY#?xPRn^pqaNJolxnorS5V zK!f)7Z&}b)P?r&T`5yZS*<0%^sA<-~usZU<=3hE6EN4C@<{|E9_Uij|`6pl)eMltr z;k(Y-RkkN=A20}IS~kaVu9l0?esdPTzis&=D%-9ie<2n)e9jc{z-hBzKh1#tUZ&$J z?iZs!ZZp2}4*Bq#vl_SS@ptZ%+H*Ub59>jHuxaKB&=p>oK0eA1^tGlo{!Isg_OZ}U zA9Z20qAtoY#&e)u7~b-f-x6pCzOHbHSp#kR+>cm~JZTr8di0q-o;mDePu6n$azpVsrS)E}$Iv(OUnw4|G3TG<@Me{pe{AUmYI@ATKICrRs(NIWj6hXl)$kG6mJ{ z=g0<~63&A2=BV#wZFk^2p9Q3WhuSYNUzFt29-1l>2c#{IB`1y{Z*|{y|M40N+$;I( zyYOS2kNVBY znIMnv_wa)mMGxe=``(2uU(y3cduMt2Gn}VuD?J7t+hU$l%(k2*L13hr*b@HAp)PTY zmo0xl>0&YiX$+1UK`Z@TMP8Bdseap@xD}bIg1yfKJ?mW zsj^mM#BqZyHlp@S(v-L(+8^C0rJLk&8g>plTw-iUn3&5t;* zO?<?p>uQ0x$vDmO3>x-`{;VJGpdh{;tz)74J_jjD*6>CPlgKMl0`c#PL zGc(4qu_N-^hkrj1iacVu`mIG@AQ)V(2z!U~{L^^S6~#)>a?5eDS>q0h^+h5rm$47p zZDDuuJ>s)cC5LO#ugVmE^0S(VJcf{WNW$_?VDfyOvv)|toGZa%>q^x5{#=*o33xtT z4O-I-JclZaV}GkB@m{sscjov4JS&sf6Ge42Ogkrth)OIg|GjmO$62o5#?y4#*$& znrqlS1hTbneR3i4RNqpI?pU*fj(19gs_`+P3jDG{-^ZfT3&LmHR_5~y1N$wHQ(u_E`{Yo7u z21>;EBQC%^zU_FVDt;b2ZW(8c-@lpSo^N+hCwegIU};qaFsXijx+{>^P+jFJ4@aC< zeAkTey_=}-o$j=|j_=o$yX`NxFq|ifyE>m>4q4gLg%>+p@SV$C^6ZsDe9HS;y!8s; zME}yw!WrK)xxvYedFV^fh&jOb3v~>EHzi)-IR$T>2;TGs_gaX?TV$L<9xCs`-h>lC zd-pb#IfuTf8xQXDNK|1RcThV`oCF#lkF~4A6yojG%L6XAff|u!=bB*&R7$(P_6{+C z-?{{adpQ85UE-gHJ^;AHE66Uk0qi-GH56t6l;#&D%b4RwVSPB4CL;v87$?B+MP8lh zux(WY^$m?J)^{&|2J!)7li^n6r`{C|-+7BUS;zQKoQR1<-HD69%ghQOc@)hKJstq! z>RUdhWF8RX8Ve{6IY8WbjnDm0J?coMYrzO}N%sdBANh+s?ohO+@INYO>zTB7UB^C* z!}9E2iZdvZ#Fr9R*5bUjbk0uzeX}tt?1}&9k0M&)ZT0$r8Pw6?G>3hvryfnFd;pjy z)ui`MD+ALoC1`tz0_sPjHr!V|jPt~Q#6K;_H?1nkybZ+nY+xl~elzkMPh)bn8&ZLh zFtP6v_hUy~=*hiLMVSSMi8GeWPCFx!Eo&H!y9Qr(l3G=8^ zJUo;wfcmR(OMM$FNv!ic!h?D~Ky$j3TxN}Yl+@5;(T`7o`ia3=DTDY`;_Ixr&KjT^ zq`Os(6M)M0)O{#U58&zMJ$)gFCwinEYTA$WME=-Iy<};iv|cUKUWfIZQKE5+=P>H4 zx2eRAPNVnasybljsl`RNh zUe>*-_lJ-d=_0khT=WCQHPJ`OdyuzyUM4-a#s~3@u0+ZZ;vJ8m`_FPGFbjXRG%MlX z=}YR*eq`ghnLm{_ID&Z8mVS0!2`{p)ce{k%)?6el@M`d^W#?ner?=#XZ?1#K;Z=X+mA^~?THupD?}V>F(^xeeYPACD1a+{*pA6JH zS%;Q~FsIkd;M&)xH004)V(hWVqk zsDI|Qs2_cL{+Vnm_E%~(0UL?&KrS|)eKur)diT8?yt($EQ>6cldL4B@N^yr|jm>*=qkcmH_tr{SreKyZ{R=Rbn^?!W8&goZOf zJDO3UI9GxBGm%=Z4(CC$@YF(cl?W)bIEngLAuj&4dHKy|OJI%+`mT$@_i1p)s9MBh z#A&Y>ep0nY{CxLw?h(|DJYH6Pf;m&nJA#EDq!Bl~5+Hc&JL(l&i5SH#h40&m_wuAn z#MRjicE%O~lSA>-B0~%qJ->bW)?(jK=zHs{W*;#8YmdE`xPg82%)VeP#IH7snHt~Y z!F?n4&u=0ROTYE`AG<2*;w($<(Q9x&&$d~oRX5aAcQ&+(@)-dw)_|GRsE7Df_ROrw zL!kbh$+Y3-#s1eUx58`;sJ85FkGWTY%C}+5o69=@8r(?hjpzXW3bK1Q+5o5!yHdJy zaIcZvJuRzXpn!7$Ll<)uA1cC`?R=<@vsY!?WDDeMPOk=kJ|K&6sV>yBfzIt?4c@wW zpd(?1uh9!4NpQgm~kfwfyW3 zm>-~?DG=?A`@rfc`;2)o_mY-kvUdtJ!--FKJpTd;DdUlUvJscsSWWNpLL7>xzUBOG zoc}mKdh}CKxA-m4$=(vzg0y%96O>`yu^6r%{t#%;_Ei^wOZ8539H0c^DMg^WH{2WY;UXx?7JBUw8c8&m)OEZQw+r*!O7sM{q%6=M; zcmY6-k#-l*2i-2hu!_F`6x}2EZQ|a82l8>D+Zs{dkWg}R=>m|G1Nr|Zpk8tFpxPeo zM$n0VP>~&ix%=E-!q;<~11Zww{`kXuAZ?)gPD^)Sj)T?Ff#dsuC{Xmb;X*3v-Q`tx zU5f>R%o}zNL!8?mMrO+2$35M2Q|E&YUqCC(=O|dFQa+)l2GS!gQ|3T7MQF4-`AXt1Lk-4t$6@1sID<#;uG8(JzuOUXz7=b(!N% z--~!Z0=~h}GWKCK#)n-Kk$^e;Sr5bh0R0tDS;x1#K)>|pATPdublsU^@reNvB*N@f|?Ddy=63j|tEU(5o@>J^-53Iri|s{Gh<} zRW_PNp7wCmYl%K?f^+IYqC45?GxUIb{nEaz-wR@ub*U5A7Vf7Bckn%1Td`yThIQ(`l52@3>OvsQ>*!3 z98j0TXrZ5DS*-=e^;qtq05xD(-+;E`74es64^Ue-tEKdm0oCu;_1)`{zm-ne zF|nA3bD`AiX->DvVhKaT<+*?sGEKZm)aL(QsDdiYMA z6ue&^g8T7CUVN~5gSsrIDyL9IN6?<(ungzLeJ%c%JIv7kqs>K@wM#&~`>}4lC6Oe| zZ`i#t?}sudh^PM5JTZ%UpKqNuZw{hvp}F*^CgM|PJOVZv;`!KoZYs0gh36!8E$T}O zuypq-ux@q%OGcKg6peiDe;Xg~RuMtIW2zyxNeJ~NpI?iP1!H}gCzqxF0;V73{^5P7 zkK5OKTmRHaoM%3rO%O!A=$BKL6;sH6+>6swc=#9?uD*|`yOnT$q~v@r`-Hd)x1aq6 z%*|j;*f|Lw%h5jx)7oh5$YE1S63{=u7`|H;Iwl5P$`D`FwsB?i zvIO0%$Ls=2n76-iI4{*C9LRyaxeNDjFZX0jOtvWEy(gy>c)YlP^l>(h%JBn8hod>( zy7&OGt%(1MNFfjn_k}rKLBDgGxw#V?;=hMpH`;#<1?`?h{dK0utJ@ZbJ>v2Pt)Clg zLhS#5mhMxUZ@M++DqfAZx6=XnrC9%hH|fBNSC<*gehI8t9=$$7Hu6mgqh$RGU^p1IjxC z;YdBqHPH-NVjDOJx@n~eqnJ;jyY4MZm6(hCZBw(M8R`^At_wc6gnM($#q9$(JqA*% zttLg}AdndP2htv70I|BcfL{Xl-;sLb%QI4dQ0W{pj|OD|*+V<90_TmI!IFjGXwcR# z6#Hhp4zxNNr&DW~n5$9Fp3qy5IewEr6GrAhzMpdg_>}{zFeU9mM?SFboz5*wt3@8L zopXeR=X10BdK??_>ycr_w%vBX^8QTZ-Hdp;)k5OakZt&$y^CKu`VLqU5!R{3slZ&? z9nLm?0GRLVTf-#8P_KAiK2w1XOkb-~0-dygP4*%0!X94HL*0CH>cN%Ze1S@^yBh`8>j-^2gbpuaOl z@8jUPi$EisZ5zFgc@4uiYcCCUmN~_E<68N!vLO#tHu>$nFFBHM<_F1wgjC6 ze0+bq*8}NA$(@jGPk^MkF0HIr8gnw%hZhF_1)|(NF(0lOAmo2^Z5Y%6f^5vw60N(S zUGy}{pj2gULGFI70PVJZSxSvRk^ONIg~CcT>L#1gR19W1A8<^z^RSth6I zX5`O5DUbdipXVF)>>u;Rdf(mr6Zu}u@$L2r!Z{^+(mIbF&&!;p{ai;JKHnybymAqfz>n-IGi$%yr6J&S||RU^X^EA)GJ_JmH7Ou z0r@~TfrdW^Dp61RV%N|CtT%i1#vJ+;2F#U+U!Gs_KD2jc=#lDynXz|CLxUffPPM7Q zYK~anGk8ZsSh%<1dwp!qSzwgc&mJG!iF#gB_s{9NI44%6EYYxzf0mJtycUAF8&8GV zRuNxer22$1P}eZ~k16e*hCKS3qdOY!15LkMIpnS&P^Sx=v!;n>ee$`K>g1eSKG)%#MK|%?zMZ0dPU8P5%Z&o@;%j zgXrgsFj(OlkO2Z`&ICsk){o2argfY4pl^*$dUMG$(2DyJznK?vmx2&8mzdiFt=I>LZCxGCMV|MhUiLiZbF*~z-aIFI5&Pqrqp?jmw+!E^+Yq9M{jlD| z->cdo$NvQAhWCHESn(r|&c(K)Z5LqPer0zf;#x+{5j|x%|NV+LZ5L|<>h0Kg zlU}?ZRMn#C)kO3Y=0pm~qYxlrpzEFBMFc!L&ySwIhv%`nv9LAPLfz3sh`?;J4$?T25KeUU0m@F@<{fb0+_aRbz2aOKX)^9WQ7FwiGsv;ePI> z(Taltqo9#IK+6=Z1^KgOG8b%bgWh_%_dnMi06ng*4T0=8fwkJTz2G0dKl948fErm~ z4ga_)uY~Vf+va(0Hc4PTDqgq{5R3KY{m8!Dl`Aze_2+_qWIT zy+Cwn-+=sVE%nyXd+hjb+0s@-P`_yW*s-K#6!oJHt0%9Z|D*j{$G%Qa)bpM^R$TZL z=aGMfr?26AwHTqTS)Ty(drB{~ZsEISu|xD~WjXR!K~fJncMd082#nS8tAe_%cU<9XF$feauNowZow32^-eiEV-t5D3{VzkysM3L= zBvICHfI7viF^O|^jzFHIywGdc1M=bBI%3$K=~SwC#OsKF&Td2D+DtFh|G4Sx$)y5` zGtA=c(`m%jgV>8>P!~6SP>-k76Z_oZb3M;dkM&heUh26m&g1e2<6CM#>ub$_Z|>oq zwKJoicZ#BJ^iiwVR5Ip`Uaswt;uZpV^YZH_(BG)HW7jv1XH}pl{3`8k>I2Z@FH!wh zDGhq-MwY7@ULbGlLX5kP_veezznj9SvuaA)MVLW-LxG(c$9gO5#~%J@pnd?BZC=k7 z3*_H5j5D@-HQ}7!sxGk+=k#|PBi9k9Vx|-ke^;DC-Mi7}j`ecDl%NNt8li7}pfE-L zLNU(m#a=F_v91_;4Gwl7Ud%2n_2UShL)mzTYA5zvw!abyb7?^T&rQVhL>c-)E)9Nf z>;amU-Ma2x%)MkI5mfvOfSR*^B%t~YQ1y9M_Z>#QW8#7P-l|^!iSox48_EE5eZ=p_ zR^oa57oi*U4=4(`|2;eC3%Xab3oZXg(RGJY!A5aqBx%`2W@M&eU-vq9Bb1CHWHhL( zP^6SmW(t+EA|efBgvcf%%4(31A|soO;yd489zCA^xaYp_d(Lm2Fc%;W&nJcuqkw1_ zap{2zz90FfDx+i>%mp9{vH#rzgmAUGMoco*THdSqY#k^1Y(+|cz0(BEf#LDKGEUI6 z3N5oL7zd3{za1yEDnY}X!{Jej)lG1fyVf-=Ct0H%y>;#T5itj~FgHLa$2e(IGvO04m`ICJ$?z5+&< zbB`3?W7IKrJ*aWO&;NeyTwVDFV7Su{&t#K;L3ev9{Rn*{{PrFj9?Af{Up+L`5B*e` zo40gHTtmEz%QS%x-xVc;jF|+yuZEW?6L(wjT_=j#26F<&#y(PPJ(e1TfZ zE6l#H3aC!>VB!$+ySxMZq3P&5DBZp>;n+Q(*l#;N)PnaG$Ck_cPwN8t38_3m-v)8s zow~)|pU`hRTl(SH9^?rhuUZzE03HZADT(`7k9C`l^gjk21uL$KgzoXgu<- zpBZ;OAL(Em1j~*{wWpZp7qWk}9Q$16hYcl>f6+(SAfsAti+bLZ#w9pMLhEU!tF79SA6D-pS%_Vy5{Ypu^xyo&fOZXQFZ`YmT+l;sWZ?VtT*h~ zi+BpZU&8KK!Ox?|_g*Ex>(_DDgv^u^yk^J)}9~`>|{=kw^j^xv%wE z3H3kkZ!13>)FuX|eza~i13l5Q@{5fv^QU==d!~+6qk;ldv1^X#xIM2 z%nRY5WpV6YTh~L-Y&N@jq7L;YH1%ZFZ_?=NoVJ?OMgM`;g;Y}wZ%{8TNDa(8iax^R zuSZVjgIeIpq{uabplbd%(vrmm6olD6h}gXb=3&z=!*6cDJUHM*xaa{)-PVkE#R(8B<4ov>YK;d0xz*uG#@h`c8{aDitSE~eI6fW;9kw?7i))R4M65^5e zqX%<_?GYF26RqAJgL6rmd+>uHpjRKgahePJ;TxizVXe_Xrwfmp*B%Bs%LNl2%&Vgn znIB#-I1IFNKfkw!z5|-*Ay2QcdZ50mYL+o$NB_Z@ZWCVAnMhm=&+`2SlzO4WW#bd* zm-6!|Vu%A}Q`g#oS7AWTKBv##g84s(DsrYTp@f8|`Z z1H$<%z0T%b&@)m)M3CEcK@Df!hb81rOuci3$~AC!jD$P4k1 zanz6crn=P%g1S=W#diFAHP6J?FLKZ)rMvj^?(jNLSg*;?`M?60_M5%yuKWh(@%!79 zUN-~t=>E`;-)n$*VDREa6%Jr(6=ewhJPFL5`M-aE9K`!;So(Kc6!u}K#EiG2F0oE0 z@-OaBVkCwyE^3J(?s6iDZyxJG`gx=!5a;{#iq~_G^&$RfIc!`~5A>**8!Uo|;~!kU za^v78pmP>u<}nSn|CD8ym~`ItdZxHNpv#VjJ$h?O>=?@=E7b*e6W4nG30YI zLc2p{fzllLYd(Vn6n9Pk+X0C8@_ZhUr}6?hH)}AWJOjuk2E1_8>qZqY z-F{qo@az&WT~1$=y>S+pr=}LYR=a^|8B+b~f+#Tc_7`W$%>#4azi#c(a$pM1X^fvs z2gZW@kEt_*sK?Ij*LsBS%F{Hipn056t_ZQX#T`XlQh}>istOo<%YXCqz5~7MIiF|> z^7RQepP$Yb0o_vbk8%ypiF_x82hj&gYg*sn7zCU_HV&l6!iw9;JQP;3eqDi0_UXu>sN*g^E*cgP3dCR35)B z4s)=^Do@a8pdIU5qmMob!rxO$qop_po_J8-f_rVWKCo30pCeC8y8A@=6%jOZ2&c6- zdt*M|Pu=^YVd%3Bn3UdV0UCmAmY2CyK>dzIH{YLR+_&wy{p^7{P_uXzzwp=@RFz%L zEUpxQ{I9otbJb$N^y@Fo(8hlE@^On(zoLNY`K3$7h#i=Y=3LokBEU579-TJM0w!EY z_sdoWrnHJ*+77H2yG*U&Z)4PB+tp?x?!$QXH@l1D9WX+-UOT}y3JmkopXv{W5l;~n zD^o=O$4~Pg;j74_q=##~@wfwYhkiqKT><2K{g13zpbnz_?%AGe-l$j6Gm73*0W{S{ z!{Q&$f%=`vQ*zlIsNoY{zw8m`-8XBzH4^o^pMs6w9aaU3Pgm0;_cEYtmk2vOMFnzE z(x=2*!9YGT_9SM#0>GmFHmgng013}V7MtAxDC>k9YcMaaE#=+CkBgwQ^WW7qD}F%o z<$j)Ve+GyhB~qU8nD?`HPAq-)GH6F<=$SE*f0{4Lm2^XV*G9JOANs?!>f1xd6ENpT z?SM1n={` zpk{c2J$YybRHd5YwvXh3{Fl|uE(Kb^jNpBHobm~np%GR*K0koz|EGjZ*$+%F%eu3N z4+GQTO&sYm5txPw*MFjgh`Bd+<#+QQU~WAb)#Z! zbH1WKN9vc_22Cv>`K2 zzu9md_Ytma*=+K+6nT%2b>EG!9zvh5&NpO%{5ygBqU-ShI4#&#KK*beH3eXq&^xo$n4qU8wl(=aI=w6XqmSuAh z_uc(uycBgO1DaYtch&;!PFKQ#L#P|2lJ_LFwE%TIq2yy9;)}7ODoCXRRr^o0eKhJ$ z`i`Z^gkJ=T|CR2&inBlwj}~2OLcIM=&)Ow1X&_s%e7jhF3Q)r1Z&1(=kaSyL`T)M? zlpmiuRDWVUPHpZFtOXs(-jPKWGLSAxOh|Go1M$5e$PBaNUi4?4-%W3Vc4*_B>aQn& zFlNW^AfN_>!^b|0vnygg+>>1&?xDU)cK@qO6R78n9g7zs(m<1|@}O_~E6})>oW%uv zpuXrc@lL!P_ik%HJ#=w5;#QxVbJafs?pw1_!tb@}rf|{0!W57%XGu=7I|Ix#>XV*i zdtj#I&K?wu0cPCVfK6)OfO%8>aQKs7!1T2!Xv2M%%oAReVA);Rf8B3z!2XlD>m!{& zDg@?Q%G>l+RP%hAw|8%pK%AI+b?D#)Bj0tZ1o4~-alxw)II=u<;xPr zxkjL0Nwu!Gx(syHmX>Y$Ux7AqJo(4zN}$CD%FaJw0h*qp-l`bpG|cMg(>+IknxL6_ zZ@UUm$)W9O6f%CS4vG>aoIipVAJyAo{*RP@O5&MpAXk7%xx!8$TXzroc|HgDcfTvY zYzE-rSvxzId;ltQY(Ww8u-X{M$K;Sdm-wOf@8%UCd6|^1B|HM+yQ|f8gQ&mSWpdxe ziy!wyzMdaS_>8dEBW}05%Rn%g^OTLQ2d#ofDp`5TsO!1=re)VEXx@G^sIHCqqO6?5 z^fl$6;eGPNdqY!DpR78<*@6C?bDKq+_%Gq!ZGv+O=02$@mK~(V7J@31TQPiqWc0P}f8FY%~6Fdwr%kwo1v^S%_gD0BhyhV14+TbvJFceJQm*H`;V$K`?;TJd7jC{8*8l=Vwr7{DQyY+L z;$^(8(KlsBB!_-FjQZ*gTUKh_upSHU{KfmR9*h1{lt!!vyMab1;#cBZ*D6V2J=|AE z+YckI`?mBzSS9M+CHC~_W)MKzPq%%d8S@jrO?)i8d=3cItt-htkT-uC-@a5W1X}!; z4opwsdmb29ry5`c8ndHZ4>Wo(|H^{#c_9Gz7Na0t{sKeJ)|@f*~( zZ%vtfh5I>YWY(*x?*#b-m6z84N`N+h{w8O+C(g<1k3`XIfHv8p$7UD`wBc%jh+Qv% z);kh=We|UF*R6KD9tO1P@7Xads6TvJ7ET>(1X{vC{BQLB(5_o*C~!PM9j`)_=5qq# zQ1&Tr;?huO&86M*W;f6_?w%~WhPdsoZ|m*)`+!;{T{LS|jQSq_O_9%YkOwRo^ZbBw zILQC&mO{V57LVszZ&Ana?Fk?0`wCE=b}gAEa$V>4^A|m@(=_vpZs`ETq(d8m9y_wQTOw3y^ne6JAjiJM}wTO z?^4=e$}wyQIwL2qwz}Q{oy)4z-GsBCvpJyoX94EUq%kHQdSn4f>x!2)MK8R8gotE^+(9(25#J|?+wbgHaPZKP2%?xyf%#BPx71B3LC|NPE^}% zC5`ie>a+64S~$lkNTl|TdSYLiV1E8YG|)Fn+?70_4z$H0E4B*soeenl-MWsrV54^U z2T5hbJ%}?c<;kcQ_3n_;!v58HiM=|H72kvR7x)sef0E+dL0Q$puW8=QG!y%!=7C?# z`#aGunAv8%V+yFQLXNVY$d_wV_w!454F5c-IxKCW54dn zb|H=>x?K}8!UjLq@s-7;6e&`$hXWUQY{z#6jgqtlu3f~obh8On`3lBWE zkwhI(mMZU~RZ}2R1UT~y5a0TA?JM`mc=R8*PWOLCpEO5LUF)O?5Rz+t#+$qWg0|RX z`zz#0J`X28j9x??ib(#MUk#u+#9HNhZ~^mY>@FB^aD%dPqSWIc)Ex$o=U?sqi#Ud9 z=i`b6p!)|;j12`K&J?!Gum$^4m*X1@K5_uvcEcUBi{q#ly(i9vekQsW$GO|4&w(y^ zGP>X1~1=F`*Xl=k;hO1w4pQYoT9P=-NmYH~d z6y)_~KjL}$+xs{5@mIt}Huma$$9mkakBReM2UG{?#HexP1r-RUX+M{MG9})@*pG90 z{_nAMw>f}vp=9%ko!vlDOQF+fML?c?EvWZR3&=0!s|~W(0ol2fBNu(;WCbH5VkS}xOhRe9QoWVzdk8RQ{)eoFmq!Z2%VSp&&=RE zbM|CoG#}!@YX{OuE|~KdKhefG(~svO=+yZe=$B4WqdaBc+;~9Uq0znoc6Ud|8_D2( zUfbRH?H}S7HHyt_UHIOXi^tpMA>Q|@_@+QL^50LFZ@fB&JZt>uAB_kt)Fno>zfVA% z!(%Qw{F@Qbk4Z>%ClP_JBR29|26c^MEBVWtE(7gfQ+9;V37~zxXZ?~J=ZPHGhy!zq zc&|CpofS?3?Z~~VcF%7>+r@o6(KZCAGrgf&71F4Cm&tz75s35nqN<|B8K53;wcabG zg!<}7gv~BbFvsLs@;0m2s8dW|f7TTF^8?Rsy6ne$jH9bTlKKbxtD_OY+5doiiIro^ z_&Da?I`{6tZ%b1;@EtH&e zGEWN#nMR@wI<7z<5+xO5%_7A(ghZ_<1Bd7{!BK|i&$GUKMFVM%8{L7bb0KNa$K(G(`%-WPV z!*}4lh2pMD*q76vxElG&P6IvC|KK3*F`>It(HJ3ud{a$;guyw)(|Ou9-NCt>L&v?M zR2XPqt*$z+830=L6=(JR+<0DIP0JqX0Ggrb61fraL&0}<-*n?W*86GbR<8)Y-=(81>9)=3^g@ovKPKN?TkVnKL3i9~^;XplrF9EHJi@_mcIX{we`|WDbKoFoJNhYh zjSKT8j$Jx|9)92S%I&17 z{Z^A7kh?Y=nOs!?a%7>RE}Jd#go*RBF|PoY-(1>chx(uVEjQn}A-?DwExs$e75xW9 zm8+;5*QwuD=NrieI^>1CwMjpLRJQTujZ0iW(mv?S?m+@#X?|fJQyPdmD&hOlH>O=( z$Duljx)Xg{=R0dtfY7!q-+Ape5Ug)DRcsRgt&uHj%33gQ(c35GK!^!waaN@q+g<^h zaRb|%YJG9P=Y_A|1A7toRkL0#UIV+g#^1g69zXx%Km77lmVsftIyz&fjk*yNxj4Bt z>{I)N?h3!hJfEz96Hgex*i*&Nk)77J)_uqN^j2I&ITQUCi~BVv)Fsy6ah%$; zALx&t9i=_M_vWg3!kpA`pqpjx6C)umB3qdJB@)lYLhOVk?|Y!t+C~1o=Yj9Ok{&4z z=W}y@g}RU~)G4ZXL6YWYGy5xOyyO4nBNc;rW&6gP1ZP31YhfjpZznLqW(>4Kr%-3L z>TAo6bqJK^zMP6WQlHc7^Lem7XB+)l)WlH_XMVNq0^){rKJI_4Z-Ak=NqqDa^0%9f z6ZV&1!u##FcErXVKyRG7z30tGpr^VGHO1ro=6#hh+IJN58TOe-3`7B4D23d1a6k5C zKWaW|AwT$BU~Z*xC(ztY$anaU0&V}RgTKV0@IA2}7rZKq`fA5{p3Rd$J@ZG65T4i?3FL>tdV0@sE;M$ypUt%k z$ZT;o;jg054v3feJ<062J#Nsm#oI~DhCOvzK_tqY>Yuk3?`<=d_h+2R; zQqf&P(Ghc~uTETho-Sio>@3?$d`v1P-e-+5HK?-wD_N=*@xETndt&db# zP*#*4)yb=(0$O`ctDGJ}9Z;!m&@S&R(9~Casi`6b8jte7_Fdi&>K04upFB7MN}0P9 z`JdtEpIezz=z=(HPI;DY#wWzhUl*3-3IHRyV8!~%A7DhkYE>iSIk{GI-y#s_@H4+! zY^ZpD8Sh?LcO2*N{b_MB|KnCX7D}~7NkIQ?!}B;#68nR?YtnBkfqp*&nHPNbodi?$ zJdjUUQ?~7RAP968&d6k8yr=5Qg1R<|pg+WU+5b8E4-TkIpTExzwDtS$$7mzITNAvG zx>g;iS4>u=;|GDdzeLPQ9PyE%UhlMTcz-?k5$E!Uig^v=kLt2<4p~rsBX|dW26u|RMurR0O@UwH#W_KP7w>S+(Q@nDf_QR zO6UWLKUi|(H0CRADLJOm;)%Y_I9FZdIf-lgzm>OhfcDiJRYMQ20b#}O)QPXi8(uA= z9lgs91Xk^JL03{hE97^mhfy|YZK-cfn|O-%R1II5ojm5dcjmn@!`$l2wa!H`xIapb zt$9u1MNsm+)Ht?y9dW1UEpKj>0HZT8d^#S#|L@)U$^*(!CnqoU{N`1}(OdfCs`daQ z?bPSmU5Mk}T%Kw=S_%x0IJK7Ds9P{QSf81SyvKgUHjDFkUN%xM-B->5`ani|V>#l6 zuUs1q#IR1+^R_A*0N4cg}vt$7ku zfH2H%bP4s81V@6KplB&*4Of3L6R-j;=a}||JCmR}lia;ulm|3@`{K&G5dY=S9cN9{ z0u77qsybfGRpc96%~0kACFAp~W+{mCEv_0(1t4zzXCQp3goBCe&{a}Q3vG4+~dq_ z1dtNm8P+NZI$6230cAR%vu!>iLj5d|f@h=uSs-q*kj&K+9fI@tnEj!7^hxzMQ~Wj~ z?rW(Q>HQJ+9(0P>@2kT5>afRF*Z0D>r$t$&!owG|OzHO5j@hHm;c4-g-bIUoI=r|3#0Ot~gS`0<8!3?@%M+O{O}^nZb=JZ2(v9+>p?x@=!cO{dqObpa@IQV5#omdVc7=eBS6>9nH?(G4fGAy z`$eqpBR?pYnI_o+wBR=*v&QI4AfF81$QlaN1zNm^Wdr7!T+_OA7yDitk|)bKJU1KD zB`R^OqrCpsbVfNAD5tjE2qoe@w)wmc>qbu?7aMC&s|*AAMB`#Y48G@EKeZ^Y!`!6` zHw}~35UfYUm+R*W0VHKE*srk$ou_BVHpowd4zFWXgJm@Gx2m<~Vy}VtyEas-tPAyu zTm#Gca;P6&82%YJ0@`{3V?SNKv2;TwF%ZTaR!QRg81{?_lPFi`6fDeF2C14 zz}@e^kco{#qnl0K(#j=3Mom&U39 zbnE!Se9d<_KOQVUAAo#$Pu;oxICsn;kaT+$FoOE(;CJtv7lF1;IKQE*l*t z@LhM>{ly*mbRqYDf%e$v)-WSiXU+n}g%?vb{E)ZZ$TLbJ0l6%~<))4ZkR9_RUn(^s zj^(2)^BHlg%8#!-PCUVS)NB=Cj{}g(AfxUj1K+Jhp<(|?cWZ> zfn>9=1>6H|!p@rFh;v}A^r3cl^gV0NvgxP#0^#KeY1ucJJEP#Zcv!IwHa^BYxEuDhE+QkR)7YJY!dNJ2&k10)?cIBf#T2e9e+m{4XCr^Uc|D4@2%mFLwt@lA)c!&f_-r2QG-9<8t@&tHJhzi1~k6k6G`{+ zJ+FHZw{IDJQ(h%>mL5f*N?zu%o5NhJX7=`u#~Fw-1`N^Lrhp=%IFWL*1IX1Ulx|v~ zf9;%6R%H$P3k81cur0X*P%UEMbP?|@w+XdLzHk6>(^U&W#7Q27_w2R7^RdozaMTj# z4_9+)@~&YZc1bvVJdgYo^X=*drazEBp{@iEr?;?PuSMa*V)Pi zT6fuK2H&y2;>m3p-s=gP(R~ERJ;)#OUo*^7i2{wdVD`8dxaW58V&B2@nB$%i@%b6% zCo9$k-70^<1g3M@>2q(8=Q!(qrrH+yj}sYhgI$q_vN+_K(}TFWp3nN&0Ms$6$`?jS z9>Kb}lQ+(M1;(o7xK8OtVDv0pwXDZ?y~tW5&=mXP$Rz6JACh=Z+VfOo=WxyxG$SQk z0s7)~Y3Jf$pjQwC@1g#j9(Z*5xd!&bR2ExncJvvpntIZSTtF-G`8myk@4L&rs@531 z$0XX!NDfS(wwbMIK|Y>(O?M~HkK>4Ib&gEv?Ey-soJ!F<6`)*pK1-^+)u6AiF*$9ohc|$lF8>Y=|)cHMFv&ws-*dEmXr~696&q?AlH(&`BEOc!K|* z&RUiRYA`F19K|X3?zQ4vPOv2PAWuc4QmVRQ(Pt~?E$WDS33v3CnWOKN5Pejfhk*0o z`k>!B=0%_tc(l0Cem!We)*YKvDF#iyiqV%_twEE8P|@Ol4K#w}-N$_DaIe=b+2I`? zpmuve{s88eDQ1?K)8dfdyP?peITQlSz^^r*(6`ULJhky54fSyD=Zd)Mqk(B>9x7T{ z4NQZ=sYcUcVD3+3f98U^6ahY0dd`pkb-s2bKk+?pSra050pF9<{Hhd&~ZUT#rsisvKX+k;(h z-_S25oBdob5yFyr%<;bg%n(k8 z12Rs)yjUof?W_(=`*%xZC1E@-<|c2Q0#PStucCex-<$Po31gm7sPEN}wy9^LKF+w! z6Z5zjA$w+nHsJX%V^x!#ng_;?L6-IU>wx}!q2VPT&WmYQ%TIWhfo`w*euVrI=ps+{ zj9ox|VtZHY(UTGQuFnoWx7`RdO>x~Z<`7Vag4ajA{|M9=Q`eDD?60)*AMjY?{WQ>F zTr_}shLFCA-m5u4Q51X-g8LWA?DAlnq^+$UCBT)GCN1@@KPj9);qT*?g?!uPy#LtRk|;w18Np1m`^pnZ?V z2ozWZZFWQ6d!7U!TvTNlkwD$g=x@KYLzhrL>d2_3;GEGDdn~;j=W&~tx|HsUd44_{H`sp%HOCEqC(WONqF1+pyOR|#b7LAd7;gY(j*51t`6*y# z3bHGZ@%>1I)4_P0nGuColF6uhxOijtq0|9jS{F+dJkr7U<#<_i1@;3X5$m`ODu6L} zIIj6cIxrd<@8=)(14i7&FkyqUz&NF@H`s{x+U}FX?lGM}pDvE^w>Sy(JX2?PUD?gFh3LOhjH(eLT@;E`7d(5TOnTc;7nni6TK{+a~T_(_r^=Wd|V z4zJi`qpo`7{A+v6$)rSHd8(GQ0VsQ3u4tNF0&@E;iCreB|MAw73<*Mii0DV}l1ZEg z-zqiE^X6ea=#z}rwO9}S@w9WOq#`!vrj>~m-TMt9!9d__rj$s%){ z$JeU(iJ|VN{)YGNr&mEkFD2il3-bVObLOr|^aeGvhioIA=RwiN<7;h?ATaA{KYP@b z0<*@Z%p*P)m~Z5N8lmo<`EvJDv6M_;Cc7JcdUynwVSj&*#~eWY+_y{n zq7BU5Kl=Ud4Wk}@uPTv(I7+vq4rQSM=lnLF^j4fVFIbB`nK^~JhVOzOvRQ$##{UEB zTdYUraq;qJj}d=Ns(JVr`(Cxvs#a6T+m7}HUpzqsT9OLwRS@#FhBxW?BB=LS5)4Zj zsRe2p3-4tgE5zYF3wv~2fHIl7lGu-PM@;G5m99#lsI1g8O3}CWal-#nZYkpKb-VVV z&X6qbJ<9KQ2J5l1*Xv#_*2Ca7BajC`#Ii;7$9~X>)~WJ2wFyWQ(mkS*Bp@9$j|!7K z55(MxZ&f8Yhio$yeym>y+5xL`64=)fCi2f+mSF|Lal6ih2Twq&b)nN1^F+0nXO1r$ zb7P;IQD`xu4w_nzoMJG4LZiswpv_y%+t-K6lsouK9G60Ylg=wfO0=wAcyxW`U%;D4d^(RcL}sE z-rEP{D?*$n)6g#^@h|J%$|^wpn_sIt=CK|JH#=eO1qf$6n>bMhI=3#*42EDXz$jlM zQ9J=i`s`bpN2-AMT-#DP{Ui{#X2w*$#(D6PHfy_nCFaQtFx!6zV}8l4!#A775I@{= z#))GXw6qF$6$yxfW-gz{Mq%VR6g2~5J8D29Q?Mt37te`o%Awmg+fi@Q`sefPc2H9x zDJH1tfTGGK!_|+Tz#NUAv{vi~=CI7l-HopVp85wdLN|Z1i71Nz@53Xb1s{ z_FLyZdGzD-tPcs~4MP7jh1{8lIv}aj2h{Q1ga((0or5@cxEo1q3;GJM{ja63nhEGc z^j_pay(ejiIGtRW1tj{K8Kc2MAf|6ivrIJtB9}*GVs$oXyRY1PXZh5R`B z2Mn)b9zcosjq?4~xL3HT`_BOx(0qL4$F)7^?-VTv`dX-geQxJuFB|U9+4l4)r`lmq zxBB`q_Qxkslisl;ig|I0;-3ZtIPe_&b(D2lR|(9;u|Abb)U!`tj{0;T^`nErUEaM| zpN_VZ_TL79S@!gY5bH%?rslC4n(f7YY}u+yjsuv-V^6)L8Us@;(Pp{#D8BD9svcWc z5f?K&FZjM1=aRkKoITm_9hr)>{)_n>vM=4IHNOLW@UB1CJTKxXHE#OXjevgSRGsZX z7Sva#=MSgp0qu46q)4hA&`xJxKfkaGXj|J~hOKY_wfI261+m9Cr!${DGb{iq%Ys!0 zXAMwNZt-Q-qD~GBlMf9W0H(|&Iqoq6vOjaQUmo||?krp}KhFoyxHV8r@Fmtm-)7gS z7}n$HleRCoCo=4$UC~t+APpprN9+#+66o4QRUt2!eE8Cx?e;)qeR?)$vnyzyAr&9l z+z*8I6{eM0ED+$cDYql)uyRT-7!_cDB^4Ln%6%I&A2_VjuGt2fJRC+|)=kKhdmZg_ zZ3c}EDb}yj#X#L~P)hG{FsKQPPe<&U1jSA5@AiCV1zm1+7qf{cpu7H+{6`-;=&s#A z#m;U4%(()0CJE=0ACwDSSLwiP{@Gi+B8m6ci>M>hTY(w<^o*9!|MSb_o=7+B!)SM} zv|6KYK_D;VkuN9WE2kb0pF};@i+A&`wm3I>tn(AlR7Aa^=IKwp13;e&S@VWn4d~Cd z$1cZ+0^M%Ak?S1dUA!+B9{U5|~`C*u7j)Yy@MdRuCF*xf{1+_UP? zG~e=l45;iC&JylF5LbLK0R$7EP~&+_lShF3-S*Kn)RB+_6&iPVqwZaLs?0@)Ssf_CYa+-$0D(S9}|T{L?=s zeBcOG5}?QbByzEI`Kc?Yz%2@J$@<9!t=YqFJb2Jyok z$NnuQqh4_^Q5yb$`ij>&`PmH2b^j`}qa5?9*C*>=)7b_J|Hkr}U+h6wc-uKU6%Ei8 ziVo~@Cx zMYm6!-B>5%*VAXp5nqw=^ethczjLy5eupl(Ue>UE)#R^a-e3#3Q!|;Xuhe@pi{{QJ^sLa(`pLLH^NH7r2aipP)%|1qJMT zcL_MEz8wc>+E1*UKwi*Y+t|;D1?#cP+za_Ro$DRWRX1ya^mSfl%}Lxdte$*zsy`3+ z;8omoPoKp-U&u$R9tLeIA=ZE=$j8D_rXds=<=w~9zkJF+$eiV{yy;l7=KN++MZj7xxMXK#tArwgbKCP zi(ozU7zwu(@!YTny1&&$-u}&>+-u0|(9bug6{w+;@{Fo7EN6#XX<-)X$FkAHDcZ{|M-}9ojs) zCp;3!H)0#E1T_FzcGu;gTAa(9@_8lDX9n*3K1ur{KPB|QV7m$CRtLVe63E9qvM;~- zGH=@fY5!C289l_WZjXLvVa5ECsW?b~Yy;Y6sbUt0mk>&4&#?+%J$7C8`W=9ExGOjM z>Nx5a*hjw@H06M%&&$V4k1+3Q@+^P`NbFTWJkN?x=PEeOQ_$NkVH>gfI ztyTRf4+_2V9#I$kL08T2>^z~_Gp=-;VW)^fdp{V&mu&K81v zifK24%NgHwxfdK&=x;mR=hZ%d=Vep!20QJwK(C8BT(-6Z=$Cp0ZT4nXZdGNf`wF^mpK;?1#6)e0Rad-WNidE!6 z3`}hV8r^|Bto(F#JMJY6*(u$>191~M8MlLBIFG+ma5^9=j`fgLROrB;LOh!f?$HDt z|2OoU5jP-xT4yssQ~{Fm_!;LpAs|NBbR=C<2JJDrC+puZ&^~zU#%y365MIf@Je7PB z2;yu@jnA+SH@TZ8KJcRNdC%CaFF*3Kwt?hHvL;b?-#=VOt zKz)0zW;hS-KOa0r8}XC|h1T6-S0$Z6mr~?pz@G)WAnBz2Jp*(#?6(-}_kpg$<--wY z$3S1 zv&diVdz-?hvL1P=cMEkr%0LS(h&_1C0Qr#I;&}5q^h?dBpTYi;dLjQREdq5w0^(ck z7H$G1&pEwvFY0)WzK5GWN4#WI$<7k}M&!^~La2fekmdOzZgobv#Cc#nL}F!b zPXh=>ojsgA20B-}TNnQ21F7Sn?cJ&m$eTOuZ#b2JydeMCOR|`^Gz2m4uI)pd{nMk) z1k@X5zn!;q)&_#ms&U*r@_^URcFU!p4}JFU_7+nLXr4~`6jl;cOo2?G7c7Q?+_eS$ORiJC+Xmb66JLn#0?$$!wNtebV z8hTt8bk*6!)$;Fw?#}NjIt@{HP9D$Cas~o($_Apkaen`>gWu;6_P?2bVz@D1j(L^+ z%MqbG^dZ_$WdQyzteCr-`w8MGfk}O?SAg+2>}~1y1Hd?OIxVxM5Ex?Q32_Tepns(L zbm4tX553RvhLa!Yn$E&nvFJnpIo0mOh5078%=5Xf-9dj&vu~X*;#gloX4+y!fqJR5 zLeCcGk!^{4oX?_P?bY$k{1yE`G1et%a(V;#_lAA0tJOdbo6cIC3B`I$FNu;+ch$@i zXXJAT>#@c3trhmWf`W>gV&S0U$5%Ff9CQ0x%Rbm>wgX8{aK?}aaowN|E2~SW@A)3A z$^8fCbJ~T&tLTFvWY#%ymX-m5=fqOEbr5Lz=}Zr`HiG7Fdi;UAxF_=XiHGq!?Lea= zg6mio=DHg^qx2~vKl?U!gJB@*eAvT_iY^X-YMaHshcc0%P*^B$e>od;El!gkG(H4f z^ZMwnTbx**arFzY3P6|K1M-#|Kvy|QNK$4B-+OJ}sY0C3m*1XSy;P6)ma&8n51x~} z@yTDJI9G-g6N3U3fqAsa@?;a%Z70>GcnR|#Mk(fsa+n|RV$?75U?nilov1DliUx+v zM`mER9?*Nv=x>da0{U%(6*rRt)YUz=37ufWIlb^-Oq?9h?j(P4zq0{oS`QQsaLpmE z*r9%N8RvDs8#^Ao?*XdFKt|+GGEj;ox7COh0L3JD;ANyfkjI;N6jV^B7@@xM{Q>Gs z6sl^M;*qayK3+5R#T4to`hei$03eVm+Iz9QJ6~Afx<#Eu~In^t#lL~}1@u#gb$w1&%{yPxhhC0vy|J3KO>`}=v zqUOLH7}j6PTaWmP;mrLo^iM^7CaCPafOv4~>r7s(hhodm{8mTIjpqQoRU)WWLc_uCm zMVp=g`KDvYQJhoBia|d@q(`wHMSL^&l9B(Ik2>1B2J4}^Rg^arbS|~>{-`nrQZu*J zn0FBFiRAdwIl~3S%g?&o51s?zM@f3Qor!yehh|$7?qi-z z)^r*12Ik2yHrkv&2J~A^W)6%XQ?l=;KVNp9tVJE$hfb$#^tsaO zr1Trw@$ZVxM2hQqV6IipjO)DypvV04F+79c?<+@->fXErbce=&dqZr2&a_<{rE7!w zHz_$&iAA7uNF2&xTm@Rcqw~QlRycRByIPY}1GL+l!ptU7@9q$JLuLo!x+)Kj)NSGf z8Y{V4%l;-%-^U-n+SHGJgx8@DzPJF@F8_$eKExAuC55bb%L8Tf)@5HZ>f&A`?da;c zg86;@U+nLmM!fxsNAqKLe9z^LIg-%-@wD=9?g%H4&ywZa5(V&_q{Zt5BJMsuye;7R zU9883%b71Y04{K5h!)NOX!YFiV+I1S1oOHkC4x>Q+oQ#Slb|DVKk;)I;=a#oFo+-> zNF@K!I4#UgZf)w*I>CqeObPb_zhEBh-|?tlRotl0Ds_tK)j+)*OT9!!FA(ZqowYpi z75%xNrGD$8f28%Px~OwD@+0p)+*GfDJ??z&7R>HGQe zc?a@+LCrQv#U!lH>&i^EfA}7hija+6fiBe7PbjTMURE=+av$>JRiEYj7LX5&c`qq; z=m5~{_n8YE6i1)4z@_&qbfEr;k~g%)^HEmRLDK65YG7Jc`l+WtWt>YFk(xvwf}CNF z-6BwGXIdgR#ULN`^OG(5{3s;pH6o;6Kwk8p>=>&BazVf7k?x;B_8^t5`-gt$y|FyE z27Ure4xW3?S`F}0PJXU|72y1_;_S1f04kTFZ%2?pXM)XVmpD7Du1x5t=s%FHD z449bj9y*`bRk9ffk`@(`EOvl<54=CLsbcjz z@~qTu)Qx6UD(}=l9!bW*Gzjl`JO3%?QOXk6VK>G1_1XHVxi=7fUF;5x^EPXN2)Ua)gmfzG$PWe-d0(SPtW zLXC{``p}L&H^y6lac8qs0t7_U3lGh5Bc?kx68O_60{XR zvS|mQp0_NHlY9FO)B|laOMZg6utRcYG0_^JrPuE*>M)9XJq5=z*K2@s`s1*NT8O_U zvApyxJ&f~#y8gSZh;Q8Mp16889(8Y1a(iFl=kM>k=SVv0+}yAJ8i_v(3>%J~nyOY{ zFt=&tJ`X_MXk{%l{ze>~yTbr;G3n!+j1!xM(I;4aVewHlo|}XFuD&`1^owsY-L;&s zE|T^ZjWs~u7A-&0^%rP^Qk=WDJwx65nDoyM)GJ&B#N?L3bD^Su&_t+HBw{xuIezlS=P`0{|EbH-{ z)Eg#7_iF?Bn(3UL9|OpmS7YNEcLU7S5639ueU+_f|20BeOxr=)FJ;gM*!J?cuBYgApWfKD3N8RCO{`udQ_)5VW~)_QOue-z*SdnV*oVl2>(zBu~+ z#7)EzFUhXn^a5(<$Dol`exTm&+tR`G0IFVr;z#~L#CJWv<^1aeN&%_l#6NSOIO?Px z&_kWIu)kA<9pYFYSa<${As}BbPinb~J}T{(g&H>t0A@QJ^l8}lW=XzKdV+JiV{G2* zPDg;9yPryYQvsdI+H8d>^r;h%E6qy02U3aniyfyiM~<*Ynex~P_3nSZ`ed5`5&o_z zWV;61Z`rq~Z1cqVoh#w9_%aZ_upLi5Fp2NQ$bJzo1<;z#=dDz}3|aw}V%`dE$miVY%Xl5k;F$Bhv*W2uH0mK7)_N{D0Tz0^- z@TSNN){VNp{Qgy7yg5`><12ync|!Lv#d|EotS2?|4lo=~N3N%1U1`6CQuMHHJO2EB zqkj(QGx0l0oTh_zblve(xLsVRY-J`HC1qsqeeS;32tSmSL^P05Q6wWI zgp81tM41^GWu>B2NW&~6k*r9Cl-~3H<#T=fbsx`j&iSr0tF88^68&ohJ9f%*{|1sn ztI%V$>p$-ai-z!w3EGnViX1)>i?!(6W@1Z}( zkRdtv6!XM8?p>@oEdsg+*}jzIwBSCF+n3IJp9bxN-@UFWz5vCUX4Uik$g?U+(S*(+ z53+CXg~P6On17`q`AOawd2w?>-M3dj;|W~s7N0?Uu!WL3lYqJ_Y10KAebmF%bA~G8 z?<*p_jVrP4CuC3_H&vh>ezOw&6EEsYMz1M2D zXAfeak;{zXCD%tw2ak0rpwl+msKXF7cxxPjWie z@%XQwuQC>ZK=_lFll2hbm-8`S?^=LTUSGF5ZU9$S0m(iALPN^W8?wyCg{ZGNEp9i{UTxQ7y!^F3R7z2a$|d}jF+ z^pf8t9h^G}dZHU%I~?NqreUG94?!cHg$qdgu-Jx)ahs|RhcH)z6Ztn9M*;; zoU0GCIScxE0?oQ%Puq)dpzY6&EAT+w3E8_{dCCEKCat~gxTlXMwI;bf$Es%n&zp~!hggUI*Pcp+epATMeoP2c}h?h0_AD_eXQ8$m8 z61;&t$k5~tOBxW8-qp0yQP)6LOVh0x#Pj%0_f&`mDB;N0Nj(bS?4Qm4@hRdb%2bmn z%*V=cOC*`f&0>b=c>jcZ>JkJHMx8LBIt7Nub$Y6y52*yi^H;4G3WBF zh^B`pC|-H)&t-jh8ysjz0C1zMMQpG4g03{QhaPcGuM*`H5iA4qf9{J;rmG#cHS z$*7eXXex1~oS0KZ6KZ;U+XL&$^3OYpQ>a&XPj-#He-)_ZjbwfstUD3Dez~;wm@9Ms z=g$#*zjn{%l<&p*{%zv>tx@#r)Lj(jzQ7KYpf?X(9exAFV8im3|L><-lP4>F#CuWe zZD~7^tLjN|>nPsdOGXw8)oEc!?dTgR`en04c zJSx9o@B`@EJxS!R-v@gAL8?+6OrU2M>byA$ajg%}GY$}>K-YzFHKwBmbiS^N%5I6k zoUCx+K(2bs3z%UE*AE9pr#guY*GR-?-KZx$Cs40IV7~qTyrt{!j|BIOpw35n^n}Pf z(1Nv1muv96P71VS7!pxe(w1U8jPID%!6QatM}a2XKNELL4X8gHM5ei!0rl1ssWN`Z z)81p8tTzU#Uzw8WUex~pi^CTmE1AB#RW z-n#F?u>(Nvh&WjjoekvB@akM%W}Fv$7j-O=kD4sh(5@$eISjx%#@tT8emAD>^$PI<>amUps@Z?QdA!niPm(Ga3}x*cE<~M! zrQqd@i7ueuu{B4tpcwQ?5s%>NC(wK38a(n9^}I&6vW{h<@1Rvnkd!qFx)dS7&2-dP zzf}Jnx=9;!wnf;@|B3*uj)D*`j$u<+eo!L)}%&LX|MvA;h5`-RwluQPt;xva7@4Fi8u@Lt0UhHw1Bx@5~ygMn0WX@ux3n4oE*XFRKJHa2{E`2mXlf znw71|ztaHXvKeVUPXUOzy!^f^#z3T*#9F5zUa}}%7;>Er2wADmeBL6y$VfR8@2W&TA7`CNdDu{c|8hwu}kq z$3IWUeW}Pt*-&}oaK2X$|C0AM0rB0U&%5K>ft>rTG%$8QkSznBeNDkRg~_iv+1Uq*n-d14~^nHp5n;YTK)=ok;m!mAtyoW+EP1X?E@$*Kpu0;6`=jT&gPbb z@6L+FO_AAM$Zv#IUXlKSypzIq-)PhU_1e*`TOI=KF|X=TUq0kJ>@7JbBJe$A0dA}_o6X7OA_x1=j(gOV^O0{e^!=r0;-v$p>Wn1 zP`4FN1A{3ME}}{bV+H{ z#pQLBUK>#Yf~jLJqX_4Xm8)m$hH?N3tq)wftOH!eA&xj(A`y_fmelzX?IWN3==NtPQ zH<%A}LC(MT9RiRqZyf1gR{%Qa>p?=%e&o$fzNEjyy0V~NaC|`nXhSJx&)y>c^w_^V zasc%Wx2MHs{dS^0?w^CL`a=P^H~ZE_U#qkUD? z^36bX&OBs2jC16!nrByKl7KQsFWdHe9Q&;RujSzXfMV@FpML2I&WQ&8tN-+X+^{S0 zqciG$P8v=ahOYows8K{y`wx&FJuUVt6F^L2@h!W z<we>B09Jhy6KtrDV`)1; z55OGplm2t+WM-Vp-NJYD%z&W|t?0rIS1>5x`TFS^&L8|`TR!9>4j(C?ay{ig&|B5a zzpUU3dOn*sNS4*1Z|&TkXlGW;0SH#MKB@>hpV+m;;C{729(*}JQF!!T$a zS-VkhH2@0L|Ajr+-3xSu&cD-rpOBwD`{>i4B=Ui$+!yy3BLCF5NlPdh=xlB$2DcRe zZRrfB-#!)8GyY&7BL@Mk;fGkhVKmS(B4Y}KUjogqk+(Lx323ykx20X!FK;_-v0n=J zhD_|$+dagBeAJ|;&9@g=-@Bh=FMdMZ4=ZOH;$f7Vnh%efoFPj^00K&gB${iiJcdbx$$MJLSK-gbgB`Adc^Og5b=MVh_xLs7= z9z6>1pG4RvSF9f!6!X&qUW1Wq&f%PZbTEAOy(QeL5BYSHJ*Q6*!5||&w^R)0j!myZ zlQ*Y>zJLEQ6AHdhU(0n&N*|$q6n6gQK|G`{^x9#2BlJ7F=+=1Qp0)0Neyu3HC+6=h zUhR4Z+9{_?4-a9UyJ-N=2VyNKr2WmY;@^e*>^cwcaW~}AvkemWgaTdfg38>JPUHo1 zMIC0tQP;q=V8(P2^;zBS`OH{nzI~rocUA{lPgG)M7}lHeERMAjmySZ?_?zxq@HMT+UvbQ=kECf#J}5c)wvIv5k}i9nXyzI7@j2S`2h?9bE@2M+MF z*4V}jr0wr+ElVI@+xXuz`@am#ZScu$QX&G8`RKH)JMtlS_xKv>)d0b~RH6A_9-hY> zr8ENj-uy96my+TYFn^@7<6b17{-<&MBJPq0*j2k;CE}*4-%&qkp?z_7fe(2nZ<3P86cvMXU^$fO_;fEQh zH?iDi!Xmc`=oJ3VeA$^mSEu)i40fXq=*b=R;UUyzB`T3=zkxQ<^ubG13*RrN_8+Bq zJ~uAsUiI4#v{UAp3Y)BfX7JiEs^bRg6{Uw5FA;BfeTqSHw+7UY{){Qu22?8tg&|fS z#38BTv^}Xnc~)`n6er>-7aqGhO|=6>@wSQ`pA?WkhB{w&az$N3xQn?u>KjyhOZL9H zhCF(4oTfecr7rH{?8)E+lH`@<1MTO4*vcGwS4ta*E<3HptIq;)qokbAf(sCeeqQeV zH39^Sbcq`)TzDSq@60^<@jN7Jvru0F`+u??zhMbRE0gBW`B}i|ptP6cH{5HBYkYq- zrGTNBT-X_BMdZ_8`$oB8-S~E1W-A~12oDLKxPBMsz|QNmq8#KmU{1ol;}huCai%TH z{lj^DJWu4m@1Rq1%(qGoKu7jU)X_D}k@1KQuHgI)TGC}>Q+lbO;QpZ6BclQ6-s0>g zy+?uWS(b29?HthE4yC7jR7T!bH6qg$bwG5r8-ywRJJplxOA+!w7oI2`O-Gz%rP^I= z7tSH?CJQ!A)M9^}62rcI8FdZs+IwH2?q`4NWo>`d{fGn{j4MOk&!`}~c;+lnZ#AR@ zJTn05k*llkcW*#FZ>7Z7A|s%@GpXEunGTfb$Yq!3h}-L2spCG6ebpCSWE^M-7J=Q82w1*m>l2$BTN5* zy*Zb_urgDdDXtU@1-@Nv*Tj8mL9VIMZ&7FR`O6{KdgRkBJ;?7vx8U3{vL=~q4ti>u z!S^}0g6>^sp{&9X(3RY8|M!6<=-gP6y*7b3;x;H!3zA2_Gk==a^>Fk%E0ILw>_NdI zj78wOIMBlhuo#IthLDat!EgAzpF3(e>nwriBX~_Ye-7`@1k35wv-qxkn7{kN9O!Z! z@vXRLh|UrG^E3!56c^L~K zp=6)0U}P$O#a9pOMhR!a`2Y^yuJkt{9?z(W&=Tga9v4LtpxO`7XsewxQ+PX zGWYq%=v&+4lytkh8gy^uuZ-+@47ywELsY(~fllnzij-Vt&|wpFaS!tZZCa1jV{K#H zm-^PE(8(P4r9KE}zrF_a6rB&&^9-P0YY6SD6a{(=;d}pw7@!CDH0!A1d3pNz7Q9$M z{fXlB#lUS?U-<8OeS3mBQ&kqL@=~Dv%IY&^y@mSTllX|M&<4{>~rUt;II(pmL&B&D$aPueCx z?4ZFk7;ap8os`fD1}Ba9-(K4S`aP8&wqQNc z*VpSjsJ0jNKd(j;c%FmacAFzj{_UubYn!*dXb!rpyr*xfw1ZBtlmb)7cihwY{Z=r6 z0NPr`6Z-qbLGwq%p~tzmKtYDq;K&yX^a9byGBqZk-@5*$D60(UnH=Pfh221p4-8rx zs0I3kZ!%iK5kPl8y`ivu6m?qsO)b@X@Sc3yV5M4tdXq)-DyL^SPagcWnlOm~Kj&;PpBBgOF@+*23Ls@Y^z05Z)SbQ3&Af?mr)DroURIA_r zq5t+ya@GI`@>vIrndGwZ-P$nm{JcK$BgLs_rG0Tew1`favx&oelW*aC{Bl4_Svz5Q zVhBiTA7`gjFpu~3z~%7b`#?N(E%(WmP$2S{@NEu#4}^PbN2fbB0l_NWrs+K5RI9>$ z$9Lkqanon3mD2+NMw*k&?GiBh%9duPf%|ia4odf?m%uPr!1ay`GZ_5a<=w)66%1TX z&zTspfd2F4*AbKk&{xfNFPX-EH`m%)->4Gwc)5}#1ziw7to8YE&lz- z+%;#)KLzxhoo*%gJ<{VmGYJy{u|FPIh;`~m3{O!yX&;)OUMr4{G?${G{cL@FIN&H%ePx1iO z__Cnd?LeUXJ8*LSwLVZPN)7ZGSl^v$cI77i!i6* zp-I}0VlZ&nwIw=S3-lkgU+8ze4EnOyV;zuJ&`S+VbVdF`k2OGRRy_@L{f}MhSjK&8 zGsKSR|EfU8Wwj~|^Eb3V25Y`xjs@-QE-VKJ{=IujC5+)r8ZT8 zVM@q+w_q3UF}gqXS{Hp%)`ZCh_aQ>-ANIj7lyd!@>5^X5olZU&drh?gxGn7xX6vz`t5l^?{@2mgY;h-~zY;AGIdlpnGF zMF;n^=qS~7;9P!WU_FD|1a#h?Z3&F#1|5?>*Im;wKfKLp?a}2N&}J&zN`AHxG#?$c zmR)`b`zHBJj~2fN`UrdEONnKme>n9`H}4?O-`(tzj{l42a+|G062JeN&?jb{9Qb|_ zZGCGzfF8DN8tL~1=+2dflW9Ca*Nx~)8wv(G@0H5&B%C`&2FdJ{tw1YDekziT{gq!Y z$6gxZkQz_CR}}0Kmk%v>jYs_bo_c+Pln45z*isFCP61V9ucrIF22h?inH!gG1j?CJ zSwbh~oQQJ-1W%!U>*+4p6&WWWAM-PM{*52VYzi4trL90JyxgJkOcO}N`%|0Z-=ZJ= zx5@}of+5bj@G6{Gayd9)dxQKI5`Y_hoQjz4p>(mu>!-%HtF zQ&4;oj6Pi2xFf3r_uz4f?t8_H`W|VGp)f%(_|ibRSC@o24Gnp6F()vOOn|xIMnC${ ztD^LWAAnv^CSJ$it^tZj60yxos z(3&JW9ovd^MNXi0MGoj!OV5#Ju;22Ompjxhh;w5DU#2hi$J@^cw~?vX-XZ2+2)T0xvK;_rXMQU{dT(5L<=@R(v1_PruKBgA(=m3+VvX4;1M z;>&|qL&(Teg+#h6MWP>Mm?9JVj2}2(T5($^Yn<iH8-k&ZaKe)2)t3X9u zH~V3|&A=o8`AE~ZVnHw(c;kK$bwx&s@f$3^dEy?UPchdFkAT6a#^P;UshIQ1?mcTK zgt%_4<<$9)pwCe$n-)(7z0*^wV!madJ8Ha1b^(2B=55)_EN!6k*x1bSJ=PJeXRYP7 z*Fn2Nk%^+Ahx^Y(>YikUfM)T!b{g`B`(AwJE286kzRXmpXpZ0W56AEC%@JRmJsoKt zcna?g8h zIxz?3$B~NxmD_>Va*|)MlMb}Vx!e=8e~@3~CI6wf0Bz%s#D5Nxh@Z6CjQ0J+9EXxi zXKjp7*Y)Nvt?oYR-A{NQRtW-1SkBHm+fks%=DjHViac&tp|f8E&gVYE(+su>Aa4n= z_#%qF=dwm6@%KtVqQAHm@_Y%1V~eWMZ*qVbG%p;#jPv0(K9Ti779iAGrU%+6;CbXJ zpR@iyUh=bX@d)yR*<>4jhw}iWaN|EpsH^TXw*EE2hkKJzt91D?b0nNeYt!-7()$Yh?JWb_)||=9ye5JJ|;NnvJ z8Sr^jsp9$2)Q>7C0DYS6=r%w6|L?oPJ)S2C^p52vIF~3|ly4FI479)ZC%-*Wz`E}F#qS9d@+BE*zpRphX5n;pnT|SZ?lJFIS|vbz zX575D?io-oJZ;FZK%Po5=pl9c5ukj??ib*+0m^0jo`}=fZz+zy4RT}w@>>s6Rpm&; z6?ZqJIK2R}0QnL*mI|bbf3?xB$b*=~PTQ*QN8VOh#dD?+bq(d#rhy$m6tTVM5Ml*{ zI;nH#6?frY5Ekj+D=+XoW={^2>H)Ie>DsTn0U+LMt;oYY_3x(M+!aUOTt=zTJrni1 zAre(<*D#N4pkVu?Fe?~nm3n$FyaN4ng=ZBKf}Iib{Q+q zXkc*d*iMl*0S3E|9bJHg=X2_1u^)clKXxSC5fldcSooevyGWpSlz927;C(8+b9Ec) zndmXmb4M^whwkboDRd5TVlC?zSGK1BebedKhM&m0zaANh4tkFK@5A*UloIqI$TW>{ z&SBqc?#{4S#JrP(*9`qo|9Hvc??^rJxatqwBb=py^68Ydbvm9$+{49$4an!Jy&imU zf(OWbpXUGUHU#o{X^Ahd-2wAqVS>pYNcXvW!0|+m|zq`YKVo{Ck$$vG36>k;_9Imeo)f z7Y+jD#|d}gfgI#59v`|BihH_VS-3})qi*!RXy0>HL7-$P3f#3uoHpoMRM3lkKyk24 z{au&}6z#zLxf95D@NeHhtVaFLjKO3|E$ZDK{q&Ijy$yXH7D0!ctAXrxxT|9v_ob_= zf2>7*kIXdIYsZ@bq?hNf-Mmi1`H%PV{d~+Lv#)!)H!mDW5>W%w-4Q_ibghre59@dS zN|8<6SH!Q5h_LV91jN0WHD_07K$tFQ9C1W_T=@n6mt4<)a9T`ljDmcwcBEMs5%I+J zs=ZPxR+u-FC$Fy>18~*6OLRK}d8&rE|3n7>#K)$`l~6z06FSde(*z^;qN@z{gJAeq zdwxgw2pFcyIqq=5c}4NO>Zw~h!2q|)_h@bf1GgP-+^S13cky^`aK0qy-~2apEHn%I z0BYfNRt3aW9-TQ@qz1|p0TDNEBF=YSb^fWWFzO8pm>%y$p4D${s6QCb!$arPv^VPF zoShd<27`e5pZ{odIsQKrLjRh)ME#pW6zzDx0_v{gS2^Uvkbk`$#(S6nl#!kbDecNY zd9?Fhon$HEA9;V1QW5_+=Y04w`t&Fk9z!qM`BC5VF33_t8}naFj08?0|JT7R&~Dd< z`ox(R%REuo*Ir%}Q*o^HKAlBDyk07J|$KRYUF$Vc`^*7hciP%^DFmydsF^YXw0#p^EZ|dx0W_f?) zakbt?MV}1?`2DEvHv0{L=BOAG(-Q!fcCHJnA-+XV6r)l<0`PSHxjyg*j7lo~Nw?0R z|GiCnyp@#Lf_VYBpW7LOj9@Yvt zA5_JZ??)Xo^$rIFnl=G7ogrTNz8ZN~vr_MBoU45$?x||q0oC?7{Zk+E83vY%RJ&o+ z$3H)H0d@V9zuK?Tj(j_VJiN$V3_H;lg57;!w|E`6TN=CE~h*%_)3ycn*Cr0mmg9fs|(S!{9gO zFIlfxO6qI@(w0ug$5*}s@x=rND|!MkQaI7w*$F2XGZ)2e-;pN_uYFK&1cV3G{i_yH zKnVD_^OnRNAZY&nwRXZB^(O4EN_mkltluOR{n;7)AhTCo9~c9Ek?BKX$g4A*Se1Ks z7>us`XjuKVAB+ULc>?M=!7$G;?D-)24VA99RsFym>z07LQzLu8z+z>|^4536fdwl3 zZ>)j-xu>5`j-bw$m!)FhiwX8)a5Kl!9r3MYuJQM+pd5AJ`sN(0x6B7BoMN7$Ui8Mz z6&3v6*N*9>*^2`8d-I?u{VY%?3*3qq5O3;}w0h!({OeQATVfhGK9w!>c(H83eNna} ztfSZ`1q2!#56?zso#Y2C{+OsG?=P|Z+yg#5?pny)E>Uif}}>v)8A<}l*z9@>kZ)*3*PT0c(z>5KE=U)5A4)VC)|an3BEe$?2-nQ;~Icb3`( zG0fd1H1CKb-a7?^^9h2DIa+ug9KjdN&}Xm|^K>WoTR=a^YNIaJdEXd=)P!mP)eTJx z&K6)a`O!Q7#4#}PxG@(Ws|<$U)r*{pu>T6oKh69Qb?>aBno2sD@18im`u!cAhxnaQ z(-sou?Mq8P%|%?^$Yv+&W^vGaqeApOkG?9EM9Bj#LZH)LExd8e9F(12YEBoUzQjPf zv}vOk(DZDA9cD9dZku?1Ar<-WeFGu{_e7vcsukZ$MI3~8?WpTTN5pBh-mfHB0`>EE z71^h9h!1KIE4R-8wUqnBTs@vkOmu?X%dbFns}&ja&A@w8`01zg1EBJG$u1vE!*kgY zB{qcqgsP6d7xP$mF2-sPy6T~BG+=hOe+E#v@0vo8De9{=9%N`sBJZJldE#Ux;)p#n z!d5qd%q=|Ln~Z(cGgT`joG)jNO$CAm*Co->S%3w?!@~BHs2{zuT*W|r)``*i z=H4Oz8KT>{F!bMcTOa-W&=!m=WX`vB+k@eom6a!anA3Z(Y0-FJH}=EcNl^{=z~I;> zxp6ntEiMM`ja&Q-`oT~6m(A-zpYub;(U|w3m)UsHD}M{<{(5t(Ku7^}5;mTY`K}4d zdZ%7!3n3osmsNOvEgy4~9{hdhhv(wKH(SkK1GFQ>`=09+qmDF!dLGJwM!IuVH)$jK z{da5+jz>O9Xy%#vPY%3KyQG%ABY-;e%DZDT-kbW>tEmqY5ifkOa(w;(P)|tIo@$Q* zs=lFdXX6@Bx#S9uGwb3zwkDkVAMzcyo@q}m6aeMKoe{QUy+Bc@+xR*feIeg?8?SdF zKU>zd^%Ii>>KS;}BkgQ~EVW=k_=4v#l$gRS;|Zi|JpbA`xPU~Cb+o}UK>Ve;Mt$W9 z#Jk%Hd2bvCq62JX=U@dQZ~lzvCo>?l8A13w_E{IWnNKTX9;`YWvF+q4z}&vQd73*> z|8sgqmShFsGB_l=9eFAVN86_o_)b0eQepBG=MpWQN5=x+fMIQ+K*;esV5q&D<-F)B z7&Me@oKlR8-*A%go^E|6uHX_%K)lSvv!|7YvJyKg%% zchqsoY+md#D2v__YPxb6X!(J*o4VD2mKSwL``~7vWtPTS92rG_=KLJjKm7h9{>x;Z zK;Fr3*!*@H>fjIED14xWd>}bVm~jGgPWHZ@;c&nlC{H?K12a+A5dD1F%aITLA>;Q; zUtR_Zhvu>HetfUmhnw|su)hsmvkxm%2eNj_LmdOmQJmi*@%_ms)WtD^xDRi|{H62e zd2L!i+R)9la1iIhO0P`K@jb}fItv@>pl(s%=J>g@FVGJn7bq-*{OyHh&%$KPy;Ng% zEy+Ot!8BEzFphl4ttQ{b8mt$Nt_=Fbe*nU&1&RL1-xiu_w|F4GE_tRRtr2;utT)QF zPHtc*>Uh}k$21sZad6lYGVz^yv&Z&J3+U&UbnX9X1Nw6D#OG2LpjYkl)uQzy>fKFD z`Y86e$6iI_k+BTuDBWt?uD1Y6e{25R%<>WE1gFjvZoDU54hNI@W^j(PT-)Fff_Xla zXEr(EK&#Mu>#vDCMvk72mk;8C(Pmq`wo3!;)CD&g+bW#%dX?kQ??_WRVLHjf3p5Vu zi2%%Tp^k<8$v)Qy)EYVU&@FsGjkKTi6T5|dnr!gqo!D24mVaI?@WFXw?XgPKEppkj%$!gJ;)AhSb{51uTxV>+l)foscT0SYLgaRSB zUe@i$9w4avT^Ke@1Nah~Qq?zxc$UKzkDkK-2aY==bz)z|TYArg5B)hQ)R5k)axmh& z+M?R5fcom)b6pf0^m8(^jo(6DR*0w$Ycb|4{&Vj+%!&O}*pN9(X9VbP^0rm^gSmcJ zMH+77T&pM8tDihobU^GMwj!xZrXX#ORs*K-T- zT{9oJbS4}93%dul-ov`XYVbp*0{tPq6$iflLq4z|>C5mE&O1Kq>Mw7gFH48Z$$*S~ z*WZB+vl-|EX$jlSwfq0|L`pb2OaS@wVYewx?6bbVt=Ts{4&KCiq>$wpq}2D#7ehctl2ko?q>WB|5WvB*mk zm~V1(XYMp z9p;vq-S0btb^OGSWC<7SrxqHArVb$9X!zDSgJA{QquCBz7mYwE!JRtjQa}apwayOW>`v2VLrou?4Fx0Vjh4~;fAi4K>b<%F)A_ys88%OsP%Ynt_B6( zXL*Xe$G*0^I;bBNj%9d+WBur>p{K_*1106f;osxvuiii78PR7Aluf!mfjLt^emEGg zcx4CTiQg_f-pd5!9XZBaPr88gg6pvNHM}2Z55MCcaz;N$XWrB!ULZctd&x4JO;I!6CLn8nAX-t*#SPqigXU6&f&VBMYUfnfJsHr zA!*bBF&iZ+3d(@d88yO10|3KG->T<9A*kn7+HhRvGw$~~JTJA&2@FhDJ-uym(I>T# z7jMysyt?jqX`e0VwRb+)6nXXS+FHU7&wzH*^qu&m0#NcI z1w>!n40O_?nA|{S%wtGlrgwEBKhB%t6pDPhvS#bfE)(RNc)R`ArA+W069_bL#(G2CQ&$yC0~+7)6T!*YhYf!} z#nBs!^UR3HfH?NeUM3HNCvAYLWMk}j8TGvLqOl4sh?5kxSf1@uMO~ar16zd%P`1hP zHGD#!;Y-cxW3~A}4yu^8l|?>XwrRi|aXZrc2wQ#QQtY$jd!HzW0%_0mobJmf=+6;3 zFit|9^|`@Q{#Q`XyL->y%T19$c)dK|7|IQV5UQDmsXGvqI7urps2d#xF=vw}07=8d znA=O(n2hMY%EtP=a{hohu?>veMoYq{AA;fgDb=Rkb6`lnG}bgA2L?@dCITf>aQ`qp zPePIh^zYf1iFnw9zWkeB$q%^Cv$${vy+a7}F?E_~$CS3^8& z@x-F!znF zkXWL%nvVKXcea35VbuHltnj%agzuR-^MnTn(5f$`9g}zrw3s^zSH$;X-S5uS?jrzA zLEwRz%q&n>68F0s5rF#W(2BM|0#G9|`5mr$1C`>Q_vH0$pfZms{hCAmscGK>xm{RC z&UnVSsxt#crfqjC%M6eQ9VK{&@(AmP zqFZAfi#rhCa}|uwV!s<~^@!`#B;qD&=c2b>2Ev=$hkv|A{3Ik-HmL*gUd0{7x4uRK z3=0lCkKqSMxYXq}$AOL7;Yad`sB@pAave=z1|!>e1s}0EFl>+I>fWvihFZ$Jw>`tb zpxEdA3s&6MB1zD0u|*$eda7~OXXFq0kJxa9rGs8#Mn5%?3HKMN#qjqtVI7yUeuw^D zodN4=q5XNk~O5uptk4sjwNtFmo8h_AZ{hS#Fbq-)G=n^+Fe3iQk9FEfD_ z5EB|`&x|_j@d({w{JSkK4x-FBZ}v&WjsMaE>J5sQQD+-a?WUN1FCoq=v~O(99{a3r ztzBC&C!7)~zwfDjJ>p)9cZp|_51cw~lVXqjVCugG{q@U0CWv!;$ix8Y>&)*lOD`ZL zCTBm~5QlTf{!oF!cAN{ZxV?YP1;j94eX@io5M|f5xtu%(gm*IPIof4-9$yy37o>rp zpwYFB0RSI3&Px2mbBS{*kMi)vhe_V8>bXDiw{Oi^&LS^jDoxto_73%NMr0Yf92o8u z*jImp1P1A8LKIo_+j2D=$W6BA|zy+5@_OskDS@7$U7E!E68Z`{7_UrxcC z6P-L^L)>@Jc(Eeh%^9@a_@6{Ej)CGIj|W%B+JJu3*(Yb@F!FzV&a=JEKu?nm7XSDh z=&?lweO`#?24$F?R>XU9Y=a-mf2%+@n@gGAuY>QIM}_pKRG{<3$y)oPo_gxYU8Hsidq=bCD72Lo^)G^z8s6Hv>2$kv;EFkj}c;_l8d z#5E-|7JuGG{A>N@GB4tkDUD5GL8!x`h81I!E0BMlCBDSmCUV{*r*ho0LpF)4x~3I@ z^Ezv(%zbSjrCV8W)Zu%jR~}2Y1L_xcma(iU(8bVHv;$1)59S?jS$4buTL!`E2ZqbVD@(op~7-SgZl4Rf)++*v&$@d)%>IQ9}0 zD>0vUR&uX4>Uy0Bv)A;(Kqv39{PsV%2gIat!$Gmzp!h+LJG0LL=nX1xw?Pc(^#ezb z2O>XP`F3~8ovp~Z4Bq^!h3+U7EpZUO8}5^BOJHLqK=f1CvBx1k35JOPrX+%5Tlz+wfTmCsQA_F zD)x_r-sdGh+%f+()Jpb9F6tHKL+>@b{Q}U>u-HC=xK&gEk-el9Kr`;s%ieUH%NI|W zH4XotPj5VQ4RNZR5UYJ=*ynPHurbdngTcA5)rKg{Df?O)bLJoFqTH;>5OMO`z!-1xKTd=$_#IOyJ#Qq(cZhR8&ABY$3J z5-WKh=mt;M6Ed+53Awummd+zzTiGak4fP}sTjKXo6@V61T+|_lb$x##Gn*pT6TbMA z$&DM)KmBa~8=)AWCOFP!4kQ0TKRxtIVlPnERkzpmAUc)bpEK#lLErRJ zrk?``=(WBfaC2c^na=ZD2No1T_r6`jA`2CCRnEO2nVkn6-(GE(N1324ZXO=&mI{iu zqRS;rP`@x!DShD@>U_S^&bqzQ2Kpz?m&5C*C+TH&Xp5-=dYh``W;Xo0d$-?xy5oxX z#eF`a{3i0Xm#?yQod&wqHm@Zw{Jp%wkj7cm{j3kC^&G`_s*ChO?_3x5!{biD6>n-i)H1*vpDuA`E=lyQRXBxA;QqTjos{94InWhz%oR!cggA*!=wDCF zNoJp`cgGw!#pnXj>+{c$54`0ctK@`yt#YyT34EWHKin_4g?jgy;?b3#*yj%3vJ$n% zy8pD3Ny7zy7Hbu3b7Mk&aPh&1;3xQgal4GM4FTOS_b>_P8v54eAD^!vFE|=GC}eDg zI+HD8TT5{M_r1VwbsNt`ZJKjq^&iBKFC?aUY(kv);B>`n1)v_iC3nXa@5{FEe|a1U zKt`5=MSF8y^Bie$luB;YyVXH z2JqJ1!L+pl2-zN!c2<33dpJEg7YmoN+-dnY1$1q>!m-(8cz z`eFVrG}NXG^qc(8TU>O;Jb;cr{x{KQdvm5?j-wy+ggPsgpW+^h1Q*c{Jh*R-BQumX zN&y|ZF(09m2wK19TK`CW14Wqv2P;;IAE?$;@-XQ% z(!n`D`;sH_MYM*?2L=NF16mlZ;(!7Ep7`%}cu_vqkvCRH+X|6y`TWeOS_%1-LvP9x zLxH;6Z6=j17AWubZnk*Kin#%=&WL;QB2N-t<;jaUV^4sYpC$5FXZx#NgfKTtxR={j zBpG?CTw$sR;#xLmj9KNZfw=TNd4nY8n4~!7@P{*isClZCN}N@cu;a_*O>6`=S&?cSL@?`*+R6dLzDHt6x-hsbC*wvL(R1)k6V`i7eVc4dm_3tduvx8)@2-uYa3Nph$km2gyk?*lX*gD-~1%~02n z+(ZmToIaTD{^_|G&WDjg*X1LDGJFPQxF3KLLu@wrbq#rRv8@fI@<1L?>6uSMJ=TQ^ zt(KNfAd5ZMoMpirpvGdG%^vAMvP)ZeriS|VWpx*M`%WNUZ{y!1`WJ}WAi5B@8wf+0 zEyfc3cphE80WAqY*xS`dXWkC*I=O9!Edta*0tU;nsPElN^NVjn{IHl2+Hp?`jM!;M z+CDFXp+~^NFV?+a@cP9}1{HOSI?6|~O;8_qJH2|f6#Fc`AIbcSYM>XP{#U-l33OLX z^t*BgLDyU6i}f?i9i3_!I?8$#baqPwe$?p(t#<{FFTPy_MI_`t;XKIDyTq~Osu?h} z*XlWL129yM;i{E!VC;TDVJ)QLz1c_Vyc-DgKWRN{-)N|B*zP0chjr!A(@S0!!l=J4 zqL|KS0^N7G;>@@2IPV90?6KaCxym=om)j8c8gN(CbZ9}}^xQHl8RrluduzvZ#Phdz zm+diM0_xi{N5TVIfg0^ockXIk| zr%5*TgxGiRTIxxB6t>OatTXYkD1^PdpvfD}KPSn!`gy@~CB`Z)sPhi`lzx4y!? zAi9sV&2g{Sba=B<<5kdg&a7JX#$4Wk0A)S&HS6$qS=Nf+zPmO>YpL2Tps4a+^8U^_ zV3_(fIp*Q_&zKPGzW)#yM1$gS8Y?g~!o;;S&HzKIZdXB=5x!&7XTt39U0RgsdU+`y z=&!>+dT9RydI{IQ5GMQ_IwbI+_8-vyV=MR|gg?bA;$m)ILx0G^iicVT(2A#nCuh*7 zbF$@ETJwIKN3I`E-+=dFIHi{L)FtFg#(PHfv5t_+jp7Qio-ayn+f*9^luY-2iCsH^ zLafvr9Y+4}i{hGt*Grt!x4hZ-3+uT|^v-X8@LsgFk1c(>38W)ik8Gh%*~r_5ew6J{y8?tgS6vSZ(*U}7)99~b00QifSe-fs zuV!veuQX9LcV0_R$j0W z8_?>6f_l=i5B7Ibxrw+cO(oat`#D?857^+MZie+Et8CQLANeZN?j^_Be4wnR99X-L z{CmEvLi>GDpfH+x2P!cCXD_Yg>=!F}f);4D}7tEAlKo2>`FAe72mE z1~_|%P)G6skd!wl{kjv3(tD4#+2n)ak4Aky?*`1j`sJYFiacQL>3{~`HZa(+D^KX< zebA3sGQ6$g1bPeaxqq?LqW-6T=a#H4)MLecsBXl4^i*+P~;G6aCsidmJK?lZH5a7@As#$9mtF>y09j?;s`v;GkUAS( z$Nu4Y97{20Pepu@S@BEjUYtL2hHNbDtAS_`|4c5h7zo3L1xE3xj|&}*AK}H%(kJb% z-8~EN@(u5LFX~Coa4+=PBmW^T;MHa_4o1oK)=w@uf#H1JufxwC;QnpF4&6KRU{L-@ zoj3gi`ko6`6KYmKKd4qS40eFtDJw`9OeZu;}KA$6C4Ghub?Q_rZKK$O+4ar=n^SyUATR;USD)@Eazt|LEE z?z1MxbrSXN&bd7GztDg1)#0ZQ>ftJNBkYWvQTGs0VuE-zd1W=={Xi&?(_aSs{)PG= zO@*cSyU5@6ShsBR2tpnta`*ozy6$i+*e;$uQf4JHBeJDrbDr%n%Sc8cL^2Xl$|$?C zLXn+Kga#5yQYe`bWu-DAN|fI8o$s&b(pA^>zR&Hx&pE$!UO#CD67$8Y##Rr2n1@AN zA^?c`r3;_4Fn?+6<*tL6-$Mu=SJa$DU!nBJhPOwtzwPWQX-ruJI1|rNceV#WL`=2` z=K+I+x!)D_iJ(8r@3qq$d0J}0@v#?1pjQ&R&UbSk=xwg8cq4&xhd;L&xo`w|*#zD} z6Wn`XEEcAtEd$z()o1I$7JZ%j<;)erL96JN1nW@-(0m_Ea*5rEdy5_?bX1js(&7V4 zeT5r9k2W3^Pks*ch*H0bdPksNXc-nL#_!+f#>$%V4t&ql7aG`)0G(VaCh=_r=(7KD zmD#2Mot0!CSA}!@`1OZX!A9uoVQ9V?_6zaJ@+GqY?61r!uB6f~BJL=4+Et7Wv>|m4 z#tQ7W(pW?rZX&K?_UJ+24Xo?Tp^G8ipMd)C;#=3mDx5Xb)+u{vA?U)l_aMx>liYV>{p~=UGAWsIpfZ*=WDYG)Mp%S5$4=I1Q-HEbcwis7pEZMK}FTCgQzz z;%kqqa86G+qt}A(mh*$5uI@6RFfncBPkw;7Vp-JzudhJX8xsl5Z3EKKpw8DU0Fv+E zjphIBfW%(-v66ou>J`&ji~L%F2n7W$3t@O3k26|N*x-2#Ggl<+1%lMP=A;#V|1amC zb@ZXm$M=mV@dolBg4bk&5W z#-I*L*Trf3yaDn~ugWrR>(`pgF4KQhuPXP=NjU$QcHpKIc<(;0r;0 zXaBr@AwDL^^#Tye(i7f{%)IZJKH1v2ivKi%>e$b`f5nLhPE z8fgnrx`p%k867$OWFOoM5_vM3HV(wX)$VrOpGG7^_l+Ay0%1ZsIqQ~^+)mI@o%`3Z3-c0lKMgMqpzoRYvot{+ z_dQ3CwpF@r0nNq-FD)OsfQDb?A&Em=p!9<9^!lEoKrih}{~Fs4^kPX7_HS56a`+Bw z^!)>RQt1(Ry%*>qU*oSnbOO5D+&zo4j6gT6dF6P359dcKUXPVJFx>b&wp$GK)P0vT zCs1fp?KtBCs zY0v?8Ad}OiD}tne^x@K9MbADU1q8jV-7K{8|&y$9g!rsn$%`N3@-0V}scFlRq%{oPU}@`8io zl$N8QuUcv7+B|ZZ0UuXl7 zBo^sai29z1xnqjbh?|7Bo1QkT27+XX_C+n!m9$@`Yu&yC;AJwjHroZj|6iz@;uA2q zuyuP~t~lm|Ki}-m?u&aUI4!hjSjXc!yZ-v1?|JUWlf#nuX?|ujsmvO5>JBKz+}sa3 zl8TZ^LzwHHM7kO{f_f5$Q^^<0FmLH>N`u$!2Hdx1%CPy98)!Ibt321L1ErcBWhVns zpZmlhbqI6ysm(7kdJ85HPjb?>tw22d-e&oULi{Z4BBXjE|D9PFaJ3GAdNp%Mi}No2 z9@pKJnL~Zm@r_@bP8$N%DA;Va3iIJq)cz`pBYw-f&r@eA2PjL?e}#9Tp6a#sHVHlC zVN2{76*tOJN3!xCjn)JdDxx`o{%Z zfNa0t#N#aL;w1kmznK{W(oElP6`pLwb=wSOb-jS(Gowx_LHUcwc z-)p@A)UA(%#&-+><+H}vNkvznG_oHO%SGLFyzaSIDTt3ae5MO*IasSP#4`V2S*>hQqG)XQ)%G z_o@xYdcr_n_>S{DvAHRJ=rQVjLd1D{JuGo9JYkewb{h!)B?;_O$O1xBhPBRl736P2 z|CNWf0fDH`J(5BO0!#n3c9y@`2kXYXQOQ7FJy0Zz*#*El;US6?H~o@yd~KnMM9k7}4zR6w^Z z%Yh&FGU_Po_W!Of4|@p;&rH59A)h)iIn;)JGJEyyA*3B{9(-SzY;TCZ1={8-GauIw-}wF^_YX-7d2yECn)!&M*K;>5zeWAR z4YrNlXA@Cx^_R_r_zd}`4Lj>YJAo=DlJ~aEAMee{{17fqptStj*UoGXlxy$z@yN#k z#YWz53+B>M#D0~OTA)vG`l#p8BsCzHoZg|(JPu?J!x#Jn^ohuB(uZoqNj}~k{dy32 z+8n>Qzpod8WOFLwLTNne-9t{7d&~o|Gv&e>BhKkjW%EH&m={23;+w<1p0Lqj8TSTx zsmEQy{c4D3U19bj=TlBEW=^60H zy#27lzb<26b~LA!D-C(vkD?u;q86~1-)mUY55MnR>&CKU$FL7gi5liR0?U$M&2*x&Tm!p z%`UH3rQO6j(5?P`CCmu*J#-Q3^LE5XW!bMT?XR7nrh?ZIuPT9z9d#6FG4*yaJ%9r z5I3bx-u!$T2#p`vDztDeIj3QMwnG~T>hV4IPM}Wo$5bsl-b=Wrwx{zB6M+A@bI;p6 z0ruCdu*G1G!@`4~=BcPx^dJ8zV}oXr=f{tVNdpJk%H{f>9@ug#@+EVSMiMq^)tXhHKM*QdT9<+K;xRc$H4Oc@qsHa} z=Ah@*-@02D&*4{&y|%kE=tl4RR1$@F{D(<$&cpve+mn4Nebfe2+oL~U!9DYad>s3o zS#KgfE`Gmp3VqF-uHxLA7Eqt?PTAu*@_IiaywBZ0Ja+1&+RD@Chg*dK8Yi? z)F1n!^mhqHGI%cMxmQTB|1fv7u{e(d@00R^0>i1JSce{_Ji&d))FB1G&$sn32f(Ra z-~sjlXS|kv(*x{to_8 zG+0FbJcB{vX*rO+x8_SDe@2!#taJG|&VT)h?e)7(0x4qV@2xk7fV4lvYF={#{e)H@ zRbntVF2gg5ZKDGBA2cZZ{r3cjOgdxAD~0IKS$OaZbBG9j9h1fA`z6SC73`|w2AEzn z&w8;2kf&sBW)X<`>PS%`?rDIXi&T2&DdefT2QGgr0t1z|0jET^gMRhg@^jWtpueAK z<;qvgA#K=6t@w&_BS`jN8j{CcSiusy8s;=veqYRVtOcEt2UDEOL7;u0+QQT&2vm#a z#tz--LY(Q-F;;pd>fYuO_=^6bKJm|X5*Om-YCAuCQ$XHB+PL8;KjKk*H{JToMuGO1 zB~s9T8E7B#k}rgyj-)+coIdmp^(0BL|v z_URMWGiq0rvh5P~vuXeBHJ!q9Ix5Mjl#c!c3GH1|$NhjZ<+RNs6!F8n>hkQJm|x;R zueKW|0%aTh>woflP^Z|-YQOUj=EeQXQoX>v$vBNg)j68pGEj|Bip zpYJ38FDD=_lvxb@!o9XRiCyWNkvBZ}q?a!Qb#lxH{w}}AT*dkYCU05H_4D~qI-7w% z%P@6i|Fi@cvpc3?i}m8>dylYW?D@PcH+r#d zB&DW7xD@7zj|6CF#e!bSfo-;~h{x~9X_e620lGPxXU=dsg09S2p-l>hK_{@`Sgq?v z&}JtDjWFaNzz2IBzFBo3cTCck8j}*Z(1IzGNhM+ZMn7Zl?>4d%gp$wANI#58uHs3!(a< zY@k_KN$Lb)-zL#*bfYT@s0+h4fF@8Y3@bAx%3-TcPR!({^i&0-)*woyC z{nsOI8`mUHp!na5u|#~2B41OS{dgac$K_WN|6sqBObAJeJqu)lAj2IK%)?sj9htwf z4@kH2W+dv+?@4_kS1+*zh$~c+R;fzFO_UBbQO*I;($}JA+5w0xtPxHg5kRP0P{}np z3Is3F$1>m3fFNI}SfA z1^uDVjy`^T&+asuxJ6+IuVGjB9@0Ec=WZXLy*e7s9x&?Ipvgdc@ zq94R)&r^O=%wZa1itu7k0afpe2BQhohh)BQ-EN0?V8*j8e^F;^m=eUYDIp6CWB*Ku zIGLed@$esgyFt_~B=+1>wnm=(?)Oe%#HG}qG2MF;hdQ6P6~#$-4nNl8Ezc0~J;O){ zWp|+6ZWKACwH0Uq;b-ZV71*bh=zb^_2HF$AtTsp~5#=PW{(GH*G@t%nKvzDPesU(R&< z!-g@?84~T>`REkrNSwI+WeWGB*Ey5e{S86Yn&%=_cN`2`KOMMY#fSWBQ<>M@8<-YB#cAz&R)u`j z-J5RzC1K8teMzM5i=RMdN$feCaRW$|QO_;Z^ikI^F8_;w=kTxjzsHY*fmk8tn|xvd zh&HQl%V~)~WF_2Qoj^Y7!LQ@lPr88MF7PDSkrN0zlOnS9KLNaUOXxO=0Jt1K!FzNC zK#M6!@fX(b$xDSNxKqKvGVJq?^aRj0$?}`d38knij$Ei$Ei3 z_%0YuPmuZiM!;~4%xRJ)io6CX$#Mnpr)Sf57^m^GTIEutusPy|$`_@mh>KiUq=+BE zTvGdx`ndOqR~=XwCUBg?ckED;KnU`*lg-gG<5*{EjH!8Pi9ieCS?+iijJ$_Dr6A`b z=9AsKFI0CCsGVI#3qi}spC{dNaln3yBz^096&Fy}%aVWic>v`u@n@JyKTw>vnP;~x z0)>aVYaIPo_6pDf55b79_fczA5%L$vb zG9XqZ2r|Fi4Mf|Io~D%rcpmj<-e+yc^I$!35BKa4T-!4;zoMRW+xL*%@5|oDVO-x#!Jy~vEBPf$Fo3Wj#a_&ftNn09zxEF5c^@~8Qzk(#m#=(% z9Q_A^{XhQ>AHuxkpC$8qFz1Bd>rar>70^jlagZ@U{m;AD)y|&Hpyf}z##E9As&cPM zw^}YD{&aWxVVphk8NSD~`0<_kcbDPA*;|;;aK?X1TOH4-rPX-|eIh-%j#GW7P**A< z+*aR#?;J@m#qTn{XHrj0aSxB7)tiT%dIsKq<6Jwio_J7=n0$dcsaIG*@BnIdZ3k-*&Wnd<`%}u0kJ`ej&D%ExlqZVi z2JQ|(IemFPQ-TTSM3pCr-D^PZuzR5lGeAD0Xq)bZ=OOso2fBvQpA%UA3HR8Mj;9V3 zlv@Ld!`fr45$D31>Pc<%VH53h-~G#w0V10)?*(hrm)sY2cU8q)#p4<84g59(fiE$s zQ~Nl;v!Bo1G(G?XK7V)lJL~KRCeyb`922O+ z>d+VbDguUsuL%2HkdLi*J!>n9_vJ=@=gQfGV0ijQ7>m*oFr?aWR*z!8yknhbrkx9D zpVE!gF(;gM*TmQgn7kGQx2&gxyIvRj^69%am_q@?Ajv3FmlhNCtlI%cm>X19b2`i?AHVyi~&)+1WvzNz^O)>GNMh{i0*QsUOLD zh_f5M{NnQn?+M!*+tdC)d;XfOB?bA9D-XW?7Fz+D@#N$-u{3-NIWTp{FL`Gx%P6zv3PyBzF)xkqi!#oNG0Nl$8xvmZM%o(QLSy? zig<6WL-+g9gFrZzt@7p#9SB?}KNET+02&)}QbL#!@4YJ9`vCRtV!i&n5$<46#JxLb zXEPXZn+D`EDuVvSgTb389YOEwX5m#1)c+hi9qPMT8+7{v7+uUzCuht-4(5?YUPM}W z{V~>YLVZTv`D>W3DDmNnsW@nf2l4uSF9nrZ1#yKw#Lb=db{2==_kXlEnOnvU=!a{y zrbLj3G8$?tuQ(5MZNnismUDQ2w$_R8BVV;yop9^wPt0ZNoM0{cfIQShaQS2c=KjQ; z-N%sHtS^gN4uU z9r}fH;y~yPRkLyQuS?I{^I~1my*}7NZv)Ew64|cH3@GU*%(91ZJ|T+pR!my}d6p6{ z@63Wa6PB>{NI@X0UM1bCxQ#qI|JBy8Lgb}nXRr3f0cjiKQt`xI^mk^78&08q)Nx+q zM06OQ$CrmoEvVzIiTkw8-~|vII-XsQM*S#9Zt7h>N6K&R^Q{;iy?pd&A3`XHnYwB09n4qwUwEw&g+iI)kebUv$y$-9brhUizZzIYBn zqKC{8m!tbm=^sf{1-i?-s=yt;QD?##@IWO5=z5{s=HuR?9t&C;e{TSt*;!94?G@&i zEzMl;+J(9wrc6&h1f^xe&*F^}n5qjNp&G3fvJdZa<_C+Htz@b26m33{Dh^E3#rKu~|Wn+nX&oNM`ib@N7 z(**Qn)!LqEMW81%$F=GGMgHmJ+3%;npsqpv&ZfgvK=+iF8;cSIy4AsI5i8`|wI0-G z_To7Td3e_T!#RF6_*y66oYK9?|H?PiH{|my-j70^yzldUH4$al4{Nrwn|31p5_h!y zSrO`f-oE0P#P{nG@k85O1nPd4br;H#f%=2(p!yDe#8d94P{=ubsvD^%_3F4VF2#)TL&LvZuO<->^BxCLH|p}R)>%f&_C#S;TqOGy~iBW zMVK?CCx1n{zG(?`Gy5DkxA0+J$-rXkIPM>gj*KWsIt<$X1{j-lXyJ8NpqH56u-f7R^uj^Y44y!ir;$tR$Pz3}cGXaoAm zqT3Fdc0f0)9jX7z40PpYQ5nc{ zE$!>;_>DS~1M|`Gi2v3{vbpX=T;7p6fYZYfD2$(3^x6qPF0?V{H(JO2IWb{unCnNH zcvw*G=L)3IsH#P7tnXr4ZLa65fY{OzD`11Xt&74dgMRcQu-hbsYarf!m%QoIYAz6L zX3mPTA`Z`}>zfv61W=`sRjqs%z`nQl+cSK(HZyHeqGDea6#eBkyE5p%-(Dzo;2-V< zDc)~>HwX1tGB0dG(GMaVHyC|s9`~(175niCeFq!OoPTi~xE=sDbrm5un%np61w|2lS$#%NGv@ zqP}6nJ%`-~dGz$B|2w1)q zevp>Sn|fVQ$Lq7D&}w-ds5`woP8TDO_4JKIi})Z=+#P+MKf$`fX=-;&wG7DRFU=+jQ_PXgg^;K@e*Kp<@5WjAR@9Jj(w(FymV!4Y~uPLBfsE3!5-$ai@EICo($ z){S24_)Wey(bw6=hr1v_FJEOy?zRx~vvepa)bZTCvaJ`$gcUL|7w_&UU)dr2yzGJ1sUa zXW8&=!rFE-{Qe6f_IUWcN4+Ay6zlL|?6-~ub-hNP!BX_%DV{2z-KloV<=6n4+oqbV z-8MkmnR{+k8S?`=AM)(hy#~~CzLxJ;V^Pv-oy{wAkd_&yp`m;(5$! zIFkN<9+%F0^WuG|oLzdtv;YL_otJFdkmuN7(_Q2811K#&uJ;`AU8{Bb7sW~djEgPi z+T~#2x{*a}C3D$^37Wh;<|X(Tvk;VW3BiPet3FLcNKw)zgFypc{mT za=gcXziqb@AWUTOb}u|Li*T7yIAddpe)+v*FO> zw#!3U*OzAULy>os9ulUsl7Kp>9Mbw-1*n%L^KU1p165%nB#&V)Q2K6A^arYd66kO6 zq@)fgJ4$jYOTQ!j?rJ3|iTY8Cky(E9$&ePz)UTOXA%A;@Ql_y2q}{3g&$e;{v901I z>!-6obgR^>tI5anNW832gL@(?>HOV)n}A^1ldr&scvL zRtu<@ue4>P^8)5%Q1n^j!Y~iE@xY8w@;T62ro0)ITmj9SLbpB0$)KXMI?C9x2K4WK zPQ0&CKk{u<)2w_q&}W29RwZu(eRLljblL{=4yAU-u!pEa5y)0Y|2sYH=Vha~c)TZ* z(xZYWu%66s^A>uB{sg(&=whrFD-ZeVmGFK%LG=GC>Uv}4&J%+Xe>66CP*E;Neg#4s zz8B*>BC%|N`2@6!LN5l@ULntDx$>NVJp0%$DY3g=sGHcAFx!Yf@89?S#hC`6jL0sP zp?``JV(@IH@c>Xn?`SVAN&~quXT9bf&L1{L`drP5Kw4U^8g$tSq^o9g2c(36BwH(Y zK^ghMc3u%*(f@#W!nwqIyB?lL#+21Z#B=Xd?}&6|1%kz`*0;(|0P6>nijL$06ufkJ zOG2L3?DyVj%X~0cyPr7oLlz9I+S!J`zd&Ag+k$8w?!gmGsXJhnj`<}jdp~<)e#y-6 zg;;@c)c=Gtxo^dstLNKerA;wsNh5x{M9NRlzB9=3a}WA!C+CzM?(l+U?A32R;Z~p` zcizC)rV5N0E!2+B?g09~hob%p{y<;*c)Dqq5YXqwCVul&1AVv}+A(jP{`B~{;kG)g zD@-AqlLk;%A~gGqkJk*A~M1><58y~Wz^~X7;{aYgkL;yloN49@1W3|SkG4u%O`n- z0xABthhtnfkmSl*ym&Cj?}bA-H_k;wcedfo)24VH`Kt5-;&>inoidE5cRv*PeKQgJ z+h2LRGt#aAjRb3YZB;?1eqDjEhB&)?8-L=j7SzYNhkcu!2d)0p)PQvK zI|u*FOh;Z^MNmV`C9MLCc$KUFUSR^Gt?^uaH8EhsT2`;^h4kwtZ zc`&c}x5?9ss8^ioo6&j*hPzq`i>F`Xd>C=!&IaP|NoIa~=K2wjHw}J2{RDB}JIDUr z!JN6w^yC;}>~~4ouQ6{5_VTmduB_4OavTZ(vT@^Q{9H#|we%NPqHl zWfzdv!WrDl6EGj(ES=+91CSI#t<1kZ2I9*k&tG%pWH0(U^9=V3SEQ~D z_oGkepsVqrqUQi>oSMzU*yrYkkRo>90-)a)U%j#w4Cakp`wt|60rk3w{W2N!i{xi% ze#W5B#$0+c;3M*~TN9fiE`aWUrhH!<`fLsS?1qZJflg())g~rx&=Kp;V)8G-e1j5JX-;yfaGh!rg@d0Cc7Z|Y- z!$&u!fxgnQZ58<@`Ul|(@fF0oo*3So%6*4AMrSIg_-C9WgLjGUdI5Cf@{5y)@Z5yC zV%dDLet&A(BR;u;ex1?D|CD2JeZZB5!dV;KQ?baqbq;y>X~oDUd#oQBKJDSvD%kgq z2S&bj#9WQ?^{F6Jpx*vxJ)5G8bK&Mcb}OMkS!5{eQ0N3oBH!*K8cRS?I;|(bHVotr zbFXdQm;-zK$VKvGh3%$76&Vn>xUdzwDxFDctfX3XGu zltzzw#^QPKoeDaMc!|05`dQV@06*jH&)cv9WM7#z7_?5{vZ zCfL~m^s|4T>FMOhJrvt*@83NNdM>BBN^J3dbk6eL+l@G)dPrB^)+Ep=*txj(su1Y# zS3dQQdjr}ra${eQx?xW8!}1FBk!T)2JyLd74wQfM1%{HgfRW;kRkPjS!AQVwqxnf^6Td-l7?1p_<7A@yD>brq;e+ISx4Z+Vu1I; zMtd zQU0p*XpuSch?5DL>P{a&g3bK%&@dca0Mm zOn7T%72|#>?cE%bJ+}cPvkbPVBVM(J>(hH{K+oPT@~j>59IYCrWMlkPRGV{tl7Mr$ zoVVOO&hnYjHo)?x4qdq68FR!X~J$!)TtV& zCk|Y1ivuI2@GFUuWH8#bL+AW)M=;vrAoV)$E6{)1wPcMlVLg#(?xkaY`=E7I9p`*{ zf~BeDb`kW8%$1Sd_aP2hFpzo``H}T3SBq$G%(Y&*bpiWR!|*qh8O|!q4>*)NwHgn! zp9Qi7W{CTiEue48321f>Y8JRxipC~V6)))u)as+Fj{2w}^N%f$1mxvWT-l9q-c9!)b>DK+m#oSBHNx=swyR=KX&j zN-Fx+Y%E}&4Ev9-!A&@qCpqUhZ3XQ!TewFGFsH9TZRecxN6<7CY)#Tg0p$;?95D(n z!HAT}D~@=a5qv)Po=}MA)9JvnyAO;Mj2|~-DT0yUnMJXvM_{zc`0ASytk+Z1-mBtR zFP@m++QwuE^z_@R`BO*GXSHGzk#G<3M`ww&$FqoUvHDw)br5f4o*qcI1;ety+Nl)ue|8TmRG`nZ_x#D$ zV>rJj--=>0Kwp*V5ed=HF1R;uBx=jHt3aza*`@Lp&%^zl(?q2{>Q}4dZpsmX`j{cI zCjUB6o&MIz2tLF-rlG#WY|}u=e^x|Ln*@s9&jrid>6jy4D9ed@6tXY#v2wHvkeQD) z{F9bNUBi|6%xjq2p!PYlR?q{8uTSV2kE5>SVP@FR;s7XgY@Ka1AUlZtr1<1b0mjvxa{*=ME&7kdg??#H=4Cad7 z<_{Ib{pYx7s=28Il-oVdHE=%%qay-|=EBopWPL>Y_6HU)GL>F>cZmy(48mSbcw}RJ z@iX2`Jc;#$1?Ym6KwmX_{dw#@(EF_pEo&G9y+Xsvgc<96DA(y*|1`0#f727*x*6yK z8_G#Gh&R5oJMYJ?i+Ty!rE_P*z|iX2L~khv7;dily15MRNAuH(&Hqr>@QbLD_}GxjESH-YNbk!2O22~;+^c(unKh?9=;XUD+xYWd5k9kXsJNI6e2JO#UZIN70 zK-(rrGUI{-Xhn~VuRb0FO*NhS`>!N{a^u^nGY-ht*&MfuJ(q<#wojua*O6a6YvQah#-(2C6rKZP!QkUx#-Eg03_|8E{!*+Q~XmDU$yNP;=FkY zDKj`9hM!QeKUoSy(vK0A5Yz#&(->GrhJo<w_0@)aE=`|s|8}P&!=`4SM2}g8@TUO9EMvE(=0TtcaKBdfQ^oh` zhOx%Bg9SQ`o`M_ff!*)oqdCS7RjL{1o2)l@RixKUK z_t8JX_LiqQhb35LO_&V+V4L55a)aAZDO|p~Ti8)HYoh$9pr%PPqTYb8-8!m}LQ!xs^*kbExa7`DMhESA=*~%p|YGcc5rK zsKTN+wNp^npwPcBuH6Di9~B_i zdoQ$qv;k@B{p+3RGbMJ^_U8?Eq29gx$1isD9}qK6u@;p8aZ~W)H_Djf*J6DBJCh9h z57-UD8qjxOQ2Fo`cO4KIG}8#NFHz@El%-xU1Q5NP-t++R6yu#Pkw@{K@a&w(O~HMV z72_M-nTT^~?G4DdLqGuXtBJd`N)YD*w}?aScTp!2KDGS~>U+icxBsa9jr*Y_ZfylA zp#8b$b?+iO&U3v22g=8Q))|>ncjO@6vv;lojdb)gzxTDCvBmnF`R~m^JRgv4GG~1T zv~5W_LS)prf0-GL2}GYr9qAJT=XRh*JhagJassHP)&ot(%s>^;+LKD<2Fma`=FD!y z4{s@OZhg8A6x&nxN=mbVvfYYo<`Is4?!N~oEaxz%A+GSXMjz_kw-U4D3=uDR`1t-u(rID;oRYfPsBm`4|8WbUR<% zFMv8Z*TRFQsFw@=y+`N*o(HpKw0_zY?gR7Y+2@b>ej)~{Ih}jZ2lC8wm6ic|Ol8gW z#h6(#yGFB-qI>W+|Tdy_3~KsjeAJ5s_cA;`l{V( z)&JjaU*~eet}8`l?KC z3Geb4eBZQ=YkZqV-PP0o<~dq{wp}PU75Ai2KOP}h)E)!sZJdq8=#=etm5J>HY1Rly9@VX4l(h)Yrc@=V9E&OfN%%?UpC;61)y z7Q&mnCtZQeG{kZF4(={)6ZJ!UiU37t{wn<) z1aJ+%KE8MxK>BL@I^i)GbnTL=DmVfL<^uW8W8R?NeL=7(GywD+Ztt<;M*R1)V*Hjh z#2x*j#M?hIfbR1Td$%m&{$a|3p=|0q*lVFQT4am&q57tN`^Qa~16QIn(8`Ry{-Nos zEx*7pS5fT!bDXP_OFh<(UB!9MQn(?~7k!%hZR#1YkF~JgnErrzQT1ncMxG(AzU@lo z;Hze!EjO&VL`>klIlg7ktOa?ev~8DKe_{UBiQ=hjeAf)-yK|_BlWf*rzczq8NB^mr zj%4I%({H9tjoJd$ZdhJN&>W~jhM%j1?13`G%9DutcS^G22Y$(Tpcsxi=)c$r)DjNdPps!;c`%uE_>DWn6tm9Sc$C?Du$L20lx|}eNbzEX78u27}4_>2n zvN)Ic|8>f{jy|b+6(h%b0e`iJNyMh(GLs3x^7sHc5_6C6{Zffa zf5z|ys6XG84ck@&wSlkKu_+bz! zf8bmS>fL!0{~kf!liX@HX?75Emrl<=HzuPmMD)h8T!j&kI-@q-uPp@9xlWPsU_K!2 zaeBN_jCkTZk}p98^>J6dhAmj|Q-7%T&)yS2_!0W1^CId?%8m-uC8B@O$@^kg1fGXr z#f}cdIiZi2W0bcY;M%RLnjHRs|HEH~u5AHeVF?pS3j>3w#uzU1VlZGz2zc@o^`jBN zs|yv#=dzr0PIA&gek4>ekWCr%xFf!oJU)&7Xzi~5vmBr{VHryli#Na>OM${>udhd~qy2GXa#{25=-i!sGN?HxWypn}H&*&Xs zSm}IohXnp-C498m-PM3R;H6hqE6u3$F@5B**AEOuZ12YTVZB*w_({RNfw=!UT+RO^ z&|-VWY_oChI9M<3^@0cMiq*R>MaXx&ZJk!Mo#%9amGUEaTNLyr1m+pZ@vNK-j|Hugc*Pwy6;L63H|7MN-0~VY|#(msjQ2> zE>c+PRV5en=_pCKSDW+!@jd6vQ_MdnUNbh4P(yvS-uo|Ka?y{o^hjQUd<6)FAJRRT zih*E9coR0th<(-M<(1`Z)Q{F(Y$V`)xYV5WW+W4VkmcdgTHGJGm>yKkIROUl$z2{! zIiNq)zHNPX80b4G%x-?l272QS8`7`dfu6Jb0hTkjLHCn<`lb~0<0==eNn1OB_QRWl zE+N-Ibxnq^X3q%Fb=M-cw>?Fi<83Sh<_yyJ2b5plh4`V|p!5$0RJ)7yNJL(vs zZ|{&`RI-XDC$S6%GsN1aUS$A z8ric8>xww1V*TaoKP4_A=pUfsucNouOe8ItMlMj%uST3suy#umZ zi_3qHaKG*7r4dF>8uGSH;s$9y5jXK1R=uu?eyPZ|=Uu30h-Ys3#)WlVce+L9avu;D z#d6OJyrq&pGbiQe<=ocp{kG`{px1P>YL-ST}%bPK~<+>VF20 zd&i$)1Owxbu}^yNeQJ9cVYxgH`Ubs6G}7=sG|4L!gx;oc(V ze~d0e9iW{kQn7Yv0942L`Jr zHRarR7EnXwEgZAZFS1X4u^4spluv;#mD9EWC5?B#<|owk66KvWm$A?NI-_mvh`4*2 zpHWR^Kah3)M2^?D18M5BfY5(gwv{8K)-Cu4K23^$m8*JQo{WAq+@j~d0IDzekAJy~{6(A_VF3{5h>=s}R7CtEJW%Ei8=l8m z^Rh~Bf8@yWl0fQ0{grp1bUOp)WprM*_7MQXKQnq~Q8#S(cIdMBMZ~2l zD~-mCfOJQ$iEag^wO1cpM+$9TH1u1wz5`nTsU&M(K#cgdkX&MlreWP&(= zq`kqc{SnOnw2l z{i>QghUX#@G3FIr0|uql`)RVaU?4OOqL}lepBR_4$)N`HSqoXoKB$iim#SlzC<5I- zf4>}dIfwe{JzT~TQJ~XUe7(TD0<`HjzIog7f@;nDP-XKe#GgXs83wa~UbcTmbq>$v z_E9?<`V!D@tjj2zq2M|3I*?FTML$z<=7Bu&Q?~tj*E4GIolE;9X)#H>6INNMuT2{W64q`PIq{~hYD zrlX(I8yE3B;(MR|!2AYn5n=mn*ynzcFY7Am0zz7CsV~kY1WKiIT@B8CYXbV&2i4Kn zInlnIC=PIpE9=^VF93gXgq;lT%}MR6j^IHamqkQw!Vv36(2uP3jnBA$*!1LwY*Wy4 z6We`mR1b8=?b7ctZv$QXwU!G}L7`uQg-vy&2S(T+-B&#=24$9-wCIhI_hCh48(+kGSqp;WNCPsOLSyXcuIH zy117QT?|=(mVC+IQ3L0E<7S@LF?`n;^QWh61Q2gORB~WT9#BvGK*B^E=fo-oA;bYG zEoFmuFQ8u0gS(IIKF;x5IUW`6I);7k)0KsOoYyV=cN~vo1JchNiHe)}Ze;{ps}P*f zPxx=j^sX2XKg)^+vi-*Mm^m`asfN(urOFZ>65D3l*3iN2i z-y4ozD8c$&5dQgytTpawsfpQNkc#>^a+8E#4(82xP%lbiuHw@7X@_3aIUE=Hx0{uU zzVnd_4B_60!;1$nf1Cr|wh7$S#SXfFBBK|6n9E=-Q(USC+FPS|m05j36>SJ+zp<~H z$$NN;hC1obL_Zc$#L36^EEtUcAHO}qy)We#&|BY{Z*#o~^vXN;{zuVu#$&xl@dmPG z6q3kDD%rA~XY)K{7qXI3MiNSdG9t;!h)705Q7SVOLXw$^tgJ{S2^lH(+*dw*Zf|bK z|98&$u49s^iu$;TW}`Q*_?{)D{K7mb1GCzsN%XNB>Jm%7LzTz8vx1^L#Bw$~+*Vr?yNkP2*tEvMX zeQZs3LRqIdf$Co|PW|2tR0-)$Zd-StylLC!UH1Q+)jRPsZwz%me%pELBY<4lLJ;J% z1hS1Ft!%~z@x{-hx6dM9nB`M*H(~`ygePUY@LmFO@>WM$)&U^Kt0=V&OaoEfMUG_c z1B9`C3gcE?r2SGu61vS`uC;sn}-HY+F5Z>qgZC%yY1 z>fMjtk#OlnUBf)hcO_dL6oP6hLSA(Mor!my!eRyTviF+rR>*_FicbL7JIv+#;mxz} z+8^Z2@2QTsh2!_LOJ(T{)~RTII`hX2=4DB=yNmxu9;&u!Zy45-G^%2oj{Qb3v*&!V z7W%GOD-8$nJ9z@aypbf(Kj&cn>w_WaYe&4v!2e&`pUyXX5ig;YySP`!VPE%l_3^UAM#(bg^;ntA{l{foll(?n44G<;C2BL#HPeCMKjX+RfI8aiD+0(AaQ z_q**=P|xu2a~1lf41V8r7D9a4VEAp(dCbKyXwsfjT@%1}Y=P;|)Mw<+IZ1mO=J5SW zjVr$Q2n^)ztCbskz5Jj?=I^mIB{O)YLqyi?vDGS z(?#2pT0jdu`s!i8B+kE62UN0W5l<11`n8Jsh6IJiiCo-AG|6&v`uRW^xx}t`%?9yb ziL1?<(XX?cS{yKpzT0MTcCI%>AiGR&WW-e=FJ(}xVU&RW&T~E9s=t6l^}F)9q63Iu z73n9~F>faR?!C@$mOxbNaMAuhXY|u87ZWC&vtsy412egSptd7gqhJhRtXkDsdKW;_ zxW?ItCxC`(l`p1ps5kNW@NIP#^vrUjHm)24-RhEC-B}a-z%lPfP&q!!d<-@*zI(l43HA>)UZRa1>PCmwUw*-i?^V=|{K}ibKv3$5ma8KJ zd@3>?`-?uQxGg$ujV}NNK9z=(tDrZulKGeY7wC}(kMK>R@4TqM{L|03petGx`!R>q`u4I%PXKuR(U9x7h+vZUXp83xA2Q;PNnN1 z7<5erD`6ipC}K}KsQwhclkoK>2Tk2u-mQ`8>B zy?mU`yfa1J$$r6_Yx2m~PAoM2rGx`5Q)2L-KL_U6H2u_kTL9Em4xeDsI?O*2QE(5$ zer_zGQp#QclzF4;@ed|}lKRH!2p{Sc)mrR1^9~@7e(rbR@^i#Zw!N4;)edA%D>i8! ze6Q}GCpT=?1QI<&cFu&3Ir|n_GLcWP9={*aH*o<`^+@KYHWCm90^3xsO9CO1(G{~3 zaT56^XU0L)|MZU@C+S@WxSTfGOAZB4|0F;UD*(N2$IIUfE+Cz|XOS?i?XK^oiRQ5x99rlsDnSNHp<>$*w$A?a%&V-LQ{~pf4*8Sxt^Z%jFM0a#D z0`cF+Zi?yOaWApDc>WpQb)~FUJu&b?J=RTf(TikJo9aLzK+Hy;Z_J;OA4e_sdAy9xY*8%qL#sPfQ$iHQRU{p=$* z?@t0DT)f6KP95*GO!{xSi8x8`q0(^HbpVmB7UAv}093e*S6M?qulZ`mjlx#Y+qYSf z{W0c4u{h@Wcr3`wkU_iW*2}FI@Ls3E&A>wvcrX3=VdvM*`k?vi zq{rmX)1VR4|K|Ey6DX*+u*mGP1G?|O@Yy=lm-u)cWRIx>`iZJN-&xv$Zu>p?%NeW> zgY|FeFn%v8+g_<3HblLNyvErgC49dQ`M2ZVYtWVFcJw&nEO+-7uZ-dQ6|m|0;Rt`s zBQ>32Uk*TBgUqtP>|@M*FEFL6q5das@lEOPI>he}9NH#Yh&k_9Ka^L<0j*S$EymUi z_d{`8$z9$+<1KDB)yDo&wXUe?!*S$$b?$#n#J!y<)t{M)-^XpuN2~1yKq1*QzF8PV z+(f2k^2!w;2aIoddy^N){QBnY@&Z75ls_z&gmaeB%-mc-CJ=v!E!`*J+?%jB%17lh z)`RUhAF&GvABz)&PoXaEqR`ISX}rU|=YZ!XN91AOGf#fIAcDA6kVfctMF9Eu{ZjkN zaWD5h+YwO=dg2r7FLIu4T_w)Vyv1(jiK))od6I%Kd=;2pQJ$_)n2zter ziuXV0Cwq9xV^Ak&+c4nx0qa7!!FCh#spzt9B6qC=fX=FMzS<4(uTg0)O~Add9De@e zPR9K)|CxdtFZ$d(d6UO%5dSKv4*uZ@`hz!zqtY61{x$rpyDS6xhsMl@h#lD1qf2SE z$j8^Zob<$8aGH1C4f?tZKodFnrF0qj-k0-UBJI=YyLGy7qDc>^9AB;-9@7KLgK`$_ z;dI2`|E=Xlp8)dMFJemp;=AYH?LBU`706qUsgAoS0O|3sb9(LtKr%i%uYac=>oL{y z9{D9=f^KB9&lC`qJrjg)V-7&Cd-<0<)bobQe~-T)4Fs8|^s29j-*$Z$iH*Q~fZ(p~ zCnd;B?X~5*j{BruDKklkv>x=f27d1KKM%S=Y{bgjXEE33*5GnJJLniGT_)TgLp|0b zCrMBS?Y*p>nfE0@>!w0vek?al_E3$FE9d`$#{ z*@QVEB7O%=)EkLgpW$Aw@m;`97WHwLvPxv%gTZe4Ooj>WgJ18)h)(}Oe&vP3v;T92 zoXTT)zu=rDRIVs>Zy)j{lV(56C4hGB^y3s^#N(wRbM20e0=3m>^4fk|pq^TZy3v4p zJ6~0vQ$I8Ex%GyJbn(9WL9mhJkVAgzIJhn$ZgL@HueyOPkcFwcBejtiEZNdAnve`6 zlhG+A{btPZ%k$=Q(!zQe#oumm1)@?9ge-M`odYp9wg(8?Ee#%??A`C}$Rq2( zoZboVCG-(K@EumX0NSDkG9k-7pcP-!DEYr1r}oyFkQrmpICAI2Kus4YY-@k;Z}>dW z@BGSH>=6Tc{=v)kXZnGjd93SHVHeQj5A4?p#D0Ii)5ok}571pS!?s)y0J?s-+1DC- zpzo^c4yzVJUHsy(QVGtz?+)${{fGNVUa#81zkbY9ezM(#wHy1$O2UH?#2J6TEmtUs zLO+{5v!WW}zh3p?0*+&NFJxEc*NX)}dspg7cR}B0SbAc$`UueE)`^Y_p#JKepkKD> z6ZGfsfc~YA=$8_r9STETb-6Pk2Jc!?%%uy*tS}$zdwg!hcf@2o_&$9QvTT&bJus+JzbVlh z2$E7eG^48lT8*1zC$X=eRkn{7K^{c1Nr@hb{A}Ku59^yUBx0r*bkT=uTp@ddOu2lN_mB!E^J4VJcvgXR-GV8c7g8V8vLJVfn5 zfp6DMmOMwGmp%_rn7Ib@rvd}ZNne5fKsa}75AGjXUGXfaC!}8?$5Z_`W1k6r;yyHl z{r-yRu1}WOPl8wZZPBm5<$k)98Rx4Jx2Sv$%pWa|=bGJ#drRQoD-&(+zyRKg8DvzT z4`IK9_7vj2FVwUab{|2Wm}kIg5`CWg#sZmg89*EC*W%GqMch}CW5-M+&{V#h&YMMk zs^7*-4|Vd?kODoD2Kqt7Sm;R>sC%f+8)Hl62Fl@5i4p?Nw?DmVmVWgEIg0;?<+>d} z-r*-GPU8kr`B#otr6+-8?tbIW{)1SLZw`w7C$Sz*k`pJDfT-B;O|utqlJ{&=$)0jR z2$YGW5N;taC}4Tjb_2lcS37eUh*$ZkeJXu<06^TPWHUGNvYFHALQ4&v+4EELa7(DJXA&9~zO&HO%3YSDer zAeb#rX(QgwzBQB&B7y!g&h0PeUC?Vk-G(XrcdmH1{5ui%j|aY5x{7WbQb4gOONrH7@!L;`u?%A1B2-tA)ZU9SFHBDK>c?d^OVmdxNnR{ zecaHSoH^W2IA5v0-KT{5Q46I~KJ^)~Fa`>1!oWBRUN^4&z=T6UdN3ZM}2V z2Yt`xyV(qp_pm6xIjp6DIb{07BSs9+5&wO!=OF6it~_R%{`?KJmXBMq&^7ShHkW}w zYzb&yKN_n>ssjzx3zu?sYJtLrWcPUVPtZGk_I;C+0eV}_^^O@`pf~1+cw=r9y<$(@ z??SB0ZL5gSgp)wOsv$b~0RNtMKNsZyE9w}Hf7HnA1G;pf+m-m+=oew-<5V*SgIB?> z)a~YoKgwn|sUUuTXy2`|6WG_c-s`>=jC1bWmz)0BqFyB?*W`;6;_iXc-avW{?i0k#+?XZB+p37q8dWiil&yTnXCUk^@xPC+u#_xOX%OOoZmHq2Klk zx%=2AATK)3UDZZ^PHf}&aK|c;C8ie*GpRtTI-oFpM-WJssp;R|@d5GI`qR_QxCbV9 zDgP2K0HQ+26^#!#?{@F7l?`_W!dc_zT5>;tAZq<*)@1^qQ8}^GWf6IgZaLfV0Dx`s zg`#b!cZ<8AY8uQ7y5APv4u22=UBjo(nFTQypg8|%+8xZ55v=Iq8mI>Ci^Ici8WW&3 z!&&wtX$7<#_O)H*Y6Q*L#*+BrIndY>nrf#w4)TlpTk>130DZuZ(EDUB&_7no&AVZJ zx>BysWa|OFf!SYhT@KJ6^Zz+Q$9?g7Yu-kl44l7ow{COCzi$;NQT)3a=n5(KRz@^{ zzVY6rlRI!f>}m^M-i&zf4GB@-rgSiHXu5Uk=>g2$80<_r(1`qe?AYx9tV7bD!#;x( z$nToH=@DN>zWsSW(`MvHay)-({No3jL9D1Q=2KID82%__Ab%J?qL&3Ch-01SlorE$ z*cMar7Nb_6981Y!x;g~pl@RBIM*!q_bBP8z=9)y^`307H$B4EdDq)OFWP{k>UA^de%{`rKY;TUMTg1QRS4E2+Ar%&mu z5u!lXd>*Um>4bgcYJ^JfBKi*9V%V-sqo3V9AgcrM_~T`txL@|-oaH^7vVo5Ji7Gz+ zG2}%uYAwU_5a%)~czRr+0cfjvO3`?Kg?6{^p=f6c(2PUx7p-A#!`w^R&dvd#CievM zIrjrq>8Fq)yEjnU2~I!0WC6u(UCd*He?b0w%wpG>Z9q_TkcxN@PhB#u_1*R93xR(!Ai=GYE09{>%RnZmX19P^Y zY-vRu$)+8rS>9d(?NiX2A|wM^1HQWb6_~TnxIOsPM-}g;{uDA*!F->sFIKe&M?ro_ zSd;h>`@t`co~jW7&}SI;LfvuRn&f=_5AVa#KU(N-A7}-7)1FK8-@!mHx}mmsRUhZB zQsW2tI466?Ecd_o1az|Eg~;DYK;K%YS#}3~2;-K%d;&Q47I7Lz9=#6+J}mhZ;U@Hj zxXqFzZy^pgy3-#6K%{|z0-rC5qkEaXu!A0)~x9^}1#d1^l@bF&r zOMN&R|Lh@9(|t2$wkrem06)Jq>H;WTQ@Jr=DnN1H_xZ_9eEbejs!fiQ0_g z_u*R>e>AlO2tv0-l=Jc7d~tHnzsm!2so8hAvS2^q^9pF^kpex;S6(bbA9`>5*^vF> z=tJ+J_lkeTy9c{@UxgZA-qNEYLaha8AGbSvZP^0vP>AOy+#3Zg;*|fZ4fuVWym`Ny zECU)`Uq8!Fj)45zkpqiQwgUZ68L40QAJCV6`9x{s_wn;yQHDS69iu}$k>a=ycHH0^ zRTl?(**E`Aan!+IAF?06itm*FC6U$+X`mY}$rN8uMf}ldvk!|K`Vnr~jaMLkRl50% zLJlkL>(4{o>Te=%)vlXCLmkmCm-(=>|L-9W)z|6aUSiYLp88lH^jZIg?>vNa)l-L+ zrN5%+&yl@cN1F%g-&iK$bLN}3(prar z+~k&9J8J{vOFa=~tvNuZMCWrA;{L&;lrqBl5J)c{Z9gU>j5)A>5{8`dUJGT5U6V^w% zxPfrun)cH)^tUPc8K;P0pI>1orMe1XpE2vIHbwsGD&v{c%ZC7me>F;dGsAs_QrkGa z4e{Ve7Ui5d%-d+|8Vo?(ad_9MV{SMXlVw^x(Wj=Asy^bRg}D%I~f@hE?k5HZ+*>V6d&$_zb=oZj4vJR2D5U1L_xv}fe1LQYe3a%0m zFDz*^e_*tVypycAQ3Cb{;|&y#=zVyn^H_AH_bH%!I$B=pguHA%AI|{Z>!G;DT)40v z^`yH-vJ6eJPki2=5SEb-h72uNJWM&7XPM~nXn zoQD(DhBq@WV2;DVO?>tB*k2Tb%?t6n`7{*6%Yk~JJ7&RMhR*@KVxExfi~&?5V#K^S zKyNj0bhGw7%-eS<>($2GeaVK{PFgGadDaK}T_=L}^h++kMF~)Huz3)JK4<;JYiV&d zHJ~3q$gxp&C(fbIws!^PVjj%CU$3!$>z~mO%a~UOeb=#DM`H2M7D^vEE=uB@x<5f? z1M1(TK1~sYobkOewJ$r0-`AJ8XUAjH(eHnotMJ@<)QjfcGwzuK+L<)&?oV|YmVC8tUDrrrf=P$AMbv-ZC73diM~5@Vkc_fl3bB`P+;asI26edUJf2UT43q zDZ)J1=t6#Sk2+8&VT^VEe6Vk5>}90&>Ni`1~dGiFmiC=<)8xeqJ@tl9vRep@-?G z{fvN=mix)*6!v%1lzk`PW3C40#rZ2S$lo@*RIqM~N4>kw#y6;EA(EJUc$+b&cYVce zf-?4#xJ}^zT0pK=43 z3B>Q?!xzFN3peW9wgvA-KbU^U<0XC);(tw#x#BGm-*_f+?@H4Y1edc}2SS#aze(0XkdC4%T{C_3=L zl^6N(kj22dRW-ghB^k})9kaGzT@6^*ywKs`qJ+CYe`3o0@Y*e+S*Ojz3;1H zv3`ho0N=KVgk)f@&s|O#&Wp-Gaja5xw|)r}A)V!Ehui40Ev|mvXb9wsIxHV!E&*9( z(qUZ$=EY4FjdRhkpJ&JVZ4u+dxi@4r9`R%n_r*Zbo;1t}h+i`KhVRqGJBhv?!Kja` zJ88zL0feQ2Cgw`K!&W*!_}muzyB`Z{oVzIylsWGnkVn7A9J9>AXb|e%zq6R0!oA(U zre%sr5oNvnn>?Aw7)BhPG^1{zsem}vra4eXU+7jeI&wmTfWbF%{X z4c)CLP$y3{I^{Xh9gVtC-qzRUn9oqJ8>w*^u%GbXadgILeUrKJe{AyQreEQ+B3qt@XGi$wrA zWO8c7GxX)iex}@71CU_3ne6uk^j;O6;+I98oRJ(4bLkA~-6KX;A7D611&cx9CcK)u@U_kZpzyF9G^;LJ|S9ao_ zz5n;o3j*gbSLwL3@+QPZSea~O`Pebv@|}!H=n<^X*oiJd%<*}w=d;7|66V7#DmRGW zyXPW8S{k_dKjOaWHw7p5qyoY8^>20L zF$o;omYpNR5l4yj=QxD9SQmvmMzReoQ@38Ul6S^2?WU;dLm zPt0dx>*U&ZxEl9w5jR>S>fkEU4_V8p;(TDgkJO1gtySpcsUkPT*SGFG`i>1~Uo}>R z2weDnv2Z*6uY*6CYAnl%_1L#*t#d!lzZ2(D8j8>da+5vJ=%fcw&H7(ddbR?UncI8g zRn)haG_o<@!ac-E;+Dl;C?iZ^NThds{e(d9hJ)2BK5RY$H-7h8G4>|(k>mM9KonnGWyZD4NC|;yzr?o#veU*5T z&aVq#(6>~f@LnEyjEmD;z1J{j>BXg09@H&7EBl;mVT63Fcl7b7^QgO;V{KN){oBuo z_w`%{7+736l%YhOyUb|W7W zr*RW$Fj!6T)trt*-Y?ch^;#10u{*cwUB`E;{YZ$*ef;+> zqui+a!U+cH-)@cYAWwVl$fu`)hp{eqYDlwbs8bxu7sw-_PEl~a#02re_T%%fYVFZ~ zK2@C}KZm;a5=j{qCY-~@3PissA>VH_$_SV{& zq0Yxv{A}rdF!)%0nO_Hars^^wXN5Avab3$S8+=ed+UG0#6!Anuses9M;h1x6{fAE+ z->vUSQpGn)(T^~})MEV<^n*{GbGncF4jdHb7sCF&mL+0qmJPJ3V7=FVhCuVsBU<8T^dj>ukh_E!@9_OZ)V=S z8OU$nN1X~l+~iEI$Xe|Lkhil;w?QB@*-9J%aaa|2__+Ef?O_e00NltXFP0 z@)w9+i{)pVg@L%;?lbLBAP`#Rjv8=@BY*4g?b#^mPUL4CFA21uKJI;4L!JUaI@db= z=}gp*#-ETmhI8+x!v~1)9P}>KTziOlFuDr_C9!>5K-Y7>hlG3#=zI=Lkjle6zoQ~M zKb;B(?VH^V0$1ihOZU_?x z7!4zDyW7#jaa}y>7RwjX#mT5Ajq`5$`4V+;v&_F@k(YfoBR3|Gy6fbO^atpNFmT_r z+bm%PbFS&{?tR0$u?FWlsbk;hs=Ry&bx8VY+Z-)DJg}eCyexZ$d(YPTf2MnhKBW00~^1A)-e?Qx_DX+(&!#?|> zQ^Ev@wL4C4JuePKk5@hO-iT)jeNXK(!+!qi64Qk; zKkh#X5Wj3pH%i69J5V`lItBNQWUDk5AG|}+RQL{gM&16d!&@i;n&P+KnUkEaEh9UtF&5;95XDF(~!hM`@tmXLY9Y(12>*>~n1x{~1=s zzZ3Q+0wp`DnYkBrS%m(ZJVEk69u*1F`l|utu&#x~(r6${YpHW-ppDZ*D{?pXUXG>~o5G%o#W@v$?b=#-R_+r9``q3FqR1S_zdb&~KRA^>p$-ND z)lsO%wgBfZ<{oRuPK&Xy_JjmxY*k}9Ecz3B*(MSRy|SA+o1zFBA`t&GP_#7jCrGb(?02YgW|@N4V|m_ z9^H8>knV%}o_r_mnWR+IF$i#qynO}qgm2-;_ytk-Gs8Gv@EyOO-48?VqTa+fFW&VL z=KUy~bfBw;0G%^qvljBa2IHE{zsGS-D|cpcnq7zdxx#i??tMRaWr{ z%UK}HtezJ8T`qY^Rm}ipTD2ciZqRYbAxO+Dcc}55^ za){?vIoRJB#5|MZ$A?Cgjsjup?`RX96y(#_6Z;IW0|bN#rk0lh>^-fZl!pELMM`1u z4dik6vQH>u?zC?Df$del(Pzufm6@HG3_8IVr*i|FL3=K$YZ!TUZCTpUbmb>_kNd*s zv4Ve~F!wce?}#w!7&1@A_>Tbnxuo8}uh+E#7)+!sqKH*UxVec_5HQYY^KtyOhd`Lznr zf-D@h!%=S{qr=OCI!S8hHutj{`16e5KnpbtarvW7Oj^iCJ(D(y4}1a?s|39-locS) zkAxm$Qvq_~3(og{P~V{76X*A~4oICptv?0r0FtlL^wW>RKoV5=`DVlhh}ENtp}5Bp zoptlSWK9B*OV@S(HWeV0e=Kba>IZ@|>(aNgn}NXFP;tk&82Lix9FGUMm-{q?nZ{Tk zp1xvu+6?b{Jp!q;7W__x?YT)#UZ_`u)t82s@J?#~2O)7W)Q|3bu8p|2_8`lawda^0 z$Ga!T{^SnO%((rT*)|LmKD*xW2>t`~-rUHS$B}pXAf7h$ITYyanQEJ~UIM*dIOR1B z`KsdVvUzv{^bB>|0WajOLVhwEXW@Ko|9)Ua{~YS${yaYH+XVE@{=+&^UvNG?LJ{@E zck5B36emY5@=+apkL6Jxuao*oLlX5Q|Fr#&|6Pwboj(iI(C={}Xj4bsCY6 zkRNp5$osa-0(o@JX;(cffUmIOXC@k{H*Vh(nhf!PR;%N z?O2c9(zlbcf#{Uu`@Z)l5ZRj&bkpL1P!b=K!nX$q4)e#$4^H46is`I{8hod!e3Kk$ zh>LiH3~ha?iFy-O?M!pjyWip!vinE_J=WO_!np|0^~)!E7%G6ym`Ey1MHT2+&}|BK zqVK#}GG)gW^y93wX(yjWo-p$C4~4~XQ0V!|R5*+8&kT!k8bb-_-_NU7WM4%d{nO!= zb|I{j%EsVt?#S0(bUdT}4(N}%P9(%fqmEHw?BW~bZG9h^3|=0_JTv>TYrp;RJF)Os z&VGcses?L}p}5c2`#^)ubufr&kM#&ML7Z$b<8Ja%FyMZ{+~STneM`#eqGaqJVUa%3 zFY&!nE44Fn@&MYTkw!5$`a+V=B(N@$$uN}eanRs$Al6<*O_8gdBzZQx*myc zxv361g#PKbt)ie^^89qOB;K8vV0YCxjQOuVjbgrcfuPqrr~rD@jsW`g4M0EY z5O|D?Ixe-|wW9y)xhZ!*1a<2M-90XRi#GUfU9(zw9RmjT3k`Y6I1ld-o2Yf<#6F_R zdpXD#aW0#fr^Q$gQu&Fo738tz{QO@pBF~jwy^ix5FVOTWYgHrB2mK?XsCgv?sEM&3 z%MVb2s`!F-h=e-Dj-!pdStZD$=QsS#@B_-m7L%Zzh$m*nT@FWIGg*Ty()a(}=MN*- zR>ltD9SXZb8#3lH2|hBsd=m41p0!0=`Q!Z}hetQpZsPmJVz^?cjDGZoS#n*dOCngM z{oX!-IVMc12WGw`06g|w3sSlS;CLW3+xI>4w^w-;na4pdqSZMhH4XJYXW3uu#GGVH zj-21MM?j}8=r8#g>Z}!>sZ@8u z9_iW(Ym)czJK1_2(i54LuTyPO^9|D*kDv@VXZ1KNGfEiw0yCoyv{jQw>5 zsEbaOg=>f}ru!-f?A?HSVQs{YVbnFe4fw|Z zW{9&-&o~kB-Lj-s88>6T`#ODZsnS;fg4>gR6IdE$OoO$z;;;;kEw*`eP#anao>r3AEU-$y#*9X8E_7s{Jn z^ngMs`&}-~on**Hyoo^lC}Y=Wb*o$hV2H79oNRIc2JdXuk1}e8?Uzd3Ho!9y{S6k$aCqOmKzO5-b8d~NG|Fc*o-%i%4MOh;oq7j z_Ep*u8{y5LmVmkz*ExC?dBa<+Wi{k;K-D7~d#WIh-oNXc4eDGdes_Y85hH=Z$ugC1ABL%&LPZcvOnh^Xcg~E zS2u|OP2Do#vrDMoeXvpW19venG*3&U{>uQyfmRdN@E5?4A2^0l@xYL{^Uqq{9~hgJ zyY!Tgp#J1)npivPuKVlR5g_x`F~ySwRK_9tJweDRD3L^_M8_%&na%uL>A>?41*Nk!<>NfD&-n_)dn-|ybK%M%RPZKJa)w}Jli_o4#ZkPr4g z9!XI|UU557TJ7K&mbS0QhI&HWHI#)Cz?$+Zy zsl}tJFJEedwyS5|IrKGaB^lI|K5_(22`AQSKYmb1XFl7+mjDc_X{#`VDH(^fwUs{I z1IEEUA<|Vrz<}xzk3IOk$o(-%F~0+hEkEDSVkk3x=|RGie#A{aXy28{r~&%J3e`{1 zQa}$=)i!(`2y~OSOB5L^pl{2%rZn~e{p<~aMUj8O;MTGBdQYs2ZT5Md(G!?Inss+j z{0rzeUy404FN1pb2y^1NIO-$nfBZb{g!zEpzYGG=?|J%}TjUV>Jq6z05esMs>eH{g z1z(ae|3}%rxjqvpQzKFSx21q`ad&9@Z&{#hJ!o&Okp<+!y~;llzhi#J4nn9n&R0XC zEc+xhfD|aII*&Rcl8`{fgNR2!EMLC&%V7nG*7fF^TyKEz*G1)3C+bIXdskkh%mRTf za8Y?<74qfWZ&fL%Pt1BDH5b$c7_dIjRmB2&KlONp{-J-(IJmxM!+X$u{5jdOkOy=H zU9%2dKs|5hEQP|rKK|_tQHCG$WUMDr7g%uKjrcpnkc0rI~)cAGuFm4-Ou6;fxeJLq5dn<&-nig?z8CoUxi(GT+S<$*xNQO@~WTj+-1 zo<3{+`WEu(l_%O_gHe}a$y<887X2STwhz61igQ)Oi_)QX>?gvoye4)I$Pa@xFP^CY zGUa{sOJh$UebRe7ox30F@t9fJ>KN8TZ1aoWA6SpjiTkSwK(u;&|JT7{ApH6D^ep-X z2)AaVHvUKi0~<2;H!!h>IyCmsyn{A2R=avSV2d z&jdVD%BkW6gH!A5<{cIB4&^3)!w@~3d#Cdn zY(rmqnc?1hs1FjqHE7TD4yex~4R$BB0o6KfYlS`XQNP&Jg;g;3GFqVCh3ejk*$%qwo_i<+*C(wuz@ke0WN>4*~!21Nght1X~6BHI3O z!{ehF!j&zVQbzLKT%xyln)=d7s`McAS6xRDFst&xhf9;oEQOHDH+A z22u1BvF~@s$5}rC#`gKwbrjq)mb<12L^A5(L)#hV_YnWus&nk}bM%Ein)%$CfjVn< zm%h_y!Qh`un-V^V1~m<%NyAj!*9$v(>u?{Dr?5tZQ!tmVTuL(;bt?(`%VSAPps)FH zueLDu^O4UXHBjhe4m1(R;X`Oyd7uG{ALh1QtAeQC4 zNIv=v>%nT&r-A$U@?jm?hFlg0oK7enQ?^*XE50yMoo7Ikc2Qn5V z7OJ4vXEiD6hW-3NcEY6eD(ZQpBjd6JK<7{2eoNIKpyO18)B`hUx5iBxs~DrN)7yiY z1@9L*X+QIRzKVGnACxX%N&|)SLXN)fn!t$JZzn2d0gNd3sVy&Ou|5)N-PSl?`B)RB z>w=f?`?B`~b706gEMM*{2L=-xMfnKoeEWkYHa;*$y>-VF%-f+KL0n&? z^Caeu$FxZcARf6%eo^8K;*Cv8A5W~|ynCTydFCh&7^r=fQxv}s`d@yYQj^90k-Avh z?p6!>1i5*}mI&O_>tn~8l99)qh+~Oz1lpcf<1#VSWxcv!Cz7 z25zi}_79#G^xGcN-Kn^C4Ru$0+Y$<&0^!E0K=E=0=E~frSK6jy4zlQi*ML6eG}yjT zyo5N3j@1*+wUeOtjyKqEcMs?(G`k(Q$2^&Y#&tK;j)TtJ@6e;^P~5b1Bl;0AxGqW$AI7o_QgjwWgmnHwpSP zIiV*nqCO}KiW+vHK8VJ_wbVsGU9rODKAQ%h#gE2$eZZU(dGn!;V64NN3XJQ015_6Z zd+|ratybmF*YRMkNy0<+zUw$=NwPgiQ{+cogWS)5f24uT2>Vzc+=un}yW_&rbF4?= zJoTUQ&&h3z;SNH>S-A_Ma_QBk%%Re2C)raE!)O)4Zj^IzT zE1Om6CqcU^N;0A07ii1GF7|QZylX7oKkFR?8l%rSSMnM`;Z#P{p<3KOvRcC5rG@|_ zW35t8;{-60a@f}d5I>1{dS&qYTl`M+?ssJN;2dVU$NQrhFfVH1v_f)3k3!t07jq+>!h&;*Q6#*yQ2j6SuCA^$MJp|vXf!J3t zAjb;+j6@z}p{wAg8Ugh4HhT*B?f`wmGmG)F20;6zn!51~>PwSDwqBYDMqDvG`&Rs4 zpmqda+>prz)Z^EgI>ZRbKjqp$QX+rdOo@VF4! z*|QP!!!Mg_;XJD!#uR)wkdFNJnONoDZ$RIFM3KjK2J;YU+Ha!}&#)`JX?7m}p3zo^ z(GBPm(1^)b`Hgx7$<4Xf#gcHZF3!DBK8U~9zQ502Mjds#^Y3FnQCC$Mx2#o+dtKDO zgWLaH2AX57N^hJP(9}lX|5CvHg56(p$I+LF-$oJ0he^l-%BFL);hu5E>&d_P3ZR0^ zGs?&!>UgCtb1I=ft*s{O3Q{_hL<)De=M?I%IxZSyA#clfdfSo-;)k6^7r6w6fgHD^ zHk}*46T|w`JNWS3;#6JoiTRDZ)S2fMMV&yp8m4}b(;j{4mcw_0JWwAuqovK50^)l{ zx5o!wAf}(tcDD3G9EHNmE`WMD$$`0{sR1B--5)o#8ijb{fos`AG3Ym3c-HbA=P-h6 zgYO@2Ah1WDePfLM|D9DHFY3(U=6jK_4ncque`<8>lu>8h;<3N~GxAqnGrjBqpu4-j z`u>10D9Z$xCNbe&Jg|O4IQj?m`yAY8<{MDQ8>F!$F@*QH4!Io~VSs+!yrgbA`evS5 zO~m|v*D)u?a}Oy9b%^mr4ws8S-|y6*iWBx_>jTFmE{?d&^f+Q#OQyI@);Jr^q-teH3Rxj(K@6+>~bMAG-T+cWIeCIx@d+|Qvj_U=r_To8&jqZu&X#pSv z)P9`8Prj1DGjVoc7BsiN@vSeIbWlt(=c_>Hm)?G{b-BP$Z+tp?9r;x?0of)s!~qri zH-yF+0z+zBmBQN{m;)kUKwGHB0xCbFNN~#uhSaHOYJ6cfJaCBv+74sC| zyK8*j?F6LMoz$;Yv3MR^-*Kz90*Q|+BxDx-g!Rp}Cweh|G%osxg`_>|-DPykYf$gL z>c$(g@(S|mdwpkvv#>S000`7$(#63$xBx00PdHva9jFXGKu~iug5}qLO^^K=<}iob-dw`zB~@Y zK-?a`GGO!@2s4Rs#o>2=P!!`D5mbc#-Tj4#?n~&)p$jVhZ~~YX{3W!BAK*#F&dX;} z9~WZNQ|*m&iot7xVG(ikff$E196thPr>^cX`gRt52m2na=SLl{$&=5YP#3CmQMS6{ z4t~Fntygv#VjfJPH@(k<1NEYXE9Bb4h;M8v42VUX<6>{R+XM71$5h{v(LnvE-;|e; zAI=rK{pIZP(C5DcZc??;mnI%&yQqNv%s&cd$<|nB+ALZ=@7)IU+iRweM0)}~Mp>qg7_B3uer`$KS4?jx-}x)9>d9n6O!1 zyIhwAI=%`=OU?}fV_fNC|5fC-zirwqUFHLfVciesCi7AE#`L_f<}deqY%U>jkaO^!`5n`#Aq~{&}?<@exv_ zzr^%)ye9`j`sAE}`uyAxU0vj%{IoCcZ+Zn(S=T9B%)_U2kW6nn?*U5Gbie5z%!S>2 z{oJ>kazK7}Lgu~;ppWhDI*oV#fUGaz+oOZ}k}r>q?=3zCQpVX_?)iEkv9f-+DK!9b zrFZ94M+o*?CR^RuQ2*oGu$1u@^G+0ljGXcJCJY!xsLcri;j)B#{aL&x)@$c8e)0-zCpcxEL2ualdp8sP!6^X(HBc9_p3`f=O#7g)y~ zW17}*M1t{a%G%76W1vIda#O-j6@8fP;SOIWFt_j3qT3`V=EPhMlRjYqOaYtTe2c$0 zU(Zj6Y(aeE$EDMRIXsWIn<;aTy@2tuKDYPTE!@w2RCK$qF7g|M2VVnwfw9MI&*nj# zH#SE-J&1LJzAPeeVjI?<*0p8=H0*CP&OJJiIgUATcfsrXY1EA#(k&OP#`$lR{PEI! zpxuca3@*pI@4W1vd=BwMi5s7G;rl>sPhg4KU_Qgiwg(QUKVyB*XylK>KKC<^rs#+3 zSVxRGr?gSmu*1tjut*4XSewAG1rHPPSZ-mz|M#g`d>N8eLL3T(&HrMq z0@L_+itk07FEmxNB{kiFDYfP9E7wBIzZC2WKwgnC_STsE5&MAG=cjz;QO9uCVx(5@ z4=|!-KL1Vqh3}b2y!h@*z)&X1FW91vWV*USeKqP6%O1?%v&45TcHOGD#|l8FiiNuR zB2L29;V?0Z{9v^+N4N_=>PtRPl}(++JjJlqPW`Q@cPCPE)-3}y-T80cia7EgvwNc6 zq3&vWQ`!UjGN5FOpSf`O3{Xh(OqE#lb^cHokpHv`bq&v{Uva-I843#T86yw%lY3W{ zVK$JmiW8mJKLHY>?8OGm$0E)P`^6Ss17cpj!M7AD_PNPj?>kJeuX?!j<|N|pja-)} zqWOUkb@5!7`2is4@BDe!4Sff{^jZwRHUc~#+G$n3#XS^<`@94ZSCK2dwR_ciFe}qH z*)@;3$p*3)mH30fv_!@2F*oKb&ZoWkb9*ls`y@x2ppQp~pIhnWKm6V!>@6;q<6M1Q zBi8`+V9cN!Z)k0(+x4p8QNc(PrtPVlUxg)sN##)OPDg!%rim8A_$@Hkf!EuheW>e| zJe7|=K1OT5aj5WX+;5wct7^$l!8J1@kI1Lgk9z5DnafwJ?Yx#J@0MQ1Vx_TE9ANw!AY-`%*c zg|cmU|0~25f8|Xt{7?nbl`~V;Z}7g*+s19ixPUl&m}i~MCm`PQjNL7ayy5=BVx>|C z^mS6!1_?eyeVn{_o@ONa)=YhNh4KMGJ^e)F>GslH*1vm@^NExr2bdVt-%3zWBd z074UdRM!+R%dlvI`}$zEZXxExy&=r6?r+H)z62)i`ftow$HABosP4F<6SSwkzoV-l zpLEBRDyDk{^B35eBOl~3Z;5q$O*#pf7v#28Xj!3NF<#=G$5zypo@7^XK%Q`q+)OtW zaj6}L)HvVZ9KIoRD&O%pp3BbX*HhNwec>FPJ9Yzg37^LS1^uFH=)zXC(gz-DM3 z^*xKMDvh-XnDg`O%>!x)_Qz@YIp_U6N(-pB7CfM3JgSNF2=i};>pbeP6xX zoCj|TSUZd)1DRny8?^;_!D&9HlhxSYW}C@c^=|D1~!KZX@R8cz+WZS}GlCgh!tK2uQ&x3RO3z6F0 zGXT{14z544$Q#CXH}8o@fAfLg^scLzm(1y&u;K}(K2xg+;+0@>?nH;!%MHV{LAzUp#*J-aF*~F0#D{ z+vo_)V?rrg#2x_C{z(qsdgM6_7T(S)B3~%-k3Q*v{o1!mg%dRF!(O^xsQ|>+6X!=G z4DsIB+z|WgkA4O5BceQ83~~O9JMj;Ff%J^U8|(LL0)5vUiS6)jps&fe%Wa15)hjlq z@N4LQ57=d9)-(b%+2^`v{%%72%2Gq^1>){U$xB+#%7H3bN$@F&14_jg^EOv;)Q@Jry|z-dAJ2mgv;~qdN8`ph z)dToG zcO&j&`A4+W_DKNk+I60}CEt+8;865ya{=b~Lmw^`W5fp^1eeI-_xo>Kl0bAegFzJfT$w;Zqurtqz*#{6L-0-}O7~4+aA1>fZ0)ui)H4 zRgk#q#Dlq50c_e0T0qP;{`_GV&gG0~#kx>`#Cx@g$77JUy>H%swEYwiY@6?;S@5Dh z?q2v!)r|nJ`e<*SE8x80xM5GSC%~31La!g7F0Se1P_a83n3-%=J)b%WrbV=#cV&1k zYHh1>KevI2OMGtel_)TJANC~W=oZi}{7i_gMBGsD@YSJZN!0lW?D4EbT?6OWiddr$ z$ZxF5sppwRU5PvRnj$aWE#~@m)*5vT^2Wo%b9gS74he-|y$Ox^eXa=aiRC{@7tL3| zR1!Mu=z#e#zx(rpT&FO9G$fZ(={@Rs7tFF{MS;OQwVgd5^(TD#nvHUZBi3(@iOfbm zDk@Pum4Ne!?%`Zn`d`$$bAQeJ@daq9M@61DV}76M$D~Mg^yPd#R8Y0>7^uk>Z&W_u zd1&1gt+KBIO6N_z%Ah4?~v4iIiMO{;_ zrT5Y8|BwrTej&_N{VL)w6xCXBebguZi3k&!!guQC)!MCb$e)`(-6(hz&*S$uJ}EEs zO=Wn_6DpCHGPKpOx`RC7`|(7L41S=5+KqIrehm~c^77LI*~o+ZqRBZUKegAoLSOnL zkp8(R-o!luq-(Mh^I89ZM2*F!a~1PIMo@ zb6Jylha+hRm_}ASZx=(|&$RDf;}6+jq9XP^w_ga1ZYT)+^D_kPvy$;nWyrtM!vqy1 z(t$-~o4)s#4Ophxf6c#KMSY2tsX!%JRW{(>C(2N&mOv-ISCNk{M^n>)B566yK%XwTUZNX(8nFXHa^3+&jdhVeC-ZH zc`!?GU|8x@p-<`pNAE$@yL%oS*G|Ly@b_;z2ld&|cTjA7IQ=CUB`Vsy40;RN5r(Br z63f7H4fvyX>o2gJrjAMfL>=7z0JomQVZdVj=~Th}sVu|zO9Ll%0!vBVAUP2ASgU{i z{K3HcGBz6fBpBbXTImD&=J;-9-FJL2fcM2OXTU(@1@g60@$;Xsf8)@%9u7eMqfx-E zMOhE)d*$y(tI(fFIjm!RJ{0Fg)6MT%d=Njj&ZT5+!2Y*Gbn$o@?xh&A3Osuobyx-2 zo^3RsdAJ6+IsQU?e$#=>e|v!XP-BR^Ss$pZtIWb)_U6gaS1xoCh)v|a0Aa6UX z_EqB$kjo6BgI=Nkz@8C!VS^j`(KlY&niPlU@#y+}AAO|3XM?#K4*_v(T-+jM3lPu8 zK5PGp{gy%L)nk0lKp2T9DZhOKg!6+Yi+reeH+@B`)0PI9kT*7eb`?XWed5%r!C{QoU}fKgHgaL z7qzbx(Dpy=I7ma@@Awrq`7UE%g{`fD!4}jtgdXMB`G9(p4%$h?xmY%e#=B(k)9ARU zk4-b`v4&XxhILT4=q1SB?1B1TITb&92h_pKOtp!k-X|uE`4N2p%$@Y$%Hne5qjGt- zoxP0y-4{LY^0k1GmDL<;(*umXz5|oO=t~r|9_s4U1$uR0X!u=cpa;%;(t3&bu^ju5 zC+5u2Ue{b-NMQro5s#SMZk$I%MV8yH;++0;F(H4n1@SBkyQ81U=wH)w;_BXyx`scT zZcdmxqeyzGb8-O4m4Wx&B1M6GAZ*g&0zZ(JEQX|U9}Vf+*fgIR>PU%%>TB7}K>TVY z@yja`arQN%U;OidsPAu>G&v1~Pkz?)5+5L(Wlv;yoB@J?vP=0|dE^T_V)Z1YP~Wid zba4aD|aW08NIz>o@w^sO6gykKD&xEIa>-TeSDc zi_j|O)PDjcd5+Vs>c&$-=t0{!UWeN@e5AT7HN`mlcmQjYljcbLCL zBBW(Xe_q7Z!)bdGHv7y|RfWG~d!lJP@&;~t&B@aqqev?%4)kBE;DtD*LrH`Xus{Dzq zFXC7(yl>XqVf~mNOOrZ^bH~MO@6}pjKv5s(yZMq1 z?@i%(5LV0mU)SN+*!F-wKpb(G|9$T{5R)$H7}m4{QR{fcfDZPx@A)saOg5wMnfTB% zLjwp~#Wv=$bG&?&)C zsvk_ne^vju+XW_xa83cRZVdM%3*+~GF8%z@@)dl~6kdGJLEVr2#q_7^@!c|*B}`N!uP)+t z&Eb4K=KTF+6k)%?EPfd0c^7fXlV#Gfj|sqJ7})%f>ICK*QmvI0>aZG@==;wj-*PhP zO$Q6_%?=@ldejNgzdb8R430q`+g&T;8<;OdVxRj>bZ^C5BGAtM5N>~jdXp{H zp;a7+mozs7QVNj|Ik>s_@=FcGP2}$Rs-eF9^0ynseO*A&w5fY=o*&2!&(o#b@t(M? ziH_3M1~MCceZCj+={ar+(yB9f9=lSff@gs^EPPsfbu17QE?9iQ{6pfFR-3(kSqX4^bfX0Zydho0cP90 zwZ+@V!1Ss~sn%883$l9R@;n#v>Y@Go+pjxKTEsex$IQ@KW~SXbdCH9p%|85{gLkyL|`#{ zd4JoWK1gwxX4-~xh0{Ze{ztnM3JK<%>ptM(Z8u=x!fI=-k1RLlR@8eAemK$>VEPA;!qbY|1k1U@rB-PYH2{+ zyi;DsvJVJdcLvr!MLkw{flgu>;=3x2qglI=SnDeMnAsW$a3WLFBKA3emI%KtO9jlT zH|HgA+T-5TZBmC%+(5ia>v^t358{U+B0&Mxt&p*CRYY zTc^0(t;Z5r1IK;xT)KhvzST#_#0*%S4b%PG{eV?_=vHtEp3mdgYS}N0fR*{#i1&^b zzF!Szv=8P1%Py%xGw>s@bdC3aQI-N0_n(5OYSg>;v^ASvI|j_0VTZ}^eZcgv&iJtn zaTgUs+0ovA=x3`Oyf-I@_!iIfr|58CSQEKYEyHr> zEu25Ld7O(;@d9#-@iE@*xj^<5;q^P{jOQ_U*!~RG^PCLcs_lsPn(2DJ8L$T8r~4!w zU(6$m{h9bT4EGamn&0`cKm`cxb-joF&(8>>ofm(M{jNf&uvTNUSIPS@V-d5 zH5`8dtOu)7MD+3V%!B0QDF?SNy7<){Xe1jzz$yjQ#)5Bcmnd>repuRU7|)t=M9kCOjrC%P^Wm%Cv-^X9*|dE+^pdEe?5Q5uvEo-0MkNU zPU9IM4qgcJ_e34ZNya<75K$niw43d(_>Osf;`N=pIHw28JXPzf0>Z|g&{eqyDE? zgO?(UzJn(ovffKzIJf5A{8$@k%M}-khvIuPUtwYDjNktpw-Vp=cfk5JXlhr!Agu!`62&HO!$_aw^VX)5}7LY}ynZ8(d%>)L!`<_Vk|UrRpaPDejt zpP&60H{vQ{qP@QYff<=0E55oIm?rUSg<3sAo8H)=m~o%pA_IgiE0Bz~P83+>IuPfb=BlZXt>+M5EWI(g@~|EG z_)SUNTv5P~Ec|pmALqh4ckikxbo+x8Xr=@{$Tr z$Ar`-y%NxG`+8^TGUk%QgQLLQ10xyA@_ z_QL^>49c*ci|=~7fgADl>ThI!cH{>St3_C|ArB?Puf{rj8q6}+5qSJBV9vf)<)?Gc z!PMDZO3eEX=4E966iP(AM7KpouJAgTFXWn09oJSUg3v!}!fi>25{ll4fV09QaQBt1(tH>-Pob4I*!}Av; z_U-szcMZ3Vs)4m*OeL)w?+>^6wVWKBN7|ZjP0<44TPHnLg7LmsUwUnN^)fK|)$aD& zWTXGqeZEb2Blf*VKJ%PdMK^PsKMsd{)W>rGFquEso*=UnY= znJ(xjEU{JL#5}AYNu{~ADL{=a*z47B1$997200IQ0VVgH)MdM9pqL8DhGgplx!cPs zm>LOWpLcU^1HqUByZ3VcDbz9Ky#2J5ALkDf%Q9CbA0Q4CQ(i8u6;iyXPo|s9*3sm*H4<6F_2PXQ2+x<>%AC zu8Sjp>9kDctr1Qz-CId?`ahqc!tYIl%?g;PZBR?PK7qc2a|3I)>ww{#-k}FCok5$= zfkK{M2j+6eCN{I`!CdA^Q`@f-U@qpy`Ib2h<~(Ol&7FS$teG8=h3WV{^#@vN_=WCt>c8?iQ~1xL{=qeHqw^1-AM-V-)p-td zsoCG7sb?_%$1qI$2;z+UJl+ST@&k3UKxy)K5>ON91}Co+169g9>-M`Lpyb<~YnLv> z96w$`p(ND9z4_SN_5}GU-%jEFq%=H_9+B4xi0kHjIx>*-3`oXfKjwKc*QbBvM9w4J zpA+$V?;zr)MA_sPr}dUVsNHnPc>;BbKIi^5FGd4l-Ag+Yj%@&CHy%hn$Mf(q)F@~d z0}zYYM=DUnT=&YeXTM=S-?x&JeSdKdwCE11SHPT%XKWY8M%-{8p_W_HLq+r*EUqS} z4PstKr;a7k?%Ev7TS=b_z`&u6`+(#CGQFPm%s9moD^`Q;xQ z^rx^!y9m9SI43qlx}Eo_#QCw^$m?Dg&hZ1UvN8XSWnTV6?;I6a63I922s{GjkayYx z74#Y24%E1G9QhO1CJzl7^7GQ^`CAdMVRW%qzrQ&Gj98r%k9DYf*V;2bgg*!Bc_O(Y&5EC zD*q0Y!n}O~_w51mWwIs7aX@~%{pWT!86f*TW7d>b0hx>bquo&o&tr_pUULl3BXJ_$ z+zZb`u4!&JFY2!D47;Tw-n&sSM6XdA2-Q}<$tRqE;N>>oIfMB!!ln-CT@--Q-t})k z3jla1@A35~Vve}nkuMgQ3l|gJzeh?FajU<7WqCR=XaCZu;4L*Ud1#)W>YxiI>(|`n z>UjgkhTCV1KAr}{s&j|ZaUfb3(VDK6_uV$fw|PY zrBhA<)|Vrl17q4)PdsV)ch}&%^$pic)B`J@|DI_rKh}|vs)xvDu=bqh+n$_+c>RX! zi&&SL-|`~d!@RK1@-!D+M4rmW*Vb*<05BClc|@jT{do5?KA-~m#H6xCvIF8L`r#t< z37iK9_e}n(I0f{$$U~<8`)*Yf#=_V{sLI^}30DRnA1F z!g~)qkFBSpIQIdu&o?C0^%W40XPBGbME+d*p{B<9IUu~cdZco_HxN8sGqZL{puT6? zF$Hz5P)xdgJO3l%>=x0RF9joC&ZF6W{sNdC?;yC3BJb4K-Y-&f4opoJAIIh=q0g3@ zLqpxGiNMuPcGJ~htiAoF;U{h|Eallz(H;m|bB`D9^lO5->26}~%6c$2isfLSPTE{o zc;=};-VbFC#orPiz;N3fu0@q8MvK_KK2DnvPUY6pK^i;*Fb(nqzV{snp|7`7x%I})>M=!`Gk2g&$-j8|L3z)FZ@i6 z#QYt;zI-|4yVnJfC&IDb@-?1tX~21nO~l@z4|NFBd#aR*k>?&tD^9w72K7{L?R#g) zxW`$3P;M>qN>`&}-gA6HJa8^$NCNeuF6nzd&Dj9m?4Yt(7xLtiM~Mjwn{nQ59(i&O z@sGv`^#}XW|8ylyq#y+GbU(!qmu7a%eK(vvJ&FB>F>zq2Fk~2zHhq7dt7bLjk~7>6uS@oF*T@D-0<<6L}vkzdy16L z9}@&}+U}+3i4({Z){dr2*aBH(#qNXw`g3~NKQ#;>A9A^gvsMv#b=y655!OaPlD-jn z{vpmGpB}DNxQjZ{JAswuHpn0P{5CRG=mDbkX5;cH+^;$(9(UXl^$nFJ?<*yzfRMy1RKRdYL;%1e{(y70@H}0ry>C5S3uc1535l9@pj)~v z>uNvh5(7VN1RQl=S`}9yS*EAJ+8{J zPD#j*Z@>N2d*UeO@ml$wOho@dpTS)o0_uG31zP_+a0F<90>qq}Mm(2|%Fawtpsth# z>vPorwR+}I;0pSjV@KKhzoJf&c%vcWwlYvw2vge{9|EQHg9(qsCe*v9H+Ar=L7k#? zk)$Bz#f{7z<#_WR$T^8iL2I5M55h)?7jQ?tyS;_q_eVf_lP+id1@q!AKI+zV-vK1+ zJ8^}^s9Rhcct9kn4TxQ$Dg1AqAy1WLlT$E#?OOp^m(-w7V<v5r- z9MHTBOX;~kfTn(2M|J>pKHp6TqiI+90I zLR>dt*SeeK!ay-5Y{@;42;^x!0d>^rksoZ9vztWSqKoY35dr+Uq|m^lOEXV zzh95lL&Ij4*d_D&i}I9IKHEU-r*>UJ~gYefBXB5fF_`8IBmm+{y`VNdixoi19ct;);0olTlM>x z*XSD@)3j7FLmV+PM}|EEbw4cC{L;snxHqSjv6PB)`QtNRtY7ycj^z~pA~6yyH8;MrK8lC zo1h-5y$PcNXz@>mW|XYV=2s2lg?e|}qhEGm-bP4) zw|O$+kcNX*WF2!bt2?pJ^%mB9ndF_}-`zl0jw$BO(+*5?o2BwP)b}vm>sRT`V!lGw zTu=;_I>R~n1H;dOx#dJ;uRR0%RD-$O=;vbcXefWakMs0|vq`kQ6Yh%|5{-C+K9a{T z#e^NPE+;SQ<*=VZzUj%t&G*>H8vWiHyA}0u0xdQ^=rg1b>=IJJevN)F+h0C$6Z#P< zo`#n`M4xk~qtk2|(Ek49ynLt@=fBNX{^HX3e%<}X$zFju$>A=7U5Mun*C|Oa{X#v% z4Y%V?=zC^qu6lv^24x{BcKH_iYae_%&*Z|ovfrLZU=8}HR<9hbi50DZXBUP`bA%4P`DvUS>#6N?7pFYFSf>Yt)QyDXj{!##GQ+xYdvYoe;y zPg}NQogy&4xZJoR+JNugj+cxn)b(VzM}{zv@9>@FkMCi_{)tnl=?m(7S6{!i`Y!sh zI)|xq*Qv;N40jBrrU2dUrLC0~;#HDy>KuCy0tE$!&DDE4hm!G2UeXY#looUNJ zu5=8__x8a)YanlzEBbb1Q)xcNE3uM5r403l^E(q-@R(-L)>b;*<8O74={c;8>pVbKDO?xT=+rM$ERQV)5yd=&0{Gu z`dtyueeZ)C5oe>%5&W-|%%Z+}XVX}77Wx*YH&=cF^dZz8y7xX0^*#r$soS9+F<-7f z|K|YuLWCJlT=yb>zUR-`JsHRku6uPu)dZ*kUJQq>y+D-?>+Uha_o^=Vu~{|VmqU4d zs;SLDkuX{aIq(5_Lb;+w(YrDtggQ9z2xNSb$f03_YF zX1i2xBcINg@HE&8#48gur(V1RqIKmmB@c75R+mgEYdYdw(!*}SkGSt~p}Sy<{Q5R` z?=*AtNBwI1a$g61pAVT$j;Ge4Z?LG823j8 z4c<#k8wH)G3F2p8p-$&#{&=kVJ7A6{#_@M;2j-~6Zkw_k)G4?fj!Hz|L9_34Lv9B! zOAOgv>X2W${C&7PR~3r;*>tz5nW01273oZ^n92S0cGDQ`T_?-?OH3p3-Mf z59ceaUtj=?vz7|^e3e*VQhY zj#zKKea$S;>U~^hH!B0}nBIhHBi<7=<~;-HWc0H&i>Lh-0%}ZO%KN6_`-QMUF~70G;%G;iGF2H|{cOejzP;Pr`c{CM(s8IyH3;W#rBL}1IXoA)DcLw@ z#Hnt&y*RlU{XKuws5h^n|0>Aw4COS|eZ7wG>n>PV_KrQ3#XQA@>5Q&}LO?H7Ay=Tj zjvgeOwLMr^<1&8VBY!7$53C@E!5ouS09kMB(T8_Yc3U zLOxf*dTN6SZ|&odEc{HPc~e1|+$)+@_@-_VzHBFl6|1Auh;eT>l*n5}pR za|AAc*|FbJqIeHXpLIpcL}UJs^y=K|$3mbJQC{ibkGuw1I$3Ww;(~-0GTL?gH|DBS5{nsF#n5-FI=j6LeFxn#(`t5(Kt6u4 z`u;H16U7t!GrT20Y8^apjlUo1Sf0u?F4X_14Ak^{d_dpxq2Maw3FL3>+$h-0wFZ5)J-QwN3jjLJ zE$`H}qR!!+(_Y*=WwzV3JCJe!Op_1#-Fb=o*Z!3JIG5)RI__R$-)}tymXEVWcqZbv zUP5{@>c~U6$b=^>-$FbpCC;h$&4?5}~@ zo4ciyAK$OX`VpB$OTau8`B`2i5$nsPbob_Us8dX9-w=o2%+Iu&e#?7-QB=5?z=oek zIpX4Mj{-wG{}eMAdGqnsKE=T<<#!LETi#o48-TXjI^rrW432?OoPmFC#_umAfG z0=V}c0~*(;_Q(79PUWdJ+|$_s)SZGE^$st9GSL!pqdy-g=f2&JJ@pwVIybBfNyyW_ z{gGn&HwMTNwTYHT%7Lt;a3(6f63>H;&9_j!&}~vq1PnsNNlU4hR>=M~(%hpuct`!=FBb`cW1A+H?{?QJz*(M>&Ac zA;IoL$WtkL2iku%!97x1D*8SDz)bsFbbT)7@_Oz0e#EW@jJqzcIje^LsGZ{0Te%#7 zm0VTjuCM`lSar2OrTgSAV&`%=w)RKYsBbdlsk;b}D*d7QTdvLyy+?;P(gT5VZ zJLxpU50fQwlPeG7+#eMFYV`$RtlCz4QLzf>#nJz$-|@Zj4*S*m|9Oa$Ycv+{-Kyn% zu60@lag|?U$F$3VCL$xTb`A2j&&%p=-NBrheY36Mw)H@nU7fc5j|A#WVtB+a+ahm! z<8j{^^c(cKnQ!SvA4pV1eob5mp2x%1D%CO|wWw6MXck76;D9N z;4;PZ2$i5FW<-tH3Cu_Bqt| z>^I{PyW5H9Vi*105A_gYpKdCey~Ms?xHNP5Ci+LhY>uAp$9(H&s>zYx0DU4tBBvCA zsc?2Qf$FDj@i6Gu9%i6xr?kZ5LJT@N)=tUjYdc`aG=v!OPTp%m+ zp?@veS5gk^yRqK1)ovz`Kb)EIH1z=TiG;te&vOA;S>d|rw=5tv?=G=0Is&Ai4JvtM zF^F5aP8a#1|D!>h*oyNgF(}-AvOEa+DZ?8g7wmx0;dSxedVIG|EVqf);it~5fblTS z-CtPBv)8b0Wc}gIaJ2`pny3x3ZU@>%6Oi+p*FP^{keV$@@G?b{lS=WwUwFK)&| z9ahUh`OVqD3KrM*5^(q{asp97A327u!S4_(J|fP(_$lPZeb7g6`FoS-JbZVaTR)8XBA z;Xn%5^g_5a2S^fjx7pUBzM)1!GC6k$h=&erY$qXZA|=}y*c}0c*LHzh-^l^t7`Ky= z`UL8+WJJp?4x&CTLxZJ+JjnR~2Ny9W;4cvRDbfY={Fwb4#{|Lb;Mh66+bW2|uiLxr z^A#}VT~4$=aR!W!shx5bFa#Yj3!fg(m%#eQ^|~MlbtPXC>d1eN0&7r6ps^G2^sby+ z%nuh(UjiCg{>a1T{+rrY^cK(MUFTyfa4|gO@8u&R|59UGXe&d zBh7eE3Q1iu#=ty1Mg3}teVFC1f)_^kDcm?E(u(+H>(!vm(TF3TI_JMAd=mSu>Q0l? z4?zEUKv{KXG0?BX`%3?O2Xw02lJAv=K$}oFWUS8u+Qo5?Priyk+xGp$^=6z8-A^# zx8_AL58(D{n!`;X$d3z59sB~&ea(NHXD-00;@e;45Jxo9vd%iC31*);?G*3hd06d~ zI!?#EELGYqepLs-*hesDyY3#hM+jK| z*2L2{qt5DwKg;d}o=aa#(v_pgYt-u02@tVv+<&M+I)L{mk#;s90qcp|dh(|70DQkR zbh|?FocMC`mTCmB&L`QX>4xLH!l@-h#JS#mi}mX@*cU4){*6yS9OV@9oa5OJ zjfSA^$6QlBfw>C(g(bZm(*~FW+ZbcE5%s*gPWkqfBmXfkBR?ag3AC#vw3w78^ykEd zTnR^A;y|I)_g80e@2aQG>mTR`S^KT+!!h&`=1r?J4u}AS)_KDo_a>4@qn{kBWdm~D z43E_=5|C9?d}I^8;CTqPuVzPIi2t3P_Dj`368Wt3I}&p)UzR_KO+p>7hgRfV^a~&g z>#BDE|;{Kj~>AJyLqSO(zeq8kalWltix`Yg2~(4ktsc?U`&sA8us}eX#aJ)?l(S&JfNS;3*VDq zEgvY70M@lpXV+dl zpJRF^vd%ci>@4efqK~>d*^4U^xSxzU-m&1^ioW(I7wvlX3j;G`X1tHf5}5kp*@0&G zUQNk5iAEvrcz=t4nD0km*dL_bzJ~r!zCZg;cwikbW?Pfs?+$dQ$CoW9lF<*X=kwz? zAL8;Q5_|>!fJQsG=?wG%b>zrQtF9#Ci<}9y-;V%wgKN?6%2c2{G8ecTjqes~eW(=& z_ETR=H;aEq{phL9$zlv!JP!}G__8V>H6C~>HIBHIp8yXryc=OUY)=7bkKHfy z&h`Lv?O7MDj9M_?>cp@6J|4_f(<9=81i@VL_To~E67sbvkH+5Z0oIgbvZX)HBR%q# zUDD~OC;bw{b`Et6$*<(}H6+kSQX?y@N=CgRclCuPK4322ej_-T0nED6@V~QFh_|?H zx>k%jUut!bO2F^jB#hU)t4`=|x`;??fBl<$b)ug}5E&;uUAU0JK33Q)- zg8GC4pbJIX^xW44+M@-l-HvO3W_iP3Z+{?A$FGe*3<;?5ir23F#2gywfUpM6Ui8~q z1zYML1IkW`?sf57fc&lYY|+|0ASciom^oQ^9$B5JGzL<`GsSeW36OkJ9OjyFP8Zrp z(b7jh$TNqg-GV}xlT2g_pT)V5yIx+P6z|95q0<7VLvRi}TOM!&^`!i-oWp)#-7X6@ z;vCHe@V~A9H}oNZ9Mvg#cm>SvKd8F075xVy7X>O?)WI}n$MF@tI55e5;djhj9E>*( zT+@|21KRyFs~UYyfjM<-bhV=-n3L&$LYDl%+}J03G)f-N$Hv$>PY87B26keoho-h;qU^3qhAMqaV) zn&Y<{h?@i-GWpw&IYAPfBe&$dfL3}wMdvc=vGzegv?CFy)8wq3S13R|-C7-`d=IGd z8!O8N$%rd*hdsH0bD`Cc#cKbF+v%ZT1(e}v#e;2-At5Vh#^`m|?pPTQjBl3T?qI!ZQKY+mf zm{++Eagk>|@(JR|19~1a<^gU1@yk1YSMEapIdj{GUzk_6%9JNZ+6PPz%?ENFYr>pl zt=%NK7BJ@D2f>)PpxvR>vRf|(%>X-4=5y??yykizbtc^H@7s|lIoXgTf_sS> zTWbS?m9VbA-*m^f2>YvOxg!7D{HQbOJMv?p7id*+A2R!ta4xi*RuM;DYR)gRSbQDg zCTo^-*BJm+IZ(6rq61J~9(8(NEd`Wa0dI|tdII^U%la$F(EpsYqwDY-`gBx&eH}nO zDXBivxx{V`NC)2qygJwiB)++0^=-L8EbL($7e$}WUXS88%E)sp-wc_sRY#v~tV#Yx zF(B+_)9%pB0s{NmYY(Zu0ELA!p=89@ow^&+bFrSR4Q`+HIuB+^G96DEvrvzvCFSE< zhPfr8<XRg>y|PEKK8L-M@#Ov}$7NW79mR5uSG=G(Tl;56j zQ7AGZNy8|WjI6THy(c22tOylJLPi-8Wh9lA5{2?u8IhtCGAl9?LL?N)3L(7b{dE64 z^`YlJuIrrhUsqRsxm*<(ToN?OS~mvz0|)&BYB5LL$W^>yVGrnenzwsAss^1=1Jh;GI_-|xuU*OW@U!gmiog?}B8=L3C%@o(F+wt}9+ zr*Prj?V!`0WUI!p8}=3SWyx`B0Q-7P$6oFgU`Ghpm9OOicF?z|ry?7H?aAV0Dfr`g zF^WGVf&GO3SD^g==SSf%>!=&nhu3>Y@->`$`_5Z^!2Zj6Y7wSe=LoDIHmA%_8(=Z* z8d@>efhAb#^Jt3_>PNkWZ>`XQ8D2VByW=}BAv;Sq4t1i_ZoSuT8UiC#U3z^h3mAsm zKYTjz8t8xQ2WC7`uX0DBcdODY?uGwFNEh1xt)2gCXY3X96NY?_tT+cWUIuVkjR5t2 zWbCyyFM+CZYsyvK4k&MlTE9b(|FBr4@<0{&z{!S+U)h{Mj*R9%pCpU*pqdL+nE>hS zupIYMJ|H=q-aI$y4Nx0gN&`HwUJI!LqbXJDc7He9>MVnPUH!(@bLe|k z4Xxi4h`ivDOSy>x^`O(lwd#&GAMDH2<9jCi64>|DcMb2rK7Qwdqp3UIM>nGpImu-@$OuxKj9 zd8_2l#(#~#I&yNy;6<#Lq%p_4&=bJyjG61roj`x#(Jno1+MlDv^zUWq!x7#--~~x-vHW$qVA|F ze2-$?hhVX}D?ojCqF7_y0Ol~25tX6@fKpRY%U}5nbK|}$?w9%psQN z@8BLHZ@HoV%yq2CIY%uAoOA7+^f^7lfW&QJykv*_#^WEpr84S3!~pfUxZOaQym|Ip z#A6^N`nL#ky~ezy&4FFfxc~jOQ*^J11-M6jQI@R?z<8?=z!eAv(`k0h=__Dxq)CT! z3+5}m{MW(Dsz#h-i`S08YS3e7x}GxF4?2}+I|$E3VBbT7v3S%0v;T`8TsVZEkKXTh zM%^0wesHy_o;jT@*^S8v`r@*$ax}TY|3~Wl_gDtMfz?M0r<+J}Q-diuS zcuXpQ^=@hN>NQ=c>)jvrgx?Ht;?T^9njT>7Sl#MnNJ0LjyI0F82bjrwxmS51zGx=- zx^EfzNuK5`E6inQJiTP*{XiTT)@143PKe8|ve**;0R112es%1N8w5HMIQ#WR*YZUTtcT09%`^2ts#@96B}V|#2|r2yT*MW*y0&j@N1fuM^^;bouL6;= z!K>^c?&H6Et1m}m9pX=JoqqQXb9o<*2cN_9FcSXZr@lJsN5n4L|HAV^(e3FwfqTc# z36V4Sdt$&2I9;J9hItucmjd-M4_5NAY5wa?prv~LJUt({BRy@|B zXhd-PxErtwrJEfdEde{T;RQaTi|6KNvY8O-NW-p1Zxh^t=Om|2Z3*{y6X(q1_Na?j zY|eQ92Y=?C)ia=CA88+Nb3>kzmDW*MWRLjDnGd}yE$GWt8ei?=kNC-$jm@dLbvS21 zNN(N$Fs)u%>kJ@1FR<|Y^d$P8%j9(oN3owfxJnfky+nV`vcwZF)VJrX(NdN=0(53+ z|2?CJKpSGERc*ctw1BY zUp7Xc2J(!K-L4VbKcXx)m_E9O^|+M%E<_*e5wGmkVFo0-l#Ykx1wi7A78X=PzC6vs zooi4Kh}6GT$Fp#b`enQDEDCv!mpD_ABh<_Q1mvQg-kGobwuN(A*gbn3tOF(a5T0#1w&!CedmZ?AT2KL3Q z7v)dH@B57jX*zQkuwR9I9Idzj>|$w2`CQxwGZc8%9>M+{lT}QY_QHOj9rCBf2G~|Q z^AQQgz&>!c__GZ5ne~TH&uBeFUlo6;gOdsBdjC^9mez**2y4fw6r6_-h~9Wmp%2Vi z*+ugQ%D~Kf==fM=9_QYtB0~mve~AU3qgx>FUa39&{D>{;ANVREhz1OyEi+rbBOg+b z@$ZEh;wZ+Q`7fR#&O0(B;oyUF?-fq{pqMp4ld$EUE5tcBd;j0V*U{gp)0|1q-vg8n zvcn8!6i{sMOYR&T1M;kDq|OG!v7$O(s8bNMD&<_x7+xJnCdB=9sL8yYDiAFtTCmBIwnMBGe&^}#~1Ha^gk-!GG0W(GQ` z>Z+xuqA)L`?m;;hFR&Y0reCbbJ*1B7eo2NeuwTaz=8N&%6ofYy#~R`N^*co0&jZ*Y z@0&Q0$7Y{Yv#>P9IuO;Stb%(_%u`|1l`juFzeSzoHs#Hz2WN;? zko1?3Pk+`foh*mCAhVkSCmvv~-?+@hv&pDGxmwZpET|c1o71B0RT)6dT?%YEy$Do& zi7Jc0I-oR;C$&>iA7?kk>4vyFc}`5?Re&|-_Zh)8J58)d%-XU*8jvbG2`4hYVm-va zBsm5FafP@#B_8u-9++%QI?7Ea&4J#Q z2hXab;y@>HOYyL5J?y)-N_=Iz9kAOj`31d1U3+uJ?G(WPVAm@Kd~3jYt4u`C^~DUH z6Pu0CwXu)ikV-m}Gl2J&RqXapxF@odr^b`eFCv{?^Y<6xzEeMB7f+uH)Or)mx@Ss6dNQD|eKh1lrbA*N_vq zcjSjf{wW9oDkvvExQOrCevA_%j-d|Aevc`S1McN>->tRhBe5ROy|j#QFO*LbA!lMP zb!EtxAQvi-j-SpO`Hs5wWxWT+r1L;bo*zG0g7_67R_Kf$>ZpgfGB{e1H@~hMda@Dk zEA<1}|K17$^k6{CS*%OA+0&KF7XUQvJxwY?F>gukd}E^v=DHU=Gq~Od`ZsJ!eGYE~ zy_wCeJEG7}xS>s=8s8hxxmgpuE4U2bqc7pxFE9n{o+GUDVYqK}1xj@2`(Rxbl@7hk z1a?)^ZP72Tz|QAR25-b2;~)L4zV#8<-j&ye$=bj^yZM!daJ^IK6s6Oe4`f^BZK0ddJFu=wV2Al`q?{VFjWh#=&$z|{$a?^4oI^0fPY*{J#$1AK8v&C+Q?oc-p}*{5#+)J{$|HK4w#>Wv7eEaHf=L-kTi zlc0ZX-*A1)DCmvdO6GIp1-*6Ee}(p2f=;+>&)1ek%#-QK$ZkdbZq7tW_^Jh*HysYn zBkjw0{5q$29QC{@+&+)gQ8yi{ad~&z2=Ww1vfO?)0^@?q-_2{Nz_1Ird>}g?7|h!) zX@!octID4#`h@yw(E)3VeVD)ZNA2hBY}_N7b9+sPQLme0?bY$&4$wo4dp%T(fPO4y zS5-0tb1^g-mxEA`_>Zx+JWCVvO1gRLSA9pnIY;u1Ex2FcJ0IDydw?cK%aAg{@B7D1 zle_=&ftvN~cR?@Cx6U6oM%SQzbl1eshi%G08PujtWXu8Op-1q_80Prd1Vj`KMgT?X z=%-Zw1IXL1eA5^T0P@}Qn#nAjdo8kTi|X`&y!pSG@6Wt|)Z-kp;lLpJ5q@_v{|kI|IbgzPsTc@Lnr0x>+(54@B?tZN~>+qyB`h&P^;({**w!<*9%P<&xnV#0j^=l)q)EVovh)sjQoA z$j9DY%UpLA^;Yk=6a;XNby0b*q~D19UXQVayFSpl296}Iu>e}bk+3$V7to?v7MBvw z0L|nxm%p7D&_vdsH8=Lc_iWdyh+%#{HM0K_@8+XGrDUzs*GvG)QurQ&lzE^OJA|*C zM!llz-UM0NL)88BGBolZ1NocR!y-opknc}rk2f`9J&gTE>fM37F+xqd!3q5bDYHL< zF;_7*YW`q*50K1EF05uA1k#4#+`_6zAhsKh&zD&N@lMb!i-vk2S_V#RxVsgI+o&GA z%4{GEw1g+!^~Cq`q_b03j-d~9-!bilSRiPuNS4?g0ayyVe8u7hK-Rv!9g{p@kdXc= z*B}7Yg`CQ+X5t)bG0*d$A_RE*_En!=`i=gzA9WU=m^wgyP?K@>bpnu&y&Usaz`aB? zqdnjHIO?%NB%c4pJu$+_)8!}5zqD1w?bfKv;(k!HMi1|^Dw%`R+NS7J5A|g-7J*2t zl{-|7d*iC_hw76sZ@;=rv}h4^T49eaG8F=Vz$Rr>_uxDrR8Yf=#B=d!jIaEpBQp@si(`jCt@~MP%p&4Q>5fd!4hvwWUYk4o3-R!ziQ1Bb$Xmpuiq?~7P`{H> zS-+_pm>0%rt>1isX_t^J5qAr7Ngk3GOb%h4#5LrDuukha2eR>98OE>kDqMHHfKlUa ztA6VV<|T`Xb8Bn?hMO~azdxQY2$5aA0rw37FWKkY@caL4HV~wbe!*nTE$NEwKtG|9 z^h+4`4Oy$b;j2I5{?{C4!-e?z{VaB)=U2qpIff*o5HAs!2t1}B4Ajcl$*oO~fqH>I zuYYwG;=7lY+Wc&Q($3kg5r+5Gwe;c5H`9TlZKpE5AHVnCs+Ga+CO}RTdtST-`Ke>8 z^_||)fGosu9d6T+pW^s&8gtD^L8~6S&E^0}heuxASq_M^oE_qTdftLrwdGjkM_hX= zIj*(n@Dd1TYL$)Ey@8-eG*RXsbwwOd}DP`d$OQ%#$Oci@UVdlFVyLLk2`(Mj~AG|Wgjn^qE4i3 z`Ege%@_Dr<Kx)9R9?sQR?Nka z={UC+b)m~=9`50r1xD*WBNv5IV5DE&FLnPs`hNn1^o&vOqo?>)@C5R-+}R^X?}P)r zetp)M`54e6&X=8Gi2LXu6V!IiduUc^OG!JP?F$ldO~W z0JKPc=>}EY8>7!FEZP9OJU|@k@viY_!oYkTYiL0j1LngNxpzLV zQ5WC3`2LtC-hYIe(my=FRGAmAy88(4wRHkT6T?`S8wblA&9L9ZE(kxy^K)7=yeQiR z7>W^}_O#vt`gqo?t1t4jPYSdJHsf67{9@hp@7P~tdx!Td{X-uW=<-BK;#{?8_cnV9 zXa>pwpJrAAb?l#~(M2Vo-VLt1CV_hhd9rn+4`GY(>+(Ifxqx!->`av%`Vi>154X4@ zt~mS0L+Gk2kRL}!^7kVSZ*DUdt*!-RKI?yukM;rSWthU+t~emMbu6D3MSa#z_PVEJ zT_ARM|LZ|N0WtR4)kh(`Ks2PeEB%lH;u?vBdY(uiRLp)Y3=9N`(d*u!1Fkd5#&VP3sz$OJzb-BNwAM&iTrcM*o>>5+@0`~&zXoVTq zEaI_8GS)}#Pyp7!W7?;pmXYV{dYL}w0<8TiXL>v?0ZYzqO|bb@d^hTXT3&51FsHoT zqtS29Z1t2fkwu<7-}i9UMhfD$2|Twtz3_eX-a0)8Nvw!4rGG_K#(ECCoI>G3z?&|lkhCHbx*@=xIh`S<=roeAvXst}F_+Mhke zoA#oP_mPi|lEHeQne7YBVwnMr!-ukF(^s6gTw6|E!2R5mT4z1843q`4oK7bqP|{wB zSZ>9+%jjZSwjb(v7s9s3bs~S8(Ptf(h5myh0i;lT_l~^Us)_A{_o`xf#5E^s17UVNlkzgT)VDi+8zzzR7Cc-mlW21`9ds z5%*+8cp6P@M}KS>eWtMDCF13^6IRQ4!1DTIV#&h2;Z&=79%UL>W@pOAwrBuLx0d%| z8R}2APiXA!MBbd^51X?~4Vc~E^b#ib1GA{1Ejtg-N7$Q8+9NSw9_a9Hwe|az>2n^MLwxI2PKp%53PxaG498qq?)LRed;=b@2 zrJq1wTT(INg}$89_op7;k^|Z)!p6+7H$W5CQth&^1M2gR>MNRvW7!-E4*$>uRBpi| zi_srYXQJWN`T+UDLshcBbaH{bR8Yc>#Cz+%#Ru}d2$1~Nmi&+IHwt>btPQF+;QHL!AN`;lwKb1 z-&Vqh?^D?JkdGE1U#n$0Q#=c_M$+!T#i+CPNsSIouK?P1KcALI$PZS}hCO0pZiW-p zq1Y!B{W*QBzjXHirC>H$kN-SSj)w3mCm_zq5v+5#1^apCC{4o`c`36Ohnl5$fy^=V zkR*q?xF=_?SzNgTBy0MG1Jjd05;#9G^|2F(<=+!jd|v?Z{5{EL9n4wWag!YV0{cZ* z`BX+T=FZ%bk?^0m4g`8pIqfqi^0@9C&#Il#$9Y&Njkh1b>zL~E?-Qu6_I$`{UO$jm`rzw*%<&KA zV}wj|N}dE(reNRCjrhIal%`+%f%lqwo#ob)G+>#CIMoXx?yj)Dv+LRxJTI*qW36x= zYjL|qK|KyLW!dwa0rDMAaa;;t7{F9E67^u=y){YE5hMDd4m*#`6bj1!~2$R96()zgd=VLS)f=oWt!~I1Zof>nP%kze`WVEdWf02|CSfz&*p{$(7JN00-*5aw!_V z&tmsWe()ap)DNb4-|NBmqwf6Pp*Mo>M>z-N{(6Eu-<$A|zcG4D!k^$C=gZK1n z)a_0e*R&*W1lGWb<=#jqU^RNueuW}WUi3#KXZ8y6<>Tv@F$am|>ACaNZ&P3y#yVDO zBEBngVqWvuE9@^b8;|4M$b4-#DL9Wf;X_ZjuFB!nWq? z{Fo!IqpfzS1ap46f7~uHG6SlggZRyYV$}WU90@)k0F+m`jeNql5$7#RzV~-)*;){PWU*DAn;*%nC zw-(&PZJPYnr@5d$4j4u5x^z`!V@Fy&t`=4cFE*}cFAsvYI88bi&1y*Eg%@jB|R_H5CA z;jb55%Y9wmjCp zj{WAWTUHjnE6O5Rk=^kevxH{d^v^PWQe?#ecK6KU)tIpbTCexbg>JlpwsAL1x0mz)9w za)Fk9?bLrU_kc$I8+_0Z`N5&TVX}L%Z-i8;tEn~sRc3s+Zx`NEl{MEl^X^9+OMhfy zALjq8F&QiWhJ7UaZ&Jao3?Q5C-Kx210!Z_N&jQf@KuX(Mv(SpU0EQnw^q`E2I6vcf z{|LVCm2s8qTOWmb6Mx-R4Y-f5ZaeUpqz{DWp@e-Y?{VLV@N(Mr9SGZcMQ(3b!@cjK z6A$y(|8d{J3iNLR*;{}!<~a88J2R0T zlCF=4pR=}adzRD=Y*I_2Zml7(_h)80t&{ z&yC!0L|vR-()9!0eZZKT{_xF66c|quN_aXRAug8PVPk=Oq3~g4tyBi)la;Rd-XjC_ zQ=DIqta%G`fx~3AYYC`}>nX9UPeUA~`nupq2=43qYrE~xmvh}M+4|2W)R~AKi93$I zgW7Xn)(-{&<&;nAb5~QK@a>{J5%2+Wj<;Vyu^Ny~j&F~5Q3cXm$L^>24izcoOP-Y& z_7TR3VUwEQK>TxR2gw2Vj|cr-)GXAU7`=}*$9fZ%w=aF(?16sgjvnEG|Kn4?MJw=q z2Eqo5_!m+M2y@HsG8$J*I@y$tluuK0#0 zd4OvEyZ2MZh|{{rH~am+9!|LyLaaDopD-}U^ce^C;eLlII`Sjry9OeDH-N3=-aN!k z1h%NxW7Cduyw9FiDDyl9R+D!8WUmdd9&cF+P>TVUkH_XQ%$sCUO^&+yBTu-#h0OGg z#9T$;tBSAx0yBPZW!**G=MRyt3>`##W}WxeO>&LEs2GV88{C6>_sW0)8#3lU$PNBu zZv^@Wtvy$td_rBE{I@D)QS{$RmVW+aa>ppEo!IHRiI% zb{=h@D!u48ntg;kVX-{TYX&IJ&SzKWVE^E6UW!6Ko1F8VO0>%Z^1;M*%lJAV&5YWR zeNg|C)SS0=8{$_K%8SOsKY=(7(MlJZfq1vf=FMB=sc3m#p`;Ty=ZX_;MseSG^pkai zSPKMmnFC66#6|c@8=n5>3h*kY-&Gm$5%(#tb?)B*c8A`VPL0I8%ZjxYOC_K`&NG~? zumpOh(8ziI2B@a&olr#IJ3GvOSqS}r?9h2cgd zvA-}H`M9J1U|k$i?+Bm{MNm5S&$uY+6~*dn|G%faHcLvs?TY<=x?ztU>KJX-TJL#_ z_twth#6dRZ$&3mPdrI2@Gh3tNN-X+9PBC51_m<)NRp<0(8Y6Mus*`dlzl-?~7jI9x z-2T6B>OY$+IY9ps{@OM+0_ed9E|mR2+-t}8;L)H5=<|FLub07vI;`*NaU2e~hun&r z;=;M=E=O$PCgg3^etw%DwFOGkgM;_dPXp!b=F*D&__@wZ)+_}3MlK=$*s*UwHtx=5 zIyBx0{MfjI z-MUpfWq|GbkCL|$^(OZ6#)k$9fK5AU$~g*ew*-kAUI=|8I7Nk->^euKr{mVtFqsiSo*jRNhXlkkyo3IYw=WhSiQO7-9;3>cOKExAq zZ>_xdQ^k77_YHE70%^*nlXWT)ND0RdWLC@qNpJ9cbwDx@hxj*r<-^bD*FQGcVvdaV zN>Pmm75TzSUrr+OQt_OIL(d-ofl}-uwHtBU*$xG5*8`}Jv*(1{ivZTf!F>E4n2(iU zQ(>_e3~rxps5=u2`ekxC+y^;8Pg?Y|s?7sX4Vjd6fBOevMZ2u%5SR&Mg?cF5wwUs=qkmW#M$Wp&;SpfRk z^rC`iqEUyHM0SZ$MjaNxNb_75>aY%9DmTS<4`xpc8gT;Z? zX(j5l<|OKV_MYKxG69;PudVM7#CIQsNF^OXeVm@yKhu5+;)>yC*rzb>=lrLaBaW+p zA~@x8gDH>o_$<}WrvPN5O9@;41OsW}bAxUFF2vaf8s-q!BWWiz7r*1iT;5+ghQ)?J zjOe_UnTh8^l?K~gb<2$xD#$HFCMSZp2EX1d<0DgOJ^|}}a@W3`Dz;-9j zRmHnGej~BOdq%&S17iXF=DDZ5OhG?g{@k2?HokMfu%366166m)A8ovz$Oq=MDWAe~ z&?NAu?oAZ1YgONdB45ca-4^-t1?n9#zBnsLYM?I5&8Vanb)z056PnJ*Bbr)N@N^)L ztI*uf4##_p!%;BP@D1jbDcnlTFUH()gI&3o=TY}lHu=zz4J_F=2mSdGuk3eeYkdm9 zy!(9%T^4cVgUlCRPtOCBvzFg^7v=`!1xZ&}$YBm_YD&)dM__Oqi5`o12lTXh$|B;s zbn>nPL70z1>wnm7_6GIUevW~nqsU`zNRy6lLjOlr(ySI4`#M3kF3!muD4lU9XXOik z;_+iJqFDqeLSn%@Q<(enL?pF)=R+VHer~^dehHqQ~6%cp&W$eTiAm zKvmcO8Z%A}CtVg{`{;m9i zH<**LmZ~EgjsK&q6G?8WsE=FI+UAQsTc_P-R%!Uo+KrK*a>72)os(~iG+=|Oqsebh zPzLr;5-0U4=EM!mL{A571$OtUg58;TKQ%T~ZLi1v@zRt};^`}3r>CVq&DjL(YwxcY zarFb+u{&tjrz4nWHn_Bjn*-P)%R9KDrCN`!S%Qorvnw5x^82yrbddj=G=f&J38_d-PO4d4F2Z1 z3K40b=bF1v7f?6KetXz_0R107X)}LKP|tfs#JQvr?=MNSE1LHeftqLHM17)+xMJUX zm#h@@qubxtT|qt8g^xw%C#r!WyiLsLS0C1cGS(N1_`9KQoZ>NVAdM|V{NUzwH7*IVHbZ*N*%(GnJ_7-nLoygpge|qA04#p3z$(Vit?EXJ%`>MI|+%V4$uM-7! ziFJTYR1vW6YP+p>SVSIulJ)i=_M3yT{qb$)z?Rc4c`1bFVQOLa2l~xeFDJ}S5b@p$ z-ap^pzZ+P@$ur03=tp1Ccdoku%` zMUS0h=2(xX znPx_Z9{`np$bVsCH&A-#3`A$Qe0`ks}9b6%nzYiD_K{R{~RAAjBET2uyt zUp~D$Dg=30F7h4pgF?rbJ?=VJP~V_dDTp{R=y1;%Nnq|+cXW!hH{yttkp=Zm2hewt zw>;{D?+>Vv#`$Y*&702^z*bky_h`a%#pR!3m58|G zyQz7-zKb|-<=gf@IEc9Mr*5h$`VrQJmb`oS4475lPhEZT1DM_tC%Xet->{P@9y?f# zc|mE3*G}V{<$Ew+I05&?EdjTKS}!7=W!aEcjeMe&#JVIQ+y`gBuP5w89^}TP!#2s^ z$gjH_n+a|QYDsoUcq969SV4&^wXQ(vxA4~*L|wJ--Vd@d-dK-uS<*pKtj8Tn|Ftr# z$2NJjOOikuz4$#satcV-Q>#O27cn>Eh7N7uFA&?*zm`Z(0P*4t&!<=7fGBf&z-sCu z5Z-I+nA; zfhI*e=1Dy0A9b`^9O3}os*B3C1Q}2z2lmKDegQ+N|Ndydp98~9zkAnjc>{*Rm9q8O zf5DJj-l|AQ4cL=A_jIhseWasat-JFI_W!LL#c^L}-_fxB^bqG@H6q|K+WEPmg@}U=m zALE==per?ob@*Zx@t_oW_~64$+=qz3*wOIql^^!?>XB)`5}dP63|W$mj-&qJxA(tN z)S1L;1Q(l_18vvulW$g);roO(EgMWEFdx88_v+2N$V)~3M~Fup@nVK?<0ATVL|-ID zx~O11UhJr$8vvP=lsD)m2&559g(%Ip$kUD%y|>1^A4SS-HqUOv*=^OYguh4Kf|~lo z9_;5^pB+BviRYrWKVZNL^`q`N63-<@c@TK%pLRCScH%6~Y4;a-sp{&;;b+-*9s zub~1ArNxe&siA_Qs7*vP=Rq*!&?Lx67z2AagRz0Cg8Ho2?umogM;=FqYSW+LzM`PA zZ4BqGga6IF4t@vhtuoukDyo1rRG1j3i@NG8pWd72P*3U<*O#DFi9E{QK|4dlOS z{qbpE7l3@Q>n*|0VDOYCNV3L!cS-MmFYx^keeG0*w=X_{ZU$MVNtFz$s&PvHy7<9R z+vHBbEgLZ0e?9wb>IX1XHt?2H7r?r>7WRG61w%m@jW?(pX3sc`n?23|_Gfa>LCxF1 ze%i8Z{*Q@!iY$>2b0gT+Y%f;N8pOd)t8#}+V;{NwiYbM<>f(_(joO{KkKESsw01x} zZ;n>kDH zz4hp&I;{rOJ^V8&BW?rwnvBbE3i00iQ5RkgeFK`xH>!N17*H$5xJBNg59H8;9~@kG zK8DX&kNBg0)SpQG(>DtgvCYLsACd2PGB!$6s0T7L&*H?#1|a=7lIq>`5lGj%ZoVHY z0@7~PZF;Bsf%x9c!}cc|arOf}CHQU`abtT&=Vu=vyxGZ{^Noo7(^jp-CG??-l^kzy z_4|L0c>Kw7^sSxG-P(yhA&_3M-MBdc3^HQgH8e|Me&wz==BM02U-80p(g|!Orh1`9pcfa;4b{*?aXGd-%lT;sWBn>W*%ri?4zD zwmI)pa}iJvkGyJEj0DQhZ41&nNk9oWwdI~W<}Zmo6V<|bnw-Zq$KQ*42$L+v4toHk z;d4LzYJ7ln)ql%{7pH(Eexd(_18F5hnXIdlU^^?TViPk}+w`wbt}+R;bYT+6x3 z2K1%P#2>R}K{uLKVr0(`st*Q4mmfOQ_QVb8TJ zNbs#DA%QxA<0oIlG=i&^rZ~kE2!>tsu^5I_kUn z8Xx92m~W6w$9kkJlUsM!0D~a3JjZ_s=)G@Z9D9;5N8BJZzS#!oLKU|0>riL%=wjqk z5A5&zA8ZrDTxDwQMVlt{k5P|uH+u!sfijYx=A!l%D1jcQ6^8IhMKpMJh7r;vgQmFRvR-dgv+VQN_qX}`{y44Q_R$<ynq4RA53v@$@Ecajh4XRS9tDqWx|7~9Mm_*@yWjP$fGbN7oaW}Kv z;|_+D;~Y-;SHW;!alU_IF&Ih&<(pz|8+*RlgTiYB>`%|G2Fd3FJBMA#MtZjai{Y#28|nefr7r!L1{yGPM~51? zOHlvSdH#X43hsp;c_Qxq1jeJ~OZP32r=rGbZmp>V`at!p>N-cvk*mso?~Fc#4VCu0 z51@YWzuBP)Z@jm(<7-H`k5TJK-n;o=J&sN7b}i!t%CBwtw{ma~xqQ0i(c1slqe}hA zgGH=|T<(5z^noz0P%D&%fi(C@=LGjR%{B8w$Oj%zy?*W7TOjaL4p-oNZSX8I>gK{OhJ1 ziHgo0U}&8rT1hnpLt`&anMgbrI)zd8udBdN#(L|SRky)#RS11v9QXLIT9r>?OwgZj z+hntBFtD#aD*kQRgnRpqI}Z7_z~1ESB6y98IReKHi!`CH@J;}~@RQFt_bxqcEcF5w z_e#V2A4iaH&zx6d~x5?aMZ5`q*xGf|6rv>1Wu#_{m1b^8RYfp zLBs0`KfDLJ#Mx6<1TO z3@AbL-nsRTn3KGJc%c>NsytQEZk151hoX^F7WxMVw-w75qE9M#CEhY%HIQVg+$1AC zfcVyK+@|#&@`BCd+X6oWQGnmubt5kjinw0h;lo@@tHQ19E7(WY2<@!#bweC+L-@jn zPypK!xrX3ufc4}54h+*VPsY`kMd1YfA%1r;xz(W0b^XJRH<*{s&kt=m;EO!_L1L_J zSO(C4#X9GRdjmZ*PvneBB+xh4njSxL7HD}QA0`r>qW-70gT2QDsEsNL{GRDRwKj3M zFk6UuSP%7P403=HykVsLb|}{4Ve6%SrdA6IALza_~tzPUWojCHk!MT2P}wX{m5(rf(4fnYY=f>Zt07w zettsV^Un{Y0*XiHZ zcRS2Lb!}#g(8vfFUTh^Rt95~)_iXYG>PxK4i6gm^7s1eOv&*JX6)-g1qj0;U6Aabv z?p{0f84NdERA0}9=VH8@ab7t9*wvqcIWFM$AMd|RT7!GL-9(eUH~JBFv3gGXSs)&t z*U(jiezwO3pO&4Q5Qmp8sk;uC3+R9OWnw-s-}rmz_oQgeLKuYgf3 z`Dk-e1?DaLIC89d1oR1~4IO8H06lzr{R90epl@wUCH%oU6qMdQp?(BtL_TY=QC&b? z?>Yfd)W_M>iQG~0LLFAgS?+z=SdT_Ew?4#oB{+*@i78kQn!8V<5Y{7Z$5+(flLq>p zw|zxlXV7-qppP$*wllYv9L9a4!mMJ$vnC)qXntBcj=5O8!`d&EP=A$q#{lrHTkSu77!2Hdw>bSt2mSWaXUmq8_>QfT zQzqiyx+fBLT^9KRs;lRc9&Z^1CZySa&%sXv(Lkx}gSZDc9KRBT`+;gg0Z03FV9Mv~ zJkBx!=B9#g{PM_G@IFkQk+#J-C^Xo8JNg8A9G+-gTm_6On#oB=)V)8}OnVoFd)!ss zzT=y-fMM@wU{q*=dc?AE7YIY2jnR5B5yU-4cBjVCd;hpXpPoiM*DpA$AJ2v6vYhw3zd)UJ_IRd?^X=32 zkdF#mfO^i}^!*&}A$z(PFTX`Ta9Dn#l!iHF>4c|h_oskzLjE1iBMd0pKi74Z9tU!t zF$vO3f&3t{Q*j9WQ+AOmcl2X{EX$mIq>s4PVBOakE99p#xgMuemw@ClE4ao7@3(yq zdaKvszCOqCZ7yMS|msPnm@?l>THt7oV8W4_#@ zjIa^Y79bp6oBTvo6X5LIl_tY*Q19I`zg&44=gkPGY=dUh?RGP^;eNwRXo;}I_Xn8K z=fq;p+yds6;*C=8LxAb|-_p5XBEURx(923I6mO<=rTk`PzIeHBBQlTp1A{H{As)kXYxYdV!qzmzoJ}ZHdTctot8CZ!BU5h@1oq4mj zu%AolFvA^BqP|2c{PVv9s2ioUufC7GlmUzSwSf;Pb9!P0p16PHOOVGnCxPPB+4uA~ z6DV>4%f%_mSP$-UaV|d~C!MA-?AN27_wl=V%%vx9e0BAE3HJ5&%(Cj>KR}8Au;H0ol_#vw0^S@#-HE>bz`uw>P=ENQtarZ+Fem2|@5iDad_qNc z`5Nk{N7{PU0pb|_Kko^?!@1{^I~P%GFXqB{@c17fVNT-I;;(2U#LMTC`fn8h^K$gU zOY1#Yr#F7nN&g|A5#I@HJWpG;ubqB?`sx{H;{b8&%MGET%BNF+k#u=-f9o9j1ka^S zzry);zx_g_MJVFx=ig5x<9$?2$z*;#zTeUq3Ez;{F`DZ~S4)ruvF z1=Tec`-rLMx%O8zKo&UM`B7pGkm_YD z?s6&P9NgZL{89i&B)7dkgrA`AbJS*0D--WC%IRVy*I(&M&vE*rW*mlcr}5~c;){&0>)_y5da&~T(6<-RNZCRF0}gw>J9O= z%~=m%X}9o;`2+(?V{dlP87W{X)Eu(>i8_U?se|72vZxcSZ4tLE1m?W1kY!OU){A#j zZ+tw~N#pyc69iyB`q%?w4v0q$_DJax(LZ}d_Kqj!!m2)Jojs=qOrCh`!MlL*NmDkU@2E3$e@#jG$tZq*Nm zFMha(yqr=pjJ5-k*Id*u>SnyBX4bskGy}x3;l1*MIR9ofB$RAC48+s-ra7+QTr6)s z<<@{ckfFsRvPX@9kP-az`Jx&SPLGBt^ELuOL3K^ZMq_}F8VY~o{J`MrGu2(K#h|XQ z)O#`-zyH8l!-?;x8}VOyf8c>IuzbX}P5nY%&sD!w5%Fb~ZQ!-C>?6hBNHhol`IbZ1NzCgf zQ(8WS?|KfT#Us8KZxVr2FxnuPy$bcbH#%Ppi{TusQ-4ks@1rlj>xh4_PsFE-+8}>P zG&P?oo2QzDEU?n@N`n*2c1O%Ckm z&BXMhkFkGTthY5dfc~i+32llL?BmUuJLMYhBX08dM#M|xr4)nA`!!LY*rVSYJo^BB zo_lW|&xry==6}67dJjm`SFe1_s0C8S&)H?#M%0gqe9K;x7^y*q2$%H0puc`1uz%vym^Fo@txo48^>$cHspd<^&{&xwd&}gUSXhux62OSDN1$=dE<*ZIJ(~s7vwn@6Wk)`i($#6kI2X( zem>_@J=tr9bqV;~aG(dz%ew{RC2wFJ_ll9YD31E-_+X_dTwB1jstOK5ov8MSjXwq|S8=NXZQ{b${`En4UOn^%nV&HFCn^ z)94#~#oyfKi+#gWWZOTto#@NaxKr#g34}qnpN@zJ5mH`%qzXj=!E&pV{60M(Y`m7U z#}x72w!h~>R|f-ltUj_7Ck+P5>&-u990s)y%Ti~zo{_3_#N@&OTkm^d$TceJbH7p#0d^K&( zVx9R;)K@>CNM7bbKRWfj#X5+^yg1paCYe^CMwiq$-H8FJ#&hq}!{}G**}hBsM>0@C zf5K@t@`Nga`l-t3|M(JK!ijzca@dhWb_Tvc)^u(85svucU?X3FRT<7zu6^FSXMjX! zn~|lkZ!Fq*ZI|4K`B<6G6&y!#Pu%9LE8mMaeEI7an=^pW8eG346n#?HPtK085%;B@ zeD|=^6ZaGUFHIqcYrV?&aA)TY^hfnoTSo?h{))X(QkWK~<&~UVbcqDE+0BiIXC)Em zFqVlg8%3RBlzDDrJmP|er^Fpn&rwx{D8u%*s+n%qO&a8<8%%BuIsZ%hl#7T|fR zF69rT=wePBv8A&K@e!|-)gR{^(RcoBXO!z{%(IrhYJuMo28?rV7j5*u=oWp(nzq1AZS*-yeakwNOtVJCb&$hOzEua>=*Ozr{ zC$Izg(|RtoVs1?7Wa8^|U|)E@P}tuFY-jS8U;ZnIf9#l5B3;8AnTv-P#87v&mqn0B zzK(jh^zT=$>7mXi?t1)b)RojICf6`(qA^!KLb{$WnjI?~@gvtwtPDP9NHT z5I;{I$}HfziM}{@k;NAqiQc2W9<>{&qib~+mfGVzHGE2f>mK66u+vpG=R2?-1I{)> z;Y6pSWg+HaWakDIhp`j*Uj0Qbb$pLb#b;TW9v%HWnLA!6D58HPy~$cK-jSH3 zlw2v&NkD(kc;uQp?}>^3h07B8c#fP64qEK~iqPU#__=d_#6(4@HEi`S^tl^EX(*iTCA#BwP1&l5 z3nNNnq?cjNjPm{23&^kObZ}f<&h0^T{ChrixpWX6S(UUrQ_KlyS?DetM7=Ozlbht3 z5Td;^&!I*Pb*W#8Ju!;QiB?4WX2qLWA2@sS$y_hdoYQsfy(>jDGtatNKCHsN(IA;w zhdh_C^B%dBBtq(mZ;l-9fduNc4tg6AvX0a0Z>umla7XzBM`kBcaa{5(_uMgJQm;K| z=!*P#ZAWj#GZWOAQdj&t-#|=?V^-YP!uu-y&16#-=9WZCZM?V*`-{g6_cw*u+PUUQTbCN{;z-d1@hp2`gqga z>=?eQ6BA$5TloX`qC+K?-pwNVZ9gnIzt|#=@|4nT@E7;f_bi*`$NhtRX&%<9JfcUb zIQ#20?%7VU`FY#giEh-Fv0z{HEvoF@aN7@kyg!uszH;GvAif264xK`uwN!p!y!bbw z-7I5o^8Gx~_7ScBbqn=e>5D-7O-IeqKdR`OdI$3sx%)1>-cyXa$XCCd0u%J}{x&}R8tb#%`>o4%>>p>CzXr{N zh>GdNvP*LK`#+IvJ9*Kcn2c>s?hA54pU?Z4wY^oSZ(Ls%n6iVQ-ANFu%tgbr7*K{mpGm%pFzQeQ$68d70WR>wotXBi+=M+1rp;VYG!>SJomAmYg7t z{E(sfaz8WaL&Si6u%UMn^DQ4HtqF3pAqHAY$K%(2LSI~MUO>bzqVKoNoA>`d2MNw^ zDetR^-b+U{!V9=hc>U|u4_QQaR!1S<4RfnwiWWa^aKn1MUvhf|^1JQll{che|G1tJ z6Hi*Rk+AC3EJ zb06OG%)CTj!{vf9zpX@NU#RkrOw zoFT@254`W$`XP>qdPJ+5A;zxC7e4)UC&mgHzLKwyPnleLM6Bc@-dk5Rzg3`qZY`ms za1?nLzSUHdCCEFLL>>Hn4E>7sd3A?2aNr)>-G$Rva1SK+MyUI8kc4 zduy~$3ip2^S{@g@w7z2h*u0EWG#q)}Z#;!6*7CR~w~7DQj{5RXe=S8i7t6zQk;=+&5W{}&u}kJN=7O7O7i(<(qDf2yqkNPx7u~q6uiB5l2y^^CNvY>y zpSQBFKbwpAQuxdFE8CEttlOo#*K8><@_9AF^Fv=l>(dFbhAqVKhD+?A z^Lb(@IaOGF1@}R!t^VCy#5@Q4PNn{)e4_v7aYwWp=8YzH9vHib{%ZN!H|H-Y;(n(R zuX0`t>LBjg8wuibR-i;_IMyT4)OPZ#R!%jp;V$^%H zCh}I5ik7N1YlybfstAW-)Tac4hVC84{hYEuLvv>%#2riDb6Q~TzVOnk!O!Q=Z{ky& z{&19Ny4iP~4lE#=l7${wl1~u-Ij*~tQH zV!wnvqM)C*sN%W1C^0^N?YeVSF8Z)|hth2^C$1ytLp|o78-)o!&txHv-_tQri@)cF z1KbMjO!V`Hl-4p!7tn_#C8JNUuQz&8i%(s|ynxOsOYs6?u+)Ez{WioQsqtHW+42#6 z73?B3@*Ltmr}^BOq(P!7maefk2mM&}Z`CRm(ckX7M>c!aF7zu3 z)jG%jK|TFh?Rsw12?yK7NAO)(x!)8*aZ_KK;8I5@7vg?r((zoJ&NM3FZ$rJ- zbC1v^7edin@+)aU0{uUywp=uiLjPiN$tu)2O=e0tc)od{kMx_cr2Ge*lYghWa8YsJ z%DA)LH=LNLbzLt>LEdYzE>cM{kr=;IaxCCR{>4Yt|CTo5NR@?44L0a68BKouS}l+m z-PI|$c99$Lh@?$vYa20~u`(C_dWsk(h^BgeutQ${X5{l`d~dbw%Y(y-miX?MtiBlX zvIZ-vdTR~hh<tp{&{#@6u zAC2|!`&g8*n&^CAG&z=z`mLwB>^I(KqO)eFMPV%Z6U)ALr$51bh7+5YJrl!Eo>e>j zc#4VE^SiCX+4qQ+RdKr5hI!=GZH`GuN}zrlI4Kk4LNrgxTCa;VAeusY4d0gV5>oXo zDs|GH5YJlP7Yhh%x34cxy=;X0wTD%E{^34ObBful!y4SLb;$_*5JM=pHn?aQqfUPF zQfI>&^p#*5p2w4`Sf4d3TV5m)ijDhuoyM(rUc&3O9`h2)HurUwPX*D}puEaGpM#im z_K4SY4-%97NTZ{&oak4yG+lgAfqA`$58r63B_;xoXSM&baX(* zjJ2NYj;uld0{zY>71LPs{Wu&_42neG&zZDKq3CaCmy3MQ$Uxr@zIwJ@73W@&=8Zn+ zi|cW{QjYng2Hq_>W?85wig-k6R+ka|r#CpeQl-(?pz3*cBl;7+USo@6POhF)(V)El zS)%)|P5Ke~(RA%a0k7IC1#^pZInqM6h4k-JnM^8i@7 z^Ch`NlQ+`M;g1s`Wyy|KZ%_wx5wb7-dKCAaXKFK7;e2)S$)?=XfkdNxexP*CAW|m)m#4T@5OOGDFoY-Z{m0ZyGW96fUOd|4OySR$h))M1i z7Qc=ot}{+%dFq%1q0huH;hi_m#oXst-KnS{MnyN1xxkzl9ebO++E)$r676-<`y`0r zQ>~1woh)K#IJQ*6A2pPb)B8Cz`Tp-Sq1=u~---C6|Dtwt5dG&>+U0FHZ)rw}TU_}; z^jfF_0rIF9o;Nu~6CZKE(ZK)cv>1^;DhqHSd!e+WeZU+U^CQa1S8-p5^8z)%zXkJrI3hAvp2azrXWM_Mzmm0Ha|*AixbN&M zas=P&(a5b3)Dgk`^B+(0T`bUlm1C|JtK32;S;;DE^^6GRq4QJUJ_SOF`6@w8`bsFi z%}Xi|Ek)mndqDg=E~L_-dMt`mD5@SKLFoBh-$Tt>y6-gkk zbyihUKlLi^gRpo1EnZCwi&Ta`wEjaJBA91*SpnbmE>}P3a)%h)xd6UG$jfg$WKmcC zmf-tqRn;Mw+n^is!f-W}=>6E}t-rIC=(*&x#->Y&9=CeAw|xcX%e=V$dL8adsfn%= z7B0Ygm}h=8w;?)iXRM?>tci}0UUXY6=E)R}|76R!5bYyIqc@N06D{`f*o!|fzvS`y zA8T-bPRr20+kHLGwex;67d#x0&lS10I|%DxqAGBg19>X;PkWO`X9&spXKd3_Mu^@0 z4_94e(EpP?e0I-y0vhkvedVvjck25c-Ui}(UQMyJ#ubP=UbkF|5yktdRMhQTSSg|8 zw=V3izd$*ZgonAr=u+4DwsTUb$5WG{J4}h;YmXBV&98A^DsDi+rkofo+;qQx zejDx+x}CYNX-f>YMlpP^pCU8ZPdzHMqBSrI;E$N?@m@jeTJn(TLQwNgqPL=traObYAQm z^+HQ}u1ye1t&z8@9{#-F{dU^eTTCd0(iehoPNt-`X?aQqVV@Cx(kq{d=VaXK*K9DM zXkQeX2tJ1X-omptsg1;Bvc7R;Z4NOh`+nXM?;n$Z5s_PGk#Eu6y8TOX5Awp#0yqlM zKU)4sa{_a-j6J05*;coE^oylb;qw(}xis-lUbyd6}Wl zs8MX`&T-7s;5XQC{yVn`0gFCC@Ua9b6w0ZOSda;RAd`Yj)d%Pqyf%PV_%uvl4U2G{Q4? z$KqT&to8cN-e{s3eebsB9-MdghwpWss6bpUB=4FzM#$X_KaY27APy|()qjq@IEF8` zp!r37FGr$oO!X?hJK?#PQz01N6CU#9y6;UWLtJpPw3bl%mHQ96BVW={bMmMR*5h;4 z)k&*6c#p{m6{%tWez;0j3g54x`1^Jqp0ywpyW1o`t_yu~`!0x1#1qPrmzFYuLAW0( z@L~D>G-8r$uMkn%ihO-j(P}*d%uV(h+)%%b7=QJzsPv5`#5@PhlS;S zmLytnH{}lce!#uwozcEmIf!Qe9Y2|4&Zs{H57%4Z`Pj3yE4Sl0Aw!lavb(DZi5I)Y za1|p&=j2AWdxE$}Xu9RAl{|rElI#BSx=1w6NgVxvxg^SY`LnB}u`g4*wlPCy2xXer zgQc&E^@(J3#@-~9cF!Ace|#a7>dJqYa9*M0_@#2>CJ;*4yI8sQ2tsj++P=D619AP* z9G)xaw-!`42vYaK`Bz8aRR!KtXNqjHop-@7&yd%~lErt6c&Q;CwOJB4O5*_DE)64p(*DhbWY0df{L_3=tx*?lE zv<*#%zKkUhtw|aFlm;!L6)=-#E>sxb|=29AHn)qtFCQ)hUZ0g_D&t0P?~JJP7UL|RLoHL<*7+1iTp-x z_v#7d($hzVqWJIihjV^4V?Pn=Xf5B;iF``x*_>xLkl!+Ol?`_wCKpzu-tC*l++?;2 zL*pmK#&^Oc4GLm za_5c5hL~IZ?*%anAclf}$De+?jd^9WWlv>r|5<&-@Y8pg-&c2QdPjvO(YJh3`y&+Z zr(utX(NsJas=E$(kzXtKt$VLSNSMA<__RLmb*{)bg5ewRN8dQ5($N^vU#co`}f3Ly(J&cQ9t<5 zB!sx+-L3Giz1nzhxqI6ddmwJ??@7&c#y&FPu>CIfdCBy2n!-lJBT`#-idfIU zqbG3A;(XaH6^A-Ws&R)s`iI7XN7zd8=vx{6KAJv8jE%>F>MZ|{3twIyy?KrprFwG? zjvOUM4Sd54oO?R|IXmvv(`ta`8=X2&-bT3j*pOzOYFFy2ZRK>cJRuhe?e`r>x(_^ zJ2!9czJR{l1EY%dU8{(VbKxwn@Z zjqwo*?Z?nu)I~z+?MS7nOyc~t+jzGQ_Wf**5XIY%2qjQ|b!WO9@?RUPIIlPm%Jwv? z2v5{~X=AZ6Ymh&ABRr>2k2=@&0|iPNI0x^Ey2~}gLyW1i(>dSK@1DL#Z+8Ity$I#Sp`D5I@BC1U1;@x|8!A86+YgRVpj1NW-+ zTtdB2;@`0xIUQn<|KdnUHS+G7VXX9t6wEWJ`03<^KE-2qckempgFX`(K^arj(Y;45 zh^X^oJsOgdD-UBm8khHQZoztVyT{mVBsxv>qQMO~=bq#Lm9nUh^$=Ctg#KpjbRLD9 zBe)Nu^~3p5IQp#y1752&Vs1t-OKiy@%o~;8l{a|~eTOYOn>Tde{@V4e1jb5*xp|9OPFYA+_|W^-Hs^7 zF4>;uqYezA9By`31uz841U;Tw17pePrH|enK&KxV`Sd&l=zX2z2TH1g$1CU|}{-^0%>?7hCrlaxZCZi$z*|-+r~qh`IMJ4w2QbfU_TRG87UmyaIGuRR3+8n)11zR@ z!raj76@T;lVJ>jwTHl)_nA_+o+b4bvW=mst-aoPlX3b*QTdR_QI#{r^ipB}lt7OAh zTSuS@$cm>eqr;40aLq z^*?&4c-g)kWX_TPqskvuS}SXNbUrUN4=S9O>d!!TRw zXv;$l7Qv+Y(eq>0RhdmI8na-ap#Dq6$0yJ~ z%L-X$^%(jVcy(Uc1q=&G?dC#7U}(3dT^}g} z#?I@>WvvdxH1MF9Q96l(5}p9-uq-ihRyF3UpOfnS@{$ zSYVhmZCO|k3ootY_Ldxgg^R&I%k1W0VT(}u9g+gH@3NZf_nHFDPf%icm?zMrezSQl zVI4jzd}0>jITn6{asFw*aw{K+ZxalsK{pz6Q!OaV^j<4&r zX;*ZD7W-UfU)^3#M!Q|Y) zk#qiaFsUSWA!TL_OnBa^E9Ogs@wbh^k?gxLzPvxHZY&zcY@aOq(vSqBg$s6~-{xU- z#YSN;zroPsx>bSeU14YyuTIVF1{e$ylCa$z z4+HF464-hJ1}?8&Ngeis{uhFS1LCKkuPn4mTuv0)0)s!_S{MXI7VopAk>S8d?~oKt z5Cg_N%9_Fsy}j9sUHy9(X~#)^S5Uh^uTci;H+ zZ5YoHf&H7ul8?>y1`1s0CnOD|m#2@72P zrm;HWKzsIMjap#|&tBTgD1=`Z96SdCkfQpfJjlJNT6=2Nus=X2Q!X}2R!zs z!*uw2kNcs_>w_ARk%07mD-uH9dwfbm&1UC<8iv0`KKSL==dBatpq_Mi(G z9+VQrzf@otx~^{fd;u8Z*NqQ1O#po$MNYtMBi?81wPn|@1O3d$3Yb*~`X=Qe#p8Qn zq2-#m&6^%r2>kBGacMIw?DXHY^}7|&S}IfStW5ygl^++oG`WDbTA;Y5QU&JovrlT9 zzk_+bS=t}X44CWOrKsX)2y-sw1!afBVD@+W!zaRzVfM}!8&ys_m=&2_?^3!GsHrI? ze%|sxmH8VdzVtNAxJo^G^Rp4AWA8{$A5_A6(AS78;<=d6Wi(!IfXPj!fzPh&gbACG zSniN)7{50z`ZuW*#(EWnx@+-SF4_2apPFkhdTqXNzAgktnqFL|9)&} z8w7e%_qtURsz5i}OBGYo2Rf%&oLZx4&9C4a3x14-Y3rXP6xE zpRwQZ5hld~PaS)B3?|GDZh0GZ493IC-`f5c24jus-OJjqz?f*Kt*YJ{7_~pJp>OCu zj1*;U{q)xpMtJ8gmE;D%u*07f(szErP<6%v@5LQ3Bwe@Z-Oni)j5c&T?C%Bxe|T~_ z5_@3aLjRS8yZX@IUvW5d&2s1$H{BFzVFi8C4Y?uuHPBjrb}@F11Tc>^59m2x2d0gM z*@>H+z%=_6=X_-Xm0{!FR;kp%DfbRX_z>$tApvyLd+R#H_q4l}H_p~=G z_&hg`i_?OI^&*Pw)LNjumR5eVW;f6*)bjn}C1HLvnxkDd9p=3Q#R9pbv5(lVzjkmd z%q3i3u5a}K`?{3g)oq0^n^|=5Vf0Iwm2*Fu7E=b)f`+4=Ey_UMEn=QQQ-PU)4BoAZ zRG7Zstz{#B8tajv*tw?`CI@QPP%R2za@Fd1p0}rALg)0|4{QY(zY%)stOoY+x7JQ) zxg=qXNP5!A8X6JhfkgXQ~ieS&xa>~ zDO_u1oPHedH_IcTE0+SJ@UU6XmJ(oG8LzstaT*wECI^QVq=7z@fBR`#FVNG?ZqmZ- zfquw2C*J8TEU@*>-25)U!h`LHeKszG1r6KA*2^kD`>`XnbJK62T^to`{7eBFXTRIe zPIZ`%xsbifxEbcx|7!Y8w}iQ@;7^ZDvte#$Wmiz{ahQG4edtWrUzpv!i{JK-1yIX& zF0v4}Sm97Ajy%OhjR!6|(@;~(#dym4z zUePZhbGk6@rgUR_s3MHzO7G|{(1FpZdcUK!Gcc+;Yxm)}0E`5<_eF_@!SHu!8-x2Z zFuZ+Keem@Z4Bd)erR<&!gG21w@pjlhjF(X8uH7(D9JcA-@!K%4`9g_L_dV#353A(b zQVD&v4qf4i4$%8k`f|9#acFg_Q=H`I0%mp5YW1;wz^vpI&M7(z%$EYjr!sAUnfBSI zdZZYbA?A&rCEo(`Y+2Rr(JjE#T+ip0Z;f?%c=k+$9WZ{KyYxlv5ilMu!eG zN-+Z-$89jHDVO&jdkIi0Ct`FibOTlElaaytM=%rp^6b6ar7)c?@Lq-HjrDLicm4ZW znCuF8_nDIklia(WXW!<82}Me#+?{a=8hH=Z>#bK%ej78p_ z-&DW_qn}T9m2e$`(UmL4OjcXL$kF4ON8g0NaE2`H#Wt)1L;r7}i8&0JMabJd{tbh< z-#1m(^T6QB`HUU`tjFcLrzuV&(BG$|-Yaw)`VTGh*zEod`uv*$XI9>T-Xx$=o9{uZ za1%d6#t&E<)McGAZvjifY4f!JbzrTe-R>n7!2CT?GjLN2n0?20@m6I5v%+EWO9$2^ zaozL%h8e&-os)mndk~mA_dC))N&$n)MZ5~qf$>bmDNDrw7$;YpN`ImTjFnB*cGoWh zy`-|{u=gFH+saKP7VU=xmVIJY^cGl%EeO}CHHQW1i}4MQbAVPd_g5yr9cVg9GUAGN zu&=)oD6gr8d5dRXb{TAjxwh8*+aI>UoMqI>HNyL0wr%$+fuf%^~_Ujkc^}=*^{oW(nZsL5E^uXqo2~4&|OBhvnzy$sJo_0z*Ol*)+ zs?1*k<0jT!-OCQbnE&9D&^?VX`X<5GU3d{j7WcPS{)~kYt=y1ovx_hsS@KKMWekRT zRW4Mk3Br)tg3Jn<01U>q90;&ifPwj^8x>8j!GJa8yoqB1^jF^>9e;5W`jy>+mbb8= z?__sMpMo>=US+GjoXCWhNt^T2b8*1Z|7ZHhPZwA^66yDrT>;h}w|#<#Lx8o7uS0m{ zYhW#3w9B_M0p`fDi~!ylV3wPnP2S@T%&-MM5luWl7QR+B5~jcuU2k^j(mG%?@zt)K z^2Pb<)@I>R3B;3MW|Dak4 zuK~2iB!d#YZ9ua+JQMcgIL!A1E9Psr!@NWIL-W)rm>c}y*%YP;a}JSWwbNT+w$~t+ zKd}~OZOs!0Upxb9>qg_e{hB~MWZV`}PzW>WoQc~r+hF>chIGuc4OkC>ZK4$kF!@bQ zndg%hOi+E_r=6aGiPiZ6%{-4_Tr>Kgos}Dmc~E8Vy~>2q+`Hv&+FCF&VdwGT+I|>O zxSpq}#r`I-~xe7xY%Vj2nbYRe%QvUtD2@G^h&ASP(Vc@_OsqRSu z=+CN{csfsk{?(aWdivVXr_~y1_;CSx?Ea3vUlOpx^YX-1f-_{No6#>h+#vt5! z6j&#QeZ9)cfn_4&S7iGUSc(r`NJkd}OW;(oz~zg;>`##0tN#<21;>&~A7P)rGXCGP zARAz+xypxdJ;C`{+VIs?RqQ9`DIbuWW>C}~yQU$YpI={AiA*s)?r2ql>jR+gRK4GM zrVSQ82)wbzzOry+Up9Bxb)fZ21iYOd1e!B%KxF({n5UlhR*C%#^X{=$H0Mm1o26#G zVvobz#r{=WE5%@TtajvG^>UbX;3~*@A^_A*Uim#umw|dDpik=pz)beu3~KUvn9lPE zit9vFRK z9a8dN6^wKqwibRN3L_h=_$$N;VAx6Z`{V5jF!b{6v4dgEY3JDa(Mxv+nX_ zgCj7%3vver=m9hNsl&S2o4~Z(V4RnZ`npa9@2#{b zK^f##^6WYnz1o1T_w2?G=XbF1b7Wm8xYgdrT%T$N8$Pf~lRyg2~Ts&OGXjfQccQ=e`!AFtM~j<@C|( zFfQ++rf8CiJV|rSf1f|WXmoYa5rrEt(jeqB^?L+H1cD4K+{9q`@Kno|57%HQZT%Vd zd|w!(4SsMRN`OJi+HE%-ieMloL^|<;9}EZxeON+%LBHoMo%G}r(AQg`ZXkaj`uJaN zktm*rUK!2xCl-C6<<{4(fG4TIDr**6Bwv8_vQ%W%8g5`c_2j&9#vkh>7#Z(~->*K{ zs$MV&tiyXht`(96mdvugz7^8Iq$zA!u7KyGv`_j-+6O!*M|My3$pcgF)7;JQ0bq3b zjT?130OM9Q$%tS9L#9tn<*^vhYvf+Kl!*ZS*kZf?^P{jp&2`K^VFU}lcMrC$SPKih zTX(h0MglD&|8ws{RiFtzvVW7~4)c+=M+{hjFwdtKk+D=3`NdksGi^b{>AFh?V>|mIthy?N^fpvRLhumSL+|OY~{tpcQxpuDQ z-U}Gk4tlsbyBmh0T&cYqQzer=lMa8#%fI`t7>i zjjty_-zQ7EROw;poufGBn7oBvA-UsB?J#I@+UK3QWj(OE+~ZTWcmwN)(U+&Y`+)Vi zJ%IX91Xv|ovrh{g2i843ndmnBdzUQ>%9dk4F}NO^YcU9eGi=)*j{} zJbgtsn!+5nb-zHxb>y)!XzSCy0(JarlV1cAs3)I|hi^IuGcUW$$}25kx@b&P-18Dl zmF~GLw95e|Ki>X(^VBp<{ETzhb{ly_#)k8Aa^)~CG2Sn!ejdhj%kLCRVgK+t#ufPX zJdEVW)HX9&Fgz`_<}jB$3@Z=yf0T%Vp&JkCJ70FdVAG~$6{G4fxOMNz@z4wy@T=VD z7RHAD-dminxbai(xWcW{Waum0yfdUP1aXH9^X{tU&@&gWM9Mcni;?W{vd#R!`jgpr z-?9-{EZ6a{WD8(Te%VlBQVp#3=IXGuXMy!PL@n!;0-hJq2BvT@u$+>fEIn-qEM*NB z>g5GsE~x((d-gQ;lMfm8emEze-W1bxVGZJwxTk}2BETp+@3S)CEikOK@S&#ELVD?7K)B1CWJ7$6>j<&}D)q$-(=OzF% zWi5>C+>0<>>||rQ5&LkCf7p3)!FfOe8Yxt5c zjO{zV@~opGj5>Sx>xWWdByI1W{UK*zxW`8*RG$LFTR5Kfwy499OOoB&)^-?tE3gB6 z*Tdi{r58Rj<}l#gwpp?B4fKC*-1d7_9P}%W_xG#gTy=lRuw}A8^j7b1RiF3(JvD!G z_ih-2mYvs4w&ZaEdws~&fX*|(7T4}Ll{^US6<%`Fx{rayQ24hjCkt2|ftv+dPXX&i zMEJNJ*6Eh#4yKDfu*@8uC{!u|YgM$+I`9K#gKC;a+W;{A;toDOQVGl*G^bO7IPZSV z6x)zN1BTlohpxwKcK6NZl`jJbS~}dVxe3Q*yL=nfn<=PjX$eZ1jSW1eY&RNQdFC=R1whzYFxLcb?F9Yh>ug zzU|PPx35g0Eg5=J&*o0@`$CJT$ePKk!NA_Hl9TY*1K7KJ1}Y-QfGs=PE~51a*sE=i zEQyZ9x|lo;E5N?d{PU3FJ3K#WvSQ)Sg>W7_7x{c*09bO3{j^Z*Bg1jGS+&8~-~Tk8 zEgJzQJ|ySY_J96(%7N%k0V83fw576Wxu8w=!Nkm9Kkqm9mvisP)6Rj=4(Y| z6wX^lS6^EDHUh1l_rx}a2heniO)lyQiMH@fD#k&RNu|)?5Q)(w};5>lR@22uCMTD~6Gfja;jg-@$P8 z*sbb&cs`cO_~cLQL_YUPW66yc7`!JhJDrpQ15;tlnm>HVSHYk&Cs&l-9zXWLP=<={KJMUD{`2yE-O+kEd-0sDx}^YFc& zfNiihtA}p|u$9kkE&7@RY?0sXY2H|uDWU0?cY1(T-qaV6rUn6?d>kxBc3@z2~YdoSu-DYia=mr-X?(OFuuEE(t@Ty7rJ z%>(*D^>g8JM_{2{IO26c1uR&f3JA_S4z%`!#j#o%(9G9qjxYNT^L6$&Z)`V*d5s?i zaWkk(5qn@ZvRF;RYb{V0En;b-zk%v9xNn|sEzEp4sVVXt=d02U z$$umLVXF9*Iy=u8Cd<0c_jOOfM6JPCM5+^vcfD-miMNC?R?h>6*_AN1A!y=ojs^0F zXCf$D^I+tL{&|a9aTtCz>Efid4{`Z_Zr8l}VMycAF7|(XFc_+3I(aAr2D-io-OT+8 z1G_|nG~`>MKepdGXe0&t=*!!y6n8-1@ng;X$dC61DRL~IiGd!o8`pTM}Q^fJjoJ{1ZLgRJ6El)+ZkU+OaRM z_@zF;{P(JpHzR+c9x}*z@eK03CE3Yh>4?*%{Pg}#ARdfst07_=VU|O6e|07HbJy6$ zXX)Eurq(aIU#1YI%eKa;a^Hoi7a!wR=-0z!$r{NDPt>8_H`x3F9~f_Y)D++S8^-2L zUB1d~gt67Jmw2wdf>9!8n!Dc#MlSt&VAnu};hgjQ2^BA3Xe>!v#OELkDaiG`A1Xi` zNORPYO@e`jvNfzaCm7gj!1ItKL4Sbj?5S2==o{qRXwV-_sufNf+o=Pz6g z?9F#}4$|y_HK(X1z8H^lasZ`*{Q~FV7gg=9!-yM~1*b9$f!R~t;#|K1n0M5k2FmOJ z=Jw(vKU)ic@gZ@Bb06wg)*A2iej;8UT~Xn3;}Os=Id`x7fV$yAji1-iQdqbg+9>=_ z3~004*QDPO1==|gg(4AgnE&;rDd}h-%$p@lF{8X-u0m94&KmKET(-G@;R5O)??aaE zYKK|wu?I_jZ2+pfP#h+6OD1koFOZpK}PN3fntA zAMAw5!os(_KOe!wYkB#}iW4wi|L;wTM*)lt^m$y<@rSV`;my~PhZ>c8_kr3RRX_7(?qBL6-vW~@HA2#o8GYIgB_ z2FCJzhq4y29?=$R&t*7(E^N80RhtJEqDp&Ki5*8=I5B#?=^@a3Pv6oHoj~5?{yWLP zmtg+nl7=hQXJM{!&9&^f6qwti8|at#8fMd$^88F-!z^F-;QB--pk5hndiKT^X1)v$ zmK@-L={H5!Jav0us-SC!UaT%m<_l+ZZm)rfSIaDxr@w*mj~7jPY3(r9^>=@eJU@&s zx*0T!pM=pZe*fOH5@F=fgyzFyHy93fm#f*?jCx=@-`+>lFvQcnx0P)Ig9lBwi6>(} ze>k({QEepjFNAr@<|Chba7KD}a0}v&Q6W`n2x*` z4+Xda>pJ4j!nMmK&MlhA%y~>Mk1}1a;3aMO*Fj4sX`1$)d z?^beG&c)`#SevQz0WM`2rNufw(0T%+5~1C%_w7Lc0!^9U=qL*JfF7 zQ-VSEQLFJC0Whe&a-cl)G7QA>zKE`Dg8mVK%^u=spvX?PTQk~GIViE<{;$7`XN z5Y_^{J9xgSuKWw#nK2cmZI9r)m+AOo=z3r?))xki$O3!L{X|#)GGGs0)=|Fj9@vel z{d~iF@jk0F6*%gH_t)ViSFY*+`{2KPACWYihyQhNxr%uGTXe2j=nkB>=yosNwgOA# z`cR`3&R0LY+)EFmo^k~`%v#yN6j0+yoI3`L)QVHXbmUWH^b}Nob|as)r|Xv+09}5$ zy|Z&CEM&_CH) zTGh*8HYc%F6mh}qDnk`p%15C3=)U7yO<<tiWS^fQ$68NUd_`|5eOfEmt#lTVpf zxf8`<;yEw(Y`PYVzb;>BjWdCen^?`lRhA>hmBd)~x!5dQ)>%yC~(T=il~i+6F_YXS;5yq?jP; z_KjF8m2&}g{pFfpH(!Ce)Q_jOY*0X*p{G60&<~@I`B9_qCqq%kdXcJBoUk0d~QDKJz8WJET)7?N`{?9i={zj9mNPOMt<n^RqRWp#XtM> z)EiB#Hk)xop=jLuAdgQ{CmQ>`wq?8gX&jH26s_VwH2StBWN7Lp8hL&F;lf-f8h*2h zRg8IlwC*k9>zZ zhH!giwtzagGqaQ{H=wq&%1?ic???6K;eRLQ`4C&yR@(FN7Q~i}sL$t?vAEyTADP z(FL?%^RyIv_u(mEBdaT3W5A+w%q1H z-v3)$1EC+~qyaSZY27{5;uXv@c4i8l$8~Rf-&fN2PBbl;@K3ybBbxGl?hvQ-4o&v$ z%H%(L5>4(GRx#7QfF?2@Ai{kPnh?=GyM62q8oz1$lA3JL zXzE|~+uRZ~lED3J&bJ?rJf1pje|rKAy^EO2o51PQ5L}4>s1Ls#J=izdyRyCjY)powg&srp#l7p~(vL^pCrR;Hs>ix_D>X%+#auc|Sb$0c|;~EvHH|UkB@N^F9sbZ{6YnMbl zg7R*}Kugqpv~0EatRm{li0Ap(hfo(+h}{P^19hG;Tlr|CjykF{Y6sU{LG3M-HZnH( zs7*a4h;923)o(VFzw#~%vCVl_t+H8<*e2UrLk(Xb_Rid6gGI^s+`L-wt*J$93cr$W z816s*O1d1&z~2ONm+qrOXwi9GR!EtE`;rY+wdNXVp?-)buOS&Nct6}G{+~6@>*qJl zGb7P_UT+QkgCm;XZ{wJvkNJnDtvy3`&9I+4V2PI-VLo_(p8g)|@b)QVg|{>?H<#Aj zXH|t}3|)&9WoyuM_NlQQE0@u<^xBKv@C!`^QjEt{a6X?%$T8lG`@%z4!;IFpp^3cZ zf^hOGG$C4IZp$5m#_y1QpJ4uYtkr5<&sYon`^4uoe`_@wee<)~?B@?O60?v0V=vZA zUalRCJ))UEm7NAx$oxb_`VXm5%2kc2eD7lo>huIL+s;n=Fd{th;4EI z&9Q|H#Ma)eSwHy>vDchwI7`BLe^lDVN4Wwm<~}R>Q*#O}UgKIfg_Xp`t?x#a#uv~+ z?;mTYd+X7{gSrnVJn=bEnWeK%XyJZ6;lw!CGMcwDFq2!te9(ZtNSvV-nsZyVzK>dg zX8*~F@C+oO+0%25AD3^SnRfC{pJ^PI1LZ`ItVlFn^yR#b;3hP^@!IG?ktWRloUIj~ zKY}LbR=;|A1^el?(>~oR6=-)O|EGzk;VE|^la73#&k6N{E_BwQ9CsBYHvesv^^Tk_-@&deiRKd9_T&wW0Gy4j6^;-VF(+t6vx(1!Wuf!Z8+D&)^mpjN8dwRorl_5G~#&jewhMhrd~ zswV*TikQ6YzGR?UCi>hg83n4+i&aaqT0mKm*nU*4A1GCOS5-!M03}?@*E1s+D0ad_ zQ7-3zB2METj0yyD%jSWE^avn_=Rf>z;0WaXzvm9&cb>?^j50>B29PqnWCjh}f#h%` zqO^1ikhp`t4V#dGn5DNjAhHCAw#n`VU6MdpSyZSfeG7zG=k&OSS3uacUC;g3BI11O z+S!{BfjIop3S5?4Xyu6Sjdr74w48E_|Mqb&w8ZgJx3dyJONXthmO&7)-;?&t-Fk%c zr}Mq$7-6({>HG?6#6Cj{E%a}05w25&-z0sPMDy>1#8jPe{kY+v_P27(ZA4g?4duQ? zbNm4#Z{skR8PIS*HQEQw(q-qB1?SO>pR3jFS~8m9iq!2`+J&YcM*O?pSc#_EO1`Dj zccIC~=*SX*lb8!Wa{2h=C!m4*{LXDTK-<|!c>TZwXxlgw5@dd$Da`Me`IZDU;cvP$ zeSV;FuJ|iGEd^?~#C3`M2S6>U>JI)H2-N2hLpvj`0QJ8YWSvV)pu$4sp-co+o~kbS z)%8GW(60G$3IXNmnd(o+%Ybso=grI3NT3M3dsO=`8psur9Z#h`0oj{0bvDZZ$jW|` zkH+@`si`a4@lphk?i#KRHbFqzG!*xQ4*~HfIbamOOGCU^Ub?Ij0YoA9hCO&c79neU zFqid5AebN1i*)56PP^2@SH9N}M{=$3+>a)-ax&mmgqk5*PPcZtfO)8;<+GbNZs9{q zW=U=aW*ZPYVQ$mYADa=IfM`zwZlT4arf``QgOas$gYT@`y)c|1ro=~KW^6ykP-vrUk6o>?g$0DN6^F{p*MM;JPpE~x0OCx&Rj5dFLY&QhF;~1cqZK!4pMeY< zk4%Rf$+SAO#NIHc>T?S%?X@KMINd|+$e*^|J-BWhyX*EzZ3|l5cX00`5l5^)NI#i* ziocAesPA){Xx`0H&*Moa)_>v`*0NL3+#dh$n-hi6Y}UNVpa1h_3a!zPjr`C|jEv)t zqq1mbT~XQH*-Ut^uYmv?_+4w|%|KKb~SAnLcY55(&OfmU%q z-h!eFw6E6{{Wz9DD}e+Q)e+^?`PW>fqk%3p6LYdo~kd_*@-w zU0pp0G!b6^thiaA4#d#jjk*K%gG#bIO&+M%JELdYRDg=wEQsp`@jYe^KN>IPZJ$FW$#|el!IVJpWy@1dlk#O>82oPMRGBiGJ0|J?<;B~10adgbZ z9;egM%BAPJW>#C#a#s1AxLh1sn$NdvmO6%(^eh$3v~MEz15cv0AntoRD2kh{Hlf9B zU9T$1+t5PDtf*r@=9mA;%&fX~7R?{9Q1^e0dCY8QpAI8$G$(1iIrJX(p@VzHZ{5~G zGaRvco?~y&%!Rh&_L-Qw9ATYL`>KehonNTt=*FO_K97@|98X|h?e)VGl|5)uvG0Y# zwHv5^m9JNVt|QQ?*^AXSzCb5cn%|Nz2ihX-AxVM`v|*1E1xBlY_IpkH%Mg5j6*9fn zo|gn#^x@uMs}!JliLx%?cPeQ6-6yRgo&inlibtLdzPAPrArGSkpr)zBIE&r@>iI2( zTOT>%{Bm#IlE)sPbe|yP2(QC=WiH0qtr92(-ttd0>VZ6|#5|Yu7s$_a3W>!_K-L|; z!Vw|>spImr8DSboHzh@cHG+Y(UgnegARXtC(#t30@z(@Y4J%#%p|hD{Gh+#aOMSI7 z^!q^I-s=!z_#JT!@>ZFDTR*eAOF6G~akz%(DRJkFAOPQjOSue%jK%+n0)F zIo$iS{5PUm7m+*CQYmQW&p^O^KFo<5pPbr$HwaCaT%O^&W{9SB=tpUn1JP8@a_9+b z?At87eCk2La}!JF`l&rasPE5pnTyxY1AS-q=`Xoz$?Ef8W*!6W=Z2kEXzPKN^0mNf=o`>({dOxR(!xY*)v0qp3g5j|D4DEf3U;tZOmXaS@nKG`PoT4=k+HkwRHpPdv&T@ujm5M-T%qUIt~Ec zts%|~D-p`X@B?A4BNL;BQH_*ZF_0)+qK;JN26)*M-=wzGPFE`goCjgCRFi;~<57g51-#J#SQia^Jhb_%yD=RHN1D<9R@CSbksK$^r7lP9ExE5|9P%d;Pn71xP8n?zMBv zK-#s-mQP>~uK{UMk3Vt{h-WM;u8Q>oVPRN+5~2+Rf6k7pA!R^V8}3t^Xn;7jn$5-< zUTEdsqGw?#uCMZpkIo#mMoSYkaRuE)w6vL~J<)a*vHw$0O~ahVV$MD{QZqg$$t}yw016R|2Ue8=Zs|341KiG)QEw^hJZFSb&C1#P3l=R8Ml|{{gr}sx3K@dCSZ=} zKfgZ{X&pd+)$?)7WqdwfX6H+IGy*+b#q>iHJ~#Ic$+SxC0Q!F#%O>Z0fPSzq#^v;C ze15zN?}*TW&ScizNb&?)(?_DYn;_5<-;SLziUXP}U!b#dFVHqKT5f8`0(G$ZYpawi zP-7ld-86XtREwaBDQX{3I1A}+)t`ZqEWG_2zavmgrNciRUIy~m@vS>)hCmJ$Ht#YF z0kXVbQN;KJkcyV>JhAoy(!qkqW)%z|_OUMTJa`O5Pnb3xZwDeJyt$!n0tk;>-zxuH z4FrjnA7$-zh;t&f+-?1Bv=SI7;UReeEq~m!I{&E?TKac-(>-Bjw4|_R;aw{rw)0xy zn?<8&F=dZfaOO$0FzxwjtY{5d*!4j9-e@o8$Wc;R!*l(8l`7`=Bn$q*>-YPSV zCa*WYAHw|n#J!Ebhu7ix!(IB4jhEzrUdP~%eQp5s>aXE^$F=~yjM9*8jnBdR%F4Bj z5uiuQ77WR&0R5K2#`!WQpxX_mFmqjiu72-V<8}hjDN^g43=@G?(-tIR@E_1Z2eG|{ z^UOhamnTiXfX172ZtG+RP(Ods-xPils27M+myN}MD*iksqa+F_Uw&GOo=*hI>4Dhp zG!jr4GS)grEP)(Xq1f7e0?0e0?QbgB0jbW*wRH0fAUO#Y8bmq*aaw=J9`5x(^sx}K zcccK3&+iCV$_fx7cgw6I=K?`C<)!77Sj2JhP?*RwK`S9CT2}`%a6EoD=Bu4ROT#sR zf3JC>C241_XO+B&ee~*D|HD_%;>*rQCRSQ#q0h^5cc(Dsn${Wa$sR%TKJi9j8hGC5 z_q4juY0U4d4wOC(5ybw@@kD3kmuO}Rom!@2p3m0tY&+#En*NeL{-y-aPi$il_B}p} zrjpFgn@q9Ll!VJK50#f_(uTgL^P?V~M^(QgQEP+xM5Ho$weWdZN`7K)!vXq&RY(;z z80cemhI^lO0ln=jP3W}`(7(kz)@T0!dNOD2E4`mUzq=@+qRIvIBk8Kw4Elhsq$e;# z374;#oH!+i@+wxX3GP#?wK{62*1Vx5~| zj^3g`=@{JlF$L#!9~q5%#N9xVxL9yE_dg)#$<@*}C<58cm)C~s1Ej7$rX7Y3K)Uds z5nPb~5;1azDfJi-gJT}nk@|qjV}n45dHl}fb2ku_1UI&q&=JQyhOE{-fmT9Y zo(hwV&~pCaYnpYMXlYRA&;|R0Xi0R0IQ2jku@Awma#O5thq308ylXM%v^{=m(F-j| z2mTpVrK9=(hW~ARR)>9O^<5e%m{S%-o4wu#p;@ngL}mRF%)N@wW`4>>GbmGSJWLr) zC;NY##&fUJBED{Uns^Q}z@IFUp@b$mo=aRijL@XU)pJg#UZ9CRr)(1S@LcY{g6@%# zSYXI8fBk-Q2^iAxlD99d1IC(5&9){2z@Ym@jSTbP`1B__?ViHtDEUWFF|Nl_`~Txz zl??RTpVWA1NM)&b%5S*0?I3LtC| z-BvF&fH+=;PtU=AifGMiNpmxYPUda(-UKXQg&$Z zewnaTvpQO+dht5KD;0B?-_Pw>U5Dl!Ht6rK9KrKozOu3lEohGZjULj3dA<`BLq~pL zzVfrnSNYXUoX7qB4i$T%=@2qqKYAaUV&_v|{fGO%bC0E#Cri;}r%U6#v1K$VGHvP= z=Zhxfd^;BZD5Ku;@)+zg0|P&pYKY(QVC)+ZaT~h=4CE(YJf#hc&3nE@FPQ>ESS8&! zC=2LwcJ^E*4{=<2<{7(!fSxd@bY|ZNpkD}HNb7ll>$7G5-=;W!ES>6)#A_mGIm=b5 z$`^4yS=_I|*#b22h%n)fW~{%gdHC}AHQdh^MxObt2voru(a>|wKzSFc8?e0!C`Q)T zZ?&!ga>rSd{pIOEzOXJ|r|d0|NjW?bSLA>c^2qwJP7{#UvN!Psa)9{CKv8HFzP}Vo z(@z?W1L5tTx*gN0K-gM;K4gpwac+27dO7)^mB?wGn5B(49z)x^HO|62s-js5l2u`UK^CS^rBO9Au9d__67x8>0ErRm+Lh5kcRoj3kdP8dQ{<~!?R z+O*K*msRZ_DvHp=qHfLo@KNk9AE^m?#Q7%{LFH<+)R`_m7Tb%Kc%Q4Aci{Yiq8@Q1*PzAA_d-f<_+Y+Vx#H|N=ELVtue1Ni zhv)QoLOoV8(A{M3j6(U3}q|$@F;kj(uB@>tV54|3QD<$_c`3z-tVlu0~q0v zExtpKfDuZ*e3%R0U;ew#dS!9pHGhs0)~jCv!`@@_#lYXd*m=+5O&blLm;60%ecgaQ zs1`aXlMeI`t32iGb%B2Meuz=PdZ24nWF(<{piR-A9&NyVe&WqA%SHmwEZz5>lq~@2 zvgA&Oi&%$@secl@9_JI(7< zmasIL=f4D`r1Gzue*cI2kgAjahuX&~f1ADO#^`;nbzcA8Ge zB2GYT@=!oAT6uZC@5I?Y91o^WUl`UC+jTT$g(cAvqoMt@$TDJUCdTFpU?1Ae=YVPQ z8MN?5XVu}!b~HbnaEw!Y7tO1M|0{36`Qt`krcw;nRZ4Dric)`5)Dv2TeX~KbR1ej3!D$%frRg(fF_X zyH@`=jd~r`$g8s)fstEnuy}f`fvrwI2iYXqa)rE*TZmLpJTK0zP$Iwdb-@HTL>+pRwE0%DFhVb^IawX9pXo<2_mV2=U zu~jG6bMi0;c(RGQB^Y!4FAHC|Nnqcm{Xas+4MD8uehC})K$HCC@yA5c(=-G09eKTj>g$a6Br%ND{K%;5b># z4AkQ|y$D})#rc`xoy1Bj#{ag8JL{=^64wE#Cxjz*0)2dB$GM+YK+k$K>xSQtp}W_y zi{D}WMWMI3J4G7zC){&^$G&5|(oeo>JN_!YI94U94AiQqeVME81NC%GdsqP0jR}54 z^+9`}JXu5E9;X2mnctR;l81o&Zv8;?5F5x^J4d%r7l8CB+$h~7YXE@T(-qN z+K6z;HN1x+{lnQ~*D!xfF5-*cS%YTm+O#;_t$2=p%5hrlRQtl8`x2#n_?|CPEd1LJ~1n16~UFn0U8ZHmWr8GZxJ zL81oewH5NVIfFnC5~-Fet_1onIZ*>XE3C7q51G9#$GYU*DD~?&&+9pswYXgbYUjG5 z$xFL|dTnvnJ=!^(*DdERcwYrd{4MH%Wr(NCKH*Z5L ziIVZ{`RsFpWT1=Q(MdHIT7pgyo;227^|Rp!)=eRqjK$aD)WuC z{Ah9imnHiL2hoC0>X^;|o>MK%;>ikeLvt&sjEE`*<}jSeBlH0@`zZHz2iFXm>Aqwy zxBDNSlekbA8iePy!vpzN4deYpbD@*N|1!~(J>FHW;Ft-{dAK!ium|NU(>HA*;b3@yCt%>iz6o@}-y6q4! zW`FLxypEQYoBYYOa{mX~4MB+1)nE28LeWLI{5Ml|klTCc4!Ez3>TJE8i90 zTkpLbzeE6CB27sApDWP5RVjM^iA7WpTAM))M5Sz~m^5OSG ziHB_@#~z#k!cUs!)Q@%`m@%QHv;}cuSeZAUrlFPO^64L~H*kN>5q;39f|lyNeyVZj zBKG96ufKm1Vy``9+p|#tEgG20zwgI$tyeOR-2GOH{lNY6t{s?jot(N`d$$zLX=gH>>iPq@Yd&$G3HGT@MP40N*9KDmxjUxv zIzT#E_bU2aHW0fM+;64t2BKZ<_Y5Zl!BNpXo* zjak6)h`HPIB@r#vX?EY;hwI#b3;9zbzY%-Yo0c7QSJ5I8s(iB^^WpB)JoSgpSVuJU za_U8Bu0Po&QJ@FSDX}jP=;M0Vlb`thCHDEhWdDAgiOe#rmhGg2t(DSr0g#DzIv zp0(C6HgN`~v*XKCT?N2A65#(yXc?G>jfBKbF<@@8J{GEf37AafO^JA4Dx>YftlGPM zz(}=}xE0}x`xkb+RRlgKYA=4KO5r>*e3`wo0N+>9-`4uZV!e1@-GwnyA<)J;xADBb z544ASR)Th&!Fk=xbKrzA_I(fiOjUVyKpc1}mKZS##1q`Up`veq(4_Z$Ybg~7mO~Og zk+X>N`ozj3A%C=z`Y-y_ulG0}8vVWW4``{D_~N>zGGY(2PHFF^VlGfIueN6%Eo!c5 z=J_Rx7EZ^P)fD8R`Ipbcj-AWJ^Qm7qA`<41CFY6_`AMVM(;SVEzdP|BytLD`<(M1e z{u63ux&cj}w6HxenS-WECvsIDW4={Bc&apm4^4(}!bP);(8RK&L!i4Yn%KBcGa4D9 z@jXU&b_6e@o@BS%@~uiIC+n3gF{ulwwOP6bR{KWr%+`lnkb0skKKX%ka zhXPYte&)u-D13iS=&8QOdA>}ye|>WYFz%z0@nGD~@7uV(I3LG{xZUpDy?UT$CZ!*? z!#c42*I4n4IP7;dXGV!;^phj*wv;I+s4V%<6g<4}8`9=C`NjZMLI@Aji| z4-A2FX~WE#;c6f++`M;sLky6wChb3KhJD)wlIR0{d~aPGYv1Wo2*iI4;%&RJ-s{W? zjK_XIp-ohoY$gYU!>^B?)b2-|H)WaUnhelN+Tm;e>JK#cb65ZK(PcEZ+JWiejCp*! zQ`J{J325exf}rH-DKx$8sqEvOho%p0=qwVwiKeoc=Fcqg9xvgAnV@u>KW@}K5_*({ zCWajp+@0_q1L4Z2yZm&}xZ39wM{RD@6RNoO7ye<)7uh;4MykMk_U7`Tk$hl22qZ|o zs>RQ-Iht0rO#<_%f!i*5Ibdp=wpurO0F&><$sH|Hx0@4ie=;fe zW4#sb7qwnlefkIVuZ_QuEgR<%zTgWpCxI@sB|4oW0JQhPmq@AFKr^`-`|T0dPddyG zt-|lGQ_s8hKi-Gyt3?%)2CJ_?xiuTfGM4}fMeefIOcaoPr4v;ghB1F)b}=D&2}suk z^umtdK5+W`%GR*&Ks?)(_402Y_6e(d)lPo}g023K)^+%Nyk$SXmAe70q`$u6bXgb2 zW549ss6AS$OucXa2WzRbW1L?=vgj2TV`K(N%eGfN7r2^EQni60r2H!Ej>$2%hHXZ8qETG@X5|8tF3v{_5``4zaKr1tI z^1<(_(CoD3Tl0f3XGAr!n-#$v1YhLyP~4Buvi+Z$9so+vv82a@M)S2z6wlF!(}XxLF8F5dt3W5*sK{&&|?IQJ0{dTqWu9sK|VyKhO37flf- zgKMC^9F9kB)o@D;_G`-@T)4M&D`L0zcC$--(c((jNaD6=w79`>Q=qg3 zS}?265XxYt5xc8|A%E}I+8JiIyNDQ$%Na#c%) z4E6!F9N&t6e~zZYhOVgJc#b)-XK_}YwP^CFkw={|J{J{rx0GkO(fCx8v(RlkHzW|B zUfYs}dd{r%@(a2G%$na{pR`s3voc%OBk&6_i>$OR#UBJ_a&echnmjOrd4AEjZd*K*9ohS%iVc``5*RV`lK%q z20q&^1c(9Q*yi@3H>HU4e#Xm9Fbu6^Qt~c&2jX}byu7#WCtCXIbve7~G-9{dyshl^ zL5mA1A16(*Pb;n_B(fFjyZbW5GsE!w%C#wx4ZmODy@f^G!C~0%m})H-|JI3hEAfhc zt8g^qYo;oof%mC3>b?(ooPg)Eiymqz;rhxi*2lQA3{4K?f3U)HyOX9}c{k#QF-JM- zrLiUujdz>(RpnWrapHW{m$mk&$4d1Dr|twWdwB$812gXEq&ePa%e-NvbY)l#pA&fJGl=6O>U!nYe;a|(L3%S@iS@52ErSacw}D}P zpiX@<73iD?<6k4O9{gIDb7U9xA@^oP$P_FBt!Ibm$S)?)u4--@K6f2x++>r=*VxYu zU!m|F=fXZ!U`mGu_CsC?d^n1Z14U|1_7?Vu$uHs=ubd2kyyjMavF8S?^UlH%1Iz#7mvtXTj)C&#^a?|r3+IN60=&*rwEmG?sK+k98ha?Z!;iRn?a zROWKt3-gKWKVAH?Nr%wlbeEWB*8o~vvuWgcUOe^%?^UQ$v0ifFLw{On5#C$mW5xdI zhh_&qjPRx`;{7Y4J9lwof7Z+A{+7E;G+myPIj(UG?=J}2Slx^Lz$fwH+&WFj3b>OLA zdLG`}fRTQ-+v(V4U^xElBW~CX3<2}yw{NfypSvw_?x_UOt!v*s?*t+oLY*OPLS&r(42KEEr?1o!1*YMBsd00hUZ3wH^6h?95fmX1U& zTFF|iyIS!sj)!8%yD%zR`s}2drWA?TjW^bB6Q4$l;~Hn94y;9sg67uojjPatPKcP{ zAG{y$?1w=?$(LyERnQMc66THDTk-{l_oG>v|E$|1@LpTj)p#9}51K9r8+D{$?pxqX z^f4zq$93-F;nK52%q?8}bu?N4O{zXO9GAU}CY~4Wk!wO|y!78?$qo0>Sowd>3WrKj zkBYPCQU2G!CGh1iy5tO8ymtk(kLCauq1^d;vJ#HV^Qx`G$MAi&s$Xdq*S|^oFREX= zgY&%W>c{`#^R(yXsy`!M_}&tcj8*jk#%KP8Ho*GurSAgn5-Hf_Bz((Q>#h` zFt>90BBd@<8P{1mQ)c2=Knp*~krH?cG}--pv+BPvPj^W5Gk%|(y0zb<`z;qxvd<9S z$9xCM);-UZ{be9;XP_Hsq{i_Ycvt;(8L{% z_drYpn19NS)-bF*KV>Kw7h%0LW!w>%2 zFX#Y6{lFXJ{hmPolj7Q=j^lAT!NBOTEzns{4Vw2I2U=X)h{o0xpsBWo92>?QKJv3N&f=RTn9BxtzA>jODEVWZo>9L$qmRphQ615)hpJsn=GyRUZo z`}np!5bqxF*Iumygc%i{8O&J{oV#f&qXCFh`4qmQx-Ejeq14-$&87-R1FO@ zDXdhVybAB%ym`5U&-^_aPYijuMY|jC6a4IIRHcS`c(`t!%FYHZodfUJdp82t_T}9N z&#eM3MY_(u*;~N1`r4Vc=n7!Yo@bp+jsj*a=hJUL1~6j}Dv15!1*S`Q(66{vK+_d8-KmRxk*~WuEsDy3x^L=^6<{BvB8YJAa{^HGuVj3Y!@OM4#(pl$pOUw7 znJ-$51L?K@B_ZQN>=OzI`w@eH7{H&a=#O=hc^Wh7I_4A4w35YLl@O=+!@uWctI$ez z#-GXHTR0vkjt*f?XQ|-Eqvl5ji2eOjpIDg$TI}kQ;2FevJ26h@9SQHBk}q|lZ1X_# zR+L{oc>aGbKXR_*5 zJSYEcEc16BnoQXD;odi1G|61;Dp-x@hTPe;pRVBjz!4$V+~jC_O>#8{7%D~^w^YA+6IQVPKx0QPx0RHT$Jx4Ulfj^Sya)LPm{1+d% zo~Ty?{(Tw3F&C-8zs7g{(K=1w>y#rZw2J^=TkKg|IOhQ z%#Ec{r*&trj<&h=UDh7Vi)T9M`ubr1So5YaH}(&xC7XUcxPZAmlOwBNjAGsF?^5Eu z`zl{~lAUY#Ax%LbE;J0Z ziYNgwa(~(lj}Ji9uBwvPxP$vr!xPSWSogn^S*0r8h4~6fbW8x|^O8>LKNwI$D{l&K zHLV{-%L0BuH%jq+<|)wsX3Z&JZ5b5KZ{i1*imaMVTL-W z(({ZCEGp58|ECx5cc<+3z1e`{6n;W#-6-(;bjqu|eFyw|Q~$n{J`MZ~@y{o>I|E;d z10~Bt4frlbdzd?Y2R>=Ko#FCX;H{{0FsOF~-g9bdL(g@Am+9ziI5G)5v9VhzKTZPA zHpT6S^yt7{hSW6{X~1nJ{d>DZDRBK-dr1bryTxU5x{NQD4$QxYqnhJvfO$wcr}Fk& zVEj;bF?m-948w9>ue?n_FAiy?7xMyr$KKqDcMd@N*o9m-Hey}C+ zj=68k{alHUfbye0T~Gwqb9Vg{CEO2@hi^_W>~S4&{h^ET9UCCCxH5lu{sK}$r_GFi z9*}hDT9c}OfcWRU=k^^~C%D9Ww-87wuUN) z8W6{DpCjZeqm|v~lFwUUA0|E0;^`?|e`&PO2*s0tb!tb`Azx=;IXUSz>~8|r(dHCa z84j?l5?j`s-43k1RaB3lAHdQ)SY7tx2(UKn+ifvm04$!o+T}B%I6f|xkv!eNpZLsg zy157V9XFlZQiIRUS`(|LVHe=5Pz*f2H4ykb*et&SF5nZMaob{@2fQCFJz8Jeb6o?;<87E7x0MXJ>&C+)R5XQgAuQK-lLWtuhgI}1N z+@dD2B~k}*5)IGHzl=gFzu$*lV=cYRV%i^}a_8lA_EzW#) z;B8=GR`dAu1K?kJ^0fTiLws($m1*D40RNes=){Y5z%P8+YhBO{;47Hk&Uqvn3c-Ifs<1>DMC zs`kuo0kb>*EVm)iR^*fxe!Y3BC;CYnl zl4Rp~As}17`}E=l*7y4k{tbBV2_(;FONT>cfyDF-{Pqx^j~BlUJ2ZuWxIN9N`du>+ zevHzpu%AS5y}L)cFxQx1Z_04y?!T^slS5 z0LxprZLjbWupF~aU6L*Wmcg^^AK5&>l5JC-ytN-##IT5KF@eDUK1;`|$db^pN3!x|jFbB3!7t0RGBW<9TEIgTh%?gJ58R%E6dl`m;2LOG*vQ27`C$`R_t4Y8{2VZR zlY(^x#fi1ZCjb}^r#Ynpi$I_Mz+4=_x~9{H#8)~QK&#)hJeV~BH2s_}q2nx|=BMxU z7jDD-&dR1M1^B+o2x&>U*n_$518ZVmZUu6dlESVT{MF{Ieqz-Lq|d#2o%VQc%k-sM zz4;IjTQ`1sIU5N?w+o*8>V5)|boRi+4NuIg65eY>X#zn_#yM^N8{$0o(=J?RiB^8c zRVFl9qm?x`9K0VNK+7bT3mI>O5c{UZgNIK3Xu>o0a`ad;2&`_=l&(1p0)jf^1-|?;7x|(Fgt(hsA5*mcV~iC8D5E9ry(i-jsd=yzf~{Cab;yue#3Gs!C*2+SRQn))41z<6oFYq$3*_A4U-EU{iqKbzBEt+gI#zn|9s z)|m#Hq2%M!TyJr|qrGzfMmy&1f80%8`3sac-({xre1W1M%oMtPc{N!SZ(q7r%oW;Qd2uX!}&wx zmx3b^`;$(h`);t;qm}5;%=LbM&~o!+fpQ*Tec=4Gfnfq-?|NG{AD@Q(La{QA&2JFU zI`~q;cmf18EgkMso|C zPxKu!gHuF-ul_0j`?YU@??{o_J=Hf`;MFTFs&NcVnM+0+2)UIiVDKPi@s-!DoJu@}*L(@3}VDLWQ zWM+lAN{?5~blexwnjf;|xv;Lh*W_&PDmw4vG-8gzu4rB8TFeh0 zecWe`xt8cWXq64X`pjXCYf5;YG+xGilbj`(>>1qrssV9Ny`|)1oW~m< zmfgH?7xz8u8HHaTAkIqhrt!Nw5ob$OI^XJBXvI0%R4Qs3EytBb9}jCsOMcPf-MpU~|4wk(&bo7N7cRKO6)B!sje|UA$1jl8afud|Du-^ElN=sP)>o&*DMXUnXXGwqC z%yE2VW1F8%$pU}R`gixGa6a*rCF*Jl13xj{(0OkL@cHpBmz(MWA1z{yjcyz8-g+I~ zDzyweGm%KeULSZ)ejk}=`3l^1G3WF@H2}Ak*YNgsH{goS4ZHb&{$iz6ac>aTKkb%6 zukG53xr^@1vm0MyAEs?ws}t+}UYtd*GF70pE4_+PbpqNx!*fa<-kAT=@;~B%IZ1_q zy8n9C0OiGwuf7tlKoJr1+clbsIlK$C4IvUhUZpVoXAjmd!{yp<2uA}+)S8*6Q3Aw- z*H;6LaGk40`0PBN1B4Q@xpyioARN5?e$TmP#HpjLJHm=X9Ks#7>`Xu_+YXgaoF7KZ z=j}U_LJ*!KZ7bKhkNx^zLe|-3&(Q?8Y!AhI2MAo32+C;L3IbPt4Sjc@f`G?L?V8he zAmAJowkKvA2prCnNiK;2f!z-6IlTY^igD3@PI!O-?~|Z`hd9rV7>T*Z83OBTYfq)S z6R@JsT|d0O4OssP*-Pz?1(xn&E;H^vJ|}ucf4y;C953m#au4?@%2Jntj5>iYz2$Ju zcWL0;l%h1d#t?YphBaiqi~+CE(#4y9bAacL-v21N@@Oi&E@~bhZ+_2M2o;4;BzY&I z%u1v*k%SZtgfgU*qD)aC5lVzaAu5tG{SZRREDxA6Y%>tPku`CjOd?N?^;{ zbL^+1G_bL@AM)`T$N5&${^Id2)=Hz(K^waz)(Vf3#J9e3*0PR~hHK+B)YWe&r=DkG zz5@ABHd{DrY?!Nf-C;){$9A^`hIRt^VW=~!F9669cgOsK*8n+aXr-Mm1IQlPb=%U< z0Qp3}wp*np*3FYw0UjHGym3tUS4=sOdH==Q9T5Xk_nYR~vUVWlpFF+pLobkSGk<@$ zrVk|RnPO>0ytky~rUg1QfmjzWDyP-}L~Avl$%~F4+||>&AJ)JX-Ls=SUmq@bAK$t}Qp!+K$rQvrB>d)BOX!a2+6>jda7$zG za$_EFMOOc4#krA-xAqeCaT;(2TostGOaqRkqUIm1t+GJK7D``9Wzv)`x}7Tom1aek%!lcel zAU}Qk)w^K;$dPgtMbk@IN28-AS@J+WDZjPLr~=5l+m)WnuLH8ora!Z68-TQ^QsYtO z38Z>nf3}uEASE`ujvTWG(%H8w7YbhhY1_}Nc?Bh$yS~fcxpfMNzH7tJDW3=7g-H%6 zQDel5+3~8A?jY1xQ06>13_|-ZrFm|~`>N2mR)W(62oh=cZabub;FX!g)NbV0TAn7X zP3{8$712ABlO?DFs5q`rsDgS+&5d_RsQ*?L_{#YWd6U~N?bG*Iz%#HNuD2roFg_S# zn~yr9*J;*E22|X)2!CFG8u9tvbA4VhsQY5e^ph${2hPi{$X}G)fMepw_gi<3fx|ua zm9)fjoOAc7t4VGE_RCIjX>r?uZMCv&XZ{GVg&dQYeP{-3V#FU68&9%U4@OZBwhpsa z0*3qR`5Rcvuei#ug-oHYKG*g&-)Yw3`!4&Ty;RnMaV}x+=Tz2Mu5P>i+dDvR9H#m| z!|(r_UwU90e*aaPXLycbpZ~CSce#r-kTZ8u({&7h{NPFCnNtlw_O;nFKG6f@V^`fW z=DUErL-yAkDFn#Wvp+hY#RKWjW%gqU75}djx?k`(kggy67Nsl+BxB!#;g7;VBChrv zN-qZDQ|7g-%wIs1Olo|Q@BxIQ*kAwry$He_k6nmG+mKJ`5Iyf{0fYu+jp{=yKu}$w zvM>As!LUM$WJyb$d+Xf}gxv=Lom|7exbNVP_!j>=73-oWKg@54iaKMF25mmvQ{G#D zxs{4@)!#DVIOz#Ij~ebaEeYVxS@*od0P_sQUQ(w`k-rSytNF727wRW|)~fF~2Apoj z7X8|Y`v$Ho&Jp-gUu5~&G+Ywce-~Pww?#bee4iuxfezyF>gN3&xF5b^=*=OE_Z8oa zhE4(AS8A7MIJY8?X)AE=pOp`5IoQWJhaGh-MG38C1l$ux=F}cK+JyNppI??)zG00$ z+AXPc8}FNc9$}9nQ-M6R^ygQ97?At!FD7il{?Mv7Fv+_c$X}_gDVr_=IfpW)VfY`A zV=Q%o$D@Jl`8Qeo%LMlSiB~2YQ?RcD2PdiE{j^+@f3^G)kZO9lJ)}hu|4;0Famx%y z$7Q#ik$w&&nN;e-cI+eNdk)L?Ndi$PsnMzvdB>cOMnWceAiS3EdrIF;5W4yI%&mFE zg@X;Ysc#5C*sD^bR$l^wPcLtM{LCK&=9!(I5xgK^5_B9khy(v)RneL}pzANFi&rZTjW82A8RZi4Y&^W0EM?f{$>ADpm3Yz?8A3U$;)5PuyRF#JkEM@_nj1w zJ3p5uD+dC((&1RH5!ku{WO%fxag-D5M9RonP6qpl zv%8aH0FW}`ZxM<`fONjk-r|fVkkrrJR?=Pz#QyJ-U-;U9c#PSi#k~x|b%GK!Ivs?y z#P7M4MS{?i{I1K$-wLtqlTp}Lig^97=1oVuuk!XBn0CQB;k$dbH*FX4i%Esnf^)$C zd|qMS0V42C$rVV{+5?~N5^FHj1O2JR;oib7sQ<#e!5g3PJlvKn?JSbq_fumV~^Uyt!o+T^i$tC(Dg5)VQ>+!*93Ln8oR?XST<1hl zhv!ye!0tJ~TGZoNjbM+%Ty_}NJvM|oMYE@W<|BY2B{~=UVFyqoL)Yx_cn1`EUx9Q0 z3n=^w+Wn4#K%PDA zLw)EkaKC&SXjvBk+++z0&-Dc0@}8iJHKHE!4_EL@f)VmoTX*v~8v)0Ej_;I?^#F&# zRaMpYW?(NnRJx-v6WI0oc9&U10$T<9kvXXss84-xdT%!7rMwZFP}uOEwel_Ijqp+I z-%}Sk*Is95ElUQ95qVy+mP{V__v_EH7T3tBEGO<@&F2~G9yveG8nYDpb)6{RQlQGHjhrVM!pJzi9O2LMDE4Rt@IXqK?w+>fVz5pMf{Q z{PTkpU)ESSZecO2YF$~>-}w#Q&%iu_?yZlW1Q-M7 zzO}+rz3ISFF46w5wF)?Pk}pZF83p!&E~b6L5U^{y{t6a%2ezX4WUikjm@8x@{Ex!L zT75XrQ;oiymE0*U2fc3A^7k``XA4U)zed^lRDlF*Ns&^de4T{3i0pCa#yeQ^kxOA3 ziFvHCos-v;KSct?^y5bBIsl5XWYV0HH&FC;SOgtT1j>?Ahr1hQyv^syuN@ZQR0 zQU7fPQY!kNUk3u|lsSj-bPUeF{-Nn&zk!%{zBbhZKi4|45!HTz@C|e3vt%<6>P_|@ z%@zWooj=En^aFtqb&)b-WCMbIeYvmJVINV=H0<8K1_XQ!?GCaF1AqBef>XqO;1?87 z5TLz4zg?ANjsFqgP5QFPcxVhfQ*CEQvxV_II<>wFaRK*>oNaINhcGW-YY#tQ;%}d7fG36MP z#5&O|wdWOT2Z}V;A7iyxpm1#>zoFa!a*ugVNd@-#qR{e|Agq&cE{iE1oC}WsRQ&Hb z&S{F<>-%SdfHYyUu3s1N$D3X1&xLt_bjfJN=e0cUzY=6=FA;~-_U_y3!VN@?WmEW6 z3Bqw~{Eu%Vzc}Y`K-|~`ge+1|e4k4JLJFuz9U_6?o3+&q{SQJ>yG&3&G2?mAa@|I4!^|4VppdFXAfjn)Mv`n(cI-wk^5<#9N zY2l@WqA8Hit8YG*y9w{D0WH}_*!MZ~l51JY$m@H0R^LMYJ}@_bsu*$n&Mj-MJUR%( z0n_N|sfA_8r|-Pys^rnPjhtUqHw^I%B=o6#3r1yU%U` z2pX3T-d4r?D)KV5l1jZ(C;ui^W;_% z;&YSV?eFIi2R^G)JhcXWLELvQhh`o_{q|D1ax3ITSJ58=!49LVQ7dq;LJ0-I#TyXbO$)~fL}@1Fl0Su6Hu z&xu89vz7y-O;am5SxYG{4?YInVlCE*=#^)n9x^sZD{<=xYhEMgXhSZ6HO4s?YowS9 zl#tO^3Rm@ja$Aj5bC(E|fYpSr>N!BUcqF#``g^P!YvQ2?_~(0;KI%8%Jf`4C=(P>Q zxh$it^)T`&ox_gD7>M(8jl@s36$AO&ko}(w#3RNFX9jtjfJ{yqbzm9+sZo5iCLiak z@Tg0{Z>}Ieue)n>-8mq!+1)!h-3~;@L(VZqq8+K)lgoeBuBI9=!G9Zqoq}hoC>Y<+# z^bp|G&?{H7dx-g4v-2q}0>B~m=UtVP4X{T}0)HpwZV4}DU-CT+Z1;K@Up}Iqo)YR1 zU$_}@$J?^kW0>z`=xps@k9_W_MeEDy<*cRK+t=qxv$GaokL7%?#T-gson4+em@_H< z^|0?ADr>aw>RBTO_KznTs^`xc110`~c!}N$Q0~iF=)UX&%1xVX!b(^_7n$^TGoOHR z_#)qC4qc#VUu!oM$2m;&=wg+WAPQ738-jT_i~xkwn6fRvy|03{I@S^KDoew-;VJG%#?RMyxq|SP zzf}yY_qZ3yGzK}GcN>b!HbvsTN+Ln>(%Bjiv~MoC-1!XzQin#;o*xGOetUV!(M#wj z`t?A4_$cr>hU-4EKL@;-eTuis%7AAf^L@<>`ru8fDX1 z$RpnP`2DtXEwJ$x?c8qd##)v5meRiE8*63DAx-OwMb@%O^Iy|5D>&ye1Zh&3ANruz z`@J%mwQyp_TqWiwYo2ZH>)(z6*61geg&+DplvoooBe^}YFKxWmj)Cwwt%HpnyQu*}_uqT`$3FywZmO~L0T&=_+^6n$eNgt(APpOdH@~Im2_AbRq(mynT_f_b72kk-NSsaMbtj)ypNbP>P zX%@Jj#y!-vM&Iai(va=P9^g6}xuZ7&eTtv4tOfng5#8@GFX+#fziivvS))lg9kYg(Kq>1aa;;tm zN-2M(DgJ*b1);$`a^*ltKer^VhSgznPUL~ThWHH}kss4eK4_u$1V~H#q0-N7kViQXem;2! zNasGRPxrr!cs=lm>X{WFrk2cHQbwH-n~I*j?jQ&sXyM}&#rrB{NBF5vf8SSy@O+c@tvA?`3^dyDS{F7146v}ldKIEU()?+II23yLuYW2aHyReNI2i^0Vj z4cz1&F?S6p-z^2xd_#fK;K?h%*b9`(?&t@Rfj}vG92^y|29)P-+q74)kKAL$u6v4o z-_7jXj|B~!zu4@x8?|xny7VJ9$_vO7-}K1C$gh0V8NK@m&*SEhW?diw$VR*@e&HA( z^L*Q%yb(G#1bg=3 z-caRxt~(tFOWG4wfp~B2V&wkVCjo+ih9Nifia?;`MBG7-55T|JPu3g13jABITZc>2 z(6<#9>Z1~gc?JGX<^SK)uE?E`%|zba#A=U!AnF*N^cn8cXacUew4YYJ4B)c%$qSxP z2F^m&GWUiDz$uj>`zG}RaD;voV|(ub?90aNGMVUezp%;J_uD<(2k!F7RYhFx9y&Q=U@X$TV`jz#7&^o>^{l!75jU^ z#@NY|89+&J`~6}T=P!SyS2=4{v7ZE59WBB8OeJJwnNtVvt@E0K|2@ zCj{0Efv|^5c|Sfk8T+$GYw(+UdZZ5Vo~H1$7KF zyPEcCjR2P=CH3eN)W7BZ_;xPF2{^^w^GU_mf#YUQcgR8ou+Mm{emHpw*j=9f)Y)YU zY`sF}rAjwYwf;c&iwM?7$u12x(-PK7CC!sv{w(tAX9l&VJ23Z5NN9Z#>UxMD<;wdx zSc_YYRX*%E&zfIg&y+F5e9R|yQ}cZIPNIQNHQ$-rK$&^Q-rkHjeDa-CvurU?{?4nE zB(DL=uQLWd4x4~dAz5QO06@uFclOX3oU86d%}qCB|91}6v3;C}$+eri8ubqXh4@6a zwg~6lp8{_WTI*sTdE#uC{2KZBu*p8lXF!&wq-gD308*PBSz5RR_wM;$wI7}Z(k`os zI<;&db}R^uSB?Quz3a;cf)nDx!I7dSb`Yvds!`)KN8TjHCR;NU2nVgNi@XW~!RYe= z>&uYet@jkYej*P9_$D~T{Lml4ioEu#BMkk&W$E{wrhxYy$6ZA$ci?4PTWoeA68YT` zogKx?!2MX~+Q|dRTTKq^v%BpJT;?S;=DMhRd-cS|aV-~cGLAf&F2OlBpuzchQ39}! z{;Vc8-vjoO2YPQRB7gW(Y<%w$&btQ*y1lDMSgTp2qi+TLP$%5MRIK^JS}xyh&b(rW zIS{>&+i}U|DS4XJGlYIOwzI7XGzQ^~kX^kFh?lyBy=z0ZfR6$Yl?>RM~@{4mRK2YH>jacxQNyg}OrW&HUbs}y36%GCk`Xsnf$})WM_v~B6))MU z=0rop_jcR4#_`^gv`ef#hI7`yK5MOwbI3a$?_(bBo zm3>lyVD~pCZg3F<6GApAqEA$yRfJ2n4)s4osf56;EY#f}5RK?jz&wc!w|&AfH?4Th z%mpFj71??D{@aVXVdI?N6WZuEiJOp(mpTYs<8h@|=_-pTnoxKTt?&l3($>Dh< z>zxkr=wvPDl)jDkMcu;J?4ltxCTp>;;fMTC4Ehu&bQtF9`0nPXq!`$}59EcTHULGK&Xk3c$L+1#W40Cij9gx$xyfoNrt)h*SA`V()8%i?+v z`fF?~!7~j)o2__PzMTMq>xS;Kf+Y}qekjq~Sq20;y@OsgqmGm=8qX3!pV!{Mbu`TD z^zTX*h|_g{8l4zL9o>ReeAmo8kTT0Ae;(Wgq@zw7%ObI_^WQvYl0gNc zLuJi)D*sdhc=sRGX=iukwu*WIA4{}k2}8|LElN%93vV+zBKXNpFWrTad zk@XJp&kq2XfdQR7G6$R~5AFw>qhFDC;_Q#(n78GwQxQ{jjJk>1iOLy^8`nFr9M!zPR&(ptpuv?j8>zU08ouK9X-JL7VA+i?d#){ zK>5M8LNUO)i|Z&%yEBCK))oDznSpq7srS0LY;-lB7B0^>rmapO8hK za(c?zapDJ%p4YDt%|cz?!IsX(QJfEWcI`D!kp`lRdsaNr4uq>C?TpXagRpXo7o#f- zgdV8S41Onp5PRrzhb7btpKBjatz`$nPCA>d)i?<5U$^Pp=nM#aT@dM|cz^(e@4`4Y`*VfPee***l4-^Loc@8{LGtE;|VgD@IDd`^iT-QXchpMwWZ0eK9wuDHJ6z zIlyBla%w0LeJ!KIG2^L@z#Xtm*Oih0u8u6ti(cn}vqFt>OMjjWIpL-FQxJzB2!eynwbR`>hi37SJRFd!E1B4%Fd{>eM$9KrPHjrQ6>G>h+Be zB2LTz)lmQGD|tPj5~O`UHW>h=y6dv&GUChN=lgd&#PiXOm#t061M+;oY9s2p$XS_H z;!5{`Y$qYPqrVh+7~3_P#q2=(7=4Ii5AykErfa#@QGvvGGaDPf5r{XobrDEPAlz{! zHj7^agtgbVG9wm2=<&uJdu{_f54XovtcyT!8gMU-_5s1h>o$C|8$fWE@{eZ3y#hJy zjqH;hARy=Kv8yu>_~Tafot`4zq#qE?DVPGjh_fPe#YW&G?Z`{f{RO-cIobcdA3|Su zDg8YE8_dr+qQ!6HkNz)@cb@k!bg*!YTNCV_Tif3I(YJJ76Cj{f=O2sAlTNhawc zP)FZ}oLdI2gC#DsPB4g82fz?1PG0@E7BW)-+zsMhJPpSAJ2FS7h}GWYsUH~yD^XL&wu;I zexqLa)F-_B8_ehVe;7t$-2Kv1*)6-tcK=*U3 zJX@&^bmwgceCmvWZthxhAi4zTTg15%rhS1fd>}8}`X|u-sMtjZ^#HBt>mIJf8lZ)4 z-N9ov2Q-_9;my|=K$9lVMaM-0_4nr^|DDBpdDis4PuCu(4laT@;sZck^K#i)7W>ur zuLDy2+mYYwzt7Ni1ImtVWb&@$Ec`?!=9On~oKP(=7ZMYUl16=NHTf>2L zkKlhtuoy_Hmw5B6Vt|-^SUx|d5rmh^%e7MRJS=D_iszI;=$XoV{5Z~QY}_6nd;NfL z)EBntwt?V>>(d@12_U$RJ7s&jEePECSIu6CK9iYER!>~zfZrh_w&4=ye>ERIG!|O~ ze8%zxabMBT{b?0$WZwbaoek|;LW{st6yC-qBY{4X4V^Wrw&-iPGfAu|0&e~1=R0o% z0avXXd0_ZFa7p=;NVt!n-fl3a^wdMv+>WbGoCD@S@8Xwz+Gqgu_K4*gtLs2-R#Kbs zGX#2NPr2d4TA&x?FIRp5pg%1<#}RD=^jp&%gu`Ee?&Pn%@*oH3yIn&6UYY{BcwP0C z8D60Mt88(+nhLb{p8Lxy%7AujIxtCI8fa!Nik}{D0~%@mEc3$)pw?AAXqxu~Y6vg) z18YH`>i!u1^hY1-#9i%}F7jk)bMUeO&*Naye^sOS$@%zA*xE|eyGWKz(aL~);6RX> zZ!nPNJ?P;J+kh1RdbD$+BkJ$=IsZ9@zK7D6^3m&&e-Rk;i1a=S!Zy0$u61l6^y104 z)u01FSotfdC4CeKHUe$rO>1#4KQs~Wq5=fzm+PK<@dW|zN7m(5wde!i(O+D)ig`Q6 zR)S)_*f(;A^oq#9x5?hY^)l-1lJx$%XZQoJr~x&Zj{rRPt-DNLI|C2Jp}^woP2i3? z=2Ua}0_rBzq}%`N1+K>pm+V3vfOEKQ_YzG9IC>V?+#@wvv&#p#61gt}gL&e_K%f;c zXpL9bQ|o~tq!h98djS}1p2P26T>|>QH`ebIHUPb4hP2;w8tBD)OY`fouHs6Z1XqrE@qa&Ju zI(`4>-7mJ-?~~-V^U<(QlsCRUC4%$!*;3v|l|U)KTem}d7f{ZZM(vs^0*biy#oYs_ zfBB?ZanZ9D$c{hKGh4m^ncuN^-pCM53jMd*>+^;-I;JJf)NcY_b z?uL8^?qQx!jcf7U8keS!TgENGH5~UontUDikVfB9LXjVPpU_S@I{+MS)mt;n@Exbm zo~rc`{lG99`te`yR$%Nk3JR9r3=D8OwSD~|V5k`rw!Z!c45`HrR8<#X@ZUOFa{f2a zhgYuJGVwgBJ^0%S^MIbp;hnSZG|;_EZ{Jd>2D)MW2A$~;pwrDQFJ{yO?U(&{T5T=R zo@{yHRA~sbqkV6p=wzUYJkMV%T!?j&b|Y@N0Q)>+w(x~GP}O7$*He)<=;9V+JiUnb z)^KD2$1+g1kfr9Lkgxpy!l!N86UdiGq~By9KPEyGe{P=*q_@_^chgbty?=SA$@U=- zyB)+xgf~Exc9pAb;72}ePA1O?{U%w%U0OR=kq=Y;7ImBg1k>mI-_F&7VDffNnaG_W zu=HPwoC*4l51T0LkIccj>anJ;Z!Yjly{K~H!~E6TwvMhYTQO%fUQFu_&QqtXFTbFp zPq@`1;?cXCz+=`oHzs2V+!f)4ahN;Bt$*s^D>~+;mYdhawBq|Tdw1U0^9$$dNU7xB z3#gk9U0B@hitoFGi_{J@e+0%A)g!;i_DZ!y$t1BSa@?djI-z_9Og{ad{S7#2kH z**7-8&=})*wjvA+u?G#MYfb@uPP~|8fPKFHzWIr3E7*r5qitw$K)=vDV&mcsbnTvj z1UJ0bI8IA<{M`w(vQTnjhaJ!Yu6D+^djf6y=`F5Dg@F3cXQrjA1gKB`s?*D{K1>Iy zOxwJGGWSv^|E(EN63+yrXG#M_|5(;c73zxqeE8M=V;FHwc?(BeE9&qw2c9;d{;o79 z>D)c!i;qZn8b?e5anxiwwS5y16;*52I-^eFOijxJT0RK9TG@J}{vHq(((|OZ6r!%{ zZC#!w?o;A;Uv_L~1A+1D^!=!^Z9_DfXP{{M20Pg3pKQF$C2X2|9&EG@u{ieiLl+Jzt zE*Zt)R~@&2)4BQZjsyAlu1S@J^REHc?D3e`|DIz#q&=1RiuxHw>QCkMBg?>e9PB>G zy8#$s*{jYv#=y9Ggwu%YI51Aerf~U607Kt*CdKg=Fl5C4e0hxX*Ze(cw%5O~Ud9JI zKI;MfkrP+O!T`|iX}4fy6zKA6UWv}{0^09a`HLa)KuerWylA-*`@GC*kenpY1RW}V ztc(El-8ijc`U6lMmw(@H_yttrry;GjTA;k~Hc$cN{cUUwU75INnM=_Ymm9;r9xi_9 z-(w)F+8!}Kxfbg|>k=SvUGARo5nnXwz{yUvRy`8ryH(Cc!0 z8Mz1`%rhlN!^l9;8~^+Z{iT9YnoH56ZHO`ZbG0%smROa{9k7apBTI z5zTvmIjbKgt{^W~J`!%Pyc^#aFq(L#H2^$`hEM4~IC{)nW4m5;O5wD z?C64iIKRf+9Wn#Jxsq+Q==TjccU$~aO-}$0z3qN`4xVPssydf{jGh8UV`#HRSUfQ5 z^8&!80T>mV6WWeC0i$pwyyFDc$FnU%;p$j7q0MJKb6S9Lc4e4!uN)YLpR|L1mEnE1 zgXtG~4d~;y=FB2+UVdLS`-)x)^q`GTje`?_zNe=80M#Do++DUo+QmTo7$wofu>oiv zjOz-aM}Q`uaN+hxJD@h%ag6Hy0IFY%uAMf{UvihH15=RquiSNzcKj+(T$Gx>%5wmP z&$s0hH}Wwlu5PR^T0qv>zAo7p^(xIWFYVCpMsoGmJUw|5NL*y!jpOA&)DHaHE`C_5*=s^>{cD_wga0w~8YE6!?{9mNJ656lT z{*V)g+fHDP(ZF(Ea7haA86{hN&8@~gmqxtHB}eSzNw+oXM}g;NMNx;b0dUVoyRna9 z9{QQFODEA6#MN82WzCyz%z2)Tbb02G#PoZ|8 zp9PF1wNv-%@N?eCGe>(E7-JEgrM3W!9+J*Kt{1@guRijg_z7U-_9(JA+<&7xk_b|-o%yuDfnZTxqlhrcCu@fv7Jq*EVhpkC_K1V~7s>_<+eL7HODF2gc-Cu8%@kH?0#! z8G$&D6?}MJ$$SQk$iErss7qm-j-mt!V7+W>O>BHVk8@e)0=Zx}(96GFXyw3pI;gcH zLkG`km)xPoF~lRYgT%*cEPnw*+pmDAt?v1hl>WhJuPD=&sBgSg} zCdem`T<>W5Ki_|+(WTB}5GZn2REcNr0{Q)W&G3JS*DZhc&GX`Zen9ly#HuUqxvIB< zEA|oLjzn(>Yakjsr$3oRAC})`KbaO`5PDnY_d5e|;FRJ)2KsRb+wMkuB&&g-Z)G%B zNgDb^KgQpc2|_;1B9D)Nc--w+PCGLK_$q3)ED2(Mr2N(JIvsh;hqUZBC!_+;KMnS+ zk z7iL=E_q?Q5*n1G`;pfp4(YIa$Bd?kysr3aI!LdF&26%vBJ>tWS`)rk&hgw|LvK{qx6Mi}`Z0b-q zf21elBkJoeZ~KrW=ZgErzn|_eVtxzJ<{j5Y%w@B;GuRZ0c_4+qTLU%cfsbC1X&4+0 zydJ|}4$L|NPutetzlZJvk8beoY#%4o1y}xFFzQ1eLuc1OA>xh59HBO6%>59MP5bAn ziTsF6Wb)1=;P^}o&bzY-eTdH^hFWg0W*)54|6E!HrpqmV-@e9aK!^_&bgb)uuW750-KPktF;U-x{>o{R4b(iL)pYdYvaYqRn%Yi~z>@_o+@ zUNxX?R$y2z^#Zm2$CD=fd#UGzTHI&cfGW%%pT9O2@gbRi?Z7PVznoGt6ZQ|Ko!5B2zG(su)M=kJ{goZo;c-mYVM`vcx%zrCc6W4(Nl zJbz+xFWz4-MCqRdfN|*6gNPfZzz{zn#!|eCIPy>I{e)SdhxsH%8R7h^Yr(#|4Ey?6 z(xc}SazKlH$rF46`4q@H^xn1ws6B)K?ThOM>a`>f`a~m8B}GSN9M|HU^@v*W4Ci3u zQ>oqoIOleJWtTX+3CQkTbq9vgzqsm{znRw@NOuhunubx&BJt*3$9+2L=XX;dN2C8L zcvR-#1>{Kz_4ywnekY8s)v>1d0ztuM$Fovb5Ok@&Qk8*x?klVF4#}>-zt9-a)fxc& zM(Y;%yj3wbU7lRZjs1J3@aK$t2=H2#=)WAsed8N(BFkD6c*I_Q`AA6y?i)6r{LcFW z*952d2VeACoeY0*ZBHL?w)QXjJ7CVhzF{j?A-+#`Pj2WPpf5D$?xEh4AN$WwY#SHQpKHS} z^%S7nwC|^coWXf(n3hNLLmu*3;YnsR&@4^I{vppzosx~uGu;5x2sdAc*L^@$ywvp} z{1s3>T{Zjg9rwr9wc8pEv7Zm*K91an_|VIv+H341ka>FfXo z-_!RpLCA-_pL6e2L!Rs0dB(=+ugLEk-qB-g0$OQlklk$$pq&yox>>=4`;#~;`9oWQ zni$Njn#hN9)02#(I6+ix8G=lDe-0 z=^^{mTO6k`XC=GeRSI>FPOA#)UAPCi_oi)Q+;I?kcPMx*33XgUrQ8{&SAZb%SvT5+ z2!hA8^+}0D5J=*b*=+wF`2S4K_${H%PVH~Uls@+J8=uE}sF;)5c0yB!!v=WO2$5!1BD;I^fdmlDcGm7x%yi756U{1LwMg z_O5-HBYgC7i{1Zo=bfBdZjWI8xP*_mj0E=Y0pjKr%;{wIm9=KD)PUL67m@3yg6HHN zaLjxPn7QFftCp5{E<3zzr{sZoA?ob6lmKAveY5S{dz=GAKK;>NKt83X7gH^E0^|9v zE;h$DU^ohIzy6mK`}uWqN*B%D?<{E9UZshHogx<~gP65qR z{+*;E0cfebUsVR~r{d?g=7S-SHXOa7e@z&OX9pe@_dEyT2s5pnrpULyD={!R5(k98 zw7qvnrhu?kY9^UN1HnTd)~|Txg21EC|4nQ_KDSeNXj=3d@Nc{vzGmnZ@OiaWw|ZiZ z@PG7|AD?2bmpsqb_v^85To17^YI6tf-#11EHxPi^xH0EbfFS1E9n!jTQWNK@*{RK4 zm^1hwN-WHL9yo=Cb6IOJPtD+4d~0_Bul1jaS@sY4=ryT=v{bc9q_0xE7xtd=)eFx|RS&pUm1A!hh6V5w^_z`Yg zEna0JZjWuykG}@An|@8n5~4s`=Ox_AhkRpk-F(KpAyD^!OL9JW11P^Mjg-i2TYb-hzFj**Eu)dVw=giz*?rdj2l}SBY}QJ@cn04sIlFV96W?X~BmXq- zwH1i0jdF2Z;sX&06-RnqGKf$F)V4joiRZKN2#*xrOM~&kV+qQ@to9Vh?;-&6S$$x~ z)Gc6Msa%SP!g?{fDQg_L3z*c+@sTOlaPAuUA|2O>{eAA*Snx&UE3c1)i&y}CsY=Y| zjtkJ!`94l-g#vwlz~6TDKA_EbJ~uZP09uU73)g>HK-)4qN&by6u1GB>GxN%F5e! z(&RCJVDiBc?okkqUfrp(?G2uXrLw9w`V#v;1;bXt8A`{wizHhV6LJ&zdi(F|O&xJBS)1h$*{Iw=m)nm*Rr^+^jWU_Iv~ib>)7o&oLlBR`wJcM17ZRgp8U~ z8uIS9qF?HF;$G@-;L}0OvAH6}7NUC`gdeUo9^4U*=W*S0-44X(zt=d>!*2nBRU9%4!-zGZlTXIPnyiUOCJZA)L!tbCfISCt$Lx z|CBhT4vgZsQ%|ng0po&$pwdtX@{iTpGe>c*swJy#d$Atqm%Jkx9k@4P7>hPt!g)6r z-~5w!05sEm-_dji)LyCNW~IMC^#~D4vdIG~S9iLmAMU9lJbrH#MZ7Nl=yAXT_L1a- zFFK(TxW8@T?@32onDx9d=Z`p$ww~xs2rvSoKT~V|*jEsal^nh1X^ZEPy7PYF1bUt_+2%hJy%%-={mX6i15z7m0Lu|Lsj69!6YJn)adT&?{ixi_CYB z#{OcpC2!+HPhisD^sl;1AU}CPuWYst7(oWxY9zh_L%q_f>II~G|pM|yvB;SuR5%AcO<_GdHBgUHSqyJ4FDa3u0+Izp5ip3AL8@@l1WN9 zP-F(puS;+N`Ne;XaJfv>(f3gBst1HAHpAiVp=#vNo3gtuT%--vrb0p1T4A2COr_VFLX5qaI0cg|D| zVLoSCktgb%c_X^N898D8-|sDFqK{)9%FYXVsvY<~S!{reWXwk3TGIHLQ1c$R>@V+r zd-n?Fnn`Xd@|*-tZGLN&`@z7GE#X%8mWFyRR%LzK4q%%KOYyV##+tru+4t@r-bdHB z>1BMSfQWyZPX7H45bwi*})8`H+vZv%Za zCUis{_wM&er^@Q1fUef%7i**kw7UI6<83xTb9}qLN)_kag~Kn`T6F;RPGqQ;!C{~> zbBH^xeFMr$x9mv@qz6P;yU#Rx!Rri=Dkls2*HuOCP(hmL$P33!m zc+;cvlF@n)eq0*%=)`3_k54nE(t|+g+8e5IAARkDG8&H%{|RbK@A~Ae00I|9Od1lg zM6-VyR+Y#D-vsMi@9S!O_fK4D^KdZm-ZI$aNsR%XACEL$n|1(?%0FG=@@3$@E4AN} zs{y$F30~)xv_?H}=**^`-jR!a{=|0yZC<>$;OA!1 zBl;jBx~ed3?GMah`;0E^|IC8T9LA-af$4i^B6Q~fFtxKTjLaYpKV9okMVSP~3;8|j zvS*Orn(l3ie+l%}fSD+r44@|q*B6K2x$GL8vt0d-yzlYPM&cnryYO+wA}SMT+(#_= z3Qr>68@zq5@E@Q`J>0$-vViiUJEPdb5Ov(|jB`szfc)liy@3qkLru3kwnvTt>7Bs8 zN=fA1cfQgKJ8uKT+kI*UyVyba$r+W|1L%J%Dz#1DBn5TwTpqOAgGbC zdZVQd1kPHbVjunNX>GC9n&p_w$S8`?iUU5Cc9Ga$m@nYV6)3W)2Y6~77Fsh9mct9G2qD=PFQ-ym5YPse^8?(s z0L{-nEzeRJXvCHFn&MqRO^~0vegyBUjVe_N%C}GtbYXCv8R}0ocJE1@L45vhu_nM- z6v*16|NM9of%N`=6kTUL)_oVx-s9rp+9M?yC8dmvQ)G)|M3IW3p^PXa$w9h|Iq>hx5R??1Xg1H z#>OC_3e=UzeQ!Ttx(E2YNxnV{=$~$gDg0rF`Pvk@&zG%l0FU?6EZd4~;O>&ki!Ws~vvy%-MjKi&@H<9R1;Apb$$xnxc* z@xgxLWq zI1>%hjP|6Ab;$SDrjO|;??l`;JML!-;=40j%L+w0Fi1qou+&PB=fzO zqHEgM5E>9f&_4+f`os9>jMR z&d7*A2C+EvrwYMys0TjB$zg)I4^M6#&T!ZW!XML^`}VH`Va|12TtfI>DN~&{n{5HX z!}<$f9kNjW=EoP1x(oRGLZyW5UIIT$TX?||?*h2{uNl(_1Kuj}j!ApW3liyVq`y)H zo@4j=L1hNGn-0k=EKUQrd`~s;(+F_If9vOcvJ9Ndo?X4H0pL7sHLfV@4;#r{mbZ6B6?$LRv1mwP$#$|tPAouiLRy?s4$SrjYlQt6|SDAULlZ$|yb!~2s z#t9%_NWZ~}`G{oO*o3b2LqL{G&{aj9K56Rplur`k#E;xc)i95O5`&u z=sG6>ajjOvq!048r9J|M>wX|^5?P@62z7F`U1@noPZ;%?EbkEqYi{hTuJ;hiSuN@(?cqe23LgHI}%+adm<|(hmyCwAAf=Ks*Jsajdjt80h^gwD86XdQkT=A; zIOJCK)q5MCU;}hIZJ{7}aAds4Va<3i1 zJtXwXs?h2G5O@5+td&9hYRu{x_deu%ley|bc(I>o8fdJTmw;5C>ulj9_V=?7*>9gW zf|PJzn^Ej*)S*xl&T8``{yrpff9xGdRw)KN{-FYrJ1loPMcaTx)4hw2N@GC6I4SGb z%yY~mavKRM!9HRfBFa9M3F6JBNB<2oLEO-2<-#QLQ7Id}cbnsTm8UXYb@~+6!$m*^ z^K68Bqld4Fxq#53zw@1?FCesTW@Hv~Hw5k4JUq0qf5dbhZ=62@{4MY5r9)AlEt+4~ z8_fZHb_}Ad)nnkz6MSTM_W|(C8GN605JNujuIjk64saI>?iP9z3f$uQbI^fr>M4*16UnC(c!AtxUupdt=d0VV-&@nXfE>u3yhld}=V8TTekW^z zEam>?+n-%HZ%v-Nxfk)^#2K}P6FC1Gmz{k?7)BoWgnz`2bs(L4ST=d}GDsT^MzOM0 zLF(IA;^tHST%?!JFTn^6y}rnO~G1K+8-Ob0XM$0UtD%(yS> zf<&u{-u@JGkgzama*sh?s(o9}QM~g?Fn8Z7c@lNjulHDo>AIl~%h%To=U}n4$=}_g zmq7H6w`bwSyI2p+5u!sE2)`GLIB*8_)Bm2R&iUhavPQuBt}7J;t(xrw*CUP?+29{2 zGlY3_tU*Ra@>#2(2EAncW3`F)@=q({c)4cc32OeEz0>E=U~-Uvk%H=5_M;| zvX3Q{6#?byPR+d=^?(xj@kVrt6i`C$QtFNKfO59DK}$6gC@z0&wHiZ#VsTNkAe9#= zTMwOAm%#rnomZ;ni+$yf6VEVN4&S*ER0 zCTk_5Dj>aBYxhgK6-Z$v^ouTXK!PhY=?NxC&-Db&S7M(jdbTQ65cMtxkF=fL?t}Wg zKZlIUzk*a%veQ;22I^LPyv~*MfE52zX!hL%8QBTBv1$3Rh<|nhJJ|is!HKCbj)WtBoNOvfjp!7(ktBf2;SvfIf$1K zSg*Ah8i>2JdQVX4$fpF}4NvvO?`^}8MD7<{AXd9Id2Q|?5L*|=CwL8g@^LRuGdYbx zWT}(ef`vIBr*7)@#DBzjn*MS2>mv}h+4Z)e8S{f%1rPk%k_bYEj*~a{%Yk6%wL8A2 zQUAEQE7jlspnQL#QM672C_{|2;HUq9^3GE^+~x&P8lIh| zkz#;SBwV3T@&+jJC(ZfsE-P+~887Ql73?I*o1oH2Hwoj+4fL!~w z)~@;_kRx~53+TDy_jKmrC5sdw3;V|VPfY;nrT^RM01Y5r%r&l;nFG>R(v2_*KS+;o z(0A_11?j}7f_GJl$TtpNw75DCQp20*u@>J!>Pms2y7Oj`QuKSSE`xaF>vlhp4(vO} z23K)AA`i^@!!=|wALp_hpRamYAFbW2gY9Fei})5p%^O6YunR590Cn5!YO6rR{|GMz zf68t^9ns0Q?oFBK2bKz8^wp@NZoXec@Co*z6XW9E3YddK$*OxC>50DVfmiIc`2PJV zc*Akc3U#Pa6&!35h&=b@K02QWB8vM1clDqTI9+M;%q9*H7Wi;E5&s1p&+M|JT<97d4r65pFUvu5? zEgvX48D(OB6@bD&GtBwrA&}e3pTs!~;QYK8K+Furx=g)R`VaRVo+mM)r;+!nzSKDT zkpZL=UQVNmI4_ech{H$Tf^>bb&TwiZNW0A!l;??nw6KHgzibYWD(uL+v4a<+Oya_- zTbdCcZv7Gz`2*+VXB$45L;+FicD0rg>QjpL?CKaIfutd=N<k7(m@B*Peb>YfQtiw^e6T#k?TPQRuG;4)EhO*;pKI(UZ_Mt=PT@# zLA}42Tjz(I#mATw9-g42%s!rk*ND+5?`*dDIe0V9;dL$i)TXQdybksny z3HVn>+k>S2&hzyZo**%iaa)EqgT6=ov>hEoSPzBbQ&Onkda4&za&j{e94;+c%WgzJ zUB9-+Hq_H)7~FST&kN!^%6{JXg>ym2md;_a7KpJw21|RqLVcZaX15^bH@CVU-hb5* zMC8|sCiWXpfP6vE@b(tghI9Mzab8SRWn zFz%J=l==&szJPRhHMfHf>V`dpnUO(CAkA(1SMx3M@TreoM^d{%YJKFt3+!#S0oSTC;r9_XG_v$r69j(o zg}lYNM}TP{P1zqf4FUEVC-mva>V{w~}?6V2^Fa~`vcQp*9FU6ze*T|Ll@ zZx7B94{VV zUG9!e-}wcU*}O}I=$EII9XigX$p@4Z0^v28_>M8&Joq^M9p|x6v4Y=!B7S+wJYyH) z0@O#oT0fC5e)6-ls%ACnS}d>ZoJM@*4^{QhmPL@h5^2RdZ3xoz52Yd`)Yld57WU*r zo$z+q_XU?W0Vue zdIF9f|C|lfoZq%*?KyyYto*^d$$6m4eXlKkhx7B$(;ZQICxMdYpqC?Q3KXO1@0}62 zS580INDjIWKqE+G4g}9~Ife0}H)UD6XL0DydPlT77l%6S{m(O-JkBA1a>wJ`k3o?1uxuh< zM}O!-$)0D^QLjOZuok>rJ zCeBr?amDpJ;z2AV^?hQkHHbD>RgBGqfT+Y;DlZXz*v`+Y6k5bVxa`z$sY50R3(`a4 zRN_#t@?c4@z6JyvNPC@?(Eld8jqj!^=6OWTtv;)aca`qxyzBjnyze2FdtM0M)qSY> z_Bb&VXubN4%&o;h>t0go{h9@|mi3h?BI!V@ZnOQ`&JVQQfALJ&UZ6!(pBph(1KJVU zRI~3`H;ujBhbI2vyLQ+?K4k~?9WSq{Rv+v$cMnynuK?9{lZGE72dH9O?$7F3<2?3X zucT-oP&|Dk)ib4mLZg-p-$gv&xp>`SD$c>q@%+-8IY1UUcDRg3UQZ~ zFfA8H#3g55MP{RZ#b_!~ zOp)t(0Fpk+Je;N1Kw?GP{=!YnEr=E@6b^~U{DKJoC$CW-Uz&aAeK_WG8W?-Uf3gSh z&z={aCCP#Kd4ZS7m`@@u&6OV;z6$-iIVqPMn?SUv$t(F+G>FVNq}&x#2az3m4(k%G zfN=cL@@lJA5E{O(8QuLFgtX_#H)2tLdVMQ_Y=VA;c@w|iq75M6v|8C^E$UAFp9WP$ z^P*0L#I4J-ei?Zr3UooLSi+rjps(WP3Z5?o+OHi8;Y~k*_Wr}l zGdq0Gsy=tK4uzp>&-H6aS0m7lUr{7ImB6|jBV;_pdUDE`ALUjCYU7v37bWz88qz`4 z*<^$BGhM(XkPVcvzqj^u;(VN%W_SMQU!dr2dl*eZK4nOhSj>n5^2Gx_G^6AAZXG5) zDE|(m(nFTzOu2t5o*wuOl7DV@Z!4bx$@4eYPBjaIBxlgT!d=Xlicweoo~aKK^r}KvDa0d- zrtIQ^@H^Sjb|X-j3&eYO7~T^s$9!6im|ITh^TC5XN&OTMvtHOlRK>j`*=~z|3F5?k zh6fu1F;`_xNjX&#`-Z1aAL&sZ2sH%CG(1cIAY`euTNT=-j{ zvqx<5y=D&g-f8Mr6p3=8J&3_2uE$;R zsLR&#e0(wl_rIsgaUp^r!q@iGA_Mooy$1;!uVXY;t|g`wHiF>a$h2zbOCV@5zUgw~ z6%Z&q6yvhn2Ko5*V>&n6fq!i&e4^jNod1Y__lhR*&YB00_Ut>LpT4Oig8B;jNm9#G zsdAtniZ-ax2?n|)_o=6$&Old-(mGyG2ReDvtI+4`f%aQ$Q|LtzpuN~})*!1EXz`|joQz4KoujM>F@)<}&+WQ?RkpDd+rItO2xc$7-m6}s4ARXfJ zt}(F(qMBl}M94XX0eifS$#ClwsCK`#~0wTw?GmMK$=!3J_Y%Yg-V17-l zU5MvP#K}z@K7c-6n$X&|gu6f}=v4Lb{SOEl$3}UKDd_8Y7DV__1LB9D=WJ7G1hLuY zpYK0o<2?rQhn{Kd=Wgzz?VAcgq#$9<&P}2q{PXOkd#$J&+BReFNxFc(h3PnX1Ar_v*+c<7raVNNf`9+O_J;>T27!L$ovYWNBhdAFt)gAMfli-1{8=vw z-!sjGwsQ&CXL{SX>zXzd5Ol z-^ViZmcH-;P_nl^qanXT(Ka4W@s!~c*k+d822s0Rv%aEcKjZi9XF9f z4R9~#)xVs9cgjYdO0d2j2QliMyB>o2nAd!-H!%qBl*H$+XzASp;qD9OtYJ^*G+4{cZTl?H33f)3;l59P82eyu6{x8u)tS&Sk6;1K#US zbD1Y)br&Bs)4V*){tEyMMkemQ|evp(<(>1IQzo2da_LWl} zTQ?-!0Q#<%2A71!fKF0X%*Hv7_N9At#fl4Pd2c-|=AE$L+q*m*Z3Y_k`riXvP64&$ zP3o!u{7(GjD$n9PK&5|=nLZf|lxJ4;=T5u_%D#M=VprS~e{HZ`lHmbz$i{23&Ub(; zI?LuzDg#nlr|I`|7to&~+GY#~KsskR@oQ`uNUxqcWY>VWNtSw$rAre?QDyfp5p-}* zXBE4?bO)kH6Su+{^tE4oljG%o9wbE=w{NC}pgtwH>Vxu0kf4~566NzypR(vbN$3ND zO8(lTAK!v_{kHCtFZ)5AFCJ@#AWmhiB1d)Kj*Sx3y zg7DLqzc@;~kk`6=ee~jQ5Hefx3cioNg_}adO}8%NzLBi(7I{Pg!$9>{N1}m0_jbdo z2VIzxmc6x8TM2m2!w;8c%!9r9_(*umGSH`rL+o;BK>s=YtFcHE=tC_uN=H7>J2bM| zPHqGGi(&k@Kmrnssf}Rhy<7saNbguYPi$TiTXOv zH|Hg&AhqT!-+Xs8>gBH-TmN_nh>{Mi4c_Pvjm=$qr{gC25lu^D29f7Y&@nw=mJbqS zSLYp_h+pO09~Er4280buuKr@*kni2~rH(@Y#4S9(i|7zQ>}9{GLnG>c=d2=Aw_!iu zz}5>0KwaIjH5AGeN=)LlH%ds=&|9xy1XHxDTt1BTS`@`G3G zfgvb1)tdJl=zlk;DDvn5{ZpsH1)dC`KM{9Qqhg;=;GWOQKZSj!t(rS?9Ow!OReftj zfi@msy1I@9wET*vZqM!k?LZ)-W=ITZLaSE9F$bPn7AkMsFoW-w-d?)*IiUOr@94?6 zjCg;-j*PZapfJnSyYTKUxoGR~t|N#KtGPcug8h*6EPEAoq6Kkz#f*t$Vbr5KCx6Vm z1k&3RpJeSrKf@!c^>>L4Af;qn%Mr2y#GDwSxe5#YJz0PFlZ-$zQ74zvcpM}NR!P>b zomh{?t^ifU7fHc9hNl03kagnl*ySuBDEK^PsjUX_$_N{`UN-V4*Vw0uazU*6>s%-1 zfQXKo<+wbz7;W`*Ci*JXNU~0JP>((ULK4pamH1A&R&FZGBYJp#CbLwm<67h(O%fQ>are zIRdD{ZwI*b5`mIyeSDM9TcD_Z`kL*H`l7lgu7eu4P-nEmoYv?Aq_(;*@3tX7ZxR3J z<1r)jGx7y6{BUnKJg+u2^%;419c!1{E+C~^%tui{ytiQ6g~7chKxEvE_-TpzdCKkZ zxhx%!l-x!)R^tbWM2+au-H{+6o%#&P57akm%Cjh2fFLJ0;y0v?xbAdDX!H{h*Bc5i zQF;PmMHd?$b;W{c@AN;Hdc40NuwbHz_^t?e*d(0Cdoh9Xk7CVwLFk#l+_k^rAjCO- zy`uRw2%49ybgC)f9gHofm}0n(PuXz=?ZrGGlV0F|zstvR4eEe54)R)jjsrf; z>z&=|sE6Rrllt$*LEVMFY18X_p8z9bXJvtE3@|R4TKfN(2ZpbkiL84AFb?OcO&i<* zhM~}kpNu~+)>JmCR$m7C+>6%|S|vblva!fhHvsyzSm(!n_`aFuooEh_t9PGd0i#C_Z=|uI~r1HLcqvv*`6xB0*usW zql;Nvff4#J^~&w5z&KWQjqEoD4889jH|ny1K|ZK>O>8I7hqd1xYYfk3(i60%Rpdw|L8jAh`fg?Gavb9aaCE1C*H_EMIQe8>IeFB zizC)%$!X(W9+lbX$N~{z!?M6{h+F9;f2^z&1)+<(b3)|TfMC5@+I6}L2nw9AvlTK& z|Ka7+H*P-#{yP`kXc?Gyy14PtqZ6sX$76bl^*jc6-ZEI9w_t8{g?nEP`m`7?S3ivD zrURo<^pZ5*UuIPF8ol9n#QIzj^uc$CaaqN!Q!WL+m(gqA>F==^--WKKU4Qlh$kDUzR-R7C@9x;qavF6+5zViS zeD(ErN{zv3+d^z60!441=zZsWakiGMe~TQA8n?-7T*f28q% zGR|LSSLeca9tG;Rs5V_aFQ5h%AImgU$G&b9RdC@WP*RFD_M003g|22WQI!bf4DBBh zV%HJRV(#tVn1H&KZE7my0`$dyb9C;kX&dg=HLr0h2t5`Ojp@r95R z?^rJow;-b7h`E7z5*GG|Ur16HKMlp)!g@U9bU$+z>p`O2Q1k~vqJ)~C{vZ%YQF01z z9Y8$msH@miJ>u-Kln!_7AD(@R*0W>~P3lT58s7{e&pzK|8I^+Yct_mvJ*dlG9Xz-0 z=N%B*-{>DnK!4Q@-#!Ns+&c!(OlYvEm|q^9wp=fU`LhM}E}EEM-kN36J2Vfx-G?Qm z65@a-_xXMqZ_FJHj4%_480WG5+0B}_fWDlv>66hC(5o$|c~R9s_juN~GQ9@(c$OFA z9nM$vj|t(JLqa?JvY}}Zag)Vd(Qs?*A8|>sv3Spn%A8Ct<%|GIfykrZ*IxrgX_u2M z|4ks@|Kn;Ratz3FXRkMP$)e9x(MEtQg1(=#t6a<`Ksv0fctAZHr2ZJ)%^L{-se{Sf zZ%%umzJc&J+7Nl%Z4I53WIfb3UO91D=>ka7cYSeo*oO7!r|^S1MV@f*eE%h~AXS+{B|!Z8uVj>&&3e^-qD-2C(D5|}GjYJT^G-2e5a zlU@DS+t9CYG^!^Q?=6^wUmLuG{P-2wryn#iho+TH>CFrW0qNZp)-DOa?{e+YdFD6F zXMU_vy&wJR&koc7$OG!I|Cp(*tI%C=erG0;U<6E=lYfN{Y6FwGW$zR9BfunF`RiJw z0gT0f@Gl}eu`ZN*_E$;3s0v)pc-sSvtBs>=qTIl+C7mv{I*t7#hi4^V5$Ih>=G08w zPcF;1Up<9&*^*T@Ixh&c4;pTFf7=1=oUU>BCr_Y>FYAh3$Nez3*sTZcZWU-)g+*AI*@LkMa6oo^j(WF z0|{{}R;AZXAjH}|OCCo4gD`72Sz!v|X+$xdtzsa)I*sN)oCmQ3-DaKN2SGG&Sh=PK z^^LizEBkV=kGH3;5e}`!dnAKUb^-Ygjgc)6G!KKI-$m{{4XBT=4j*vkLY#!NQ&d_O z@9zZcF~@K5g7p1V-30?xFDK0VVd`8ieHnERn3_9Q zTHoCU<_4du{`miAk`)vp$Etua@AK*MfrG&4K2>@l;V>}nsOD7HbOPh_<>W%38mpYM^nQvJF#I7(hygv>^?TXS1f(Jpeko|l|6Xu*U zb2#GNPiYM)^)}`MMcC9u%YaBqwC>#UG6>f_*<|LV3qrsD8=e$LepddIlj}d!@f`JkbB)Ua z_3msl6oN&Mwz`nwSr6BpaPwQ)bJeI07q z+zO1yKNDBHHUPs!arM{ydSGzfPJEYt8u!KP@6U$f-0QsCG*I#!(7Czmx(ix?mLtGE z=Z^hE?cSo^ovlE9sk1R0?`2c>QjdyWI1H5D>*evw#XzxVP*|fnxQB4^CudJ0zkYxE z?I7wKo?qySXfH(EWFYUzhl?Pcxn()@4f+`Pzr@w9L;lv&yz-$W_VM?#r$@8Qfe7=X z1B(StD#Hl5cl^v#z+yDvDq#e;7yMb`^rE+~tJ^H0fVm>6hfOx!e z?C)n)sJGg<&WRoXV#aH^HF*m_^k}%0^byqcL|Hs^JnW43dTiVs;!(Ho)t&U_E527$ zr=dehSPxraMek+w9i|#ai3f%tFFRVNZeIla@-Hh~CB6cmf1QW1kT38C`FQd=DFe?Q zhkJ8ecXSsd`}dJoMuF)=dUiTQ6PTx~XRF_C1?J&`!}KtBV4D3w)sE!ZG2OE>Mn%JH85& z1@e~{?*o$019{)}vOfnAcYpofX>#Er>Vj8HPoyHBeusKK&GIiui^VQ4`E>jFf5`iG6{P#0Ia$G4Gt8T}(qMjlUY#d>J_yyitcgGi;>J@f$(qQt!8 z^iZEDxUQbxodn|1L;ZgQ4}rLpylR2#FA&qM9ZOnafav~D(!np>K;(k2O3`l2qse#r z%8;XhP>-9k#CbUo5^_DFv$hTd4HQY6;_iSzL@bk_D1dr5w+rbR?!ZrqJ#O`)4ET=q zZzUve!2HpIp*9&2%zsUVM?cr<&M)#)2YBOw8GUDC;p=H&UeU4r)*%PXK*21IDm7pp zl|Ef@>n$)1eX5H}=77o89oRzt3XIA0FpoXhKPvCJYvbK9#<^Px^1%+k*z|a5_yq2S zUu4~SHa-A)l=7&a4+-c>%;dMLJ|d2y)3B6r3TXR>lB^D+4sXmkQuzVmCf<_5-*z{l z{$U?C!L1f3K5<6B-8Z1lo3*7Ac~PnxqoqIJ1 z($bvoiQoSNsX!5T?{C3C96aD@(Tsh>kd>o*3-`f?h8Y)r;(N8aT=u151=eHNNc>i7 z^yhx|g0q?EUw76_*@XKbUvZRvxEkshiY`>FM!hIuCnx_o)Q4`%jWT#Rf_jn&AC?;G z5WN=Yo!bmR_0guvozBwY^-5%zCuB$_W*U-vRa{BkAV2qM&||2xkMA5%@J!5XD?qr8Su#r^U$-B zzxMwB`!L=-vR4i3!P^jpz8^wF_4+B}c_8o@$UIt7#XOoABSaTKT*Qy7i$q2qszvf$ zE8@F`!S@Ht5HC6Q0b^#uKse@3`?-77AoQd%!_C|kbtHpFpP_z7P;N@?Lkj8-kJh@& zq<_X78g{a$5awP^|A?zo!g}b<9aJ#D{84=gCrw+-t)|YJDF`m>&bKu+A78-ts^;=x z&9kP!tQIu{%V4#*+jq7oPxC0s=~uM}ZP!5fpMs8z?;YvaUTgSbFb zD`nRe5R=`)c{wQ$M70}|HwFZPh@;TxcLEC=oI_oBVx=UhaA5q|9ZR_`^y*mr_*YzFa`bw2*36O%yym3eY<lv0d08Vlvn2z(9+V}^f|~tGu)JMX6p%{P7TTt-H`81>#XjW z+J-onN`y{1>Qg>#5R90>J^tM9zlI*OK#?fp{^^al{N0SU2QD3`KmA(hcmgy}1x1KeZhA$Ble%$nm`a0`(v%S5#7*gFdbH=>IPEC!=1T zD>VBd`hC~(84L);1EC{}y@=D_x~sRY9eH{CCU1Fs8HRKJYW~v(T5MtbvoYkc zwr0PX*31X$`;v6lnRP(*74TyRsh}QWaQ9#r&S3?|cCBI`1d7(%*ts&ChuiGT#xLPK z=BQ|G=F1DD?`ejWZybT-Tbf?62X&}CQ{o?QyhNX`g~jY{%oS9qQ_NGF1gYm*cU`zV zLCUUTIp>%<5U1p0d!LqLuJ+|$B|laJQU29uN?a~Tz8ol*OrV z_>tNVVEz$NCan_%X8&YigBb23^+%pm_c0fd|0cT|(Q=>k3SI z!p-_$tAO$K_vlF0Zp0~nwJCqbpRR=*LFkNSFwK@&`;vj)Ip2TvsVmSg4sP!{913(r z1zu5q#2q{NY$oFnpZB`Es~U5GY2rH@>h9p4a*yAofsTAHY}%@G1?%y4DoU(R1t^EZ zIzr{Lkmp_FL>B_|1M`7#{(c~@3YIQVwgOUQ?eDwK0QY%Y&7(8tKstMy@t%E{pQdbG zJ{eBIdfYL6eiH8nShI;ziV8sdUSZ0Oa|1Et&=G6X+d!ldxldbT9Ui|BaN@x{ZR_K~ zFEmC$;?Mk@@Aq-9Og=GD=@bhR>gBUtU%7zL|0ep5MHLXj?w0uVVqe;z7ap~W4&v|Q zUDdX&1M$$PcImEV5Lc1&kUfUET%NKN1;=sJ|E89<{5S%fKSQQds|JAO5f#7isuNfz z4oceOhXL!*=S!yk;lQ#I&B$j40Bif)Zxic!V6pCXCK%$rxU^MorY9em-GzUrf^ZJF zqp)FL8v&S}FEbQQ;k>Mt@5FC`IM?6N7ydrFz0+i6NB{bq&o{YTvP-2P`0eN=~SM&2Z zAYH)ar)rCH*%no~{RXC3k6PlN5&UVH#^SJFhkClQBVt;2fau4w{nySH$iH8LAfq#w zGtb)T{tEBaK&QE24Ejj>qi?JDKLCk9;|2jM(vrW#w7638Il^N&aO(5bQ9mVD)0cYh4{zUgD zz-pFVKFD4KR>KGK?&KO^RZaW&os$68-3!~BW@mtvaPj`Wi7&u9D=6?W(HvNNl+s?W zF$31R<&Y#1eBWl%Yg(Ro0`obYBj{HdFhlPoy#K`j<_@RLhEu`7_;-BLNH`rB_vd)| z_adHbzvbShMeP3^yNCV>Ag*#d$fnbD80b4^h$CjIK>IXtyk^}I{7!OjYiz`y+?F4- zOVFQ^u%+B?nFLh&RgJW3sN2p>z4kA22`F;umC3D`^HI>{_4gFcWpX#2_6Fh}pMO;U z8y$V7^1bCjf6;$cJRJA=ggfSL2J@He;yr-psYzT!ZICiw{X0iG689E@LRB;JS*P}0 z-dBM5*Qy^W3wfBEol>K)K{^;DH#SbIgn2O3Pu!d_rBs zeEv;E)Bzjp+qx0=I`OeP4dck~ipPE8X;N5)c@aPVbHcq@?8WVwuIgJL`fB;fWezT|Z<_YoKxV{_F%asK-7gZ=8laoit?>uOI70bMBP?&r1N zfR@pDu=_{^&=iMyo9ZqjzCzk*@J$u_`vdu?--0kjk$}SmNAB+Txl&FY^TFV~(0^7depD*zMT50r}nMTA$N=Fkjoa=KGJ4 z=RkbdA7c4xDYUu?bbK+rN6b&fMpCtZ>-&+(uzPaf)qLJn=t zuA+iy$nHl0*99?$Ye$xd`d{F5WLHGJe+ul)CAHSQF~HvRgEv9e71)ZI+zlUifi3f9 zv*brMu%!d65;LTM&0BVQ8gourBTG5)zkc9%)YVtNV;Wcyyp72&$-pwLs9O_|jeSU1 z?XF5DFdH|VjJ3pm<7Z?Ojs6(s+UVo!5&vZ1_4;>Ch);UB8S@0*1%{BvLodupq~~5F z{H-zu`nHd%MyjY6dQm4jQuh^g+&;kt)vvI>YYMGXrUTW%?)s@VPoVS>)onMUU(U9o zt??x%kUOHj?jU1dH~cAh_V6^~E1?6)+q*F@LgaHm@HFaw{S%+rqc3rL)wg1E%oVDA zN_W1Q2~q~0Ev0pcceS?+@9)E0g8fg5*fncFa%^+ukHD=U86fjZNDAvBdLhhn1M0VK ztIaQjt_BIMovfxmtANlGCvf#0<`Q^Ik+?2;A}-nZ)3(A6->F33qycl(4fzaisj&pH z=_gy1x4MDY&agZ~%t;Z|@s0=(Dg)trLsysMF=s~gOVo{uc3|7?Us=vG0k-uO&$9l# zz_yTB;VgLw>|Ki%^q5#+Ynb}1*+2odJpb3D?>&GmrF&+jBpz4`bKcn>F9NG6Lr2j6 z6R@J>6{%du>eNa0q5{2 zL;Oxs?yfsV1$x_ag<^ZuA04DVW%;5WVrY=H zPW1U|cmJ`w)sFRGbx=d!gOr|D=mRU%|GuU!eI8p6#J%^ge5a%DaNzTs*dyp8@yM$e zVP8W%_S923tzhJP%boQ#O=@M>Y#8HIK^_O_bhb*+i&=X z{m*h>`||EM{)Y?LXWXJ@eUgBEO#EhiY&WnSxVy?Krhsj{TP$cp2(VTE-nm<|7T63i zhuWw3zH#Ik#rh2c>qTmzno$?9LX@>cP1S(4P3M7S`z$cO{ta)LD@I%9VU*=!@!7>1ds?*>k1d^Lj6{L_=YDcm}e6y=DAH82u3aXm!oCT zuW-beH^>OYFYQd=TtK~w%>MthQ<5=9MgRK4-+Mvyt;D|VQ86IWEZ8U;s0YFtW$R?} zF|T2K#nTJ*k?ho{uK~Foz)sG55yr$m68o_xBcT@95xY9H#Qp>Jx&N~7Y&eDWsqxu$ zZ5^_!jH`@5A zwxaH_RO*NPjxnHZsJX!saRq9AW=@K8Bl1|h+mg-PfD&)u9K8*3NRHCHp#kLIPZ!UB z{$q!_l=U6oqfjTb=ihP7Xl0OoDZ+Q2?-oe!uyi7=!koHirOBC9m}{d=+a)%PK84x~ zXUtHCNYsBBo|KRZl5a-$6S8psuxnL19gFzm@X@re#6uu)_I4KU%~hBq@0YpTH4*hf z9ed;&N>Oi`^`;p8f#U7&FKGPj!yI{cd5f2?KwQXR_-+c`9o^TYdFgsK=Gq)0_K4M^ z-qhHpFU<*rd26}Na~}i8n_QKbuM2_wC?NmCCw!;MLhqBVZ2@*s26;K24D8%D^s`4~ zft^CSwdK46u*0rcW;|O1?9&?pefIU^J10qX@%#7x_pB)Sh8nQRKep_~`G++oPAc4U z1XwrD*6rKn04xJ-@w^!9>tk8%F$35~B0uIfb79|Kt@5f6eW;AGk(U0U0buOdsn$EU z0`ylgmNFANfo@KE>T3QHXm2*CEqxxq{hg)j_ZI!WHM-A^en5S&%9je-k*`3xweMe^ zi9Gs7|23zE90GEHin{cIG2$!pYFc@yZ``MTE~^i7HCx_q`Y46@=R4~ONgfWEQ#Wi7 zou>~{nj5@cd;ruzTrMgM5klVN%SBg>4b39b!|(ZGC=Li&2@8sf%vWZ{V+#P7Fo z?EwSSfo+{kocRFs@6t~d&fLVkWNkTDZXW8n9_-Ydy$G~}VkxP(&r-XREPR`A&eBho z$#psnl!tB+ak+@6FkBD#wW01ee4+aAWG|2=)tATK|6jMo-yL=rbGX`Vj*BZH?xio_ zT~Mx$^$?fy3;qXEYBrkbA-I1$YWz$l_FyiA>67X0+93I)XIk%53rOl&Q=N-%gGB3t z&Ff8?LBiovk-5Z2AdJ0mtMHQoLXgAVzuN18AaRY}=z1RW0*yOjEp$L!KWrPT#vjD$ z_i2W8-UG2!uC4-yd_h!C;@{#Kd7N`2LZ`Wm=1N(~U$m2SE z-%c3Z|G_nh{pHe){2f@&wWONMC$0i(b_XL{9lw_h?}y(1qv*Qhsc^fv9a$Im+T$*g zk?a+nj513`WNS&0l_*N2B8ey?krD|Zl|mvZ{E#vu*&{-PqKx;vfB9(qbD#S>=bZ04 zhNnSFpH;)3#Rnw6XjUy58iAzuez`~6_9Opz=W78s-jhonj)e{tAi=iCW~iQydX$NPwWA~w)l6?9Z-*LEbqHB%Nj_Ps(cO)KB2DhX0WU_?oWKG zJg>l~fq9w?RvgSVAn@$_kpI@#m}B$BM?&Hr@YlXp{=$$0{CgvYGyeO5^SDrUQ&2we zo$_XPzez+q@)Ym>o^Gt;+~nyai$d9l~E9GEkL) zo9Wxs$%g{K8D7JX6ml6D&y24W`zZm1E#anOR5(yrLb$_&qk+7>o#!@j3CIgo8sn}x zKpxwoov`8!2bb)?J@Q*Ktj|uq z0|}aiO~m_A5WiRHXM7BG-9iaHPc~2&982$&%{qZN{bxC?7Q}^*&D|Vg%|Sg~|Fws2 zQ0J)rd-(Cp6%bAr*wP=Lbu{fV&eZXmC5S8V6_|NYstqbCIGNZW}0gEe^|zkH_XbR`kUsn?oj-RprI z6d~}&f*Z(ti_`P%&*ME&xjB854pP(m)wuH0K`Q3xzS$K9#9bzy&bgI?WC=BC<%ulL zi-*5lLBh#*0&aHfEd?|j@Z{h z#2M=uPLU$e-{UhM<0}9nyFl?u<0l^g_s+x zzi_{`Q$K0*1m>XKY^tib41Dh@NzC);KeVpG6Sc85sx9V#~*PR{`X!T;QA z(K7V8CC3b=F>F^KG*+b23#e@Sx+Bw;l9J(eKB1dz-WAmysUxuLgUi3 zhLtW*)a=JsPt^lOu``Tpc>*Xj##H83{9R!5_>o`tfx-}D&ELKY$luq8Gcg~E+;ZTJ zq$$>!Cpj^4eHB<&m|C}=*bd}F(PI|1Pl2py+cbb6#fzj-lT{rZh_geGZ0C{)Rkd0I|{$ z^Gn&N3zn1?7u~?Re!1;?O9$$@SI_9&chxr2U z9h-h!M&0iemvX{hJdd8hBby|F^eR+N?WGjz;$M0Oao~A8JoAr59(gROY}4QB=+DiR zG3y`_kawSoSV*{nb71e<_%QZa3M016+aiJQ<!WE!c{F2XGE(MC&>%~FTGgFMD7!@Ti14UcH{eV*yP`1{bYsWdBB1qgM{OTFL zXEJ}EiC{l9%o*&EZV%+QUC$XOaSqAI8rDn0`xJDUcha>S>&boAD``$Z79~-Rd|?5p zkL+%Bl<$aF%0zNJLcV^c?T^2k6Y}?N-{$IffW#8D_V{+hRs2rxxcUcqlkwtc|8@e1 zJE%xjl9A7P?_?gd3HhvTv331Q@|g1>ZQzD^<|4nZ5&eXFaZVSnTB9{%UYFywum69y z__Hp!kDUXdpjC6}Kgff8vvKP5DFQ*0*am_A1|Yq>ZY7!_4J5f84yS5S*O+x_?71lV zMnuh1(+yA`loIxMO5-Q$Oc};AtF{AwdTrs>nJ(a`7LL{#p$?+3fVn3T^EI>|GhNrm zJur<)&ifQg5I3~vyxqq%xCo26;ud z23>M27YJ8!-HIb%E~oH`-hCzYAawTk-9s1MKycue$BXUTaPQUDqeHmIk5ra^D_Rcs z_iXtb)#&gNh<8g*_qU?IiX>zFiD(T1H%Y-p|L36yUNoQQLO7Ri{znu`#yN0o*R#PU z^zjTgR@^{6o#O0VZ!*pqub1uypYa94-Vu$hN2YgnJXpq&2Pw(xNpC_WqY z{7(+zIX%j3s2Kr@b(^ZecPl)X*zT-lFQ7<|nyf7U0t)-=9Y&)lAWys%^*_`O-S<)65^G*tY5{Aah_)j$;~S|4pMigL)ola5g*=nMCaCfkbLY% zbxTV{UNX-qF+LL{GHtudZoLKxLZ^VG@&_92K(^gJS-nFBFPncELh|0-J4 zop5U*7DTyih?lwtK;-yFc@XNPglpZ7)_JXfu*8({-jArqK3{(6Y6%?#he{fyQdJO=}o#1*c7;4S2-2(LN^ zJUvCDXZ#-n4_DoZC2|vR8_RP!FrNc1njgV+I1x4%{JC72BLxg|$4*}E>;THO`K?j1 zZ9s{Buy23YexO9WO#HWM43sk(#|P&=1LfG3!Ts6z@Ajvr6eZyMrIlJROvL*nrki~L z_l}TPQf=cV5$|emXoxjv2J+)65wK7Na+tWqPDW-Rn?-J&+h&Ql*Dk))|Klj-jJM`) zhafK8^{`w8^%S)SZ3eA!K~ir_-=PL^lxIB(5#RrU1U>mdmZ$=VCq$fjnIH*be>T*k zn2=9&If1>P%@{2e>bd1M#+ZWL@S45IK*gJC>sVGiufF zkOS^nU=rTpPU!^x$oo?#C0Kx;Epp$~6HlB2vpM`0@Vye6HGPWnEg@%bXTmlO%sVMz z*q<+iIa&Yqz3fE(?~TbJ#kt$qS5eqM7~%e^E$+mltrn1Sw9QSuY6X(Ld&U@lwu7XtMg`xYL#Vfp7-V{d{D|iD_Wq!Q zAb!8fU1&xfeTtznRvv92=A|UNR*HJMdPBS7q9Y(mr4sVD#(>B<_1a5UToLDGNvCCA z0AX3FPmlH>o)}fYU!$-a1jnKsJ-DLqJno##pT>IrtnSkd1LQx*KiU&61Of5p;<@Lu zI1jSbMMeu90fBIXgBCY`V9th}s7Vs$I-DDgQPoDj;aU%OO(Pk3K(S&=0?z5&$%JeX zLm=EyIXUEsdCXhC-Z;lO1H2(C`RNzuf#)I1{@R*);O;11aOA;#Nt?UQvfF6@=QwM} zP*5Cf_OEH;rRe}elTTx=@&%xj1QvAp76GM*L|;CA9w@p0f-}|{@q82xtk`|R`}0&M z{`)JS1f}f1ZMPdJPCxw}`n7 zaJPbl>HCK%ji}2mHILV<R+n%;<=KkS;f*TbUu=CicApFQ1AT7DM^GNO#P?-OL>eXN% zf4OpD^!+g)=WYBa%8YeC=sI0x-5kjJHs(oRzXO>${A#TG3&iKojn2*@54QWay3&dFKu<)i<5LjD;mll}&d-_n*Qws94vzPv)t_t8D7=7!j z-|T>I=B&sQ+~2?#Ag-1%$bU}Tk?U-Bv{#b*6)<%0sTe6OiN> z_%D}{d?i4CBHwcOX%rUAueQO1FA8z?&W zj3-2nVBhs)cO>dj$>V>j4}2p6xoqN;QNeqh-v>9-SPuc&d^6v~+8 zMSds@^G8I#TTX=oNBJ~!Jib&4+wSGf4Lj;7CAWD8||EM z?#NR-*wl|YQ$sk`fxK*VrQk!6@4!_#vFT&%H2T|EJU24OVKa??S<9RW7}A2e@(PQA zGBRV};`tURLuXn4?3x2gucX~W;#r`yjOghpoCeD4&-Iq2*oWo*`FWrO>&$h}8|63j zun*HP^11pLD5mG_i!hIeLOFQ*Ybf?xi$CNWeeMFe&hA_@gAd~OZzh{^u#VVUl~z_F zt|F#U*s6xS;!FK4>2BC>DW6X3FY86!QIL)GLt~H>$lG7|3H6R)AwD)Gs6!dF?tW%P zM4e-9YM*)|h}{|GHri_mqQAn9oR>n}efJQh5PpD2>ZQ!st+gOLG2fcB8}qfaC!g=} zyo)*J_j9*Z7vNr!<srK9o!=9rZ*xd+7f0!cVHmYMrF?%m_f$Wud~$kLOi zdN_v(oKVlZ^+OT(hp)@c_v`|G*W}D1<3qsLuS;jTi~FTL+~XIv3<6{IkuNvmv=t^i!!Z@ECo3$yuNP-2RruqlbL;Wsz^njGHo59=D*k`?B+IE=n2=cluqarHk zGr7KPF=$%=h|k_Kw-hl$U-hZ{bBG&>g)7x?>nM&p!l|Dl8MryH+?k)K`X8r$jwdVj1NqdWH%~dS?^1T+$ejHIQbVlV7f#?D;*jON;|uB} z8|NfS%r1hYy4$%j_=Zo4bIoK}5YB}Tu}W)QIH$iiePoNc;#0x$c4hQkvA%Vi;WGzO zdmSc)`eYEvS(53YVIBV!Wx?^F1cY~$-xJZ4LTCl8YGJQN0}e`3E| zwAI@Bg$Cv?UXFde@fnEW)VPW;+6D`qOd5NlZlr#D-1-$2X>V>v!jY!Ta}zb?O$N@?Y6x_~r^wdDrG` z-@5{p-SZR2>1m++`;T$j2j{;jCDFX(eylS&9fo_FvEIYqWX!dqqzdg<<}(3GpkZJa z2mWq4^0ej3UBo3tMjeu|znbENo2ItNa}7%KiCqKo*>@wai^Om~9E}!DF9xZ_G4)+X zkD~5tSMA3J)CYYv(erV`xzPA%dR^Q#kjUq#>Yn)m5*)e1_3@aOa^$JR@^@_ztITLl zJfHw#JR@9+`Qsq!`bRbMvl56DTJ3$1{{)2pL|jkTXTUu_$BG}m#9W$G1DCB5SU-Nw zE5@RZThPMlMfG095ufb5xHCr+Nc{@@dlz^S6bE%oRXaMW8QQT)n*!A;?*u=Giw zQpDwB=8}Ob8Q01B`vg!0NB=fyKLhG!S<>4NIQK1kjG6x^$NF;LT`oKt@5#!&@PioXgK%+E>3l7zD;IAA1yf z3VGVx59czj0e^F2H{Ity;5Yu;CTYgENw(jZ`CZ}U0%3-H%hQx$CTfFFc*>(@^M=EGV?f3g(s#-=}_w$DAysrX=*G zaIzKccweFo9GTo+vX5MW!RYV(lzglU9vdXJ2W5ySUU>T<^Bm55>o-#0bOXiq;wPKD z5S+(3Jh$G%K59osWw>lB&gDkshFgyTMTD(!Rk{W1_e{&pcbD*eV&(g)i9FTEgC?tQ zHUqhM`NF*<5j=-qTzq>v5zjgh>kzyTbwrwtdqoU@ES^`^RF1gG$hoH*Pp%+8Lh@e{ zLL6AmGG}wM4M^7SXL-(~3X<-7Cz2=8uecNi&&VH7bME+_qm3++zL|oc6 z#+$^j{^ti5kT6F(+&^1BMG1rj$g(9u^SD3uNrqc8>gs^6GPUg;2=*8qvaE^0eXx4B zJX+p^AYmzF^Kax)ijN#nPw4^DzR0wx`4!Y_lsaSnab8Fli--#OROcRgru zg))V6f3*8`7sqEHu;~b)<7X)FbDYiZkE8(GByY@Z1DyMEEE3=8cK{{(Ir;IPK*Ude zJQ^A714{Bzjgd_dP-45v<2bSJI)5uAE(Gg|wcsei?~R^usCwCIPLGpKpgjf8 zdvzLNzEG2{!l&n@*nhpYZ7ysAv8Ld?uRer=m|5?CW(s^D+I-W)i-I~}s|4#4*=8Wp z)xz!N!HjsYo~m0w7YI*w-8NE19o?CD)oscqm}Bmudsb!>?jzOY_}M##dQ$MxQO60pC06;hYd=8AKO{Og(Bi9kun)*n?H zM|}8))hiF2*PZ#Ey=7!a97VdjxPK?&C|b={S|5P?+eNv%}w!(F@W>+#o#8(Axj|5D1@A$z?pe1VYOXmu`HE1)<9p z-wQ8FVNSNxw+Dzj2<8YJ9r9%bK`jYm&PK#rT2%d5DsKSkhy@qZ$|4ZgTzvA3kzY)8 z6_(g>5QyqVua$Am5$Iso4BzO)dH-Hg%6ZK15MpB8!q|#ArvndWhs=O4*{mXma2Wk- zZx6rU58#|WYhBi`8Q-(7 zTb6~)6@XHg9!@io!2Y+wMlTT0D=x{g;1$*rA59CFbnLTCU)@_=WJI1(K1|bY6XL)* z*&Ek4kXO|AXgGuQJ(I_Onwb~K-bz18NAUh=zS(M>A_ruK&Z6bY2Ot$MOJ(bN3{t{M z&v-%%K{A7(_i9HXNJ@Miw3ao(ewfKdgcIuwvFy{ae~7EZ?r6?p4*;?CpT#oIlt3&n zR^}xM^PQ&p9v@_|2GJv3FWvsn>kfGnZ4NZxdBnfZVa7geSe@_iFA4}B+ZVPbfVpSW zZA}|y*arlau8(7`pb*38{wabh2;Okg?e0X~kR+G)k9G7b6i>Iju*JPThV$oFo$>SU zHEHVQbuU%YuX2KzC|kg20$ zct1YylwPW311YoAsX41nAo*Xr|BF;I>V%lyiE3R!|Bv@0o$y4EP_tj0SHhg3TrS%; z-k6g{oTB~L*aKowAG?!OkSF<*!Xxd2IyxWK#e^L#ATpN1yx52Hyn87F!-H`U?mx41 z%9jelu3xm`|H}oTp@zfXqCG&!Q|CbZyIa^NQ&jaxwIF!b&-G$I=E$>&ozDx~4y44 zPBS-tz;kiUR)4>%0MG62=lV4!plXfm?|EhpRPv=$EM}!ZWx394?a~I6F&?-(CW`o^ zgaihb;~d{oRju3wlmJa?jvT&+#sLy1AA19Zl&0CYI*5F4L)u`{5|E!r%uI+N?|%A~ zk;sKM)Tg{$43LNhspYVZPpXU{71B3UD5DFKi(Nsnh<`|Wm#QXx!CbDv@)26VC`jzr zawy-B1@Sj$RaZFvg1GF^**+nh8*ll1s#lZ;F=qDK4~1SJdisG1Srm11lX3@mW)bgl zzgf;wguGR6qsA{o#Odwd{=2gu{i5AI7pH@mKBJ0Cprgkj`_+K5HJJ$ zzw6`vn3iKc-AA=wr;+z%C|P|^K%X@sc*Wee7FY{E#B6P71?pq%j^MZ`pgw~BTkUk9 z-nZ8iG!p@8%Ee-t$2Wi)^X}B@>Q$hI$jY1RY6107`MSt-15iz`cu1O+VV|5Kb(c#I zs9Xf&i8x!JOf2$bofrm6jcZHwcn(l*AMZ&!f%urGg8!^F{=NG99IZkQ?1!z@tXH}a zpPxVda0Tl}eBJhqU5`*-HyvZOKnAiv+~>m+XFw`D^;?>D14xObdj~t1BERdKP?fnI zb=imd)_c*vaPr-(a17?tb_~ZirHj~|qLVF#k2=G@)E zn6ou)@T>3Z4LpyX9uM6$K)8E5ccMlL2=8ZQ61Z|7gj$NSYUkd8kfp@E6k%l$Y&F~@ zx`97!3EN8;ynyueOkIyM&XGrtm&gCzjs4UYtNYJ$fq3ziprB|v5c&T0XF8+aG$-i; zR{`?yx@QzSIOT!A{dQ%7KI-Xw#_ezC%m81HhZhUM6Z7KLe*G+*0oL;Y+d5M5``vcs zWe4_a)KBMsx_$fs)c=l5Wa)?lwPxon)^mzLEhS#QE_nc`_ohekW?$g>bR0S*;R{sX z9`zMXyf@Zd%sVRo;ky?8aR;3d-!s#(jw!@dh9g>39%8>$wu{Cai9G$4>?>o90zk3( z5T<=V6(|yo7BmrIZ7I{GO36Fd0(Rrw+*Ue*XQv<1{eXDy!&Vy5p`Qlb7JA>!-}%is(pYylF8c%pDWO(XuftOR%I8671z`~$DBAZ z!Qn?u#4wy%0sEr&SJCGVI%XvOLMqd^C(1O@ztQ*ck0ihU>fFU z{=WI-Jm)a>wGOrqN>Lv#9-gRm@ip+5{@u+O!H;u(WvVv%K>1#2qN z`^UCqP#E|tD#v_1iInOl;hiTF;hDWw?~qU2t(dQ{3c^OAotx)y z-$mtnW|v(fAf!P!y#8V<2tKo9{;7$)yXuL31#Gw{yv%`*P`!cqfNVZC7MLegcXarV zqdC?M&pmw#bs*69uYTY801)sY4k{oI!oTtGFmpco+iurumSKlsS&Xe|i z(Y;1M$a`VQX0`yVvVRwrgZ2VVVm8tH>lDz$8g5qR^#hIMz;tr=4WMnluS=iA`tq;9 zKaFJ;sNXM^dVM<$)X$2Y(=rP{eNpS*YQPQDWUKmjF=jvwn0c!Gyb}9@l4!^Gcy8op zJkI>#K>5YD@4yNP`L4-Jt-9Y3hjf|~JjsQ8{I$1LG04x8(temcy#VB{qIJhx96-J` z&k`Rx31q8id#K0;GDqf_6YhZ^b+NMQs{-QjlOr`9+$QLU=NkJoIt~&g2_jNy4j{qv z;irz-P1OC$Zr%pM`VU%Dr1yc)v+$C@yG0-*AIdB6Nepv2F0ry1@PHuw3V#y%SV=j7;(qn$ zg9FkBb|!(vFPa+(-Cua;pZ`4JKU&+*2Z86IXuf0^-A?53N0z(cc!L>64U* zdTbu84~lst^zRf9ic&Fu;965#Vu>!WGOb2kkcaMMEf`2`^Orqm1p>FAz#7~qmwv_dB0hOj-CY|MDe!|%SZm|&heKfZ#prT47ni!I9KFcR0MvFv zYdZQLs6`rDL!T#rdYKmfT@vRRhb;`OQDQ*d;>Moqyn***TCc4`8z>d?fuC)50VO;s zI`=j5U$CNEynu7ahB4bw6ctFcNc9G-{JxVd&P`f+c} z9NXrb0D>IkAAa5F z@uKU$tQSDLpnCPQrVP-6_dXcQzL6QJ%~%u2iyhx4W1lk}&E zi+#48dm4*%{Z{>r$nztJlg-^RUl9ii-^%2hu}IX@^Gx`b;{1Ne`H0Z|93X2Ej{Vq! zzJ-owe{;u`KuWERcy+!2Boq4NnT#=Sa8gZ!){XgsNMD=8Vg6}Cki0OHAc&1#dfBpu zI@28)COTHAzfOI8MPL~7wU!f}BuvPHh_i0Y5-ajn?~(%4;3)1%jx^3E2_yda>-ebG zClKQKSR3)q8w8`6UQr#euUb7PfATu=B_Whxi6eEQL!Rx^4ZDxLdq}5; z%NY>3OsBFM<9=7(>^e4Y#3ApFKif5jJ|2a>y`tS+=!-sWPnboY8(GFVV0|C@+3qKh zF&~O0^HluznI52J%JLY#%?4U}>tTyRW}w}w=d(V14QMe$8vmOmpoP3y5l)K++Tr${ zRfg3-Gjki-HG2`?vonjrx}8{O6mx=)zXa;YU9!gwHlV)x=5L_Z3Dj%6$83kr0@dEy zXOo^3){{o>c!}pg8BfcY`xpz9yeW?t_mMyG922-bmyUD%^FHSTnLzHl5@|Y$IB;UL zmQfxH;*XQwqDAO~pLro`V)zSvqarI3d9jFV9o?#3f%wVFzYsk`%onmSpnl6{2l4dE z##B=~5SyX2eR$prVg^q``GSy7yu07=qp}40*T3huUBtX{CpYQH9Mt*NWN1HYcn!i^ zV?X8X@kiW>c(gwlebQ{?b%Rs=I0xRPPw1Zo(wyH!hsG8low(L9ma7BAiO%0OPd@_j zxc=v!3LOymQR;F1*G&)zkR+KD?nj-FZ%f0x67XNW-Ft)q=W@XdzdcQG{>u~H9ff(V ze4BjEYXw~e0$nBPg3AeDxtRZIQbHeS6{p@FMjZ$3)#mCfVjj>+27~1tih=fUN&KX> z7oN|4JC5;MpoKFkM$kw=J4)P~$YKGs-FK7Um^}j;t)yV|dJj-ny|n4%t=KmYORHVf z$2mqv(IZJ0s6L5r51+L$J-|pVFkqYGH1@>*FSOVqjbX)y(obS~Vy6kLR z(T}3&$1S`9XfMwzN}Oe`PO-nH>3GSAaf+doMSuY#alTf8vU1D)}Jd7|PIh zMizb26?5!vdq9}}ZbL!==koXqAC8zF#T?U)Q(vQS9``LOD)T~~Wc1JbC7kz3E_Xr+ zo!C$HL<&`A5rOD%=je;6HW27-EhzKA+%tEc{G%tbQ3qj^c5(;4Q-N;u1WC-JW3)Iv zdsZ9s8vp*%P(}UR9P7VMwrU{oFuVR;{{t*X&J$i%%mJ;_?`_BT2%xnyeiKs1deKz2 zqPZP^uf83~L;e7?qFmL(=ZHW{U3$p6Qi$(bQr3ez_+Ggs9S+>R4`@3$ea1EM&xs_T zqfb?UI`L8b6kQ0YFYU-OUB*C-Y#uHv4hO24W8>5I+|4 zY9H}H9e0+K_)r;;|B*y4dItcxC_f|%7=i4Tc%yj$`z#)Y3%RL?qnx(7IN|aDBpbrI zR)SF{B>Z#Ze8@UT93#44)WBS!l7O&74Vc%sI&pL1D9$04HHNF`LlJ#2BwD^H6hu~) z%*;8pFo!Oo=!yaQ4J&?p==NR!Ve*zzqy6I`6r&&?wR{=`mxeB@8<*o;zCBm+6za5k znOReEIf1m_;L+L{%q4H?72By}0Yua1fsr)yeg0Rqr^osZ2<#m!<_|Fk{w~fP$-%+E z@4j`-CDjXcLUN~nHy#GQu)lZiha>=@=kr$|oS%5-e{$Bc6M@C_ZCI?GInaLYIr!|y zd!S9XtX&Zn0ovH%nqbfGKHq= z>OnN8bFZ`+>fqO;BRdswub9LASOy0R5Pr37gRnCmgvFjq-V$>Ip-V!|lI`dhncWq$ zQ@{@dT|@#BMp5_B8m;?%%X1(Z2P-5Ulm+6OPhv0rCIeCTymy5l>K`gkaDLhS76kMo zPP}+B3;cD(C ztiKzfPMmhb>bdj7%|P>daQV_Q_Q!BIC?swTX#7t**!yt494uyBw!nEaKiuT->RE~bC@!1QRGxLa(c=%Ps1p?{)1^FP^Bmeh*>P8;lsfKRo zr~2@b?7sp6+XfH3PD%s*=Teai&r!Fv!%r#rIt}>h-;{UN;ocX!KWj#={HVXqFiq>; z47}N&69t`YfJInZ!&Le`(4`u?cH}$;y2Or>fx>@4C#5K#{>P5zG_WOh;W*I#Nb2Z5 z;{@8E$Jg1j8$he8)b_fTg!N@7UFnPp))m&}LsK(Avy;DI-xCKknU4+Zve;iO@^8-L zL)@!M^z_}dMSQmi4C0~IKsA&wXz1%eJ&UhSd~Xf*zv{x<(su*JFKbgl(-o}i!+)e- zA&%9d;%wDc1LTNzD=c6MWQC9SR19b!RUj~F!;U`0WoMt?TEUo;GOmQ(VJ2?s8!_WP-P0xX*BT2e^ zBMfM4MdJ7FDFF53(r{Uw7vd|D`##v?++t(B=x0bkJ)kwZ7swjh<-I&2K&tY!qtXWgNU=@qZmP4!yeHeZ z!LV&0kr><^(^7~zz@xMre$0CidJ%Se>_6nCY<5}4;Qe@#Df!b=4MaAAZ~WVQ7ewsd zw(YS&y>E%zkB%2^Ak3?t-v0po(E(eW*iGD#pB1&sYs4G@!$nUGMf4?<-X(q1*^fNn za$KL!Zy?^8&*(djb)D#2s<|$Sei5h7V8R0eeD_k|?+WHINvk|@y^DLQy4{cIDga;3 z{o}%-sJ~Y66@I$Q00^;C$zhj|V7~907s)~%!2E-;ZqJzxpj*Vp>r>7G-Sp>rt4a^h z4FnGGzS@iDvr)Loy&ve*YDwp8A}e;e>w)frv*AN)B#j9s+81#0jzHc*KXtBrh1DUPAIL!_v2T zpmd#bI@yo-$+hLkNs0mT^cHtIy>yX}zkguhG9UWiw^c42dkN&7ii6o|-w|JY>ewoi z22#X!9o3L}%;C^j<=rm;5_hdV*PEO{{A3zQ||DfH0@!gdqX-THa&w8Nb;Z+2Xh zt+5$%no44F>p)l4>3@4F4CsP_ z+d@Om0d3){a>8Hix0)Yb`khn>w5)_s`}>G<`POW#&%5Kh<>YbX#8aR#M9Vyh`wrCF zfUiMbh#_pHx?^_r9OAwk)*Kb9O72N*?)zMFdvI4u~01x^RXPB9u@O@ z13YW=Z6}B_z+7ZTFAI_ZdQ7#`rk9>TzslzRCKK<;g>QGc(a%NqH;=xJ`)=v3j#E8s zu0Y={`gY^-NubMSs_{6-V?VZfx{N^yX#G~X-`AzEA1*IH)zE?Xi=%#-I2X?G4xq$_ zKY71#pFf7Y$!F50uVKSLy`gksv#vi-_qcMaoZtq^YNx!!2KKo{O_FMPhk)V|B9*uF z7W-a77UPp6)|)^dnz*ZX+p!T?Zsy20ov^ ziul$1E<4tCCEV9j!Jy!U{vBVZOeZ}G=4Ub6T&~2u)Qs^;Wa9)7+21ccsf2#R+)tce zpW}PQV0^>86ZcHJlDEk*Y(n0{K*z^l9|UD?{P)l?14s#z<$14Nfw-ZWb(RJ7@cu5J zRWJTSUe>@`_1PAj1DkrR@;8A0+fco3IOYbpdQ;cRuRJ|?g2fD z`D||u577O-wnpH)LwB%qRrx3fbe&6&vz^L;E_C6*eYd?hzj$zVH^~64*4)xJqz`Bb z?l!HM6G1!p;oE=PC_t0UTaWtb4AcSDi3>)`Kuu36-YljDRNGAgB@FLTpZan~hY9k$ zTE)`7byK+U@*H--8ysymn_ z%OD<4RI2hbMSWLY!aKoPb)fiXguflYK3ME#MSB^}A+`C*VT1TydCKgW;B-em#IV&> z2=9mWWskN8z94zyy;F=B;#l<`)=izzAH6OYE1QG7l;*+cYRR3Lv+;Fo8~g{N<#A$q za>MAyHO->tTmX@Mvwf}qEn|Lw)0X2!nD4jZ^Lp|_D+t-KRV-ufpx}#5B7@DZK~Tgh z_eBu;q9fj~-QR=0wpp_%hxRNWy4D_f-ikTP?fh5$d0j!koE*;^jXe2>wzmF5*jMc) zIFhCDUNqEn+evo<-`?iz9BtgY^F_Sk_{1(CD6sIkXN&<)o`3hvMFn6E32zJ8ZwvIA zp*oe4zd(P(m#ahc1^SEZ+f{3MK!22p0h*COzr`JWPHq+Gp$xSOrxt+je0_fs7uFlC zh8In;+(74TOL~I7cG}Q?@u{qcFBWxDNi`EVzl(a-r0`)Kc|V~KiZkxb!aUS)i_o$hhl29LS z#!@D)h<={iGWn-#a)#=(n`9rR)|EvU*}ixs7$B zxZqE(&O;CsVDc|a!92NhiFJ7sRzMuz`F2%*1c-JsERL3lTQy#oiYp5M0q9Ls{AmpQ zm1AvZ3sQhz=c=ad#}3q&=ByrH+6{aLa_pYj=-c`4-*+FCJ3x@s_%3z=^LKCT>7MVI z24>Hp-yKp7KyMRrZeeN!dh5=W#la$=e|SxAAz**|DzU@-H~{@&Yub4eJfGOe`2W=L zJiKf65Gx&lZgT(8$d+#Gy9__qjUf&;SHGw_h`4Z-4OKU65onirC|W`zKr@k6-JF2^ zFI#;dZ5tC%-^%8ECU6U5nEj&+;a{;N*AP%O}g>jpd$zXN?>{A4XhG0?j$eb$}3fZoXPSGF4K#S5;_ zw*|Fk`i?H9^zVqWpVfXa9)os|0cZ-R5d5#6c^M74PVpqQ#3_go!z+= zZk!9%{zWFeJPG8U*P5X>5XTDr5`T;v&qpkAw^rQ=^n=>d?^i2;Q>G8Kq=s})E8e5~i*Uwj)}>VViavub<+b1#j> zFF%b%yz1p1cOkOpdsG#5LSJ+ZhFvcMHE!3)qd^{^>K{w=S~~!g zA7h)n>#)zd{f}W>0B|mx_!30;1mwYKn^Fro^dXwGZ@L=7nF+Hf5mBTDDTi6medYqk1mA(I6IK=tm0N3Zm8Ng#|w%@jUh%t|+I2 zhy{go&;|WecUVkwMzT?t*b)=*6LYhS{zuVu$5Z`&aii>%eQ|O3y_8wWXdDzpQW+(y zK}xm~Dne$+sJ;l13K=0GWQJrUQHiLKkx(*=e&_d>*UQUapU3l@bKdJ5I}$YG0pjTq z@}gXOaNmoj-AjW)5Ib$8+s}Ifb1&~M4t>EnaED}IHUsy679KXjFi#`RZEqWjBTZ2$?E!*0pUmzsgE}gi5c^VIO#~gkM!un|gg~vANpW4I7SNr-N zI5pk%CRYN0nklHO6JZC`jB}M+yAelExwb&qvj%w&>oZ14`9KYyCxsS22ddwZcF(pu zSf|6E{QlvLxNh7d7TXt~YG2tPn6@9NB#Y)XKNNw=v5EON4Cjq6{EN{^$WJ}zvK_BP ze&qJ1?&_17SU2J&#U3383K)|2BoqKe$cbk)j)wYS9`@_ns2|SL2GhDtm`5NzS$-7z z;T;X@Ec~s3%xQSO{g^C}n%WA)x&wg}Za)@$@CK0fDh&lL&tU$8{zqoX50DGVG2MCy z^XUKSIjzq}-0_lBs6DF+i{M+O3a@XvjQSl;@6$; zkT1C*twd2c4bqayGr499AoXy4esMt*?hE%=x1$B;`WK}iN48ob{?)s7dk6YPCtj!S zO!Wi8)%c!rCgQ~eX^sjF$!?@F>jqZoicc&Jszk(1~qd?Sck{5)cAMd`!l!@{I?J1@3-9* zkA8U|j<{#j@(K&*jDw3@2Ro2YWM5o&r2wdbr)nlQTLINR_y$4XJWzML>#JKM&ra4l zW>J3=>-cQbm;N(2e>`5@KZ?BVgW%r#(MN&e9TLWI7q~wR`fgzmXENk})A*j!=5TsSU@Y zKvHST+ey(w$Y(vY(ED5p1QWp}##`Js_SIqbP6!Ke$$ObUyfL3nuqtLH81dq)T)SJY znB%B>dZha71@vcioIiv2AM@h^!t0vu^1?oNZuk~Tu za2`ChRec%p5-YtXEeCwB)Fuz!)b|D|wzwIW% zsFSxd-kpa$qEcdp7boUyp;-G8T@88mApbHBc~brm*1^dWs5PdE?Kvq@>McVlk6$ECyR+5bT5XGOKU^B2^a?jMLek9^4zq4Rl9LZNFkJw-deRSoNl`I8@doR&b_?R$pKc>!q3{G3Zk9i$7hxPdJoMfDG z*Gn)kSIFL8n&FPQ9Io=-76ynn=25?CqmFU-u9w*r%mX&;X!g_*2iYe>Q@@unhfc0@ zhI!u~_s4{bR?eV*=ii^PkgW+oJTIrAc^Un06C)cmu%DB*he}HxtTUhKbrl0u=uZqA zP3Oe?ph2rmhWl{8)yagH10OLbWsIS0!ruV|cWz#NS2mDX-ndPc|1C&_hIMp5RRakz zVQB%qYU~SYlKHDYpid#>Z_{4HTiUJY-*Ao)Q#n4pQ}a9K31w!)V(u|-(1)=}Dg3?# zT{CeF1e^z7H(lQq0JMkA7sz+8j;A~iRFdBWw3xCN2l%_Nuc~(3B3OoXysx(=GaYEg z#Fs;jMR-23!slGD4-?cc&67l((75SK&C*kNZ`v%2id_G%k2w4E?rS_3n|778@_1h! zN&NfQj(q#eYYKsCKxugQz6g12O4#pxYK=TV*{5^L^Y8*txCcjP52KE*;a6efG~)7C zQsW+@FN(Z%twyH~7vjGrf^${ZfRvgcQAEZ2VM2a$nt*aPHj`vlKKxno{U z!-*Y%93U%Sa*{QHdHxA$i?@%V5035p5yAW6=u4z8)l1|3`1;_1l=w5`uSV<--Nbk5 z_4{zqUc?~{T^}&Np)S5TH9@2Rd0vAfPQ7nkP`7m>q+qNP2nRGTRjgv}S-&dr_~L>_*|oXRRk z{I_AhwK?_&$5if(HMs$mVsVC;d>i?8v;7rph->8-g{<{Q9m*NooMIK^OK3&^brd!M zdEl%`zc}W4+{#7u))w^7rE?2(p&n?(CG11wM&#MI$9`rYe`vF{J9?6UIrOm-OUX=- zb6*L09Z?9fos^pmySPAB&HrYtP8!H0vWq0><9-shq}fe3jsVeF)A6V0Z;<}@dO`de z){*@OE^sg~53u$jXW8))klOZAXzy#x!7h4eVS2R&>xNo)U>f>H^X+;>^R0lOEH`>_ zKl((TI1Ikqjd?;^w4T~(QOsXHNO>LJ4&n#;PMGeJ0k^#9!asl%k?bD&^HR`;(glybtiPuBKfG+hd>wHVjgtzFwi;Al+RIcKL2et zZ~p>utS=k~RR51Zwp_l&IEQ#|eizFTb$7HFk%6AYYd~`{TUfj<12o-Sp6CFaUnCTV z-`3*%F}e_5yk!`uPpK2KQ#l$SL7#CKBv*VB2G zxR6k{by&G0LJ7$8?;pJT9f7=V-}l#qgFv=3Syf2hCi*MU%3oa42QA9u#RQ8ITr?~Qa{!}GYB(f0Kp5YN~h z2Cf$%{nnbJ;V}9XbWU5I^P(X>?|NAH1QVnf_SrLYICl&MoVVZ*9#)JpRMvW9h?)Kc@eFDr@x}->)!+GXv`lquKCdRS-~y zKW}S(_lcf__`Nm%jbK~WGO>o|l zVbd_Fyrqu5_B$(_M9d{`)6EbFssrh5Qk7YM|3m$Qh(fgLU62x&W}dRU2a=JLJ>BaB zL6V)|kuB^D1iv4XQw`dfE1PgY=^x^d-b?-&e`P^@NvQl{FxKrW?IF|~INz_8tt^>F zooUQMz?M-@5R*3CvHl7-`lt>Fc?*Pt$O+$dM(=SidKz1NVYM63J@PD?z0`p2W>-}x z>;v>Om(DCi;uZ%R&X&S|3P3kz(=J7S1zqD3$IIp$K$i>LnRs>%=p2;(SCWN5`|KIc zd($3h6(KkGC?KvC>ounIy$Wb2j||gFI)SEgKtJ;z>b#b{1wD%Ke$>t!%P=_!)Zov1 zbMD>+s-9D4nG5z?|4P%{|4pNw?)z`sQX%v+Y;jkL{R|XJ#XPSg>U`hkUQxxo5OR>( zm|TMdkd^#D+N$IH{^5CyVPPEd>@vBW^J5;G+yCteyo7Gn3xFoYK6-0L z9p@TOf8Wcf^GbJA^m~RpqpfMwto$D2cW0J@4H>AXJ9|#FQvfK}#ticX(Ep>JY+#s* zy2g=w1-^}V9`PnQ9R$1|+lzMI@7oKc5%xKGsvh=Pp1NZ78Mrq?=MPok3+f(fQHY8C z?($TycqJ#u8ZRUsTg9CC`%RWLVJtk4J!Kzr8h~hXg7DtrE=bp`F&}1aGz*i0rZ-$W6^VWfnJ_r>aA`G^t_nL23u)7uP2*q+PQ!pD%q!% zu?Fbp-Vmp==s@2;Vb(XG2y}VhFDnACfzJLP&yBy>pY>RMNUfR%+Wirslwm96PY!b) z=0tvF+Y4t|_f??&Ic_$CK6YxQ(RZG7X~cmaA9<@k0#ucf|G4Ui=sO8BGVZPcN|ISz z={0Zcw+y=(@2+4SNxCCpEe+%h58Jl|?O4}2k6vxg1=38QDa#zs}3o=>MMw4h;#O1T{6Ox>PXgT&x(9Z;<%e$2A z1Is~L`au2c@Fw){7#?K2_=I_~g-hL+_)#C^W?EF?4uob;yVr)iK+wvHV$44ViNe2y z>h9-3Lg6@HRzoNH6KZ#HlaXI!2$+UsHGx?6=7N`FTR}{bA=cD;07OgP=H$=a1JSkS zuIj5@pB6S@QR;a^&B7m|VgDa0`6i38BzC}gdyi@2B)ipZ;SKpPz<2Vwy^J z)X%#(hj`xA#kwokpe;LA(gSk*ZH*W1qkisaV2#N~3y{gtWwaU3;Cw!xuJdUx5G}$j zCXJD|D*n9mMei-{wU~G&-s6jT%dxtbc6DIha#f9t>ot(vYt`v6j{2Zd%V@jyCLl2H zT@~^=i~4KoyIlX9{yU0bzdmr!eG9Au^+^uCf&!~HexQv#lddzbs&1X zi{Jg-TM!xXjlH3x0K$ELs?9}LabKk8y7oR6F!-_yl}>#G1`jFw=ye7#*dk4K#ySIi zc49#M1>TFVMjT`28-U(g`YtJg3G~7pucg>70R6_V{2GN%KzI6ncA9V&=sG$C?c^k& zi>&VuQ~ix~#XCsX2kS@9?Fr-CsOxgQWiC^D1?QE-p!qiB*C$&p5ks;6dT45Q?2-;p ztxxTEl3IoQF7tDMmL*WC-=u2oHAi1*JjGmfJy66_cI!W;0Qouf)g}kjrJS_U(m8;5 z%GxUrJ%li~=3#}e@mD+#eM{X1>@Vcn`;cP2=_anW*=NCio)bqSiO zsAGIccX#rM#JyqZ{wI&&{+)2A&t)P@AinCM?EV(#j*IE%?VPMZZ1x)~U<>Nvy;M|P zbR9u-&Us+M8~0lHMUJ_s9|4hO-+b#(D#s-q`|!<8Nlb4tbz|pVj%zT?O>llcE&Vf6xn-gSKXx0zG1@ z{B`APIyjfp{&JjI9!5U##fHOAP+v(48=ngwG6tGKnYG6J7oc(8 z8>@SbcvxjG{p~XVs(bit%U*88y}kt73*}=S5qtUk*b-1K9ZmQ9_yH)?0hi81)Wx^- zhxtT#q0c>neNjaK`(7!(^P|-Pcy?FMD({g2L4xvywyRz)1v1qK{~5oXTpvE^y6x8-(fccQYVvTIyx6Y zvaw{-{$o!;a+BA#_5Sg3=dW@8+h&^a$qmF${3Zu| z#65cbedgGzA9yyzUyFlx6 zmB>Y4?3dx5c$5K*eV3$oiw%LH^Pgh&LJ}~xcz>`Ob_526dcwmx0Pj&w8JA`g(5Iwq zyLfGY-WGAPS%3rR4+S+J?7@5D*O2@0rz+45o1b`o3dFfa+bT>}8fc$%6HUVj@O_!e>xbtsNH_3MHW-;D{_EFJ^I{on1?xv|f^XP;o~B??l1 zz8G{(W4~*;@31W+4J0c<#B^eC50BiHK%((SAcPZzuD(V* zRGf#Z=CRK;K2=O}EeEk?cJq^E!k8EEvb2a=0HO^Kn?^39j!r*(Jl_=aWMi#m`Koa* z*!2VawPz=RJ9=Tc+V37PoRa>1{^$n`$M0jS(XWAFHxz5>Qv{5|p=G(M{J_{XFdcF@ z2N=wy>*L4Hu0YYOkl_ECeB zRIDd^9o`?A0$S-x_@^2<#LGfEU)rLMNJ(gO??W0;hg!c!e=Y{CcRa1*e!x{VUpWO z20!Xh8oy7dAdWR5-tq1@=G8Dy-pwiI0ok*M4MX4Kev8K~SL4pS2I6ww-SnyzAnyBI zK-r7?*;9>UY;Sna}8NJ7}v{+$0B*kGp@`ww?z`5jigDH*}mk=nC~SH$h^! z^LG688jvvM=Wjv3srZZP?jx5`x25^6I^7#}jKw>p%#G1UrTF=&ZIV5R<~{oGvE(F( zDn;lk31D7;_w1iBC(H%#(wOQM)&p+06Qn-e7r_Xt4L7kr4U7=3dIP0qU|jBV3SQX) z47c4b8Nc=e!`dj*%GCrIdaL!>XTyNOa66<~fWPM~jyd;g9_W2vEPF`UpFJjsB|T*a z`W5eMr3dnXZXox-Z%7m90-E8TmN-YY{hTv_*q0EQJT_xyOxGeiLR~~cg_T=yU=72thlBr|? zydUywT84fwf%L-t4A=hKK(f`F49NQia=$K86aqhioZ_BGl(&cS3b0%9Hb219FaVYJo|&Br2r=8_H!Ez zv3K(T!MS5vr_2l_-tor_*|%VyJJGN(hWlQgSjb*t;Qlt|w(`+ILk(ao4)wc8XSVk2HTOWBpR8a!lhYyAB+xQ+BnU4-DP8S0s zedK^|EWTffiAHI!$-szgu^TJC1&oV9+1eZwVAytPSE|nf171mGS#Ji0%vFMq%x9p_ zt*i6ejP<-ZR{P_$INlQ$Z3=yUbepBKi^%`eDH~-TN;e|jGP-YW%Lvd?kJWJg=L9sf zl0kl5JD~9}9Y>rv5f}cZb=F=Rc@!pzeG2>Fb>x`tgx9ER6m=o{+h zWZP?LTp&{{FX=Cr3dF_k@k`$%k=I>&M38hAq!ZGVM+>ij)M)U}65Mwnwd+n}8}dk! zcUrITZ}A1fpQYJ8IAY2QL<9d^I6e0WMA=toG&{LL#Nd6&(u4!*P~!GJ*2)BK_3W1G z{++<6c0FGHC=?i#X%RYWx`6RSm5_yV5#zxo2cW)~X_x zD9-JL-l9{X+K3asH1z%Gjdg@sqttGSK9iO>*_(J@Jcm01cgz7*s(9N#GZiQ`&g}G; z$Tyxaj^9vo7$|HB`dZgxft>26s1scSWQ|>|7OzTy^oIN~VQ~mZXWX2$FX8#H&7Ym! zhq*KwB7?uUR6y2ib619b59X089xRW3fjX@(FP?P=08wZ2v9;a2$P2Dnl&;(bQeU)o z%=d*Lj#zdjA|@Lo<4=^CrQ#g;Q}(vh1=RbRc01)?+yxR9PRtKAr656Twmn&@0^;%A znyltt|59-VMq9-R*N+?VoC5FniOK=vQC83!85*98 z)~kO^?2kPUoT=W>2MpsSqm;X&z@S+eaZe@UJ-N147xzfh>+U}re6J1k@Bz}gl`))8 zEH#EFu%7Vh$`Wk%0j<8d-2!#+G#}}iNAIJ7ChvLQXpIF>-*adY<<=qJ$noctJmM+L zg0W?nI-s=b_<8mI#=dvKI;v|M`a%Vjj|`Ln`N50b0XuO{+;!BJ-P{sL?|EGs$*8|} zVGe(B`3j^pksM_{sE6Mn@Rr<^2eRIh{J%Xg7rumGO}$+W#QE<#I*O}+xYKj?!zUGx zj*PoDK|cplee$KTwSyp~BF7Vm`GJxV=8u2R$6wn zp9hG@aC1J->jhz%KckO@dV!mhXu2%`zxzzjq~c3GVEp(QtBAP_j1m3Zm0awn-u1N| z^i}{yePx&LoCPql=f2e|5r7eq>R>kz0Sx<=rXA^6N3?DSJn1+D41UV6(_UGizl-~u zdg>q0Q~9iTMWwJ0e){8uT@BEs>soEvxPjJf^Y?}X@{!@sb%)AuZqyX*FM4waeOW2` zFW{C7d}AP z{^7+m-4!G-?WtS)s+~YlNvQ`1{s*d9Mupfs& zbnn!&zpf1+(iG}>#lZ~sCU9GA)hh#Ger_o%6NH$*^Bnswdjyy~DUEy{4}rP1AkSj~ z@5kS7Y0DPVz?d>RQ0F`ajNZ{c<%nuv)U?)r92>wo!}of8pDQr@s{RR|djJfR)e~;1 zZorV6S~3oL4)lrQ_#Ln9aBg(JS&)Tw#KW}5tOD{|L_M`nyhip1Xj$274(d zu1=77ns=Aziul!UZ0e^lpGlJzY3Fbcq=Q77UNG{JhkEGF`a}mQa<%(ad|xGfcAozl zdJWJqbwPh+-Xx9>gSaF2*?b=K;r5jC;X+{$+bf~= zn7s}}tJkrIw3XxDwjdS$hqwo+u88(=(rKn(uU3XB_H zSPS-7@t)lI0EKuyo9Es)?>zzZRgofF+$%?KkV%b>R|k6Vu0!#sT!FqbtHlXhx=ZRv?XW0$Qi;6*(|wt%?d7fGNR#f3AvF9GHIlq{bp_FEAr zCBM!iuS-)Z@Vp_4{@h#Ts$*C`4)=QZ@tOl^bi2XI`CCBp6TY-F7WLPH`>d|FS0Zm4 zl%^H|e_y3U3oW^@oM=1;$1IBlDQKeFR z&tCbu91+BK?!KOa`(~{BK9@pGPbL7vK(A+0a3nA`)E(PeJP!088NxH8W}x2;PS3Yk z1iA_By{_*Eps(Fr*))K2dg(WLJp%T<_UCVDmjd#=l5J~8M1fi&oJ+DtzRDu?Bj*6t zjk!O818F~i67RC+aT@9#Hf<@{{1x%`hFcL5M*D$$wCm&hZC*f{R3X&0qMp>BqgiWu zEs%tEnOqU(0l5S5I|^dIgX~r53lm@6@jT}Bs}CIn;;(-x*+$_&+#+V=cN=wDe&Rf* zn$eH&;)^|*56?sNNTY=^;=5;#o#J1!6@BWhyNm^J9+ZhD|4#G-3IE`PDD)kQ55<2t zb{F%?_TT+}ecL(^dlu{GYeWVy1;fvTJ>Nhyt(4^VcMwFypAGvQLp^-_&I`_sBbe(u z>=syvdn?{Gj4po;1+MIedV7pqfN40h#^37>Fb%%N`gr^W=FYa8Cyh#gshp!Iab6$K zC4A!s(mr7P^W$9e;1w_i63P?SVjo;K)v(S!9vIiNC-0SH1H*E76R|4}=lLdIpWYFm zfAdYv!kl&b1BI2AA;c-|_)qQ^t3)31K!uhW;=hd>`*e07Z{pFvvq4fG@%TGc7pkL? z-_6!tDZ@VNgig$ge=PDM*507RCZKGdbZLo4Uj5ZUnFs~Um9>qPw~FyV zocAZ+np4WigS5Dgq#|D^Dw@{VQG>c`kM~th{vaEq-}&wIf9OjH-nYr>|L4JJUO%-K zh^m>(3ApE2+FOste`g))=4vw554+*soh2FBiv1vYyi@9?Hu^ow=|9BNFQd<}zl6D8 z2_(GUo4@~QigWpr@4bn2AP&r6hu6qE<>|*<@xWXS;`Xx~#;6~;F@1wp^cqCD4H#L) zCqX1gVcAddG6>iH1}W|l5Ndk*{OHRJ;JT@E)4VAkn0Aqc^V1H%wDu{`h7n+z?h!H< zQU<2p0%7IPNnk1^xAz(F;yVVvDil?L@pElKc2umTl&+T^_0`AKzFr2Q{jbu80G83&z;C)b^X-8y!!#r{9jdz zmY^<@kvm>rr3=(oZ|lVdQHOFaSm<1XBJ#O^S)0p+fsz>%n^a#06zya6B3wN{?riDN zLwuQRFQ!p+0(Ds!LtifT07xNcRs2eofF#~}<)k<#$XU?3{#%3d;5BoFuWrg9Q_ivP zir`uFiEz8W=fu2NW$3ld!aQHk>$yS^cpepv3mWIw zFHZu2FK|H2ng=A#Ms~koF9z|pmQWs*Wb{#y>$$)3g4kUjv3t8PcT}*b@hX2C&K)H! z80QBfi;hiS*>F#>XR+X#`4SK=%q~q8xCBCFdYP$~9l&)plPpeR0n_WE;yHsSz;w6% z6e&IoOverOz}g1PBT3|=3%7u&%V}mBrv*&LaRJQ>;aFE1g;-ZLf$?d7^E34tU=)fA zdJB+%ab>sIJ>(r3yH{0HJNbaY?Uuc%??0fwX!aG3#d~r^gK|LE0O%?U$2|^?A^yAL zyYJj2(5@S(WPd=OSM3n*tMpc&_T2IGs7L(d!Wr$fAmp!vmaENV;((I-UvyHLJy3M7 zvFz<$0Qo&v?#N-({hoCQEzujpyv$L>eO`7z3LlPW{F((MNr#E{8k|2Y3pD)QEkQPP zZ-zYYKRl1~0eAcF193*cV5+eXh?~BjGl@o>uj|wy|DsWldiv||j!oOqC(=`}@)!H7 z!xy8fEvZ1rDx2cA$^ioV#e9N{7f9G8dT*1r1o67R^$NStFTx7zeCr?zVhJ*tzYI~g zzJ?L5g$2Ut3%86;bYOnQsgWYSB;azXzPa-9 z1~5ZwWM+HV!i ziolo_<~6%11&q2gn!}oGz=#oh@O^qWFwAxLHN49NhJ+NQsrWw7-?q))33&_j>oMXY zf;?E)ZxXqpU4iz4ke%y=I->uMN_MC0LcTo?Qin8v`gyGw``b>`J;Y!&R6cCu8dR zhYxw#FctSd3nawXc`AEfVP3%LI)juunD^ShtD)2H8v1se;y`LO2l?hjr-TMFxp<+A`U%tu+L_MF=QC>4{p8(#GS%&0Qaw(&pH%?Hd7T)O z4qvPzv*!ZhU4TC06#cIBC*tyb{o~a*ha3$^KWu^Zer=ov?;8^8@eaKCZ)^r=hnJ+1 zu8iXx()E*$JU2CtESw^V{NYCV7CU~_W7Tg-UUy_I;#d(g<*GOjj(K*ZZ&g9uUBhQl z5&JAIn!JKUFy;cq4K2}77f-tLdylIn$elW8w%CZdpq0yd4#upXR`<54+@8B z@N*zCG@5;1rl2k{%gR#@agywPY-iN$Kyqej&ZGk8kDdRyE^WGldy4UzyH6NrUvq8)~wp`A90wVPs z9_-V4AfiQQiW{nf@CA9PN9k%HZ&}6T++E%rJ#h`_VNA(EypMDj&92^0XRx1L zIryk40CDyJ-zXD&m-t^7)(+kU+VJWtx830F(5B>yF zY}4+QL#L3p@>gO%(Eub~lSsSTI*^MwmpLD73vvRMvMpQ2K{m>^Mhf3ESwXL_i&c%7 zHxMhZwgPj{2#*H7{lUE7^eW1esZxCJDr?W|W`cBSM*Y#Pb0EF@v}u;a29WAzuc;MJ z1t|w-k2k7#&lb~u@6{Iq$>_M5!+X&uH?u9Wq6Yi4Oi%Yb)VT|C`5xcUFar#=bJA^F zt^-3QvRsH4>#@Sb)hi72`(N&#~d`QY!X?y&CqWiY532qbux@lYep4k|nD_o-Fgkqgone=C~eFU@)^@p%+ z8_@2!_oz3Zuh-#8($iTv)NvCU+MkDEZc61r`6rk=@TBZ;&S~^Bc*%b@a)?8{gUVvi zD)Lkl-(7`*zG1)R^ZL?A8&E8lOt!Yh07Wo5_s)h2AlIFm4xZkEdCXxc1CLU0|HUGQ z%q!%p1|It_TuejVL-zH{4^9Bd_*2>Ahmwe^?8_xyTL!t{j=kUXazOUaiC_BsxX0?k zZuy^GVj%O=Y4*~~0+4ZQyHXg2bL5O2xo=V$h+dMXgy@>M7xCwh3q9B``w!lV-8T!; z+`UH<3!*_P{+&g;)(()8YwvG?uOL}ac65-u6C`&<+Ff9;MIVr1rJC3lZ{jKk{LY(C0r-Quth?|^+TQu1R zK-b#-vxSMcBKO3JegAl|-#vMH-_FfIORAYuyPJvkMb0L38}hqyX=?pBsBajs+H6~l zb4aqca>JI3$cwC>S#mrARDMI56&u8{Y7NNp$`?@|udr^1A?6Cv#DjL|qVD?bPOi+$ zs9y|ftZ7rl`m(vay6S2nkiKoW6HqY#q@-qkfutoM9q1XTFV+Ck+HIT@sxL6dzlG~u zlOf1{FJg;%gL>cNQl96G2w+adc9@>tXNeoYWS`ju9G zBL(%?`WN#6u+G3)YirqCU^K6fUt1{xj2BBQALFVJ*R43MoridCiJ8WWNh0Fz z?W`QtE5Jxll)sXR_||2A$E9tE>z-(bqDnk3J=T`5^dVr7?ta=Ea0}?m`h6Q$LV@0? z+MKrC2k7@Mk_GbY5yw*ArU^Z$e>^Yt7}m`Vey= z3_8`rdC=d^d)Cd}1m75tG$>I2F) z&+ut$)LjqlJa;1n{USFmSEt(=pr1!?mo54iNRyFuK6x8af4yHzO?U(9udmj;BqP4U zNe+LPwF~vWChr5+zXaJ&QdL_g_JZvG+hgiaeL<$WtakmhJ;-c!AF@yq1mdI8jd5k@ zhofD}Rc7G+z4WJf7kE@bTJC6}za{QdNVjy=Y(jlJHSdi}mI_Gb7%bIBtAnH}Nwdjr zKM*Q6iVF>G2ZEqpr^HDI5O3d8lc}Z*0`so-`OUFz^B8v7Jq`sXm(0Z_y)c}^Z{Kg< zhq{K}75vQtrx5Rre!DFl`HwEC8$5+yfKhQyBWvb0_EXWcr~TLPUfq}vvB?0&v5>gS z6K_1Q@4{tg5#$Sh7W}Ya!#siH2@hu`=9TYhxt0?V4y0eZwT!p=04e=& z>lnip&*Mj8=6oBF*w@jb#riyB0qYcmt3f8)j3bdB=Saf$ zx?5eSgNV|Y2?{}7BZrc=5&Ht-EH%EW6;D8FZqO#>GUD}KfiFgXf5%+es0Weim1OEH}+)g@2%~}%yOaZkDJI8;(n7zp!$@v8F_*CtTCOo&N zc9adzR}o*F?2+U#1jcErmH;zjU}!XytiQ4b=fa&{;+Y+&=Ng@xc_xNB$N@@A^8uh+ zL&Z~ntT#l}?K&Q(fcBy5MK&4rLGk;h+b$umySJ*0akT`fe-E3y`hs;ne=~R4B=S^N z;gtA{|IkNr>FMeRW1tjiggm#s2b81ZgB3n2Kwf=y-o^lV-3LJBn~estv6p2Jk1UWD ztlS2M-T~>}^ytaUh^riAIrlDH2Dz1`ykoEXMfxkl8LR=v%i-vk0qJln5H zrr?|r5Ffev2j@Vhx^&Q1oY&>T?R5}`cXY09SnvCDW~wA-8a;k?Lt;AOZI z=MTQD+pbR+fHAiHg`6JF9d*9@-{PFaxb3yHMjY#qO1aL3c=eH|pjl138{Cf%IV8*(uimJdf>vUU|5K+|pR1OUp~dRdS|ZQ4m)t%?mu4 zc?)DE2m69I;@+35n@bKh^J5-)q8K5Z6Nu(3M;|UBKHq32pDiqa`s?Vx^)9IM%}c%? zo{Ro=nhR~Z0rl`{^Zjo&;oeZ9{M65fEkL-l_~KI}>bGPq)&;ns9^!QDf8+$rp-)>pv1!`?@0Yyf5?<>e15&gJKW z&usqp8JNdZ#%U>$c#pIXR8*ba*aHS(Sua`tuZ!iKz!@=)2z42beKj2knM?A%* zeUQXJy$Wrjun_a(>0`tn>(|}`dRDk#YUM?spE~5@W5+*Or7=`bhc6p@66<|sW{>-wnLZ0#XURMX~ zyDE*ce#(CW#1Ckqe6vTzOcD7itq1|G zZlDB4J!`e(1qz98^Yml^kZbk_w9F%~dpv!AdWQGz^!;5;)&X# z)~G|_v*D6Py{|#|qGEp=$fn=QP|h3xnH3q^$_+a~#%5hgBNcrKwPp(Eo<-yQIJj*X zb5*5dQ_U_E-UF$XE6$gnx8i;g*XB!(Y9RUf1ecnj6Z&s=lU^L<1j1_``(bA{%`cAB zk&!AMV2aNAe!7lz#P;z7r8mooG;<~RZ{oqQ$O~>cIV{mu+O4#D=Ua@z&RvuS6eRrKT!|7 zF6e)U^4gRtst^?`O zoui}ur?H-o3Xf~+f!q{)y>=4!D1h%o6HhwG-nM^Itm_9d(?2LGk+|1l|G)5?msmZ;bIB+X?s1d?_4zuGk6zOb!6MCXI3 zN6FLQri3|!1p4Z7XNW&Y+=~yZJ(mvRU$d2q25_%S(Ox#IUw?r=`ss^bgGIp7E-{SMUw^M-J+QRova`-b0*fM}^xHBF zSZhW|Bjs2(zD8z$`~Dr6l{D?ER}2vEYV{u~U;xu5Rauhb8!(yWtAG9$;`^oJt@a6Z zDFs$-<_Q+alPK5ub)NwSb@aSLe>TuRJXVjlvql~8Q(N158Po?UNZcMciF&PFYMH2K zp@lPlWo$bGv`vJMxfhWaX*ck@RelrskqK>kL-g0|~1d7Xo~_WD&I<(uBIp=siI*vXteG756v7KRNxaZlCe?cbJ~ zaDP~^x9{v1IgoiDW0o0w5oDBI^VnXYU;R3V@~iLYqng;l-F?Ll=fCMUc5GWf>Ipd| zM9&4Jh)>5$Y=Tgal9Z+P8FLwzDwLis-vWZmTD>*fCP8B8?79c>sAsh9CZD`~EFz6+z@NYR=xDvGwSW!9~<5AGeiU<@vr2Z9Hfx1~0v)RD%y6(2``vG7b zw@-^>e+n#vKAu^TcfgYWCt_;A0v6YBMi2UXnFE>ZFX0d{i_BgR)#E)0koY)%um+fW z*Kul%`(dAaR6M9|AKnwWoO6CXsE3UD(eGFbjGe7vyhg~k|KhdUZtQ{YmiMXLU=sSV zcKfC0VqZ0v#nQ$-BDCbUt`gxm&u{-1Pu`4mqyOaCmqJdU`fj}&Be@r-B88!3ov%R2 z6X<=p=_B$Zx8lRU@&oy!^lXLz;w4^-Vr5CjK;A%1sr42>-SuT(IjePe9(*IeaG$o^ zkatJ>6ZGXOa>gri9Kd|D`x=8dhsm_*xEdbB{)+tK)IqIKAYKx0HBG?z?*pZGe--Zi z)_A*p`nM8DrHaT6WugyvO$U`LZw*Mg%~&-VTHs!)(}#l9E&|~o@y}Y+i%K-ISN`ij zozM=BlXpcjLEO9WQ~i`4h#CI0G}k=|{QTuN5`*-BRTRP7wnrUU1r^7O9_Iq<;XxDk zk9bar2jh9GP6O-Oi^mgg6~H?8>?i4}6|jtTOia@7@8#W2h6Jkti_O}Q*Bb9f7d6gE z2kT4Pu#l{F3*z)O?auQgV9NKsPV+)uam;RI_;)xk?s-o?O~twLsBuj$;u{P;kv=J9 z?61m}U#H%{_v)m&`1tt+pz|z$QKIcYA9ldNv6~w)cXNd+Dg|-hiQE$_HsL@GdC^%m z{|%_J!Cj92Q9yZ0JrGvD5BZT9R?jNVg@es)mgmtY;=`R`S@i|;%`zTSUFU%GIQ#%n z?jGVL1@!OPSs?dW;K*?`%$;L$gO5DoB%WJ{)h(FQU*{L^g?@e+(fXc^_vt`9H+S#e ziYrJr{oQr*5Bl2ZwdWs4U|vA@rt3GK1c2n!Mx!Yr;`B$d7UO&n4|x%@|LJYqgS6$9 z@3#B6hdp~Ac}D*gNXRZ&5jKs3xJ7$JWE$f0o6162waLIYVkWd~^Bh<`e3ynKF9WMf zabOwqH&`vn9C;G9z^XKRyDNUjUv+tH*pG#%c{&pEa{q^%_5(1T&mvV5hzEB7Av_@op_0iOTeCeH}y8kec zMVIcg>*xWg(C>(<^E94^q2Z-=>~s6eIyxftQ3tQr@$O3*$U4d1-;$?`JiF3-&dVW? z;j!k#3{mv8MgRA23Uf3{^Mp-OaPAOEx14kG!u$r)fx4FxAo-#2mfqkukc9Nvs`UF< z$Jb9&OR;W9jVf-*QDDWqKl<}+ zE3nSypW~<00Be^}ZqA+uz*IwDu zgm`54x!G?$mH2LD^d?y$ex{ximDh{B)t9n6XC<(nL~z^;%WenyruudczVAS5SEH4Y zp8(D2`m0?;)NifD?W66}Kuwu`SMf3usA?BDbQHyb(%2idUJvuHkGRY}X?Fqg1Vf9o zITy$QXOnsVBm!B2HAz!Np1sKY)Hwm<*^NJ6=VQYhtzMt-lt(j|ck(pCXd3h2Pueie ze6>L)-(1)^O%#11!T$+!_5#u5b@EUc`gXENNgF=nJ>jrT8^rfT>V)Us-5TiEd9k}H zjvMoq6>4(TyKukc&Gx;?$8>#-c{{r#RgpPUV1rR3+dnq8FCpsq} z7wL}oBP~tlY;_#SOBnPYtuzFA(L-xKhy;N=ziZ-#91CFmefYUd&l6ZpyIOh>SQ}$9v>md5ITyBX=adD`E!KYBBB+<} zQ!khBz`C+kC)J<_`>pS}kIynu50Uzi#lztU3?ut$w^a$$o65N6j3b_Zhi7L}A>#Kt z?AUL`%VIu(jntdaTc|JHwR2et&qGLWtL0o9P_wcUhfiV7jdpI*m0TsDw8uRE!22Ii zY%(?URel3`YV-!*%zudUHb?ewZUD06X3x$4RRgJ5dg5Bh1fGY-TzNk3+j(dF*(li; zmLXN!QSTVV3I(iC;@hGfeOKFl{6Hyoxu z1}PJ-WO98LNEW_vZGM1rpxF1)RW7_2{<)KD56*+c#9zVbD_B2{H9c@q+=Teyd})Co z>LA!=oWG5uuD8#Ou~>Wn_^!-uhj%|gUR?*C_Phr9%{v7jJ}m=z1@#Q&2fiRLt?D+2 z`vK*-G&N5jlgE2wJ>R6>2CP?)TY}L?!MeY9_}A@g!1B@atbf1-Ed6TF)$0m)Px}AM z>%jT&?F-@|cYa{TrzOQX>;vZh#2#3W`Uv)~H)tHPz$h*-{2xWv8IScI#f22I_kNaV zH${>-2`Pyvs}zyFN|LfgWu!!;C?g@1(9X)t$Sf&B$SfsgB=_7`ecX4~@&BE3zU$P8 z6r$f`qvVYOA)J3ROeQgBMmc|*YxhO;D;jOdebkNn$9Tury^7a>60vXpk)w}*B0oZp zX^#eS(Z}HZV+ugl^_*9a$^}yAK-BYoEg;!nSnYy-FXD{zsuS^AK#cg6BeXsfh;s7j ze^>6ndbA3wml2VVTK0TUCI?C#Th=%EZU7|_R>bKhtcO`ShwG!ippepa@^Qly$d8y= zYs{LWZcgFTm9l=+`O3atlP?OggBwo2|Bm>&mfjL^Fahxqof+q%n;^p}6y04a4bm~*L&j7vr z#e(PtoR6>ZFO1(G$2qK?xgv=V`@FcqkZu#uCZ*Qc^pSv;yLc<8Z2)M;zL!kP97TME zqW?u(4XCxv62GP&p+1`scz6vFs4^CtsxBWv{v>}D{S^9q4j;QIh!%} zwC4VZcnjjb9M&OinA7zlvDZ1u3&?xxwf+Up0qNt1&denVAh{4$7TCoD@lV0(b0N2Z zcyX3=O#}6%@?S#)q+Eee>{C)4e;Mm>>DhUrI4HHMbOy6Zkr!n0h=~;<&fcxb?rcFm zka+CvJ$1~x9+O%767gK7Sb?Ps_VIv7>D5b^Q`(_CcX5{($gcfxC0B|FGBFn_`qfbv z^j(_!f)h5+)$ga;f}$F!Jp8FLOzg zr+{yVZY~+?$nbVEGYMS;hKEU=^&@<*9Jrh(5)6THAZleIH4_+G-^a`Tt;V|Oz8|Kz z0At0i2|rt$w|a!5{9U<#p8s;EfEB)5{uOz$RD92N=xpA#h;tg33*WUC+}|r~d#a+a z&!4f(;>_v=8Y?VB_!0oMN6ckQ0ODQeb(Uf(k&k2=YS(%{MV{E%T$FwVlwG@b?SDLu zJbTX*Wr0Ybq&`e%pbm+$>6TcBGWyr6KTjB?BX4z}Jm#ef`a}kUG7MJj2a@M0sW5-c zn_GNwMDhjd7^9mW>Fyo|qT=-@sV7ZBDmMd9Q?KSJ9mU;QH1MKN+$dKm5>UZJbLPkW+{@fB6i>ITRv5~z&( zm>+xY$_9=Vf~dRxCBTiiqqL3++1?8I_WPM8*G(0Z~u>rDOlM)|5}iy`{z}`dcN=X;+_Dt>0n@bW49$SjH^SWg2@e zvkm~Q>+|{c!`N41hBiJ=K)hI6K;i3!A)roPIbnYrby|t{xXRv)0aYVLc4~wP${z#i zguSJpeCAo$?8iz_77ZhZ6jOkbD|0Bw4t-XdRdFhr3%D0nemfA=2IRws*V@*iUuX24 zcJ~76;e9S%7!G6taXHB>u}>R_mxJ=|li28MW8YU%NB*fK?n}xEKOh(;8IL*c0i`z% zg>bU;=}Ky=3+I>@-~(+}k01nI^Er+tY}F=wV$MgK)INF_C{%Gn(QQe07=!tcp~ z0!V>)W5f`DZne zConGg?&td)3=ALL8!tTZXY&urQL=5o*lfUQVM@WipZ7SR4}br?N<=4)b3o6jGoSaw zdCarH_uuSmpszRfA20g`wDAk8x8A|`>rVRC`ahaL+uv>*6o&lBzx@pvdMALIZ53$z z19`1I%8M?_*w@Eqf1i4k1j>r%G0TUn-pfihclZP7Uf7-|f_Q z`RfK``>fjsd9i??Mt5`g;HQ8pyJ9reHDiJoC&)S31w{=N4Gl;b<%Zfsit%FI0#K@V{5ExT}K#1?af zjNkt7jsA$dq3eyKqKKEcroEKdfV}Om;_}}G%Rma`ZV8Hdf%yTo~ z0QtuXoehjPO~yhuSipE5+B2z621aIe$ks;!z=*u-{@_^vFzhw1 z?l0I4jIC*rU(V$NgLm5ff5e2|X;vA+I*fb$w7S&E4xn57h>sxkTXc`$ccL2b z_x=M(pw!>W>ncIroMp`l?nMb8k8Gdtg>}eJ8Mo{fS^=bmof_vAZX)h}>i%mj%%kBW zt|n>x1Y%-KhwxcdAW~fKv(?ZiQaX^&uZHi{9-^E0BEDBu>qiGK%7fyp(-raTAy8af zSD?p*IEmZ3rFqod$QJ}ku2sT&RKMb_C&fxY4vd%9RH1+BO42VO`Zm1Zy?0(NdKhH1 zOv8u`n9qMR=9M(B73PokM_W=c59^pppzMqZNH)4P3upbm2YMftxQ%x!j`dd^VdI@P zz0jMtvoWu){BG4uG=3l7-MB=fTY)ht-;m(29vFk0v$$`h0Hf_Wc|z?r*5%p9#uGPz zk*a4*cf+6kPku5o76FE_%^eQt28NO{UNu2Ha`YRy-e?&6dw(Rka|_}t3~rgzh=-Bq zRvHz2MP4QJ+HZaABN0mqk?Htut-rgz-5v3h&L=8TcUAz^*N5nEZWB;N<+in9pHR-5 zDO(-D2g;yx<+>E+3$*WB2>5UWD0X(H7se}rJXQ6uBU}{7elOEk*x>%LoZJ;Hi@Bu{ zr6T4B&jLx{VCQ@6XT)Ug-aUptfT&!!Z{+uD^r>sL{2aFj!tTtFbEnYvS)RaYz!1P3 zAZQZH_y>w~<_X_KIw&}-8x5QL1@d>-az~yO0=Wrp?_-~jgPdw&uFTJTkUd{HcX}T6 z@7-=*AKxRcyW!NA^_bHn9aH&bT2mLKrqo^@DaU)b`=7eDZ^t~#=j>E+KI#{!{`p%A z@cS^HIvjAG4B{%$5{KP-fH$YJ=H}E@VDd2jh52^_le69B=U_B2=32D(T@nPwsPbmV z5m8{Y4oUr3g?mV`e5K;1mB6?>Jl8yj^O(b-!(lntS5#8B8CD*{{jt@32zA@^3PrLh zXD84Di=XV4Ee5)3l~=7b;=rT9dQ9hJ)TNT{82JwZO>0!*_ZrkUei2ln6=EI2x>~BN zabH&qJO51x^Ew_|-D%ZFedC^tjeK~QkMc1qGjI(3pDuZ)dRAov`PWjv!(-%a1IMm} zj_m+4_fr#RY9s1R8kGJyBYq<6)a7%&7Ih6ogT;(I%qJb7&WWL(^zpSj0~FL-?^br{ zd#nOVuU0vJLq1e-O8vmSqt8H*^lU_R+d1T+T=qRbaSP;ADR(#jK%Lvbo4&j?ULeQX zR)6M^JjnW6a<&fPd)36TXl&;LGGytmFOz@c9vD{fO%U(w^pUnVZ12K5(H~o!sHnTn zO-QnMIEen+O&;9hOpw@K%6Bi53F0KZ!OlA`fj545uWM9Jx9sEA(x2R}2;&+pIo0YOu1dKBo&FOAdxUU>rDCRo` z4B?d z{;Q##n~uc;HLg5Xii!Fb=9%Txqu4hpEhMfS#CPjJ`eJ6TJn9@XwN5dgpkL(fnS%~? zm=iR!>^h0OZFo<@r6S}-c<+i?o%n&gRPloqNx?u8vofuc3;^OS<<2(|n0HO*b|*c^ z!+P|04{?!zU~td2D2Ii2ST9|VE7!*RV0+7SNyrZ>_`LKO(+36fk1G>`alT4CI+uM< z9C6+L?&*8{AV<`!*ElE$vYuv@{6otiQ^9jp8uxt}NwtpV)_)-FT|2c(suQH%rf_|^ zn+Z~zt}T_X!JN1oH~jb9!T!M=*HE{;4{<~`Ex$Jg@1eh)*&GoE;y%=t`nXY{090^Zc>j7;$nBkn$M*9V;{Nn_<@}$&{tPTI(DO;zNBvJ zK2>+19r{!#s@0Ek7AzQVL|p6Emc6h1kcU@WxmI3l3+C7SWFD3Nj(*Tx7qVVoMm@ao zXrLqj#ov61bI}bboVn|axRZf=>6&5jBKk%Ik8O2L-UphaU%PHsW&&a-Zl-GI+2s7KIj8eUFH5<%^_gYR_Phs`2tKKAr+QB_Vwu_nj9L} zfYG?dN}GoB*KM_AUF}j}xc~c=VIP5Wa12}9tqbu<-q=gyM8xs4D~RJ*AE%^?7WuJ2 zmllhdsPqEb>x19Ivp)jOB~^E?-BY0Pvv~KcN4-|gPOt8#$hYrUyL#}%ebjAj@V5Al z`3_D=bKcXr$cH>Q0QV(;67pI{`40ZfOH@mlbOdso)T*g)%-InAdDAQ!`*@dIYVlb2tUK!B4S!2| zaO?-=eyP=wE-L@?xV%?(uR;B9O&3>p0#Gh|+hA6994JCZ6KJZKN0Z?E?t+vckfki& z1$JOwR`N9#K?ZYU<$_Wx`HliHz1a4B9p+uL@2&`|r8P3l=-9 zPjA-(#Xe?$_v_>7R5G-xqt-E!f;>FZ2be?8Q9tVQ-LHHFUpA6Y~Px7t1$q(gBHg zl-eq`I*2bC7$)#z{`(i>Ai?L+z^gNnacJKd;(xj3(}Vb~2sG?#>H3E63RALu-Dcby zT8uAV8$({>xka)v{vG%KGO&{U4z#B5AJQkt|LYpsR-+D+mfR#XO2EC(|CaADNh_e4 z|2(Q5ia&4YeXJQ70kl{Fy@@)&on+q9m+Y2)L{bR zS{u4|H0ofk`H)dlWIO(wIP^kE9r4Cp4?0$zL!aA1@n#a{CX))smVH#ZfaGB8asvI} zB-y@aFLt8tr2X2S8uLSlt2kduP{Tb%&uZ4|O)(HT?3GgbGl1|i_&&eA5fJ?E?<) z!UP3DAL8G$xaX(1zwYhBJICK^GL#-*F2~t_p~4(^$EawV0KvT!8fS zMuT9!1&~~Rm(LU-4lJL>BT|R@>(;3CzrV2%2QD3*{3?U%QJW-Y{MV)Vc zn1@55CJ-FYv>a$L1OhSfXyOXQyIy3cbeAEIrFQ6H8yVlbV#pIYRD?Odd(GRs*I+J( zZ^7`zGoYYW+$2zQ0OVgR%{UAifc#FwsFz1jzjbwH%(3SP$dZH$N|O^nIJvFq-r@?N zSMN;GeEbXORTR&FPk)dXtmm{v9FShLF~wm8@*f$FcVowJ|Bmx~+GIa~_`2D}v&7>- zw;}XPmm!X|eJI($_a)F}3!`}t*aB_lN~GD?IMC|Tw#)1}gZ?WV#3d2ebxL?8F@-$h z#)1Y#(~m%%GyS&vj5gNgj_%|34?sOvY-$jYiaOK0pRXc6BCmc=Yg}&{lye(=nD&S> z9#QFHkiT!F6K3rd)8i!PBf`zP$wAs|6E`qkl{K z3WQO4q42sO)L+kx3^z>!;h+dtkOAT?0v_#&1J}?m!du*8u7vrF>7I_gS(rDFtooEJJq6hI%g_HhIv$q^Y{=`J~i6q{AJ88pHvEd-zoxWaIn~(FFmit}X{o)|g{$=Uj zUSAM)ytFIvtQ;^z^R{eEsl$2IOZW$ohWmEe+cg#Uf&MR*Yt0!|pnn&-`9})(h>wZ` z0+NbYw=P%jNjmcEAXO`ZcvXZace^^`B(~lG>pmmCxW#%@F8(sm`E)A7qb?#}s2ynN zQwFpwSHFMqsM~hy`#k*^`NH+jQs-CTem*Uu*=8CF)B=UKyGjuEbsX(7f0TpyL8*jY z`^!=Hd!+PlBI>fjOp7nw#X4=cy?!%4-nIJVCd<`@KA(s_B3FECaxZPFf z`f)xWpCQMEisHMabcVAA|eH%pxBl0 zY^N>mle?*x1RRF(uGp6GZV$wVx4a5`i~NNAqkQr2oj1_OJNH=rVmQb>NWQT}3Uxv= zM()-&_dzE50ozt01cbMm=yw0p#d)<*lq2>mFf1*{Uw=OXjQ!SSx6n7u(0k&tQnw5k zs=j8QHYEaska{8@9&wUY+crlJB7Zw}I3oDYPoUR{l#bVW<9zFJA_MQ<(tXbtw4Tt# zy~8tcX|x*XV!D3Ni2AKh#N2ClP)CP&wvA?~J-h#Nw`oogqvOwqv5_Rsz`$*>vvd+q913~SgqyiW2kDYGPYktpz zl2*cXhshnNFAeri8bQCPoMPenCoe%E_V~4$O_&eQxhuUN^?~yKPp|bWqi<&>|H#1O zCXn-%+E8LT2eJ>g>nZZbqhFM@ZSeRxRmWDmn!QVMY zr@;j4@!{5)sh2>k`}^z?Kkn}*8fwd(u&*nq7w@#ezVT*9qB*k<2xmU!CfaWV0)x{O ze&hR8YQB~?q!Rh|+dHEb6wue+7V%}ZCn!w!y}y@_dd8#AY~RO;A#Y+96Z_Z=`~F`_OF5zem8> z_R9BH0q*Uhik?OdVnF{gA+-W?$mvDf8#h~i1o~MOBfGDNZ)uI^Z&2S0wB-n8t<+CI zdr9R{;9Uo_Q$M5QSt&qcij*IsBm(tg{(&p6#ejNgGVJp+^zCk5>aSw`0Oei*&9OQW ze76kzcxQz{nbK#uiDMg3s{gr;R3qMath zK=4$*%%z$G1o;z<#Oqn0lzd)7Dt{b(Z8|lg5&@W#DNH=Sj6SM{Pd}F(agS6@F>2b0 zcPz5DUhz-C{vnZn%&`ys?U#lgSzk~AIgZX!#Rr%Ruf8Sgt`hQyJyy-q_?`$|wX?eY zLkc zy#X+;@2s`j!9add&i%?d>_d7)NBuQgz>x5qxOv(V=mSdcAFo+NUc@vuJJk&FMcPMB z9-Pk@Row>)aPAs1s7v{_7HBE`(-YRH3ofdkstt&s_e)#-Lf(_=_>^G38 z%H9piziarsokBqQhTXza(I6;qH4zZG_!21ZDrxN%e-KCc+93DR7byIzewCfWoYJhm z!Hq4RK!&o&G35jx_1!vOZ+izwL7tDI&!%BLShCMHr~&bH-NH>SMXgt1MlbF z+mNw*80Xq3ckbgMAb-|tK)tXOUl;DALfp2~R zMbht^?-{}fp$)}Ec$N@!PyWhy?j^>sNB90PraaTclDAt2+mYIAR{hwvFK1t}C zJ`P*7GajPOH}l<*?MkQ%`s}TzgL+2mG1s$>JwRCb^zfw}8ra7p6_z~JL9vqKSBKwI zP$ayKsR|MTh4B8XiuV3^KbO2JRG0|zW|2m}wo-AAT#%tW;{mz#o+oebItsGs9Zw{W zUc$Mmc}&#@^Ucm~H9Qb|285(`O}^Xc3Cuv}LypxifO+FYjq23PT8k9KedT*knw-ZuI-r~?fc*Mt_h#*oCqQ2-vEYZgJ=*6?mml-~K)bA? zw{lN2`rC&HtE)ZpHzyaArr3E^JCqiLI|hx4z3`o13AM}FTw zzgFToP-4C=%MIc_LX>OM`2SwdV`_#d=Khe4Txzag!u@aLgV#djULb|JiYx8jgY^(T zrhi`^eF>HN&4lAXv^z06ei(hzE2VPJB(6psd=9Z{XD1L$Wk}{bci>!AXZH%xYysXf1>_j8_4mz zx<Qr2Y+`j?|ITVNE=J$$Pt1;us^Ukvk~8?f)h7eE=mA1FKv$$>T;MF zRD$1C{B9BigKyYO0W-wb;->QjU^>wi(=I;+rh)J4J3F2LlX5t=5Dobjq`{D zEC^ah-v!$JT%)1ZFx($6OsM8#J?85Zmc<5vdh>SJYQ$lv8amns|C|HmuCIZ`PD+?h zQ``6PU?J)qq^lzG<$!WSQY<;j5-2P_o1vk1sDmF~`GC;~WHUkQQ|!;^llK3d=r<3f z^Kyq*^P`_iX{383?*I^Awcg?HH3gzgvqo_Y_V493Z}RePAY``d9+7SV!tUzdoh7cI z^hJyFU|%TifBCGR=*v-ztZ>vO26qrF(Au%hvly5?BjS^G zD!}YsVUzbh9++{7|OGdF<2+4T5V69E0W_nx!} zk)uGi+$Us} zir>Rj`|l{!8IvN?=ki?f-BKz%ck4bM5MN9()34LfN44+Q2WQl0Ej04CT&%`D@W9}z zxywMYg}HyN4R@z~+E7=TCmHyy1{6>4JALuoDNtz1SfhO%>%qJd_cd=BZt}ZF&u}EjnQgV%1x9!uw9R(MsaB9>+|?^Z9i5D6(^Y|wsGH*$;=1{z2m}L} zx|_rdfyKkYN8@4wi;M5sFvT613+(5P`1i}4aO*wl)&R_RZ7qqH)PVWYop;~oyTH6< z*l=41>vTF|J|_pi6GIi*i5vJm$$GKgtV#pMkkuuJBGe7#innkap8$q)ZN7411M=-j zwMA^4w>}g{iVUESA$r&N^eBEO>JdjS?nC}|AT4C#hX&@`)Xl~O{6wFk`nv6b^{CUL zsji-t2dZt0uiRzqA9K#(;$7%>kKHiL<0plF5&ItZub89tKnqXwyvJM`q3RDtJAvFd zEIC=E0c0DMO#=ewfiyj-Z|8w|e-}8L?EZvfJzS!_>Ty4RE|$QzZ3>9yzqD6+oCm_} zGHdpYGZ2#K+F2(gfuLcZ5u=W|8|8*UWo9CvBv2bp59$I%TM}*IbQR{C8I;x6VILP( z7PVh819^`OhfU>tAlH)bl2U>>M-o8Lc=}DzmO@~yo1wnrtp*lrYJt5d4=hr@pI_88u*6!k_q^r-=D+&r4}UHL z^UFJ>kNfcV{+fTg82rT1y04;T7PE;6q zlI`)t%u&P{KNN-kt$Pa8lOZ$apQr-n1%`}}{PQ-g|7j=}p&L?9%WLJE?i1|QI^{=&y zqW;?K`OS+NzCifl!Zgt<1;SOml=t;)AgJt&i!-hPrNV+ik~8M=FMRz#!~4C8h6+RV zqf?-8d#iJ&3*M9dL)q1>Jn%FYMkvAA!FoxfXdiTh!d^owt+P&e_=+gM z(nSR}>QLUFNO&Cmzb@!3HFq8Aw6?TbKP>}lxUTQ+0MyM%sU;l~l?LS;ql4kL_^(=h z7&RXKZB?U=6F=?)#b||GORXf3ySIv---dX+qj1O5XvC|2`|FQJqVD>VeV$W2FXAPY zS3Nf70P*qpL1w}VAe!9n_-;`NgemT+gMGN4N8jT-XM;W}w!exF2j-5a^>%2ib_2!H zKM$G_e^cB-`xfjdhPpWm{^^MOAphBO4cC)*n2%|Gy0d@+a@Q9QmQ&0?c20ML-|=f8 zYoo-cauUCbn$t&yVx2*H)MBMwVIxT0TwJy8*JBX)yA(0#_yt(!B<-@^#RAK3=4^!c zC182Rj5n0u1J;o-!bCY8>m%AUB%TGVwbGp&ReiwX7u5bgFPQm-kFhr$`${P-Rf_}p zk-FxQP@AVyhno5Dmd*yWRLJ%-&Vz=yIBCi|ZVy}UU5XQO#&keWYob@rZ@dtl1 z>VuRk*Pl%UI{gf}`J67|kdHF6`cDGwxNwgJy8@_7tpXJU+!L>@`w^6Y{zGLCr%BB} zpj^_V^T}c*`lVyJ&qy?*zwO7JSj1l`2TWx3^QO>`+q3-jrz+}!q{*%)HUeqxPfPoI z%sq*6y;qd<2kT*1AaL3Zh$Stm);low#3+68+;KC+5nI~YB_e?kxl7Hw6>(kVrRT4v zPk~b0o16RSYe4b+pjjb<42l#+&Rjm~f=*pjTd>i>xoU)V$65pAiR|?+S7SbZ;Lhj| zb(mAyE3w2}jd>;zTN`kq2xRUh=I)J^1?l<>hhPWHDGi)DvtdOP2)t|4(Ruj|SZUXY zP8(H$b@P}mN2@lluC@*I?OO&`=x9pj(k5WJ6?qMB4F;C+wx_;Ii@;*v6s-9B0Q=2X z4U>sy!0gf#k8fxK=ACCQay-hwbPQ{YUBo(3%VXV0mw_>ma&SK9I53iSth<@(hkX0+ z#`ZwOQD&YW+9^>F^prow0#3IOC+<>g-ein8SKOLZS=4R$9oy?C5|VVDDyL)#R>4Y7ZGVgF%OcmUaB z@KgWpX&^1`4Ql*e2&8DMDI*V@dleS1mv{02v6!T1qIDC9d&=ee_uxK0^g4N#w;c$f z#HdHK2_PsnO7{Q6yqVDB&OG9~L9y<-Nq;NySE529D}*aS!S=CBz?%yoU+nX6pCan6 z`PMZJYocz>p>=ahDCYjXhEaDbX^>TR^{VzVNBmIj{m~cMsMCrOjvYt;vz>Elr?4Cd zJW6W*J-HTG72&~YnI^z`rMIQ=dp59&W3nx(6@is$o082;0ai@Y@rx#H!1DUs#D5s; zwzqIr@p1yN$fl<2(%OMJGZOYm|1U7hVpJBpHGvuKv>+yKi~Mf}?doOR^Zz>D<~fM- z)x)9mn~zT8yR|QcCWd-?z7N9$>N}u6EK7VxO$WN^maW?-kSF;ba{VzU@?94{coAf+ zfu}jo==2&CIcmLMRJVeHQFB?m zb`{9q=EzVP!@cj9{dgDig%DQNN#=ErKNoXfBP>DV77 zDqeLUrEfU-U$BHwkq$kOE_>K<0y zSpB;h@!uPfpM9)Qr?vLw2kos>m~#{4T8umjb+7PNgQkDTuRrO!`?>-5!WX{(>ys%% zb`P_*;U40=^5Z7)XF#4@%pX67cc)LiKO8B7c;fN}?;pvhupSFNKJ_zL55n}O>!{0m zFy>L)g?c$XUGKhF+&_9rr>D{ifZ%t^dUB^Y5X4z#WOXS}ay-$;XWR>lxr$7tY!l*# zu;NiD@=e=bhL*m@J57*o<~HmL*?4vf$X-)bJ4l@ZnV<94zgBXg zFFpLu9;O&bpDY;)dY%SS?6X%)3KT%V>u{0d{sLfgtT$;^oCDV1_r=ZwT)_I-q22lo z`^X@JFxr0*SZ{{4E%N<=RUoZm^%CE!i|;qC-V}iSW!rZ(0t@?!!zF=JUBLY9W1ZSw z3(RMiyOW-);ygTHe_G@@FxTCXJgRa582w-41?UT?-&#>Eni7t_6Q#WO%4>1{4Uo)J zuRxybfU~g)>gGj9ja+u_1X`~DId%~0;x!GODs8U-wK0>k!n72q7PTH5x z9lgj87K#bpS_ER@q3>o3K0wsTeXSN-2!sz8uD<%a7YHYZ%MTbkVy<$j(5bp{%*AZh zZM%&*Whw7RlpP~Lq2D7nIuUVQ=E*^ecs-Cm(-hZ1#Z4Dr>0^~^I<|9Wi?3U-RA39oEq=T`3asTkEgfatPe#S|%yCBmtKpN<=?{Uxx-0AbiAN1s{-akXf3E?S z!Ev*~q$OYp7x!0(-2`U);*He0C|mQ-3@;$PN{#-|`;ef4mYH zdtB0d_9G5FnP8A`i2(Gd^=a*0$mf#-iufO20NT^CRN6e^CwnyXtsA_6+O5VPp!W)> z$L0g3Xt<}3H;Z}|Ujb#W`2kzY2%!9IFe|fv4Pw?Uyzr}F!*B0txG zoIs65z1|a$b#mAja?AneD$c+gg0>(-y8-HCbQ=AsF?TR>own!eSK zIbdsi=2@w*6WCk4dPh*#z+OxF%0I~lw*1PBui;o9ZpBNLOU1w%4p~g1(6Ha^Wbv=X zpA$kjQ#c%fb~otlsN*_Z`$T&i>Qn>-JwJ-# z-20T9U8{us!)DOc$D$dMT13y8gx9w`EGdvWsP6Yqe~{>aTg zf0B%_)Xq88OpvCpj~`rn4kU-) z-)X9`0Rf53IU%YDu+5`y{lNTxwwcJDB=n)P4YCHmp>CPIWuNf8LaiOeW;bE(FvB~kX1Mwl^2EX8GCD_qe*bmRIhhHd>twg>dC7^s z5ijY+PSi6xI8f{j^D(dHtx)IwX4IuD&_ydzm$kGZRq+ECCXC9DjHKOr+>w`55yJGIFEdln4P2Zp0#P`ahpuJRI3fT5U>8k<>z}}yb z&^UJk*jpubwft)VwoK{1{*$`Enu%_1|6~fR+LHFfdi+kV?cemlp$k}6k@m|UZUaju z$mmX04=_8NBqxP3fqCKN_Z?k0539a!KTJCWjJ~%9o~4MVgk2}yo#6lm(S7qN51fBr zB=8Y8;k>oqG*w`yH|9Tl=b;k>*Zo6QHa}Z1BOTMsm0zZSMR3IunJ;=mI6I$NW@m-5S*U zGzFhc{0PLHu-ET}(O0B)o?WN~~FPx%D(q zbXwQHIo=BIO6nwTbH+TANs*2ZlUqPuHRz?pGt6xWcV|X#`GXR!eWHC3*cT4c zO=wlX4#;J04D*(XXPxb-ZlqeYRehaWSIow}`cbnP#jpPD`7qI$Hh&^M;)D3?&|>N&6}b}s#SowTlN*NBjWQv@ElR+3FL)G z+q%k|fwA#1^If+U`a~O>SB}&G{ixSu17|4Cz2jf3C6PZ2i0qwKrUPwdT#O*^4xmQw zZ}!RKLOw*!cI`^+>z6g+wzQ(2k$-7$^9<^Dy*yQzVf1JfR zdDdL}Ao|Hz6-}PIt{MR=;%OSGB@$S=`bM`(6M^~nuASSD!@zvNJ2plT1m>apLwrf! zQAc0(utq(n-X9SDiF-Sp~Geu5a3(pl|xZ*aJb= zMfC5q@vVFO8K?=Kzo+_G$g7LGwF{#!I+1Ubzn}n=MRJJV=h2rCWBj&{^EgmeC%nwj znFR7hDoZfe9>{#(W`);BVm*2SVBIAk$#iDhZI}b%-G&~Ci?@KdIeYQ00v!moRxa-+ zu#a1}EDSx2L!5o$=Sc8%P?9>k(}DLbD4NhT|9azH``C5?&Eyu4Z?!Iw*TMX8sq}x( z#G=v9b}3B76?2%1XRhaygF$xnYtv)CP9S6V>HH7E7mzL|KguKh1F3fOKIRF5WJ28; z@eyxWQ<&d*261Bci`zqKbNhk)=odnKNPnm_Kvn zp7!lB)L-*|{NwR61jtdYtTAf`Ag|HX5`g1m8JuHdyOvH7w{EzV-!@Ph^ zv4&y)CV}ueq|0(6?&lUeP8@H~A;EZ5fa|aOU&ZPbMIn`LCvl!wqEq%xSzAQ~((hgOKFIzL?w45wGz8 z^Wn6Uq1-VuqMe_x9RUyV7FIA)E~m%?^}uMT5s)uT`iKd|8EMgi^_fl zs2u}#GAnPl34RxTZkuDe@jWxX?t4#j53mW1Nh_b>o-(oai}(WWiG{<-V*w$+a#wmb zQMVoUcY(Hkzhvwq!_Nw0*8nqU;GljB{!Gy_+JyH(7}eXWmFf{cIZEMOO&bFGth&C# z9KKtT)$9J8asj%ySk41x0OGx;POCZK-cDBiT<{$6th+gf6gv$N$5K#bo1zXVeMBSl z4d&3uA3PRTGzyf2_MeA;VO@kchR5p#fE<(X%lNc6kOlm?rGs$~yqXk!-XIh8)*oX& zzD2$^b3^Qn9eJ!S7|B?eL&(F5ey4swYm|^|*k0iiyN5?J}^c zPTf37`3kJyHLsr7;~uHHr*mT_@>RpfuZ3D54j-4)Fn%l>n41Yw`gm`J(E)d6x#Q4h ztyN`sz!CYXW6xLftp|GipMwVEGASRmlNyUF7MbP4Pe|6HzG5$ie)$b6q{=H$kblgD7a4USUMhs`LDJ)w)|-z_pQ>{fBz=j%cuU`-GX^o5p^b% zIn1N(UU&a_{#B4!&$Gi>V<$*QZR9pVu2(AMt%Jz>3XnY7HSzk)Gg#y1vCEum2-yD` zuD*)JxoVLw*yjF9V1I92A99QU>|XMLwKDkMUyC03^HT@d=|!H$(SOeNm)*=8^#<6x z-8!!0-50j#n-@ay_)c}%o^s+w{Ql}8@1g1vVCjEr$>JNsz1>tgdHxmRD3vRsdSZaN z^PKECkIjfPzCOP|s{zK@{`65{6<`R-y;2QF+&!)03AIcR=uCzCg}ZGq$0;n?BW1_` zc^fMx6;}YY^nUWSdfZ1;Bzl(zuY+SC*qL^mX~0@E8Ut{ycAMKDrSUsrMP_$IxGBEBsJ)#ktaXp~qcT zEDhF}r{=RJO@OHxl6`G0?g<*_doGs<;oook;kUYRz+~S4e5DETC;6_vnWy;v^Gl|t z?3x3{>}jQG?eoC+_>W2);Q>b3b4vYF^dF=?(L5N8ItPF5^-xE}zEEVbW|ciKD6Pqg zgUHX$`W}cS|3luR#HNG!33InHhm)LJkdHd#5t1egbjg{=8+YDBpJ8NyzpWY264xJU zeKZR+6W%sfp$E`btB7dnBaZc|ep!1a1gPHQyLGQKfl7RArnRvX^Ouc?FHT}!X+STl zVk#4q87Z|v3tT{XpYnI;!#$uxc27>NUj)h)Ra_rZyWkbF4~FIOaSqa zwq1CC3Fg)On^Sv(IcHt3$-gm|h>&n$MilRj5Dx4PCzZJZL4up3IeQe83Y?53(66sJ zyX2y^M;R0>KU#4_;@$1cBT4>MGQiBzv{?{6i8==Pe$75zoKMSLJGN{C=2hBiOMc`t z!Yu3ROq_t}b?B*I9nMFV>O(;@SU1hZ-4Q-}fT{4HRjdX3z{2qzc3aQjJH+1h;D7&Z zj+C;F%m~&;Lt%0C2ISH6z84=)!2K^|$@&7~B=5R5{CM!czM*pTbnsrFTOAu{t!KRr`5a3-eAQ?qyx^e~Y@4UAO0dY5{dzT|IxZAW)NUrZA__SEZZqK;A?F zl)vp-eIZg2=dIzuSk#XzZ?An2FXN4RAfemq<~uNN<9S>o&tK$oD?h2>l>9;xe zS0LYb>sW|)B+0wqG!ZZtm9)6#W1vSHkP5CGRb`<5+Rj96Q5f}FlDjOty2DZL>)p^K zVGG3Yy8AKod?0G>TBi{CKhHaUJ$7#o5FQq6SEr)x+C3`voFC$ojG&cHbzGqImdACp zT@Y~>R)}+@Dkxso@wwF(1oFQxUL5i!f~dpfYw14Z1v!a7W~K1&e|aF!tqS?_dE(4; z>?L4MjjWxmoC9W`$}ey7bzr^`lVh_s0JA9e-ro6s)So=4{d-l1ulT^ar|8`!gpF1)y^oJ8=u3Zm#s@wou~#{FG)hs|)Y;h|E4DX}V&L)*9{lnWQb^J*iW`5~JZ_{SPR~dFly3u~YY!FV=fwfb;^Rx!S)5xB z1`--x?Eu!kW0w{~lMw%i%PC1z0oEqIJ7!*Kz>@#8V*jWC@=$`6pVb|KIrMO|yG9<) zvv2>Z?%xi~l;Gv}<-36C*=fxgkN;|YF*xYyf_ldq>Cn7(V6-QQRa0>vyzcJYDvtV8 zb9Zsw=crc|eN@+wYzp*7ySGyln1d2>b8hVa_iIzc$s?WlsB_r)NK@e&&|;R%KhOQf zKGL%~Z5sReCr<0;hKE26zMX%<2mPRgPpcmv!hE^%pY$<$D<~g5#kIA67?e5Ef4Qx~ zyOWuxuIgPwz3;A}xBxT6f2YQ4WG4RrIWYvI)X+DrmD(&kQwO9m&CxB08Da_egMJKsSPGR4LlM8f$##9(}OevS}W5TV)ej57SWpxThku8}$xCH+FvU z^hAAd{XltJBrsy&C)_r|J!GEyfNDQ}C&_;ba#jYQ4>V-GWIpBswS6L2es%+8k0<^z zN~q7`KjM~{91oPd`d1Ad$Riqlvy>^R1@gB#gEiyZfPBrc{6C7WJD%#li>qWNGuiIF zuIqAVi;{9Ok_IX}du3%MtCUqC8c4}V8AH8neQgMmJg70(p|6(I0)4ptw=y9p7m#-;>aa2`-P0AJE3G>n8Yj18uM)dR)sH zXdSbzuCsrDR{w` zg344_P|F-UWC^I#imLJJda#Ik)JiLXJyJG^^*%CKw_%JA$cEm!#^s2g zOxQXVd161mw&6joo+uSpn* z0$r&saz|Do@*x2=v`ZX7=YDIMLB5A|>ls$5!1vHvF<*Oa1JH{6dHcsTffgg>y{7Le z(5&ipg8%=HXz>} zB5rbsduxR{<~zAC|8a+cGDqpX!B*@a_fJIGsD+}A@#%qS3G^vUR<^w=!hPgQsd&`v z2Fz`0<$sZd`$#>U<9dPm6RWL5Kc~?DIXNTZgt=;p7tDpIm+<=~TeDsW`9g9jRZaDr z7WxvxhR&$|!+O-@WHezvzdT4c*@E9M))!l!kS@$0ziY%1kGh9IhI*(j<}AzlpZ|R} z2Z;6FwW^zYf#@y%P&7;&h*I{X_!urAH0ZH6%6ATWlhrI1CL;cPi0_q$^zP7%`_v2#N zA25pjMTW8E0uScbG`BT34&Mgl(_Z&2CIvuQQ6<5*1N~WVR5?Zlu+N{U9=|<`{bk*9 z!CG$I3-3#pjrd`I*E*c|Y28bpbhcimDq}vTXIl<;LNh3?q-Bqcq3`gT%z^Kn_MoU( zDSb~*7s${3Lxhjffo!sU)%$Cxx1RVLeq<>N_xJLJR|y=TKy%5Ei6a5&&7W4`J3{Dd zb5PzX`5%x(Zo5ceUOn+yPOwU<4-oAn@K7>FL>}m88?%mI!FoCGe`o1m z1oXXoY8Y<{fljRIJ*OrJw7KrmPY(7f5hxo~lil09R z(BBjLM7X+QA5fJH0u_?-L8-c$W6FCTl+1SDsQHL^?@x{efv3DcIkP(&dia3Czh~sw zvui9q5xSxXVnLLTvc%ET&9ARZ~sJ1dBOw#D<=*$vr1$d)`A zih5y!p)>VN3g*VnSM#ni?8kcvt4Dimw}M2{HKLF^Re8dpt?LcpG4#~T<1L#kt zx;3Pjh%Z(Y9BEt!^pMt0gY&q@o9xehwWJSpl^xF{dW?X!P&QJ~g7b6j$aa}`Z;@vo ze5i+cVYGd%o6<60;av79=z$pSJLQreRQC*kibuohznt8lBFRs7JBIsY%?58f56nwB zzER9GK@yaCwAY2o838q?c{FI>e#|lbmGhM^3zR-}oh)u|0wwpROKaKqom%=cugswh zl-N{vo>Pgam*Z4z3<(9rY~4rOR;PpFmd{(*`lw&5f0q3?U=YX_t@N0e+E@=67N0E6 zz0sErc3eU|yn>khy#Y@kRXvOpT0nlpX5YVK%K*fcUMrhvBH}8}rdCResC#(dGaSAR z2xAh`AHvbkmbA%b=xbkg^2#=HaCvvmkxqFbK}%sZVAjE$NcIN#8-a#C)Qo^ z1=+*@>hH%Q-|qD^tYS0X`}%Ek^|-bz2+NjuS9~4?hJ?i77aaY-*swvQQn(Em>jbve zJ6;F+U#_D(mjZ!4!doS>t_tYQ0Sqt*OGj{=D$Yjj&wY>sRrVXySfY1t+6%4yBs$xGN}O9eySpO}&nNBvc~f zDbC|c{GZ~j?{305i-$wq4tYf4a-RUX68DhqyvqGbpr}r^T)z(M(bTN4TU7-0S&f0V zHkf-d$;UrFhyJz;=Q{%4aG~#$EwuG1?i*!)RhrJ@y&cnUo#V|PfH>R6v*ilr{w3G< zRb4?H=(%u^cLw|Sc}@L;xx0YCcwdtc;tcXd_Cs0fOCZnl@VaA79nMo; zAO9T2T;W4Jyzg|g39DdDqDe(!Q9lpQe=MwTIoR*603&>X$ z>$EBdp)UK_tyLTUKPPjrcK~I=$Kqiki#S*AoE9 z&DVmwV^LRXeOcFoOB4IY&}QAD8uWd}U5R-80~DnFr+%MC-TRZoO?q6zKr;O7a<^U$ zh`;vy+;i_U5aTM$q-j=&J8GP}7P}n?AIbxi_{vciq;gSxk3SIPBDOb?+EK^om2e9C zzufn8R<`R9@6uGD{PziUL1}x7?`EvQJl_sw5uSOF5&iwK5B(}q>H0q#d;LLZSoH6O zJu|=v3Ygf`jXzHray-VIQHDpC#x{8bP$b@L$#I#1nj9+Ta4Sn%|D%&A-Tf`L9`Wz*)Ig(!ZY{(9GO zYpWel!*w!h<8v|J%q`Zm7WMEMp_^}?NCqY9i+@2El5p+h~U#nlJ|w;m#2vM%;< zp`(62=o9fdR;iCUIdXO8Q5j4tkds;MP5rYBvVpp`SVI`wZOPjd)cJ&Auw)AU6Hw242)>*!FSTvf#I9XCE&pU z4CA(#)n19f*wiL^(>MwkJP-7atTY3?Du`#M?+qiZ_bxez`__AXUbPnY6n%;HavY#?L-677F&mtNjW}1UA@19*O@26! zeZ-3_(2F>k@*39Zp;zb8@0L}-Ka&hpQnliZE9g5cs6XjzAAMD+p#r~K5jWM`e}l>q zzOY&DK~VmsdM03H4wR#`t*@g#LV2S%&XXFLKd@9{?&5@cAnM~AEI#z-?jW=3QSYGT zqfJEones}w!=Z8#D0%@)i#tf5_<9wQt%`aF!$S=RlT;ArJ>=Lp#)*2;$=WO-^m$Gw z^ZKX_g2LJ12O^uuFFLSDc(BNF@6s895WvW z*)7Ij(yu=Tnakg0o&KQyJ>#F5*ON?;VtVo0o%;(ynGdBhMtXoTS5$w>vI`h9W+i_M zp8?~CLDLA66Bu1-C3#8|tk1!`Bf}^09eJ@C;x51l+pyLAF7|&Di>?)l+^CQLq{#0rzZPf__mYSMI0vf;KNr1% zd&%2W&2VefHM*a*vk;TT9HF`U-DeQrO3^L8unBdhDtTXu&+Y~4Ge>dxjttZTl_n28 zW`R=EkIaqZ*v}32s2~4h50v*Dvpcse0L3tB>6$MO;_o|0uh3ON@n{p5#s$;^b<2=4 zrtvP7qoSwK)*XnKw7av?@qL8KEcdR%@0P$X%L8`Ei`>~Rz(M~6B-Qb0E-Nu0zT;FA zxPg7#&D}hcm;ppCF@oI^;^^5kS;oA2nA`9V*qrt z&2W&dEX`luasuxp@a^5{uY+?H`GfGM{n zEp6;1Fs0sHydL}sm_pZYQYllw_;<7XG3v+|!+k!171&pr&eUXB3SwO%*px-AOE7P8 zUsfG3a6OIRw+IYD@mXujG@!p9@R=QsM?UezZS@cLfUec9A@dFKvEOFFkM=77EhFg7 zSC5mZd+;tA(x)STcq&kBHv|0&uQ*D2s5t-Lj#^Xo8k7sP4$Q9Q0%eWKQx(ISKyCb0 z$ceZ=_3+tWes}OY_36jfFWY=U$s#~MdHyC)y4?NLucNQcOyT3xj#$+9%BJaI9-5*# z$7PP$cGO!}bn6DC1KCMaZrC>_*hf+25M%2tl6e@AkS+^VUE}m9j|9mIcDj&9}PxML@oM^xW-u^ii$J zOC;w0Lfu2`>QV_N$lf{iYswgX2!D)M^t|6=F29iD!n0xYKW|&O6(5OrDi~Xy@5g=~ z`1R6>7GYp&uiibrb~7+FFFoIlyaIEZO47rr9AGMZA6owL2$=j$(Zb_Tfid=d)|>hl z7!5{Ro?-gHNF{OX*^mbe*I*(q2mU)Nuzg0$9q5xft{*KCcX_}oth=@r=(fM>A7c(N zT~L+hl7}|X$~Yf={dO2=);FHMwQK>Ezse&L-*N7}F<-e!&>Ho=I=rHZy`Wru=($hp z2~ak$$UI(!_+n>)@SZ08X?ywERTa!b8Q810E=Q9mD{bBfJ9%{-KU2-xtIO>R)X8mU#KwGqlNuqrnahO?hE>-9=~b5R0ah0(2a6u z50KAJ|B`_|Ub&xD@3`9{(XS)f>=f$`vKJCJ)%Rl`?-m`}B{;Oz*w&*oaOu$=#3m( z^k!cG{q*YrYl~>0D|h|y75|L*mt%0-H2yr5IWdL$4w`67$|GmQ>kDYU`?}jfWzT$f z8~ZRQw}#jf@5zC(&8#!AE)4Z2ML)DPg>dejRoDKbi~217+=dBvQ1aTXNo>7^JXJ?@ z;U?q_owqwX;ohm(_dDQzrU2sZ6=l`V!MlcZY6>$M@%BgO)1@*opLE4f z#yJjo!PSv*+dcy+si4U85c)qUlZVod<6KoyA;9wi{cJ~879aHg#yzkgWJt0D2+_~> z*+f|ZK}pze?G_%Kb4`o2x)B%oIA!zcr5(u0b^dS=zYemVzbDqQ5m&ELPFo&|#=Hjm zlA$~)ke1_mnZ7*}^ZuA_l3%4k=qQhm{DLMhFRs}BKz$}N$}?weIexE#%Vq_~ZvgZ7 zuXp>7cL38+EbpGxOa~^zC}J{;PID{OS+)jz779m=j;ca&JIheNngW|G7#^ zfkQW51jqqp`d8^E#APTRm9KY@j6w1Hj7L}n>g62ut!f3Qfjp4E+VlKsARp&sP4hco zJ@zW9C#Zr#fKA-Sapa>`Yn*ENh&c{d-r0nE!)pn0P!GYQ@x}g z`gJB~O?Q`p5JuoVFBbs>*?jMx3K<}Ongc)YINw%LmGcbn-YR!dq*^-O%QHTAJ7@`c z_MFoTW8nbOi*dQ8qIkDrRdW7{E8fRT+0oRd`wfKljDD95Q~+k4{qL10uE5N$wO*IB z0?d>jRJ(0@Sf`#fzSdYDuLu9la}5I1z-eYkj|fa9LQKRJBVf!gEY>B_fKexWiI9F3 z-$~rM*`I#6uOyUy^$zL*Zos+sdBRmy)RUf{=i17b z160nH0hzVPhlI=N+y9P6J!w{L2HpXn`2NnfXYr!`y@Y5)+5w6#_kyHN`hooYNm#qj z0M_GmI8iqn`N0lWaKvFy@NX=Nu0wy}zxbqU1#Rd@5c@cE6Zdo3Lmzyu90g(#)j(G{ z3~`bq-~F@5cYKYg8k4ldJ#bLw(_0b{#O~L>aZXWs zSd8Lc-=}m#?-PE%vbz6e>G=Y~p3A6f*J@yF>{z@Qo`>J9h=>=zP%m^+%S1D#QNmOZVhKC5Rv*?WhPUoQ^@Y=P=haE_%62tq6Jd zFRU~c;_%n*Pj@Qc#JnJUGKsrDDdv~UujOZ;w3;K=@(or8^qML>29dwG4wC#;9_p-cM|@xHo7;^89XW0z-gb{$6CD(1}U``>?| z9_ZzDN5qqf`A`0n=|_E*rY_gADeirr97>rYsL%3VQIE6y0fcot?nh-%|86`uS3CV3 zz zfDmzpU-BP*f4(1oU3jAtnBR)phdBI!`RQ_w>0kU#)$wX7xAy}xpE1AZ!Czp;2s&w= zs0F57y{4{`1u!>x9=^?y0*ocfq43?8fbl}|o|q-pA;kB%aKIU0u&w6RH)|tKDLAo$ zcmaZVtp$fRpr4_jEoNW_Xm3TXZ7)Z?mh+~Tfy(p9+Z(CGGm+noe)3^8e;?`?@3X!k zZ>@YQD0j>G)1WNtv*oWm`l-@-l+6)erb-I82RCm+{o*mzjqYDTiI?wQp(y4vhF+{_ zUyu9X@5|2f^Qdd^90)Jm*A3)RzgKK)#7*3&$7$Pkp`Kw%xEkNRf^XSq8bJkf7JV)d zvs8g}VfDnFBIMDhmZxYT*Iq zE6^qFAHnZg#gUYy9$=oH72>r{1m;1$uYC8e<2#X;(YzV~j1CLFtv^+PkuZ4qzwdK6 z2T$`97vBN;pOOuipQ4ZCw%bwr*%q9C_sKh*$O2k#f{}L<>gWPv$2Ylp0gW&4dq_$! zsNB3$PC1El7wM>);ObIPzSkuaH>C;6%Hhp_tuRmaUfN328hhN+Pusd=qaXK{*Z%j) z{h%b+;NL5L7IUsA{yf3Hs5n<3`QbR`op?7?y5{wve~Ko=eXADhQS*`${oo2eL;l*E z;+*RPo^@vEPoL*tp0m7y`6l;1Jv>9ld}~FIW2aHCka^txebqk9@v};8cgh4p zS?5ibF)){EO}i#r@!jkXPPP9G%qoXu`%npBCX?-KG3SWsT=4pgxgySA!~yZU0l=8Z zyIYBl3&v zd7F9U8>QxUnp{KO*S)Eud6TF!Vtd%`{fRv8lgFn{x~&1_ZIVayGQMH1*7&MtHDf@f zMaE`*+6PK^>9;JN#(|Q!#wG;|?B~%k{e{c84=$z6!d}dA@QYE{v=2wAMhnlN`h#NEB#bp+WWZ$5kXzSL!BAf0pDIPrQGNb7{2??}e}k$N$6McoyM zjOTlH5f1^OCjI=@)a$6Xma2M|hkEM~J+rM3F^7q0)Ve!+2guoOo)d}A#J%HPyoHK9 z$c*wz(oYV6%+{JuVb-`ZlZ zy5kDsD9)REt9cRsWmeZ*YQ%lL)A?^a;wL2qYOb@0FYa1QGue!L`b)tD&NLNJhTZ0@ zi4Euz=@gTQngr@r_PP7%nCEam^{SFD>U(8QTpUL09wlDHwGHnTDgLu3{u*}%#ZxMz z3gIvykDFcdjzIq0{iAGb3+^31VwZ!^PpNR?_>f)`=8yh16Y=*_2GSYbt&I*%$V178 z9LnxPoW1RWaXRvWR73B$75rX353gi*2%^5%!f8)%9^PlW6!YNZA&?h7VKB{b06By0 zr&K#LK=w)tff(|C9#Cl89#{0U5x$x2pJQQOANku!ZUd0=R;bs=z5tTz-2@}>dn?!$ z9yIiu0<0rJ&2|&Kz%sbrc|$TBSXvW3<*{SHVqJ+T?Y0A!SmbV%>KR~8_439eKh11- z9uq*uy)jw+?Ha}^U|OG5t~|#DOxYqy;)7qn__VUDIBN)unDi0B@oHdft2@46S%5fw zp}I$-2<{`PeBskZK;O`!$mxeZ#Qe+3%l){wtCK4FEq{~~^Jg!1eXH9GN=4OD`SqB?NU|+mxJ&}dwU6Rj7dHT9 z_43(`J?lX+@ZqGN|0^I*yb~=7M?T8qkaV^RH`YV=l^6ghc=DJXrADCcN+$WIA?|^} z>Tm6etAWI6_?&AL^`r^=vVQK8KwMXJd#jcq5K7Xs_JwKUy`xWO>hlp_e`AqSJBxey zYJz~e?F7i}>f=9g=P<~g4Uu5FIimjk-Pvnn*gphn4sw>C1!=2o2hKFGLCR8$PeVNr z{Zf85%HMB*V7cOW<9=mec{tu5E58V=;{l0cIES&06>EOo)(fnC@?qC7@18|}yWl5d z1}xrpLcw*ohxBT;E&j%RzF>Fvp~^8}o}7}ZzIYRuTf(Y^+C_1XmzgP#BmyIS;eG)3 zDPZUun(B3~2Ku;V$)$&>h&Nh=omj~NIweKo;D9C2%FW@N2yCf=QJ7plovBZ&Wt!A1zlVdwaZrs&lzCPTwDtN;AqrdXQJAir*eh zZ~;oPGo`H311Ma+Ifra8PcB3>&Ue%R$WvR_;yRD@c>YH9E}Y%pTMn#~w@;StaR!#{ z=S~rujlj~;g}rstz#>e#rks-n=ImVa{%RSVk59*hm*RVgxx+F!8V<~Ti79Hg>VU}+ z@l?#|2;#$8`ez$i$fGcy9??NOjKd*++eySvGQ#@(*BSy{wWal84*C_EuA8;1_oFV4 z;2`s)3RHSuq;K1eIw8lG;z>00c62Jj|8O` zJL5i@AP>U0{w8^41}L{0uTo2efx=s}C~S=RuxD&vYdGV(n7;U5>IyfIJr%~wlvZIq zNM@-JEh06novy(*10*(OT zfsfi68qT?JR_4{1Ao79!THNn_kbj~mR5_v!UT)GXGc6SFRTMLd=GKACodXRIoX%rz zUxw(50nC?CjcxFHhdk|OgDF!tychYgYWjU54+zHUh(~E)|G4$i^ZZd!U?o@ob;-p( z5?fQg9`6IP0^U6@kYNGKa*j+qkqay}1CGyQ+kwSDp>F)@EigNmPV893IXL5HP12rq zz_gmKR-R}8rkJ{j-%=IsiP=V{|03V$_w26*;=;{rU&XDMTOHFO zd=POHF;{z2PUK~CiPmdA5y z#do-g%IJSeYwh5AihH!x(cn?^7a08>_)<8D^Qo&uW>PNdv#Lz1RBh4MxvJ%}cQ4RZ zb_8k9bh9ez?fCE8X*vdC zp4N_KzjU0V()WMU)tUhnyBSg${Q&xJ4domg@w?O$;8t)3{e?HrSDD^5!#g}FW5(n? zxSzj&E>5%s>eGFL2hN=WsuOW?8|ne6LT6~V5&u#u4~oCkjJi?>J(Khn%n9Pth@CcD z!JPh3jc7saCpMh1hYAkiyJ^miTj2u5lD77omzeM1EOMeL8F_ZGs87$nPND9B5)+my z0px(+LOUYS_oh6ww!s;B_ODADZXL5iJtJeuXD{--`XP}U1M)$E<4g2rb`SFIhO*kL}0d(4>~*Z1lJ(UCu1rP3CNt5iLUybynpGw{t* z+Y4gBESccHbfACS|GY*4^(C$ABZ8!nM|xxVwK_c==+&FY_H0I8yeRd{6Uz{wr=|TE zx`O{6rD-X5@ix$pUq11tEgS!z->@%2{TQ9-X2WyxBGBeHoJg^_i@6Sk-kpBwKugi* zD?5n!4~|QzJni@nRC*My%)SPdalV~`iO540+*+WHU`~_U!~VVNaStR}x8BHU0_Bdk zBfD7WXN#5cEDXe4vmM7P&&*=(-}jEKQGumEy%HyQcjysNRrAf)|3)9xXVWHU{B9_P zzA{|5SOiK0Kf2hWJW%ScwyNtI0L5J<%qbajWQ7Ie%w-HfvCPTAG9U9D95+ODAN+rw zuWa0gT{wr82P)QT9mYLgR;=0t`Q43t>}UDXpwO_xxgGU13PCwfyvXQhr|oAKFV+C5 zm$cf^1M_5)s7|3xh(qo-&;D(J`46iK$=1B6+bSoUJTe>y;>nWACG_hNnRYWGS2%Hx zarBf8LLc1w0o&gX@ebkEx@IAH#GlluhyHWC1q`*uHx=N4d-a18wf~tR&(xNGQ4IUD zn4V7aU#!Q!^?R!-s?kTadC6{vF3?}S9NLZd#OYa0W!CGj0{zS}eY?%5XFxyTdNcG_ z5!?=K?p%*LRN?Et507C^O)4qhXCv-^giBUvj-si)Aa#j3g39!@zI*r4XOdr`|0Y!e zRBVr#N7;ISicpfH>^c(qOJY}zI2D7ko83%Q7U~#b$ zxO?3K1tE!~^(6FJRlm=9y@)uZU#m~iQ|vz!i4^~1R3LVze-_~r0pe9_E+69uK-4?D zdadLD5dQf$o&Ky1gzH@gtKHBC=PNqI+@l4eb3fw+(D%%^A)_>$xdj+WY1}WVBfyB4 z`T5!z`SGy3na8Q>!0_G@P!PBk80MXt!v0~XKS|p&?~najHeOX@4ZffGifwsZSeJL( z{|gV9Kp&Nqgv-Hq5onv( zqT(rtSADOMTB7lSN^L@+j8h*YcpF{C7}Js;p2<+yu(oz1Fh1PoU0M z?ag-|+|vVfe^U+pF!!WR(&|b8C_R|CK5+oQTe=baPgk*l()X@pq8;zEhJKLjJa!%^ zGG{x4{c2I~@ZpinD%4%u)WkFkSAgQ`{r0c4bbx%%!E7>I7RUx`@)o!;U-^$x;rsaO zpm4jPkDg}(3j4pl=QqT=_j8Vn?PstKIfq}icl-mAahBiUsog+YdqnenOfe8k%`wp- zAAJe`J+#hw0Yv#DuYX@doo~Cw>Qh-S5pVI;Fdys$d8vQ#kttpv`Vw4*PwC-&>f&5V z!@v7z!_v33d0>1SmowS<4HzH4{H)+ays##9*QXG~b02KZin%igjLZL-pLGlY#tDM@ zxkN|AbCaK6PQd+7n$l4Z6+r(nv?zZ01JIvN{9c`ibL|7jeH?{XV0Y&)SWPe zT#TJS*^28V@3#MdIzJRYQ#lUQgk|?0^wm;T0^Vih*Md@2@}N`H7$})+KACjN5GZ5$ zIj6@khy45;sVSI<`Yge+n2s(`tQ@lniwnRzx#vldE{LZrx9WC|)&V)=twPFq%)8d| z*eQAg-^FkqV>2D`;LE2ghMW;+QSE6;yjTdNzSriV+1x;iQ;Suv-2$W?^0z5BHUe?@ z^lWDa=9}Hv%a`^9{R#U51AfgT-nGO#IV1iI2!(S8R=-BPUei24(`yXmn#JqS{rdo- zSL$zciZ23lC!c0+6E85g8{YEe#kq-1R8+Lw1x!-pA@9|5z!VJiF}fO#JiBCD_z~Rq zx}4Kko3epX;#12G^uziXa6LJJJczwWS5zt1li6W7=5P$?b0vIM9_Y)hcq=<%a0vIn z?Te+iZ{nOQXB0=k_c3;RDs+^H{O!PFVfBOPV-P;{26LxW=8o+2OhY|Z`iI1YaYImn ziqVQ=1)$ugNw(gDc^hY9@vz$}P~On|->C5rP#>yOJYv2A6;_>VTZ1_72iM>)Re$jA zq|N)2XOK^yJA8h#S1Io8Y92vJr-7o#9nS5KIhZe={nFG&Kb566ht2bsK%PtA{7QT+ zkdv#(yIS>ttd^My$=ENtcSP-TH3NmS;ZyQth7VlK+J-6NDDpuKYzRy&V=l8`624O85JMqK)n z+baqx^{(wDJ48UmStY9eBhF>3d<#Bo#qZTEpDmBt{(&;vf~Q)38K|{(Yo*R!!}+)D z`O6_P`gaNq4BN1u_~?cSBp(1Jj=4S2thYc(EW57y@)A&}5e2JCT+p|(Z`3{j?^&3y z?hM}_h5O09Z7wDUfqaENEOis}#~HEzKL2b3h303^4c_5*%DW)q=>}U+5Vh;4?oj~J zv)9);5_N!N+wY@a=z{o4X2hL3)IAh0{~pH2Vx|ScKwRf%e$U}4`gP7&9Pc|1 z1W&G3gSHnSKfx-x{}p{}x@osE0ox%I(ytA&7R%l3A_{~yd9#k}g>ACbq+J2kWK1~7VPlayS4 zVC0$IyBlGOb??*BrFjY4v9AQmeJn*? zc8>VU#su`E=wIJ8QtJdNKS+uV5$I32FmZkFyA)6%usa(_b22$>?T%|u|Ksrd!7FF4d_tw|_Osa20{PBU>lR7o2RYvL7E;6KK~z+?{!wi*2nv>%uqq1!eZ8)2Qox~)GI0y8zo`q{`RF#Z3&PBdx3y*x8u z*62Mj#dF8k=#>GZm(g)%{ys478h^1a-UAG~-O)9s=D?5?qV1y90R8RMqnZlT0i6+u zvhGwx+~lhD=LCP`L++FA@}qCgEBfg$g$1;A_RXO;k;lz-t@B~gKt-d?Gi%HZ^T|7V z%MEcKv3+ECLIL@yvFq*WR7s!)RO=ix=LDsdvoojcabLfyf#9sfReG| zkd*chC``-e#5uf2RW&@@e6b((K&g~^GWu^v-O^$iD%YP~Ug8Soa-kDDHhcKV) z7iq)&u}jfKo9hbdd?6-{dIJcX|GK|Sz&-L5J@$lHGUjNx*}U;(g2=>p@8kbwfu)_k zv_1)OU5L>7y8RLE;p~~V11Er`^j}8l(<{Id;XcDBR0+&Kx}IH#^D{pNk8-|R2Ij+O z6O%#6AD)w(`Oqp3%mbwjcifACDN+>Dy~`Ts0mZ#a-uOMcs_vpJP=kDk_`>N6qd1QZ ze%>Vh9q2jlLnb0|-!b4R9zJvcXj3mzKTj*8e_hcwU?>e}bU$7~UNh$Xel|(Fjy#oF zN_ftODNr6B+W1Q6Hs<#)RX){K0_s2URSrhyFxSDCvigG+Q2A|KeiXKY(lv65Vnq_> zY?w<=bpTMZ#%|7%0)WD9pN}hE0L5w^yZ8pYJ9#*0i@+hoeZNZyFf#Fdg!I=>n0uu^|T_#PN{22_R8@Up1$rU*|2E{=hW~ zb#o6I%DqrOC-HCZr>D4Q)NF{}{v7o|p5JdqmD^(9aCy{|)r9w4BKc_~yxWqVqH}w# z35dMo8gs+%H0z9fh1RxFUcB?SlScovS2RRDkdTu`6{R2jxspYzG%@#YqwUjt zNpIw-t`un`rr=(<_n@IoEl~0TPQJ6k@6{Gj<5RJSqf`so9Byd26z3-gyalZuY8@X!g1-F67nfIG4qyU76p+ld$P={hFeRstd-^r?=QQnC!AkXjP zsA!jsxFcI;D(*Ij6z!AV{mcSbkD^6|eDLpGs4aE7RUTN`0cu;B;>;>IP>2nAS4t|CtZRi=Sam6VsQgY}0+@e_7@c zSI^!C#t8qp|86V-BX$4oyno0e>T5x)QV`Im72djqJVX5nv06I988CmtrqLPq_xJl{ zvvL2TxqSB)4M%<4!r3_g3H)9~AKCq@8+|;Y8TZ^5$3QtXi%aFy04Nh~M~FyaU%&ft zQsT7=@`fotMDZS{QkI3;`iLP=qLe;9>x{bhhxZtR_K2HoliHOwT!ZykbH}zI6YuGn zS~r{^0r~6Nif<&doMBply7&9v?}Q_MN<3J{QK)?Z`$oL$N!J%ZxT#jr)u@5^W0|PNPHB+; zBp6^Fb`s=1Ck|c1z9FmGsylW-5=0V%)ODl~#~qZJ5(oxh_0_dF$;$xi(~GbPBO_qF z5;7ICJ&JXzYjDkr0oK(Y-UGMrchAISf6Rer?dg=r?Arh=p%12G1`m+0%Gh9h9`z7u zcGe4|!@#uIRj1JIj(SJiU47N}kf)klv^lyC@kP=$!{)u{H&Nui=FbK6Qsy?Jj%A=5 z`!B3qK%eNZ&8KDOqDjIna zRzE{M-T|opl?~QMpe~3(xE5e4i+kaBa;ZBZp#fM`5 z_|E(&ngfal%-jUKG3T#KU89u;_i?wd+QWPy8jmX*v^x<&EtOo zfqv_fJ--RaKj@w{duRr7g{kN2Zxcaw!=|aN#*rWrFjeDr-{`|7& zW}trx6uN#mAAO81Qe(ey4&%ABQ}-77-ERGyKerZrJ<6=d(ytRhm;PJ%fWxqDmECDaS$r|k_u9@nyOEhAtIn7l`-3tdkG zqj=lVO*qFhOe*#B&i)7V8HLqN!+VgYx^t?3^-G|WPR*t4e*v`O-sQ!s()ln->=+qV&QSq+AVC%va|FEnY3{14~e^7Hx& z3vWP4?S>q4lQK|BPdiUXqd!`mbb0jSU93l_)!n6Eps06d=tXZXkXuD=5CZYOx-FYZ z8At!xc*EVP7}ULoy|FHkO8|upjD;URe1P^r#88hG z&I{;EkoiGXFXqOapwKn{+6FQAPhxmo-C-bb7bkn~#qX8PSrrRKyz6bHtw)N)dw31x zux3Gf5ZT+-=t*@2w(5=9pDjwj-umJ0@TP~rW}W+}=!5TslFO~*8w+fy{k#rCCHRg` zPQG?H0<3W>sz!JyuwL@6?0BF9toZe>xfeo^_l+YS^Oyma@V)GX{O!Pe9oy;l4}XR_ z%s#VQ0;Y;xWqgP>Fg`rf?tlCV7$-B!(kuP|L&$iG!!q*gd4eaV-tGqaPT{Mz<5-8L z)Ui0xZ$LXb^@4D7GpKZ%jf7EP}IG%{`WHK ztXm#c&J^MvXnD-lWvd19BUhqzg@-^PSaalM?Osq=XOkULg80at9))UFBF?#wq`nQ| zoZI#~`hvIx5Pf8y@O~o#aeW5u$MX{OBWTub$2$~+!+)*|HyMEZuM^Yy9!Ei5{ij68 z>{*ag^>&K583Hm{`u3uF7eR!*p5Y=P1MCAvyduwqfvq22)Ox7{*g6|O`_HNYd#5tb6}Id@p=W@>2EtfHiz-+~u_-u!<80n~G4M61e`^wdq&D+9sf! za0Tb$v9dpE$8a9b&@OPxM7^W_moqt`eW*hzTa4{OpUG9R@f~Ln&!j1fz7;~;>*dxS z{q4xd90^u)dN+i;%8p$pG9Cf#c-g=Dqq~u((o)}Z67z^oNC|#qVIThyTlYC}KPWr( z1p9ls0`-gSAUy~5K!<(h)!Z(CQbXgKnc!8Rv`2-xr+p4{fi5_-9Q_LvjW-P+{pt}f z8SS5DA`hbd{)WIB#1G&2koF9R1KFeuC4~6*?@#mdKlm6F{P^8k?_pnGGnb-4bV9xL zkV^7~%vbrl+r@yOmD75xD-GnE zw`5mzVlKZVqqgr~8s@(z<%tTpflT-zk;PqD52>L1f;44d+e%3YY9s*LT1Oz#`#!ME zYE{G>#DHy(N?0!b0qi}k66QExus8YK)w<{iY}xR~IuBxi%_Wj7pYs^|zjL{e8us~= zk<8XoCt#Vjmt42q0W1OYA3u)ceqVW4eD0h)>VXHF621=sbDg>1^JFo^CslVehzJ5h z=Xv_YcQ{{l(M*24O9i@XJ%`=|@+iMs0=vtwuZLW|Qib@d%HKn8+82?(I%6s^`+wi( z+;mi<73xWSyk^U4Gl4p^alqtW5Kt`+d)2w4AG*2cm>>5y#Cc zPrdBV)XS**wWf^b#>Amdf%jhbE+wF!<#Szmfw&j9cS+18#DC)=B$!8xhXVQF%I$lh3ZT&8r?|s@ z9u%A|A0~()J~E^If?|X^#tV^lJ3pfDQ+juVFXrkHi(Tsexm^R|fpKZeL~|evzj|%N z?83Qfz=btm1q6!f`+t{fK>nJmug|X+AlIEiBjhQA?0cm*V(a`tM$7bCC-o=@PoEy9 zzPAK+l+s1Zr(b{_p|zAGe;U|ll5>t8@c{Noiu=)0dtf`y*F_SNfNdgPe#wyt}R9tI0x^y&}uP%49s~w&D`^`z|7=2 zM%{T7n0wxPW@Mx8q?;9IU)wqv5$61!$+7GXRB)q&>{2Fy9dD>~S@o#_# zGw%rK10Z}^?WLUR283Xn`&B!&fFQBF+D>^j;v=`N@WyC^T;(O&9YPw&J~E8|+6*D^(IfgS&a@zO62>!kmU!wCCHz*zO{z*?+J z%Q|WS{%*98FuigY*xN(z|0Nq+bSQj?j~8!nc6x zl_wRy-58X54ofChATjXnXMvqOeI3upBBvQjMj`zT*w#BZfcliEgoWIQx^*~#j5>0ObiI-q?*b(>e zjH{kb?U*;C8X(#K8TY>THD7Ao=YVj+HKKbJ;<@WA7~SSJkh}B7!Sj(f z=KJ(7jb`J0Bi?QEjt0tMLFI`;t2mWQo@tv8-yZgdCOv{0+;KfS=_58Y2{NdeY-o^s3I zWx$FsxhU=03@qk`H2xc>fY}zFqho}4q~9mWg)qdC*Bx2de>e*mnL8tErjS=*wofew z%K-hE2le%KXxMp3{dZn>p~FvE;W$hwh+%YInyv1LW0>o9;wE3Is}1&fj`r%p2cRO;l?f$9iy< z+UTGTey3f}U&TbsH>pwbX+Ryr9`VZpuQq~0?gWfB}GSo zU1**9rz#5T6Wi7{fq(zxwyxd$nZQ1;Wm4q&1lZpFce-P)0^78>YD*raPFp zw_NR>_{zjR#UL*-;ySR>as%cK?g2~Brsr!c;wS&(=(^*n{=a`lk<83w-+Q^&b+3C- zRyeX!MuZ}=iKIkPW>&T$R4U<9luz^znq0CJlQ;^BPYNG4DgfROWkmd7MSX8UMrcnN32`hbt{O8AAcw-i)72TE z@Og2z-UaU@9FVSU(DeuT&XUpWRm@-987Fq-IQH>JIpMLH&w-@*x-`|E8+8og)w%cW zfT-goelA%a2u*n}{B#q6U{*ufq^JgRy*a;iR?%1Jt>zQr!4I;(Lj?|0pKp?y`2ncXD&k z;J)u4d@n+d7tMQs5pklL?K~@fzcyr@aBanRGBWyzo(c?wEgLB<+Q49aHhwuF50tCt z_e^N$A}(3tCxQ5pGV7dD3Jc6 zov+P*f|65=r=h?dpbii%+!m3ivdKNacM<2_jvWP8-lJY_hokU))@7iSSn9MC83IN0 z$VdN3+y~Ffv?<%&2Zfoyu>FGRpm5O4u;2eS$iK{b8vScO$Qx*LzagWJ;gLe;?4dRw zY3vd$@P7%!+Ju;6p)??Bz8AZf^brV8rS`p!Fa&~$rEJnq66P@34Vtwg|Kvh6J)e&I z-}hTN4w8E?C*Y<1LmJ+d+>(%RSW^&WDxQZO{Qe#Fq~YHZH}1zg6V(wlF5EjdZ~YR! zcMnL}=EU%X<9!4J3fDPW6yANV*#4K00Rq=@x4n3Ud&b)cV{0Yc``(-$2#b&g#tVO5 zebxYAJagV&S%&j%l}$>_d3#_K9FVeq+yso2Q!Tx1B{-Kgi0vK6{$Xouvs0r3_erTe zov8C-@Hv}NXBy7jDzx)T|_^ zZ?`<^OKM0Yd#ua$_JO}fUw~N6m3%925{TP9+P-3bJfXfN*Y2?{5O#{k2AJv~KWla3 z+m-M+X?+SU!)B$nPT4vy+{&H#l4)rXkAED3CI+iyc4SZfP05G8{yhC>Pf#| z9B>!K{NA?n>?Gu$bWJ}0=IQ}S#jt_8e_!xEg@t~Qjw%SGHGJzHBLHKxgUdA^_m59c z$F(xefYDztvw0fltFGX5t^|BH&x{lvl|%yLp74@;c_A<^|Kf}H#JMc;x1B*hey`k= zocDLN;M`U0{HyUUFt)}DmhGtm<%vqT8_|aQd(zy7O*z;{UihZi76ZM#?$1*m+!qgJ z-AX@;K9O&C=H|>LNh>Y5Z@Hl@8RSVoS86$P<3z zE(+>KoY(TSzl!vCpggQ~{8EDaI!S7py?rZ?Q)E{^?@tAV#Xi;x=M6!@Rn1dj_C3gV zOIDs;lgB*L$n`HC`(QnGu51@XJ=`{%no`7Fi1+gbs!~~jsLG#ge!2+=HJL86ji|fU z5k8hViSuo1tnMJS804&9KG&{u!Ti2YLAtzGQCC$W+ULFsvYZn0Z&3dvlSe9M1R+nZ zQEk+49rKrNha9tZ!SB?hUAD*td>;y*ZM~jt2FcA`^soa@U~Ae?nCSPLAP^OGviV0Z zFurFD^NjBV#%v6&L|_aUQ?^%%ah_*<Tcb;)A${;jr+BV^YE>eExFQI z$CR4ttqIuY{c{bZ=W%~Adt$#=80({;A(cu+JovA%V-)hB%7q&9{bRT<8pIpM?!t0tz-JZ}eCKc1l5qKT-hnjrLG zo`OuaqtSBg50FuI%cwbi2&A*R%>6c80;%qYtQT3ka4+{}XWf#6J{>_Ji`A2`^|a-S zm7^pOIMKD;ZwBYs)laMo+Yv8W=~(zf#P9!7s>R?9?9bEG+bZKOz!)sMQRlP;7#)&t zSdOb;UrFpt*o*thWtLUi@>XD+x%}U5?}xxR;8k^W0^g0w*+2Pp49`+8_i5$NAfRDWG(i#iIeTecL`P4E-XHC*dL9auzg_8%qWbuR}js2)aM z1VvY=fC7GPpmg+Z6u5vn%*==Feo8-p zoUI$WAN|G(f0M*5_n3f!S9Y#cZV$-6HH&|nKZEtS_=j=T5$j=pjR*C9B$e3W5pB#V zD_=KofEWivr3b;Qd;S5T{EETqmn}e0O^;qnn#O$OxJC8|S&%dKeRblj56HfyJ{7Y> ze8i(>!X}9qWPUAo?Mg@9BXu%NvJ2}W?_-J90?f0VWE2>s;odPN%#*|elB*9wvTcup z#H9L$@kAE9iNEtB&xGeFm7E*G6B}9Rnuo-m-K(?BBoM(M(%# zPyeDS!$P3~yv+bmKQMMX$6w6CV}BzbR_8X05EjCp8kxi z2ZrD|iQzH)ZoM#j$;2FdW#9HB`?mAg*Ps8bju-;^#mpr>g3kRb9KMP`@}xt(>yxJpTBE$b8?3Oz&jQWBcq!@7Z z2ZQX(axcwXCy;e2^yeK(!JJY1EJFVX?&VM8rZUt)MzVSTxEKfK{oEDbG`|ylw{N5b zNSH74<&Aw?CmAHV>Gcv8*06PNQTss#9|#;+BL#ci2d1d3KgSnqU<$JmrsS|5yf^!m zKW71xUBK+4(;j>;X7)#JY{Nd|y2SOT0vMex($cz!XWiTX`ge;DFfKTbEjQx#%RioN z&s!6mw`StCld#`Nmf9sh!+m|YE%!ei|VPs-6w*~)T+;d{v61JkFBf9Z^wLa{~wPFFbCOL zW={6!X^^_)@47NW1j+Ze_O9(^0f|T7mMLlNuvO=zsZy&r2$;QC78jraJ+AQ5e^XKT z{W$4WrB@B~u<3>^KB$j7u`%G)N<8K^^bj){qCmH_w9gX2JzG8A^9?KdJGVyrk(up4 zTd}kwOuq)&`{mBGxvfAezew(o>;PJ{Qs9aN`k<}eTZttj|0H>H@l&c7>VGRlS_5x` z(jDHB3HlN!`F@yKPsjTfWO#;}pXS30NNH=*iSFQ~5eJ(;jU-hGo@$SAO;dsATmAO@C z(ho=@BOCARd5rm(^_{DB=x5(qFKw@rkGa?VU7_um<5Vp6Firt^MaN^EPtRkHkifu- z_hZa`cy7P%6g3S9kz><7GN{Ma2>!x{{IuK;fhZdzoYRsV)Y%PAp#N%d568eh5V4Nk zW9{yYzS_0S2_oWse~b34%R*hxQbFW9e_x<~S#Xgu$L~pB-Zt;osOM=ea}}IZ0D6gn zUB^lQ&{M^-T*OWR-8bzz1Ahm)!KGkia8uvpanh^qyq$M?Uy#eS=F$~)Ke9r_!n$<8BW)W;3!isopr12y?Z zpZ=|KoP_oPDH;xxR)84QDXVLB7pP=>0dKw3b(opQuFqooTWfg}y45 zFWQ}VmVulvdAYCzeG2-|^92M^-#a#5H2St5^+0}G-U&TMKG!~Ehxr!l_eJ&)W4@P*>us)3Ngr?hS5j%Wh{U5jS@nANv;o%0{e57YF@u zUTt`FwgB}Ff(5CyZ_>~gT@~`+tQpW>ufLR>@dCd;Me?Q(!+{=L8eYcS0dylO&tg{- z(0R2?^^_Svd$W*n_?|1!GEY#>>f^hy>=Bu5MgJ$~Heu@&GZ&{16lr^(fM) z8`7vB#g?p?g{T@pa7nJ6%c z-ULLqq3n!vT|nelJo*{)z6noS8xNO$Mc-~25ciK@E@N+b-8SSE-xy4;G+TmP+?Nlx z-#!O9;hVph*KvO#+FEWzUP!o=WvJeG4wSoIhtc?%xW6eET;~r(9fOsdyE)?K4>a-` zovc9l)^yJm@#~qY9{F)ZcK6`##Q7GA4A)1v^qnZO{^&jthd5St@JQ5K#I+O;dG3`j1abqJ!x9t!Ao>LHudt&kW9kqd= zkQ|%*3H7uJWNv%u<`v8{({LVpYzFdPEcb@Gw}L!}>zPgC^+38~wP6Qo5=a*9k20;I z@jKNbBea6~m{)hargilK(MT~yufr1a%@X(-rrUs!Yw7-5s1*pi&cttHd_o;OTh5bs zCh8f--)P#fgWLhJbN4*-@ot4p%H(^Tlb5oVQ_j1Aa8ka+<^*A2i0t{VH3@kRq3Pse zXT%5jI~PY@-o$xzcJ<SnXX*~h5w4dk z2XBD#-ul|)U&laMicPK15WjzuHYqcHH-Ub;<0_9a;)#c2Vw=`IMcgVcXTpjIv|fG9 z#yjyqOH66`riOFw_TqrDmwuo${D`)-gA08>^D)u}$b-lShWNchKXkLd&#i!sKy~Ju zYVo@Sia+BoFGOMDFXlBlehlA72?o;g@*(X_nD=+( zS!3}c0dZi)zCLd3_ruyF;$fKk7xU59fI|(4iu?~r9Oy^vezAk2V+aVLT+(s|X_ogxb^H_q9N#(`@_a$2=fx^YtKA=`HTn zSwVb-xXrvOeGuzQ;$Rn6=81a&4jI=aK)XVv;YqrYk1e!qcnaWu=P^z>cYXs3i$%^^95cx0a z^zr^mHuRB1>n{o{1Oip~{ijAn%ni8ZX3sCu28wE;Bla18fbvvNXyEK~^heL%3LC+k z*xrf^#(B)wID9f=jEeZ;vRbN33+6SYPNe5Fwtxa5^7SysX5`nGOZ85PfV_?Q?S@?R z>&zVwtV{k2q!fn%sorKFQQ6;(W^Y4Y*DJ!{5c=AVhHR$ozKs2w`6H(ta|LQr3O?IS z0l_Kixz(R`AZ*~E7)PRS?Veca`y(4c?qIotTr%q6IUDzPkc~k$U3{y*o)6~Cz3BWF zO$K2iyY#dNz60;pl>x>HV0f9<{OQU?UhqxrPcN*4gNNVGay8^TSU&~GAl|#PvN|RY z_j#2FxxRb2$4mRpke{F)Vq>hs?i;8(87cKx_aq3E?+jRXpGSV(|9;(ZMby#JtivPn z{`X#nq>B`80X;W3(|m^v;#Z~wx376~LV9u6eJ6 znjAo}XEodT!ym|F;B1(WI?`kL(Nm!^ps=>J{q8r+%}To&r0p>P3bJb7gEnH`Uv)$8 z11IF!&GZ&FS2O}?{5Hd5FV-bup`_UDKOk)txlQ$62gC;(vtH;p0`Wle2EE&UKv>qP z*}oHY@Ynnk_B0eA-enQXb^a&FO}%>`UlxJ+O@F(&uhrn3{BY{>CBz{oH&t(|a>e|= z(ZTz7kAlqEc+%|ZIS~4_?d+id+#gcRZ%9v#10$(P%;V`Q?sr6|E9HofLDdLAp+2t4*IQ5@WV9>la~~*w8FKG2J`Ktx zWvU_Gh$9}}+7-pt0?N|n&CQtGO7HenIeP>9eZ-ZDy=r~P-)^E%wjpoZ@uj3V8+DAn zUV9##Kzwoi{e_Q{h$~)W)7~?S{wqd`=4z!BP#a<$xjlH%FG5iBS}O&`_xYA|zn!Q% z(O?_jfb-SJwkg|wBcOOrUT1ttM7{Os(2*;sUpysUlPOsZWR?tnOW^{{B!$u0)M_9(9awAHDpCe%+uQRCOcddnGKQSO?K3 z)ymc`dj|7ROfK&5{-TdO35$hyPXq|P{Opl_cRTVO(VygR;opDhbPw$&{?5e;7uO2A zfpJ6QEUZn@2z5lRxiYed|MiLWss=L-dOb+SPH7m;%-F^;Mbp zO4OZ5DF{>k=Z}u?cySWz@qH(OrNIm+0i8+e4cIr99>)xdb^$qz+v;7;3Xs`LkL|HU z96miGJr(^c3KEsq*j!O3SIS-|?G}%EhtTbI?=V-cn>$~6%m7GU9L{rn*J9)@LpQ;rMCY1DuzEAaLJ*g|HsvsvcCcPGfG9eY`>P zf0!GzjxXeL>=)#B%?3@L8vG%(y;*fj#sx~(+uJvFEvi)xL{t%x2O*xHDm#Vv?l#f*k0JQIqkUtO zypDLH#AMB0#7pP`iSBWTU-3vRdu~Pk_D$i(r&rcMIWAFC?k4h8s=@|^pP!-5;p9y7 zcGLky3>57+{uStwr*(X^#eh~DQ?RgrxxnVk=7rU8{BAuu(EJK!`QZ;j8xjfIh13lx1}XAg_M)v-W+8yhtd? z;VAmsID-9!cSc}6dNixMg+M_(y4HVZ3CI_nu`)7#f_l>OJM(1Zsh$hnsJo;Eq=Wg! z_8U;=FmF2XBNF>}BHP;U;WI##YcW!^^1%5vCNF6|5D1Rj6g*>(pbn)=!HUQLxodmG zwL7tIz|}jaZ*BnDiHG<4_-c^9%2R#Fz&sQ#W|`&!>QUso`-*ZiK`7>*(<>`2V9YFC zIlb*8;)fl<_=zKjI{xvLvGrugZ0s z5Rd+hI*12Uf9e0Q|ICksZ$Q1)E=dEep-$A(nd==K{s#<}EYHPS#NDfeOTe=b`Kbhp z1ou=>UVpzrcG4B-x7vKm%dZ1{=SpO;DC!*g;~5BO0PX0F=DzE)I0wfcRNc=CO6LOa zwy~f-i}%))iy!KIGn}1lPpG24cgXGHZ@g=D-i^N$?>s1OGNLb5;68Xx;3v5b^`z^= zI}VPTBQFx_WJ*ST*2dNUw!OnSH~rW9E4MvCLCndo=dBw05#*#kWDcMoL34D$F&Fi6 zmuAwvQQvE&dgpfnClJTio-^eC=SP@Rc&6VD#La&u@(<|&p-jk@Q(XZFrmFv33D`G2 zTNJ8pQUSSh4yuA3nEOXDdz-gtgm{<4aBz1k$ew5z)Q<=Onc4I;_RB*c!+m4;GRtld za;tAY;_(}p8!w9I*7nkNB zU&R`KK+Y8y)vNb5wUdBx^+8lFt2Hp9jQGYL#~w(vX^LuM9jGU@dov^W1ohVL`*IF0;apYpo2$PPi0oT-WtpH(?ke7C zE?xqHy6tvd3LnV5<>H7Cpril!>DQJ%{I{TA><_sPyaTrWp4&N7kaaj4Iw6d{khkR@ z`dlAiUXzOWS7$d6GRWAWSk4Yi;++D15)UxtKIizz5rHY0mm0k)2~44PEq>3k5%*0m z`si&8jNfmcmR39i#zgsjej^(4A{4cbp}$xcYgUb33NS8dbh@y907mc}nJ*&{bz2E> z3MKdP`z0=Xoj3a3wAudHi6>)j?B(k8d+2vlo6-zRM161B zHXTuJ>?3kRKWED7QRk4M+;O}cD1xGePB&3cn(iF?laK&p-h;LUQn&DZ{2k4D^a~V( zwj1OM-vs$9fBKT#5H}%enRRHQ|Mu?JU}$EVTX9`luDy8-rfi#F@#fcfS5Lz?rz{D`nfqBZt5G+{ulHCi zR}$+n_UN@~2PkY-^FPq&2=Y0E)Wc|~_l?FKODa!6&YahCDrXdAr;i=# zTsw>U_rA?<-FeW*2F2EG2_SPbYDE7L-U~@0(X?eu>+Ef}ajdxC1b36y8X2|4)we`TH2)l1xhxHMbt7d9VAdgjcwEh6jQ=`o$ zJhH>UXburhjK$x*V4#LCgN*Ys+ww6!{NCAdWKJ()e^Fdp`S}U+XqGu^P7X+*KHlr& zuJ5RiXIc+(U%-6m1jJW$ypZ{(P%$su$Zfg}z0;TbpjpuA|Z+8nf z-cjQEsx z!*^?JnX-Li8)~A)KsF?HF^__GcDDQtICbL{$fQp@k6aW2Y0vkjvyOEj_`U64a?@d8 z9$h*7tpfXppG3Hc#0W6GqGs>xxCcxpr2}0P+Q8gPtp9^~l1#l50ii4#fJv26dh1dE zOhK(lqX%ioTXnx-vqJu<_ot<33ig$nhwnBeTtZ$%eK;T)=dHtMKOD0>3ydB2SA4i} zzUG-U{Qlot2YlSa%Xf4`ti zM!n*nZKAS5#h?^a)P2qn{f0BAgHCM3y0|PE_pg{?Zk9Ljb&KO>wHggjM9gA3|V$%3iBZbxNdJ~enY>ld$LhRCgN0oG+sQ! zyV!CUXijQs=r5!?o_>M;Z`rm7U%KaUp7PSH%~8O-pbcHhY-cDS6B^?_MlS+sJ^88R zwgM3B-F{@blK{+E$(qS-D_}-%-z~wR56rN$`bl5MfEmbYYqE;<@qAiYXpn;Mr*S!m z$_7jjqP1Au1*Sq%$*dCgn@yjjmAY}hoeA}Or#=FV_S*%@@jro47&RLJpW6OGpIS+SSHaX&d{Y8Flv9t%pq2StsFD5{7x9XuF z8sdp{8miWp*?~gw&R1JTAKSHif;`K}9}2It4TxTc^)R`3>MH8yxKG;Ol)${Kl+%f` zPyT{DpP_qY&N(1mYz^xUx(_6Y?+s4`kk=@x@-OKu0pd0`(YkWH2iE-RnnLOkAne~r zFZkCBa?>|=C9&IpTy)lbW5FKO_r46fa{}+F*1|f+WB^&4PlHCNJCs>0T;w96uJkZ{ zj$0jb-^I@k?!UGk1RK6*y8KE6=4D+`Il*FJ=2%2$z4Zm=g|nMx7aDs3lVW1V7-BA?$R*lr7I_f$@2S)S%Kw4l z=OsShgHfPpUAK=lyasbi&y*?1h}6O~#nJTw4#uCzX8Cia4u^z5_}4@`au3t3b>n>`Pj}_dzu-eork0 z!h^-7{D!+g*dzTtLJ;4_#|Jl{2Jyn6DhGWZJ&@yJZOGq{4YEZ!4OfKjf~=v}`Tn=6 zAT#E6cPjlY-i`b~Nc=Ad@25WOoMs*c!8`rm`qv)+tfay&u%DLDJObfxvK#3E;WbT%Lp{*w!FlbeGZlK9Y{AlkKb z9&=%-@t&u-+VEY>PYdfxUk62p7mpZ4n1k6OSkcp94HT6!og>Hbj$vVZ#6x!U>xibV zd&Z0Y+qCl9gDUSqfwS-LRFDwzf~)7b>&HNT1LuVkrc*#l_sKJ=OCpb-2dMEseUejel|nzr}c;ag4Fx+y}5S2Aec2IwvLQ*RKqiF@+|iA zCry%6{~BP{wG}_UTLH}So|?bC`2D)^ZABo|7?|nOoh2jK&rhEeOZTt^rt@DX9Tf^N zcebAI@u40AVxmsqoE4hOzxk&#;wuB?#TvM$ z2n)%UsA_|9edmn_whPF6eKxTUe**N*rl!=SP@tQY3gq_T_v-mKt4%%fK!f+ej8Vi* zs_ND~zg>ZMMaBwE!>fRLp=8Z)SOOGRJj{)wQSab(I{ZbPDNs6Dj@f5=0%iN`tVLJ> zkZ;k?Jf-djvRD~=1rhm=wEbT$jS7PThs69u4&o)zUoCPG&z5H?&;GL==c!Fb-F~UQA#Kfw}@z3^rBwwX0`2JSM)=xeSLNQ&QXwSE$TRrIh%40L(Rhb z9YA(IB2ho_BgiI&X;yKdK8VzASbaDOWSS0m`yXL|jOwd~%1ysPs#e`dw?`2K&yKhq zlEFUSV{|zxk_yajy`$It`GMI<-~HKgA21t5taJKIfq8$;HF-Dw{onY`d6G&4X40>- z{06Up89=zPZ}2EE_rpvrM zQ1c1U_SPzKl=y~Gfu=9|lpE*}#FX0z2viTCkX zm-Tit=ald});N}9!xN9JO z-#YO_^!;gI*GThV4e$0=$pc-M+60DDPH7e-mTSf7_nj*AoWh60S=_ng@X_UTQ*T`CmP*3^}H40tL1vuG?EA zFds``?oeSQkp7$$*YTJKQb>Q?qCNUMR~Xs1vpRqnwu7{l>BoZ z{RlGG*j1UAaqlRZzw>+nr0m~R&>@s`Rquk;ENyFXFhF=Rnoz}@BEn}fc@mes^9)Nd?$NfT6dCCfvGt8 zTC6`3m@Mw60$N_8KG<1y_)`JSTfbgY(#Yt;GLKBbJS2u@v{2mcO`!bmgzfEZKS4QO zd1}K6{BCh1Nh+D8px&jc-dlaAnrSl`nWobYP{Jfj84fl>E?Y$SY`+#^l)QpRT z2*h<+f2DOhfRJ=1Uh5R%?V@6VrY8rGk996PQHwaD284guhkVnEk|Z~}75WM<^!z96 z4l;ko?>~xohWP+lA1n%+nj;Wos-&UPkQ zB}!pGQMEf9{S}xR{ad<(pP`PcZ`Lmfb#)__JDR>;KpgTw?%Kvm^k0eGE!TBJ-)Je@ zRc*wFxpqu68~lgr8W#q|@cWOrvQhstyg*$-{|3eA+BSRTBc@ zT;wl)v1K5hc(NXJm@GlDyaQ}#weRh!@=PRC{El+YrK<;W}lIBsw4{0U8n_^-? zw$ac2n`{jF3M=*v>7)Pr`;jT4VJgTZrv~I+iv{U<14eW5QIIm>)NmYL0zs_;QLR_g zpdzAKaT#%M6`?H>dq4Pq3Qyf&F>42?ut^3SS$4vAV`2SN>LV~mY`@q>U_CnYqYddh zfq7R}FZcujnCCg!zi_MIUb)Gw+SL#DdV?@k7FS?y?U+&ffPMVilUs%P3&41!^C8dl z1^Rn@8XV2>yJhKlVX@#9^7eMdUdpJKD{Y?p8IO1))x*E0^b64c8*1c0A0>TD+|cV& zI>@tE=KuOe0Hvj;r@Hr}@ADAr@4a}kminwW_lmy{;)=O;uG84pV;X)3a~1++JcrX! z1$kRja>CJx+d!^x7O*^R0c1(yGnu{vSPu`K{ixTL|HpZ=`1V7P4_eLT+QR{)S!MMG zS9~A7Njy^H&XS&UnWq*lMqtImkrv%lF;M#N3P*F;V+ML5lX{ zjw=h+L$UJ3;*9}NA$jqQUD5#+f?j}hr!%NXyp%Aj{0b_Y1#hv%{ldD4-^ozMxpr=* zd8Jkwn7ujCcxfA$kEzy2Mq7Y+?O~vaNHy*$P6LDUZP?$bvY$^P4nx*;N|xRTj6c;} zBum8Y+sel?^VNWnVcw=F^aB|7)iD?LAulhrslHvr29%%7d5g=0Vcvt`p$BGlK(F!* zd&PsemO>qAhxTKjWyk&J6|9B2Ev23)2I_(ib3S^M8H_mANxeZG)B#an)n3ZLe80q$ z6hBjYpnTaNE874-G28v{c=ahDR~qs&#My6GKRn(8L@$$*uuBee#z(5!E7qeA+RMGa9(6o_ zn}&A~kq=Cqn)Prv1Mo&ps$_H(uRPe6s)E4c5{7^qNf3~R~~K}9CKaqjn!fq`a{yUJmHNk1nDbL$UFJTCd6wHhuKZG(1eur1 zTm^ekSL%Jy-~sn~kiIEUt-rq!B-dUa-{Iu|g4|8ZL3evVWv9fCx12GcqW86*D|-=C zH0?;T6~3TCch5+1ss|P6t?XP`4xqB>+)1_m66`BAv$m5vfcc?5usG;5Fl%ql3u|5g zX6AXhj7r2$j%1v+kf=nw>-lQ?>zlYIS}V(`9zcG}Vz|8G7Wx%N`7{I*fpL`4#3CsO z42J8#$o3G_LukMAYK_FXS8BsUKSAW#8zqn48bF>ZLS1^41!(2>4%tYcFF~YA@j?F| zP&)J3^$7Mu>OgT;{@@m%YT9-9x*|__(Jvsf4fl@ueHqTD-T}p$5O$ut2IQJ%)vX0s z4{0egon!y79^&5y?*0FrqYmMOJs^LyaO-5H5b7A%3WqUooaA)xzaJVmf!LolvUlM# z<~HQzxQz*6E^>WDyF?P=Ry{4JmefFQrjL8zS0u=V)Okzmvc`7QFHEHT* zW}spo@vplk5LAr&zIQUWfr|DE)w_?bfr^q-=cV12pdxm8G`utfRMw?EY`Rf~ecrrq z^PL00Z2J1)TFwM8^TGp{g0bHOOIu%b;sxgJnK`pt53!G|H+sDX`}ya@vM7TZ?CaO= zzZJv1@RZl=Np;*yG`agv;2l8a`G7qkQ~98LM3LL;f<5N;Ulmlij(TEC*-kE%3ZT`C zrped108M7V;K_c}ImC3XU3iW@=rPmWNByV+(yMaI>pB36mlL+Xjq3r*lKKxjJ;bkU zKHmMfM+WeoRdWVh!>h?_T+zf3g*Ec5#V~SK`o@9@X|akL7Y# zPylS6Cw$G1y$&jly&I?3w}6U6u8RMN8>sA?v?#xE3RHGIF?>FZeO;5PvDbke`;11E zx7BY@;aRA{C;d;P`G_?y~zXNqDhszYjhER8xuxg@-xk0B()C}!VFFf

?UbIYzD z-^Xjj7UnAU^l=F30I{0^h4(apXxXweDZm%?3lY5r^Eg-8nFfCdMcnY? zX8xAVUqJ3~>&DGS<{^Qs&F!|>iun5dPv)T+AamE98O$yPGA6~xa(QP# z+BK0s<;ypaeA4-2Gv?!O9+z;fjkyC1D;xEvKT)r)?7 zpx@)-F&`s81JnZxI8TgVf1s9a|1tBwJ0b^GzI$SRT&0qF)9Nvx2k3nqH@ysWYB}8b zZxCps8A~6MQIDO?^~%2Z9ng$bpBxUX2Bih1PPVIf5BHkz(id^eCpYA$2##Pr)|8Iy zyDZFyPkegt+Ve=Dk~>JeyD`7FZMw_;(h?{h_F7@iVJ;BY_IH*|+c7uGE-$<6Gf=D= zOL~?2fcz`aF~<_`;$HVAzC>RY+4$1AvZ`p*m9mNXe??!;21 z_$QuTum}14j1Dz5GRW^8V9~k4M4ZJy66&u5>3-W*UjyV#Jl#3A?Z7;zEt{7$Sf+sZ zvS;i3JnBtj^71ct;k+iIA1Zd`8Qulec>MbQFo-GB4D#{LBO}9Z|3%FtO7k}% zzjxAVQT!gxrHA=SaF3V|==SBo zK9EzPBp^YKw?huEV^OMkk#P%nuN2EfuvX z0!odMnLpKE9qHgQceC6MIAoRqJr>R{7xsIQAmJ}R8^kdJ{iOa~}y%goC z@<#rmv*WtqD(-1*6JNKGqJh!q`&4!v)~n7@vic78-O?x9cbTCN{d%^SLe@5{+qCMT zMNi~6noX({Vo)!q==H-^AqBTdub(P^eu!O3;uq%1ohX=gZIBW0!lK z<<(+NP$c+EEJRg+!ip6eA#?uay~A!@Gvcep#`sk3ivd zq2q83D<}lmMtuyfN1i>Lz!`x$lm|j##AGXwcNQKP7}7yJIJDR~xfl6%IK*epkA3G* zy6hFq*JAG)Ggs{dVnv2%;8HT?YF%BmWG4fWcP3N<8h~&~^U%7Ow;-4C>|m6~EfCE) zHvV7^@ekIU)IXbXuV69OxX_Aw+o~exhOtOs{It&Qs>Hc;rb#9DkR1ANqk^wTA&%aC z-fZf{H0rbd3>S`G0!B&8HQSrqsLNWVk&6hl;C)G7wY5I zikJ4)^#JWEHTy>1XP|A@E-A4H1f`ejtG#$I-`}NH(Tn#eQ0F7;?9A1H8hMRTk;j9+ z1X1&siCWlCyo98Rk*{K$UF;vgxvSYd>PRp@P#oAiXHE?RdEVhfStIJ?l3Xv;gkoJt z0-d{UkT-1fFg)Ie`TWk-x)D`UAiwrbT zE_*9WF%Lm>zmtsmaYJCLKGf@R3`cx+kF>8n?iaL`Q_q{815^IhF`0_Lh!3{i@c-Zi zOuiZ3Go6yaT(^^Wn_z%@clW*jc4FV@EgTpXs02ns6OmUz66aZMYganva|u{q zpCir7`>;=$=s&RJ7X*e}$v~4@5Gel&&Z?|956U+=t&B)m9}A}Fvuf0tEQpWDtkVH{ z=6B1BC755z7)m?pfOYBMSN;=#`=E0zSG_9gdw;MB|2}C8N@wMaCby`85|63(@j5o3 zW+`p+q29V@fP^eP9$Ch^n6fEjXGRzQ<|GLO^YxF+IC-f#(U2y?m1^FE+vy-G=|9B$8wE_4?=AtRT)4*_*YD7J2TX_WrLCpNpYID? zO2?dN=C0M1m@mj1YF{LM^2Yj6b)3bA@c$EI<^8Uef$wTYkYR=U#Fq`V7MRn)czNi~ zv)^36xXbd>;O;7Z*Z$3Y*^b{mUmv6Il*uKWoAx13*z!<%;j2IT)LTiho*F<~_&en2o(#0O3r^CAU(f_=#v`oWVBU3p zb!%`V`V!)2ndw-El6x2+ggOVNtJWkp_VWjH)1SLB@5F$&sMp&YD6jsIxjH(5;yB)V zsVf@wz0Zrh6Y(xp#8u(AEPN-M?V=;N{6V2;F0R~45ES$d4P0Lt0{Pynp3bLLKtAw> z!ua(`kmq;XHlK?^j_Z*L_59%Kz>;uDWFqdZAy+BnT5Se*cYoRwv{Q)``=i#LofuJw69Mjjf1_$aqAlBTm9= z5-DnedaL=2?GD%W;y%t7fB0NB*5&ofxzsPn+m1J|wPT&!U2R6MAs?k_|DaZ73iF!A z^aA;i2YE!ka6R)P-bdm*Ci0Jr?-C@UmOpF23=!fo+-!!t$Ke&J z1A)NYQ@%USSO%Dk?`;p|n5a9^?HNtR-~C6itwdlg>gIHd?dz9;aa-uZ4?e6*lrBvW zp&*7$SHENq>QCgylvte`LHXO3+aU*c<2!jNJ7=kcz8)d@O@Tf@zenhIkrx8GuF9{? zle>{GJbk4|_Z<4&m=cN{=%ad*Irx1m>QAhP#3lA?0k!K;kWBSSpjxEMAN(K*imxTh zuB}%CMXR;7qsSjoK9FJLNhDAXrMgih_%(s5p zv(Sou1j5rnn}{}$uWd9svf(4ho7Y$B>YV`6M8Q&wrV5ZE12%NqZ$dwU#HN1L2q4zw zTHoaPiC(oytCveVf$)2===lLB^i4exCy9y!0kkd-ES7^@y@CSY-x=9_3PUw&RH!3v&}(3m1Ps+>reD{T=52G>0n4;Tre=N zJm!qKt_{pMUpA=Qjyj<^?Y%ZffNABRu5%0Pq*71Xu;DD~=cHfIJ_g`Ca4q84R1xy& zCLH3nxXX+tR+?-h&JOL9QTD`l;vQw6A>a<3R`;QV{= zD1Yg`Z=l#)-_e74nV9GBW#gC?Q2KM5Z3;Uu|6TN(XG00zKN_W`-&e=nES%@RA|JB6 zjW4DK^}Xkc%~+>@f`X`SyP&=;=3CG1)i*2!`5mPLWAE&M^yYZBD)&jmft7pRBV~ZZ zHbQA>u|(ZNsP0#$DiC)p{(fFC4}?J@_Zd%o7vb);g=@EvzcR5^`|JX8IfL7l;+8-* z@7bov2|o~VYb(mwoeRw0S9y(EP*?SHLi8#x1DNxT^nqsN$G@l=c4B{G4#AGO3B=c5 z&Q5(&smJ>4VtJ*4egCGNjE(^rm?@-+6;<5Jk2TMF-swVK%AkGIALM~)m7`BSJwd%G z`Lyg0#7Bl}YjLt`WHg>gcQLcgcBNXbZ}| zWhS%-SwR1JNp*x;gF1MpgyZApKxfsO%qyHlKlL${wH>{n^iRu$9*e$&kRdHr^b1hu z?ydW9=ITadML$_D~S(lYC!RjkM^$XZ9o~SQ=|NQhV=;5JEv?0MbWy2G(WJQim3L%o6 zS;{Ixgow(Bq9UR~Mn*=)Yh@-|DH>*FRFcq8`JLZiF0bo)|M=eB_c`aYP9K>)wi4&c z>@8Bw_SirBP&vn&P@kppOep_{1}JTgCLC7pz#JM6+H(celk!EWzKbQGugc?KR$VtJ z3R{AN@?5W%5b@Vvyu_MjyN% zbRKCT;h4vt^huYx&l03XiYx4Fv0jwl>NVL(1u4Da$I+LpQExrkn_{kmycK5#liLhP zZaX;b>5A`FVO-{(k?lY*EMNR|B^V?=w#w5j$D!`QdTz#m0^%NiZ3?Ovfp1rp+pZ(_ zKv8vTd;fY6D0|YcTlgS;s4UNaB;*26h_Z2-)5w1a-cY-=!3h-h;Cns4v3{(Nno$g} z|D9|aq&~I-a;H{<$UN4a2kz-ZLS{gY)9XvwM10G2>9#nR0FX68|Lwlbg#GfL>=!{x zs4q>fOCCQ6%9Z=KUgwwnKaSNfwu1T}lVa8UWKZ;2U6z(1)?iLKdu&X8Gbqu*Mn(f5}p7k>Zsy@wvO{K33&u7aSXAs{F$X2;%<1c|=-opcS?L1JG#l_z&Mh@0|q zEC=}j?+^8X!^o>qtkoAk|J?@^OPBT3L%u*c@JcnXY&%f&a#_qo&j3ZG_51!h#1*A= zT3v+^pXZXdOXc+k^6$iF%L>^4P6p6&v@W4;XrZz8DeC8P*dp~CXHge49qzD{i*@Bn z?AdjE7o~*=yKdb_ed)vag)wu~IoSE0ny^K@W*?Jt49@ZPX9xa2FDgq&C66diBF-{k zl(qB@(6>9mJ&%0Iko5^YTlDFgPHtL$!d(9L`+o+Ik5y2e8yaRv!aU{g4STXap)QNm zRod_oby>&R5?rgz8l=|AdO7ugE zXB3=XeFu`&k7?_~WRTp?_%_%p2ME(=59O7wpx>4`#;q6k7xLZD$o8j#M780nu-iS5 zkn|(Wu&RPM#ZD<~moo6a8kDR!JqZ-QWR9hBb)cLo9&HxGcgvgM@CuP1C{DLnACmAq z4h2-ad20p~xankPk&O5|w|!aLOQ3MCknXT4Vg1oP>F<97-!Yy!f&$i)$Kfs)RXdQ! zO-gr4l1BZUv&4U7Q7Ge`oCLiN4-O6OyCnE zkh+kRcJRtRklMMyC+Ld()cu+!6@y@qRDE>b))MFM{+T3AhD0EEYT3J*;(5?LzR?nf zxn|jVq@;(agWo!HjY&-y#D#ds+n#O*-Ui4EDMQ};a+F+20e(ZYpa)1)uZ@OTE z=MX}n?v~~P%8Blmu>lo8vAdDrp>Z83`h~yhjPQMv-?md?&H^Z$0~`6Ui1<6>_AUO{ zANT$DShn>JkPEhZDf-}C63!L#j1KF(*|gzfef+sQy~wW?@vTn>OuYG-(LX{k9T44# zItLBlI{g-up_2a42KLJg4{r=|AkGz=Ni_162gOa_PvyBqpcpL9zI64gK{mw=<4rCV%}FJZHaJ$Daz#kD;~TO;uuBXj%S zLH>lff20n5jO6Lb=vzmyziJ5AyE1}v{MAMcI}SOlC-tYo)N!s+zFJ;3hrI0{hYSB0 zH?a@ix1n(f&mqA!XD~$yb=v zEO4Kg1jq4r=*#tzeC)Fy=a8WfmiqY=+;`ZQ_2q{d$mM)(x9mKRds_8r!X{WpLhD+G zBk4fqljcqTb#VJ?^C zMAR+X7;&T~V6M!>jx;BmDvW=|M+7G$Q$;5o|@gG2;_SK7M;O2Q7>OWyUmX}2c1GP z$+!o|+tTx`?U84Bk(_Ym2F@cH)pq*?5T|#LnMlCBSjxiO1Zi2s8LMRDL+R0{EAucb zoQQcGw}0=A@BEEApkpV`FtC9_&>rotnBOY@wmt5%t}V#xgxK8uPZQ)GgzVdQ7jw*Z zw1nH?ydxW-NpVa={Oa@DS^mC0JdYIr!j|_y8Z{IQ>;8=SCST4OvH}o$g5!5TJqkpl z;mgTE!65zgE8+3dU64M|x<85;&*8a>{=ocKkaEy1>NXSw$+=g~yx)i*8T9d{{%f2+ zSdIh(iv@|!nets5qUf7SjW`;13B;etT)(uq9rKf)Dw-eZ z1YRG}hlyp#lMnHI3aP|*YGC{CgAe+E(*5&n6x}pXnqFBoPvCbhuM`T}Uj&rw)US=c zjd(5>!moH1V!cWIEbl*teDBbh=z(|0w_B<@gcM_+EVo~!2Jgev>6qD;E+ALy2fPUV zh&W7r?q-KG*7xOTBVljEDcOv6$KjklE8crQ7Ii@noP8{+J3!g{{cMDO80s8eDUPL8 zfzs2uHt9m-4YgDm2OlDSQW`SorF9f_K!bz_E0{-fA(8pZk`2huGpI_`M}hqQ9FAz5 zf91;3pDYdeqE2psgMmB>vQcsFmTjmXU9!JlFMxhFXWOkpEzg1U+)LBw=v^S~Kc_bG z-$fvHTyWW*LIa}C$y0PeiXi<&=FD+9dCb8qni;Lc-1nywVgGIC1u2U<%dF6+h~tu; z?;S)Rg130h^QB23{77eT_^1km%RwCD<#Ip}sSYXE!#tmALj|U{0qC0&aa52%-tcj} zz>eDAAofhIs!S^wc&*O8=XFs4%7@7CD^|#(&-xvVb`S>2I}o(gegu?}wXcS=+(7BL z8JEq2_oh-&hvHTMl-pgxhve~GqEF?OIhz2*ZO_M&mQbMRQ0&)3Wq=|S@-n*>@5PGv z@zzBd?1v4_f6QUaCj*Gr&(-Fz@5>z^ekHVapc{rdunq>$d{>EF>GqS`8H;D>l` znG%<7HtOU|GlV^{p4S}O)4z=QS%Tg3PCYme#$=sumqtG7Ya{ue9Qq2KdG7bUumIBV z^|y|1Zvn}OWX$J@cy3E;jT`3>5ceLiOjki(y}qHOPjU>TH8u(t=5P*g-b}b2gZVNB zkH2U-EQ91ASCi&hTadJ8+V{;5@xp}&)&hdpU!-2vy+9pG+VLE#U=^SQwfy|ThWE%y^Uc&0 z>g(j!AB4EGqi&03OPdhhi_wc8I1_4soOhk7lVt>C{{wT|BM_HVd*17N?F{-6_q)1S zBCgo_qH&KzEaF?Y95PE$_n_6to?eamxaC1d2d@*(Tlp<=`Uw#KQ*^0szXQZQC-Xmj#@xlqtfA*qcuy#0 z#u_y(AXSqxbT$(68urpIJO4e1zQW6&_2*b{-)(fyuM7pmM>vc>zBC2GNs(ESX9-CB z%XhD_$wj?f`oguF1t1|i{g(3?7v_*js4wtGg4lzH!Gi7Oz)LJn&QjkBRE}$U6}ntN z-5Qv@;&2$K%sg*(Jcf`rURQ$f5stzq};5`~^_3T*3d-3Fv-ar7>n}T$5g*TpC z{P|tVTV;Xb9(Ce;Z5L3qs&)*sf5U!Q$=odjd6f@4O1LoJgF=xGT8 z+0bCY#UJN*_8(0HsW=Dr)if0sA>No!06NHvDjO}&zvx7NJAL!{xMxJnc?yV!rhB0H zj_20f$JqbsHI|H7U|wv&6ScX|v!K8d=3&E65AtsI-I|!UDfguH$*n?bkRvqJ#QgaQ zvX}QMyu=(7nH5E3jUM57gbB8l?E%uj_UWyt2P47wGyd&}TRnc7RBhn^M5P|nt|wT> zOP*a`Wl%#O^nYZR#h)Pc@Jix2k_kwWN&17{0f-;Qx_o-;50bi9b(En!gozDq+d z5S-4Who$9##4`E(x{nb^#2ynctq%tY!JmFAm}ev&t+D9-e;>%rg6gjuhQP~hk-Q;A8mA`ew9rJdm989Zxh*whnv2o>^d;!Yh3*C9&A)q`D_Uc>P zi}n8>;lGs+K)DssZEytZdJwy2+e^GR2OGZaQNnvAQPdFDjyj<4EB~?X!a4CtwVom7 z_mC5}SG@Da`NT@nbVUm53%`Iw{e9#g$GB!gUdUrUxmwL0&m7cQRB@V#;QY>BlCnpr z3-jPJ9&lu#{{2(zRsVyn*GP9SmuNPQ0DQ!FQdr1eJM3g2g9Wnz}~ z0o3=(IzCgua^dSTY{%F~Uc>tFj zKYQDG1JCBi8|}Y$1C`=>JS{(sZ4N?Bc zW%&K!1Iqj8wYvhS*Lqs<&4+;VdSR~~_ii#!Vm}(E?!aBsD z$|i7K9C2d@((x3;lQVX*X7wO0=^S#u;1A-#617hSKwT5BZQ?L4}u6>QJ}1 zX!m(G5ajy)1o==q8oiW-b>q%j(Ti~8%Z2)Gw-x%M&ogUlu@}BuyDeL}{9fZ6 zI63R$js2B8l|Frp5eT)KEP@o|oAf`ar&bX_Vw9}i+K%&|*Cy||+c!b{ui^H)Q=A~~ zTJ0=mi+M7k9WQdS%z@{NeRpt1B2e`z6e69cfvR)Pf`oh%RbxU^r85SoO7FsnJLB>G zMBOgiIs?>gBccM#?Lb+bJZmndjqg|8N*pK7i**4-ZN0~_o{0MBrA+|E=k?t+4?G9$ zW(}ceOPm+yVyu1yqOT-)2l2T%;=&2n?G#;6$7uSWWT++Lz;D@0>9EiJ;`V6ZXCC^g zwz^%HMgG_AuUvEw;#@-Rx?BTBpp-k_x|XU0N-UR1Qa|rvzL^q13IS^mBdJG>3VdwU0#V4~zwx%?=t~z=_0`1pYCB5_ zVdo0!78o<4ZXi#-?cd7wN0@7wGPixi+6{TY;z#2R9zeLO&hSbM`EiBl#GYG&Aklbc zZ&m3>^i9zpb&g;M@fm>>rGI|t@0|X5{W#|DJDq0Mx2OT0XN6Wxs8gl7TOGKdnhexq zJ5y3j&H>f_;4+gwzEc()5+6@e@my@_q7PdERbD07=<;!(a@U`e!5kyX`toL=<_(~X zE{|(_;dieXENzm-`Vn97N+%ote)O7gaKIc;WGYTJZ99i^q6G7%jt}bM+1Vt{YoTu> zDbU6p>x%Ak>9AVtgXtNYU(chCvC-sM*DhWF zf<%nYVmjg@6=U1>sH47DXNY^{5AF*YwJ%+&N8Ur##Y42U8}+04#pTI7z|-InG9MZa z)YA>$O&;<9HQ==HpQ{BxJ&{c-vepNx^FB5?D&7xs$Lmavr+~VbWsP;c1E>X(?J8HVG62O(o!4GO3~~Ii(zK(f|D|iUH2&xb zVtB}WP>y_;#=Vj%xwwTh%f$~9+^Wu zN>9}#p5IKMB>QXW!|H2LyrekJ*@?dN=_;-tdYC7xI=41>R}JJ7Ov^St%7WZfxMFU{ zJJeYhKR>@@4YD^{>VB8z;~ud4mjiRJ;dy9>&5PmwmW~M1{|dc-e{wxHDIhTa` zl_Y@3B`0O0IgNS}Vc{X%zb8#^q$%pZ3#1}4s3F{#+xKTv`mP4z>ye(tTK$-d#nkjf z=It3EB(99lvEu#^{?)!+R^uR%U-^=Q3;SLb;mo7KxF4@aLL}yrB#6tNbm(p52QdSu zu$U4i;3@8BJ1c~J)P-wgwa#NejnWUYN8ExM>M-jk=?m0TQ%>=7_-;AAVs*CvAjrhx5H<_5bB|tgt73o}7jdNn+ zT-4@E)W@&sth-?z$4JK`AJZ2=z9Al%(N&Fk9n?opwqc#;mU24Q?~nQv@xKX<*k8rk zge}4t?nPSuMV}Xe`2jjQUfPIbsmM;v{Y75=8XaHH3FHYE2|M*>&Vj2R+wB55}AK55rt%N?wIt}TSgySllwxDcqxdB z{55g4$`KU4iHJi;_M$dZ4CEjo7Ky12s9xP2iImP~+2@KG)^|_1wnm1oXvF zeV+YV3HS?CTaK(-$MNr4BWDKR;JhLxclgwpDE7k&!h_j(9daJ+8>7JP&KUfpaEb)6e^w$h*H|J8*udH1Z_lrgTk%*k{=_hlQr04!&AFYYlnC zQJ(pyze;fqDLO`?VO`PAJ@Yo-ACzXSz6yVe2POETpi_)<`fWe`k|LbXSF{?;KT<)# zpfO#u@&e`soZ|kVjeP9_9seQ$=XC9ID4Xf(w^Df#&*R^D7q>b*58qoc4(335 zl9|Aek_jX^pK`rHbs*mAo#*|6_hU=`9X|!+KO$zEwNG#&&K^*8_#*Nh{(C)bAI<)s zpH&~=Yry@(G*<0Xh^K$o5_T5DeIa2gY6mWA0)dI+(o8@42~!>wB5MK?VmmWVdth#2 zrEqst%_@jA}1a zP%q!i%-M{@`vT{+Iq-LPOJmzRSkL#r`FN-e>x=x?K;ONdKxMzT`>+hoiSM@wa(62u zK52ZmG6?I)m7uMu6MKPTTWQkv0`U}af>^2(;#wa+4@H_4BhRbyWGPD+$lkI?n#)n2 zLRjgNxQxEsw~b>zN~DmddfYcBk^stvJ9cG$GeP~yN^pL&8z`9?@fa`;qn|DMw?SJ0 z;=HWCTF&c%!hwA*$*Gucefz;ox|;{)oBXqVNx}Sa-ADzaLd<*5+OcX@vIsK2GRM+E_kc$^dKmlD{q=vZ=obJPU-mu3XQ*d9GNr*D2V_ar7+}Ni$~E%T zu@&dIO>+4^bwf>rv^#Y~qF{feUd)7ET)`e=igU-o_+5%N+Sq@UI+G;a$I(9` z^0P1o`{F;`Th3taF)3d|lJ8MDkj$@&wK-vbyutBNr1=W!=PHkHw_r!!B;;XyHu8&1 z4o{A{puV*FXcyC=G?4c2{TP*N57PYU4g%Y@gH&FRN&a8VH;eiGaH{1a2yWk8n>-?c zc=*8N(X4kszI!EjVP*{dfK5H8OfrFd^F$cEDE2+c*LB{U-w))Ny-P=UkcSOA?zHb3 z;!hsp=M5w3@!Wj$-+WvEvX)t?%)WH=d%Sq$qe?+MomD^0F&>n^els0TF~n~^Zbmp-aWVhi$9w^DK#EOAbk|5~2tin$t3&b+20 znu5IT#r2aXF$eyuh$T5m4&*NFF)y{@0y&AN9$y}6f^74!m^BA zUn&t#xqY@tXfXfO(4lqq%^{?4;z;6Hz#7wa;Tq| z@Vf{gN~~$b8FJ&ks`}iatR}o)bxdygH$YnY)6|uu{U9}J@nlaW;=_)D9>O2JK@!*w zsyhmSK;5I4ABIzqKl1QfZo7f__|}o;7Y;yvvw5?s7Ih1wy4QbMBEQ=E>iK$iERb8; zGnf=mzwl_Qjf&}geE(}68a&52FX5T{4coVPPL@8$bg@1=*!Jw4vcmiHA+zIb7`{Vn z?A%mU)NS|a^PTt#7@_U=_$un)|2uu(vI_Z+w4m{BeM{7t*nXT6!}$;7d~|A8a4u)) z9(BG7O5HQ!S8y&@^5mhD+dTzJbnSz^PcV1!mXPtQ%)_84Zy@9VICJ{Ms$$IZ zElKbBZ(o)O#`#$VrR( z^uAap{8z83ZZ09;aXNbl_qC9ff@UYru^@lWzOsXD7v^c`9qltk-@<>&g%5uwf%4T4 zhxG0uFL>Bqui)L?#>Ii>QT|5sgP16g z4k#b$e2h8#i~JvCQrm%eIUzck#|H7P*m+I`1(5FhyRtbig8tCu^w_%wAkAm z?mLv7%M3-IsE6k|2OZ`;ytgg(Ja`j%_LLtN3hsdb@u0xkZsftu3bY@iUxIQ_dd@Rz z7=3C*naP$m*rzHdzP(|M`jQr}o}Z>T*V!B0_8;~#vA=s;h(vQf1%<37Pf$7MbpF0gP1Fj_2AOMdtR_>K|US~{sQHE z1OEvk-h&94*FNbu$AyG0xr^%o#s6W|MLuVscyx*E6~_M6wzq7oDG2?Z9l_r?4S+(a z-{SQhaYLc1kbU1-fI{D5N|a{@^81CL8Dcl`P;fAO2J-{%Jr57KfcRlV)ml^HEA$n9 z|G44Ji8}d$qN}Q?-~BgL`C}35`e1FW4dx;!-_gm?ynu81i5rK<@3Vq3t$#J`AnslN z&G6B(VH?(yw11thcs`tQU2EU_K{1`wmkIze3jf|!fJ&l$UYW4@$|tjkkviccI~D)$P5i%9Yr2P z#+BQ_COHWGI%+S&#y5c!uRc`t5`P!j4i&%g9IDH-WpfapH{)WNa}EOO1@fxhChD%^ zSS~V;8)7czC7Z9!FF>lJg0xc~b7MV&M+f|qKx)gV!>K0JJwy);2KTCA-kWbeqQGF_k)-F_Ae`+<_zcqQ@S2vD+e?=Ybcl#+Tt`*aK5hYOvDb?+li z7{Gn<#!V;GHE37%Y$9%@Z~Y}A0sC7S=K%96MV$Li@f%3vJGGdky!0&w$X!F{9D?wD z%Qe|C{|5WCv+Q=O&;PH(CjGgSjei$z=uJrYhI*5iRj=q+(2tc?ymthJQY3Z@9e+5d)S%MvcxTo#Wzmx8H|DjJr?1pxOHz<@??bqj# z!#z~Ox{U*P9{CiXyo0=$6Ppm@g1m}cp-AvneSMIVpKvJTLLRrOBm8Le6Oh&HGPq}k ze%$WYRvDWy*jN4VQRl$E>OD_bhPfb+f=IWtE4E?XkYn)X#JyD6+`Fxfb%016J9`KF zQ|Z3ImL!EqkoFw!J9P?qcSh!0pPr!~A$Ljdv_UsWK_W-eU^Yljzp^*#!95i=@2p4o zaE><$4k`9K0=vT3Kfi0ld+?&@y6!mYLq>krXb&LI)c=)1T^awqcV1TX7Sq9bqQ7oL zUjQh@ZF7e2{~_Pu-}=;nisv)U;@ubtloO(|_p)B$yQgNP)`tHdrM)|g_WZ&6qdK7T zcLm7vpfh)(AIPm<_p&VyB5&Ik_mLO-2XD_8Td!lCQS&MBLSH`>oOlcQ9Q{vH?g36mH2j!E9zvR7UL_muF?jo4xzY%ZxV(1`lpzT)LQSG_^ea85ed z7;(jB1p`j6?dYT0?J(7b`-v+eUNfnUq7DeMZBP#;_t3r}tt z7R=33wSMD#1NXSJcx~45;M{1E)0jv?9A$Jx-#X+sklYWiJI1~R;_4H}&8UZ{x0WM6 zpTvA1p(~bO1MxmQ8toI~$NI6KX;@(lbKl=@Zx)U4LH+wDz6&Qyuzsh;)=Zg!WaF=K zb@PWHsbpb4hkKw1;=jOkwGMV2Jo3PqTOTMJClc#kBhK-w^pS)2ZN$?hjqMe|{X8E$ z#%MLji`f4)seA2@cy9(pYFro;^j4LwwatKh!@EPtO0ghMGtPPU1oHzbWRD*C+Xr%r z!9QjSWkI%_Amuqv1X&89V?ve;GPS2ZTjy4R%)a&a>xVE`?rF8GXvP|ltZ#b<^5XZO zxflLr0P&Q-mNVPSF=vix{?ZaB?w!iuk@P;A1=31tZw<@wUUVM}Jb4E9hPWEPV5>u2 z?_Y^sy(iG8lR0!@_ueBQ$zH|g)K~=)oBEMWi=41aT+c4XZwjcQy=TjQ@go03@2WDM z1k_!5yB8amk%xL*rMTJ&RK|U~CtK2i@?FOvUpf%ar{}2uI^LhBQ{R*hA--Fd_PV-i z2kN!H=db%BAL7qZl=V{;D5k4x^arqCkZjT}tV5jS_qkWriukkND6xS-8|NIg90o7s zqfU4ih@oDZOj`*jNSUB6Yeg!9g!R2GwqE)^fbzwshTfrwV;R0_)PHyzl$j?6I#+^0 z>Edj??&u-R!SpF&x5PbIez#~@?x~%_pToi;CX=kl-li)8O$|%cs~1P zANIHU&2`zYoI!HpYp{NoDM+4UO;RVaV}5VZ^;sR%k51C7v*^zO|4-xCRP;4bb+;T? z;q60Qo$`=*3eQKQ{AJ6iH&DqjtC?4_fGSz7&wk|#PQ2vBR@>lzhkbi!Ph+u z1IRTreP4?|h`aNDfUSoR2QacyNbm*nj>(auiKyp&vH7Gq33U!Px}pLIwdk+5wsd+l zigU>`{kZ$QpmZlq{ArI1DDC{rWc=t9C`M10CHR~Lg{9~1Y82EtIFz_D;C^)Z{sTqg zBd#D1MgJxrEP~wQ$E+KT$R8@Xm3WU~JufcUv7O8ZvLyf8SH(~VRQUMYuIG9nBX@Fn z&oi7iD&ndhi0uNB>dzEC7xafbspWpXd<2LGYnjBy13~)D7sor(=tDSZZkhAO3#9&y z?5A!oLf*<}QYwEpNXhP;WZ6ss$+iX)<#!sWx3)j{LJM_SPZ!oMhAx3b>w-2#$OZUE zIGIxl^pN+kr7x(G2CB=M5MiI&Kt0;O`rVuxsE0h;!~S^yRbSt+sBa9YRA0}&eaIi~ zUdr2jIsm9FL*MN#MBuwd(AK$$?_2L$pguHXUts5@w(tTdF~`P^FfAevLOc+8^$WgV z%?$6}@4$R5?RO$2yKv6zHdcCY260}0!qBZtKz6b%TwLnI`7z6EO`QvK{T(a(s0Yv= z+UT20#CzlZnx}p;5R}Ene#f+{fl^J~LAOH0Riw8c=k{D2;{i7uSSr>)IvrjcK-bO}?+1)}CS-=lTR`Rg%xJ=}|X zTx@^s_iwNOsrk2i+kRla+_|~ND8zN7cJACUWVHm6g$FD5ieavq&ULfg(|A8hRKiq+ zZh%By8((BO5%|jvTuLKPpHg>!1I2f`dx9gG(&#V2se6P?li#>j)bpV6NQ0xCg`@pKmQS1cd%&OZ!8eGt8Mt~%-%+A|C4O;8_{)h&9U z9qW8xwpfLvCQuA$qlv{>|9J`p`rnlyF2Hq6Sak#Qfl}@>{%LEdyv*Efp`AlE3=J!R+2oZr+VRz5QHYup9aG^u_Z*qWF#_ z;+B()k9baYWH;N_Kt0(!`b<;|ad(S+!_`Yb-6!O~y3Ycr7)ZWN4&OPtOxQplGUaVx zowMgIpj7uQZIi}+;BxCO`GAW+vG>r=J&bdU%qyslI*NQDCDOVdb)!vbf8VB6ovcXc_wV!lAW+B}P(YS(pE|$iB9mBd2>EU!!*aP{Hij~7fKM>zq5)=(VJZ1lX zemcYNL9vqWrRYJ-1>*B+^}DMI3g@0@npmJt?!8@(R|DcE<_nW~#`);?Jk!`va|_R7 zaX!xl@vA&7w?FKGAS>h;ethyT$fRrb^504XnVtPq`2@`0Pod=_p3~&&^J|k>WVk&vnzn%lA4`jBO*a*s){5O;V6gC|Rw-;Mb zcana!cdsFk)0j(4p54NEu}b%s!)qY(JaHUOL0ov)T5vU<6Zw#o6k8)EP}a*TTrT>5 zp7K6ss$U5x*+<+=gEdfWHPWqF!kj+|W@)9gL!c15RIck)jQiBLN^asF1$k?e*D4}- zFIqE03iMg&uj-o&e9pDJoG=`3}We1!~N>wW%Il;q3C}$Yy0|!4fi4#^WDCM zbKgMn{fmvLyFSKud~J3B2tS?|KHdWFq$I{Oa3XD@zL zU!K4^)9I{U@)-3fpQg?#KSVynk-M8M2Po4@RlhqE@ScQU4miFFlvt-j+M!3WAO3bP zQ3CsFLF*CYdx$emJs9==i}Od`Hu0_>U(i>bmo$FO3w1#0N+<7NU7ui7k8ORA`J_DK zS=h%aANiX65gJEO&Uuoe;!xFPFVG3Bf!} zhWexGj+oDMK556y;ZPv{6*7>0gL%E@4<~fLb;KM@h0ePPsF%BRV>gtSf%ML3c71Kc zr?RFECZ%yMmo0kk#At&#{QbYGOSgjLK^;AA)Xx#7f1Ha+!##xt@>*h_FwabXi~s2H zcfd~#n7eCo0;r$GdgRmMfV#+@nZ2^%e2I@OHK zzidFgo3Q_UY7|i8reU(`K2W{)Z*gxMB<@I0(%33p9tr^~nrv~rR za*}{@^Dr@d5a)ZhEjAOHl0cD*&fkAZ9(^Md>%O$Rs9)5pEo=(_a^Ul3UkmKBl&Yoj zG_js9Zk3ff5Q=*f=vcA?a2~O382Ef+1C+PAn*vWQD21685IROd@wKHzh%V|DRZSbZ zt8xESdP-TctP9BhP&EzbLEPOzAw>Mw58PwudTzO^3eV%oU#d*?JJbLX)%O#KV$S1zqHLVRmjc69s+J*Pz=zn|La6d4W`rf=qr3k27 z4*8_>s{!SW@L(mkF!o)?dRuLzfO1CXo-*>`l)dA}!#(by&cXE4`!MwJJZZexp_mKg zC<}%MG%}DiIYEBRvh~K0duncbeJks`h&c4b3@s0%s1)U+8FTj2%bmAA-W9Q zyP9?Q^|9|EAiGUjkW+2}WFq+$-^ZaJef9TsvgaQloq8tN!HT&{3qjwQ3-rXkh!54pMBoTKg{Ez?^YwEdjA9^yv&9 zGk=tgx$gzp?~aKAK~O_$d6F9>gsjh-XsiL>X44ThjU7M}w100E^%ZElXk4@Pi$L4i zOn)Br_%xQkuiU)Uf%@b3xwGTo7l>uwFW$3i3ev@PsO#mo9kAX+ z9ckLTB3sO5Qt~`d%hiUwdguvuTVIf6YjjH6hy8AtNDV#D5|EY>ZF5&}{_yybY(I?r z?UdP{iXqHha=eh!dK%xUcNh9x3ofE>3Rfgk889E9UUB0ZrIY@AF6o&^WgE?x>mt>aQ5q#)w6{FD(`9pRh0M9H`U# zB>~j@Htyr+SAZH_rbjP-6R38@I%sT7pnkEar^9Uu^`!1e+zN=}TOG|?9yLK7Pz^1q7Ih9ScRb=0 zW3cbl(LOSG2YsJC=d)60LFr!Cm>p*o&go~pH)e0)J{Q59hDyv0DA|+mw$loA)+-t& z!}gdLpsDxPF%{%`==ffqN4`)=_RMR3BappSc!ftx4`i9W7Qb4kf=rN2>hK%P379|j zb^-mhB&TzUOt{~V`08qNz!%J4vPxe5E^dzdpuIO9ThQY^&+R+x>oFf-%(sr^0oD)a zbHgDEs+bcieO0X&{W?J|K~E0Qp&m%cuF;VL2WC$+U|gzWzY7H(mw! zhKcHbw@w31{~B>5Nf2ndM+LmIjsk6Om7B_SZ=fmPJJx+C1Zd)lb}ow5crLE)J2gXr zx@PSEh&2YNW8amY$y8unIm39v%O9xMCqIkw9t5h7ng3lvI`+fkaW+$^OWB@%reAj( zP+r&7epyxl%6-$x#Y=Z^eh>9i(;EVctjFX2TIB5)R4QJcV?;eE_iL`b-*G;aX6NI= zIfduu{s*gbxQFjr*~vRN4~FRz#m-yd9@jDZ>l>I0RQ7Yj;C4CcNE@NS4(AX1z^hh7 zGt^m^C2fmGJZo#tVzW2S>Bq^Rz;goRo>>^UqkmjZaZdbHE%JglX8CTyS&(HQlM0-4 zK*qnhGg0w8kY+;LxjO;(5L-B8A4i|(AX)iiq%siqZ`FP``2q7x`sZWKEkN4X`{US) ze<0P{cW9_$6Zf&rXB;gR#~jSE*i%9qgy zMe;!W!@W17sXKx1zsmzvW>laZv5{K3F%C2vzJMwwydUOAMyk!$@tnk4y$8+$jTZ7i zuZa@KndPw$C@WuYe6}YWlp1dRTD8GFJ3C^T zSMrbtaXVJ%+K0JJwJ-dwEnk4bj_nQ8n7=9S^GDup@gL^(#!ug6+KT6qed=O9&L8Qd zm&8U1-(b^GxzRY3DGo}389I&z$Th@L?UXvY+#FLc@B z`HY<2bovW4!*w&XI|7Z8XS|sg3p9a+xhKF0)IYCMwS(^h^-WYb|5y@GYkp@;4Tj?! z=@cn|b2Zhe+xUpDExucp;cxmc1LddaQYGX9rRC7Ado0O_r)&*lt--ln@3jAvsu$Mv zM_ekVh&MKTiB>SidlG1+|K4^x?%~-k;;S!;{^kgi&>W8&e$IWXsr%6;VjsuhwsFAso}T0)1u9O`;oiq#h!HgVrnsGf5q z>g7fklJ}qa3w%@y?~X@{^XpcU`~d$K7KDoR%!23dwtL$_Inw;>hX=8qTzaB9^4pYT@vbtSY zOd9LSAO15-sPnx&qvG%q@vc*CJXczuA-+;S+$TGL`qG72FJ8PSeP_P0b0S`RHL^Va zm=RFSl^Z-*5cl6&ae~*YwLaU93 zm_e?;=F1nhY2-hC=PqerUT^A)KkeF>!}Lq}crfBpGHyRRU2ZV}X+-c?OgHAe>s?@6 zcJcyZo$wpYt~K=OjK#6*px(Xs{?=QHxL1dC;#u9sm~%qgo3k99X;IkIgY`>9d8Xs-gqwTio<4revsyCo4Xd({bbrimuSm3V)+CEvKtrvPP~ zGa>hL3HlHNT5KU3>v~`hV?+V!7xy-=Gv5dDzz++;PxR@=4&UtQ3c~$+KbA#GkAU+0 ztq#k-i-`Bm9#dlej&nL|ufHhbysuAfPhxHdB{`Va2=4{OQ1%|jMrF)pN}A{lDg^~$ zPT~E(eL(*7S=ZG&sJj}d;H{O!JSK(vV!oW1AD5!B_~E=O$gCebx<<7C85gFZhezUo z)W4mO^pF*OIwx}8l;V5!h?Q~Ge*}ocp@_z|YRng{E)-P59F5&~FP;0)3Q~72CI(nw zuBfV+jPu^9)CA3N@cOeJ%;baHo3^QphR_#yPiqFoYEY@ z>wU*x~kD7kwe6m(M=YJPibmiZHXi+t5#F zP9IKx3dC;*T$i7*1wO|Eor)U-pp}m|rQSIXw9>OLNeXF0y~hyy=b;;U*xJ-pvNN6sb0A7yv06n(^b zecJoi-I&us5X3^wE)zli?C__dC@SWa1zu*YSVsQ*lTuU% z;#Nsg23^6`=<{T+)!kwWGDj|cQ{;bwI_v1k+ji_gA}=h)Ep(s{q3ApP<5b*tTV~;X z7j^F`v;C!vh$n7SEhybx4pLWcUd&RD0I99tqC!8R-aUoJck9S?kmNU0R9-JbUx*SH zYf>%xLc08fgwjCbV%7_h*Qg&&4kl72{{Y{CLC-jLC!n>sS?ivc23q5WX`yQ|&}up+ zd>VHHt*CQ{#TeG{3?`Mxz#O2(Bz>8lyhh7^f={^X1B3=lJ3E$XSr7}R_6<_}0v@Fd3@nK-!W(e}3qxPrXID_1< zR#e&kT0D=0A#%DT`U;C^hAZXhOOF&qw(9>nhJ?&PHXt?sS<(N@03`V^Gp*9ss9&(> zv&g~RpPdOB6PWKSedz~*b6*$g77~g%g%C%KRuOjdzRo|c400+Na!cFzaAidfg!#x?=0qD{k!N@F9NiIqfuY8v3~b{ zPONOfezqgeE%OLF(CXrM$6`J-?LqdQJ2Gd1mbwxg^VJAwXVcfOxT#{D&!pd%oe8u( zJdFGLQ?R}Z2PDiR-ZC{%8h-o*P%Df-L@514oqWm4$RVufdP211!|lkIGifA7J?fZ$lIic*6~1cc8x7=UspB(-aU7-d?KB*$I3KgG)u< zH-YxH>(Bovy6$Ky{3tG3cFLAf#>0D$=M6--$Y_{FQOXKsXKSHCnWcnCR-}+k_Q=d= z(IBM~g+zAgcYlAqqf_T}-q-hg@BOUHL_Y!acLz-bQt^JgSYaMe;{|$K_WcJ|#zEk}XV}B1x05#fI^Ik9VB6@6nBfBh-XAf%9 z6&}NUz?n+j!(FI9y_eCPf;v^!n#hk=k+&`LwQ@%N4CUBbvDk0qMOb1Vnlc4rE>rPQ zziDPrxUH?U(2qIeBhBR#*kO}N@uQIx%r!ZGeX8Um>aJcq%KgiXIxJ#G5W5=-$Vc`Z zW4nzx8WUMVyZ+zLZOq`gb_H{hD^90b=wlA-PK8{F2k5)K?)vuJN6aT%&w2b8`t@ak z);_G|mmzLNI!pdq2-2Qm&s4HW=tGzuQArvBDevRd*&58TT&OQ6Uuwraw`+}C1rk7# zjZ@&hh!W;zG?u%t=E08B3A^?TYXZNxn!a6gF#4D-UE9-b0#v61q9Lzq@2**4K9;~CVPj38?xh8;Ot&KrIQemszZrf1h8>peRfwA#9VVT+hI^0Jr4FmO zpkC2Es=EFY>J^jcS{|;TUNQdM>|Mmw?;gE3tBE?eiyN~~Xyu}=J}vI52llgSWSJ&C zO`OAWsDtVXh?IF}5l``A6*K4nqU-Jkc_Dn)xD0zEts_CcB<@er z%L&Y3fo$MKo*$zsJujxIX5Kn*Ox>dTh4fC;TG~GX1fYObZ z9z6u)JKUOy_2Gyg?n!Ld`$nr;>4LElw-f*Z;2g>n_ zehVM8d!9Dl=763Y}QUeuapU;Ku;MZ2{g?P*X*&zSe?-3$s!K7Rxs9RPCc z3pXk6DIi-_mLA(fMt!f?!PrvF!;EAaHM%1Uq#f3qbJ>0Zu~sTDx@XPt3h?zSQodDN5E`qdF1qi@%l+k>x+8}VU!RVER0-Yd_`Y{$JQBDazZmmahr zpXajvkN_u8XV?AwP3i>dRKJ;R0^;FguUR^pjDb45O*CU8>J<88r;lx<0=3C#Rr3t$ z7>g`dO%IO)HKq84m&6&Y1I|&=M@4{oD$JZs#SHbpoTpECAg-&xC-+V222eTfPpxpE zPJaCPR`V|8&6_jFIt;`yuauPSqJVRT=S90e;XLT?EZDp$dkFn&9eZ?~aqbxXaxU*h z5AF@&Yu-`D2b8m3&Al9jK+$8XY~1PWR(59m^sJ?(-RZI?}0r3rsv7%azU%0F-WlcEdfg0pST(VbJ{{!! z)+}U9zG9BX2U#86S=29lT9-l@LR}+w;stsLP^*1D?FfDf)Vo4LOw9QALfG@I`YnNa z!ix0lmJ-(MEmnNEkBQ0;Ynz#!L1}9BcLOH@b1@I{ifjBtor#s?qh9olIPd7`n2|wU zL(_Hpe8d%*jY{P?2QW`#Na0XkGf-|_%3%(-!TNF3^q?r>ygPztb`6@M-*ety7xmbR zMyopY=LFQR{LhXZ zYamCStax5p4zgWm^5jM(LDnTS<;7An>Poj=kjC5@!h@YwUh=4e-=DWXc?0g@`I&yL z5&bJNE^01b1$D^ls(-w^bQy$Kj7N^2umPGgiQ{`e_CqJ{!bt-o)cwpS&+M~B+?;NS zmOP*tA1BWRA+8I7=5`HN@%*lyD!{xhnn?21V+0NKqn9ZD_&?X=`v;8!-6@#cB=>#K zU&L<Y8); zyAfxPG|4@76m{^2?&t9%@1`U+7)Ab}f%=~n(WN5f3kzh1_l@!c#oPb${lCah(OCxN zqGmAPudgslDhU)_;*UO6#l02Z%5^^SBfjYJz1La+b1x@luQ>gZ0J66e&uZ{mKRBdr{4EkDUqkOz!uLokhG*ZX{06 zfXt1!{Hd7so$(;Yv1r=DgZaJpl@hX(13^}sC(!?oIuM5AHN3M=1L17$?#nm)P*-a5 zeJo=hWNI(H$;tQyGD>nx+y2iBVr4bx`b!4ks&&H&Vx~Y#;aPU7Q3qPm85fbQ$Y&(n z412IL545P@(t3?X)C0*esi!-mjvNstwy%qd!`3 z&&R?0cn?-gip~&F7x(tmC-MDQm&&tFJ9$tLui}imSaA&J@h1akeDHHu{gPf1&VlR- z&&|L61*LZqroGx6nDdwKoIu05(Cf>>{yOZlRL5&rQe{vF->0d*jCG^Aq#>bs3jMc* zJB2n`17*+9o5R0!u+OsYS6^fT#gKHK@OjMZU1g#D4vhtcfV)gtS~WmkaN<=he-7jT za~ko+DIl#_?G^61kNE*-TnM)ofwb{vhuL5BPsLTXy|FgOoTe9FlMkUkBzL$gFuD@t zmHRcH4t_wrb*4h@dc@_e_vc*}x`Dh^>ySSO`Vg*c6sdeSfcp1MZ-m!lK2Sw-R-knR z5X==7seBQ5FZB0kE2@A@EYr7~8T9G?+fJYH`adT&$+A7r2ZYZygjstcKHDk#Jz@*; ztL=gHZTsti)_h8^JpO;&<4+uE_6pDnRlNLGao$cBufI1ig7|HnybCYBa{)pe4|Wm| z$JIO@L_P&Hon1vEBYRPoB_yizF&Fhele)2)pOLR^rO6+B4Ajz6yEaX{ACWzG_{0gQ z{~^qTi74P){w8-pa0cuCqFf`j2X^=UCfoXLY?*MH{E6x z{7jIDmgGepJV`RAM4uPvgAzj~IFL7V6|*SH77A z>=zy!dA70JAE?1nbMS^E!$fIbz7QoPYU)~L+1*))A1e4oV43`PZ;aTW@D2d z=u?!PQgNz4{rh-TMrA$nw)Z0&tTnjMPj&8aL^A~_+e->3JusIvzwn-G1m-wwPb+v5 zuZZ&@8*h93El}7rp0BQoJXNTI?>o*F}w#N5B%)$ z3;Qf)sV6C+fb+@n`znqakms4c8Gk$<(Ksr}(!K7aTq{6jL zLSLkSFwd9uIxkWYr~P5`ru7~2v)d;LP2E7}FNr66_u#x;L_g%N1oU+R#WmNGfHpJR zJsji+wBfz-m)J%Tr;;|`)NmJQ4-=ACbjN`fletqW8hI%<+cwr+SceQgaeb{t{9Qs> zYTu31s5kMgITnC(N_*-0m;BkNH`$!rEsXj_hgj#Z7dKH)dOStw$u>~>eKXum8~d;7 z0}0aq(D!>bdxtckAC%OqefE`g0cH8&t(UCm7b#ECJGfaND4sd5{c;hHC;SvhT!*^F zI{j~ad7Oy%p5_eM6$1*X#H*X0WrG6uMKc~2+*5JI>ZZ|q?5qA3RyJI#!TcE?i`uW- zfjFPK`!D*4iGE_9xi67VU--GxSxyt=&$85n5->M*o!Rr*f9R9G+DE!>hUdZS-9$3k z0B5mu%FHY#M?HgJe zo&ssa(nPw5AZ2&p)nbV(2#wBpWFCKkyoP1nq+1it*}!|DjLS zSWg72HJ2YC?oJciF0c>%y`S_PLVkggkrrp*hur$R*V z)~W3vy})AJ9fE#@qboiEX{hVfT(o&kPz9mN!*cu!-;s9;zN|j92z00GtZ(k)_ip>T z;3+@iSBLlKX}7Zieecr23Y0q0RX-CRtCs^^im!MA_tenY@5I>scn`FnVTW%e^6)3w!X1==L2E`AzZt#T1fTG@OGWSP(r;27K-$$Zuar^u2x>mR^ zIy&5-b9fJ)$JgDbop_KJ`LWS)Ves~idumUqXqhVNv%1*}eY-)HDVFV2=u05Pge~0k#Xfg?`o1^k zo`X!mo3aC3E+C^V%@c~|BMG)X3bFY+d`EYHP;60Dh4VP_95HM% zo1X$b@;2{$f+x_!Dh~Dbpe`$LT4uzk8Ts5jJ4fB|Jgge|dMuC++2gw6;EH@A@!-!o zmft|<3MW4s$M*Cz32lDA0F=ei7K+B8}N_N2hEFkHwi-SGT_8u86U&VSa@X30y z`4vz<8*Qa*+>CfY)pav&2G0B1PXmr)A4cEwRpc<@hrfx3j?N!Ke|1mf<@W=i-vE7Z(sequ^;k=6)JiQICqS_nqQ|O2*l&b9c!ekxTj*V z)kp3=`k+TuYVr_ge0`u;68lNH!}6<7_Tl&c-dl_yLj+m-ZB|ze(U?Cu!9b$n@cbk@HA`y8EHYY*8RxmRxLfb+7t%T!r7Z$?*t&;xVc+uP#J_= z9(|N%LtZ1lb}Bo&66kp~B5x3Pq-Rz!)p4ZE~4cWy(lx|k@==}qNb z3n%csI(yAw1^Wjj+V;4kDi5%(UyrX9rUE6ETR(US_3uWttm9(kptyRwEWR3jpU3KL zr#!L0YFt_Od+jha0`c(6 z9b;pAK)!#2Agd4Jzx&?CmgoDd?Z(wkyaR z${rxTV+Z=hcNZ^u?LvGvt(5bg6VMGpb;pLV{zxabSZ|m>9^}{8kEolV4di)oZe{@O z!HXU7=RTp2A@c6oDeR;5zFEGs-3c^qcDJMuyeF@>CApj9xg<$&%#k#Jdc@p{-57Z* zzMj3}F1?`CU)G*%kNxjea%~Bt68S=#smASyx6io_k!(%_CFer6>f|Y)Sk%3*OK$+m z`r}K|orr5W3r+;yMZIE2R#bHf^0;K97Bzup)RAuL(Mt`$^JrEsQo*|J?*2}z2Jx!l z)e(}977)#BDsP>~eyaV7IC}>#$b+Mhm_OE}c-^Q?b9{<)%I8w;iAs*?p-78T*Bb4TrXZ^ehwOWhgI5U(&5A$i?&c zq@j7Rz5*n>(&v^2vq4BQKI5Bd7tqJ}oL{+e0{!#fi2ieeKp(D@doqpZ@KS#(T@iH* zt&cA^J>my?@js0ycI0R8Xt-o1;=cKvO>js_gT z_bb=(_lAq8%bqTXl;8wfT&a}BnI_CT;}OZv)yFwSrsUxq;_lec+AI5vT5EoA5e35uC7L@i)3myEafc#Xhr~mm!=rgq6Ns#Ub zijDq4V#Ix*utm3boook1uRfv5bksNW^~^Iz(m{c`!AQ138_2gEv)QY%@I2o4Gs{0g z9gy`3f!+qhw=YslN+W={pB8HM4(E*qkA^BqJQroZnno8EkbA5q#hA5+ zK5VhSIgaN+c3XR@fP0OK)2<72$D;nkP&WM3Im}VEN@~O_l3GXg#a$9z_B$)`iV73o?NI&$jz9YXs1jR&&nq zKLh&oVMlRA6f zV7;Lj*Gwy8-?qWksWS-c`M|rWo?7&mWLFhO^=w7HaK{RDAL1>_jQ86f9>RH^k2lv5 z@%tyA<`o`c-xb)XD$_NJeBrAvWpapXP3jY=JMwWJQP<(sq#-{wq@%ZZ7L+!bvoI$1 z0j1*ULiG_L^iSEZ|Gn=b&V|QMaFyczsi2=rX8DgnVc?2_>YrB3>pk7~{t^7Y$0g5m z$q3J5bSR_{_Y$8vI4)`@3B=bg(sSIE-Aj6Qj}9MNtP zr3d81myhnkJU7|2NICJPXq?AuDPl!?fp9OPZ1>wOK#(4WzPue+$BS||6JCLg%CA3> z(TIz*-cDf}B7pS4n?f(1$Ko7#Si6qq36d#xk`FPTOmNJw{m%F)V2C6O%^n&DhLHP? z))#%i*!n&G*!45O*vxmTI$R6S=eKoAJO2KEjW5oo;=Sluuy{qP0(uGU$zeh418!LL zb#1y1bdR%h>r#VIuT}Kcy{H@LBAjO#LHI8HC|o56B!?_wZ7Wy|>X zpc!%eEdg!$ZOBX2mo2Hpqwd;O@N8X11yK0jcX4>BV?JzTzpGChC=9)93Am;U3Tojp zhd9hJKRI?Qqdf@EqQGpa}xvxl-#J z*`5c3TuSs#uCc2iw{6Vd9P?^rGpdF_qS*~ylO!Efja9Ihx6_|s8`&*{wVi)5bPpMZ&*?X z2HiWwXhIek)ZM##_O%0pn0Dp-lg+@8NKOp*ECvRTig87yBhdeb=-BW0jOP+k>_w=+ zx?>Pr@Q@4Z%NWO*s$QU9_A)Q2Tn75lKbi4E`%xF1m6b@~!+H{;{2){neI-TKQ|GS& z?WXCLe161@tuCp#D(fIF>3Z%WPb=z4$s+4^hhzUcHE{1A3s8+;b(oh2VO?k2y&ZWN zrK-v(YA@FF(;MfbN028Gk~~YTI|`IG)p93Z0^*Bjibnon|0}{FddVE~%dX{^l<6Q} zINCfHjk;0=&EsUNpcT};JGzX-yW@GZ_;yrs0qNwakc7u~PzR(Ze0`@55Y_a^-$$!K z{(%)!d3zlCro5<}Rfyxp2Un@T_6E7lE+57`l|l9rQEy)n`qG(7hAtN70wHAPYx7fU z?5hT5o-OEt%vH;GN{X`R3$gEP*?kgoVyBcgX^4Zg?0Dw`*V7;s@{a4>+cJ>!)R`Vp z#(ly?mlcl`M*`!3#_@7-Ae`c}J! z_LG4)*SFtLsrEx%>5Z?7T`7pKd=1zt<^?qQ(dPv{_`Q!mCTxCeh5BA!($KDA#J4OL z7TKvl-4fbgvHvOJ^5O{BBaY=`&32ag4=C+8UV8T^-iscqLjORz+5p+5R_G~?1UQ$Q~KqgsiV56J%Yi!`=GzR7?3X34J~=nGMQ z{@?=Qw`YvkR~^H7<2S#a?Y=CK3B0oEz>7Yqf3d^cqS5z!b>~#!J`+;*KYooWHA>v<~8{(eeI~8=;qrtHs0)`*Ubeyc zft!AL^{grs&HS~>A z&MS&b_y}T-L)x!(tB5BiU%#9zUCc*(<9YZFXJalU z$*wTcU)c?P2s&BDZcl+o5&L;zDIMffm9F0%!2P%Er?}nI?LqE*nNjn^IOdr!$3~87 zfvl^pN7GkhAdESENg8$nf}@SbIa$n+`6{qo2X$pKE>{AMHmQU3bn@*@GMH-}ptmh~ z3-ayEK`)=a_XnxNlPUuVcTgV}puzFR3j{A{@L0wt10&E;%l;Iehd=Mq@Jb*sJY_TA zvWx-4A*;;XA`ut|W0L09pT%>Tc_83{KTE$8t9HkGwb^>pfy4NHk6ogsFTV$RqpR2# z^lQ));%?#gOaEd zxADAKD(L$nv9GGVH#^nmjlSH}isiK!?6Y1KeYD5=G2kb;$s-(fix0I!6x%_GlKt2B zEB3eV;zuHVFh?saZOF!H5-4(P>=*Mdf#SV0d8roupfH;epq^C>3WiZJ@de0BWo|!p ze(@2Wht_hc5a#}z7)|NbMZBct7vC4rMASJPNi)ns-Xn2iS6z(|$g@nON$E?1obOM6 zQ(I|}o!BHe5re)dTk-prw{b7UJK5B-{y`ud=6Url4tc+U?hwa#>~pR33B6lT_x|Bb zUIONLN;~P$jyEggKGpmCv`DB2+Vh*m2mmCN&&e8i^MIhU(>{}oJ-~?JkJv$C1;(|8 z0|qCJfpMv3r#Su|GXl9%lo~mJ;oNk9{>l^>=EFTNxtoBo%R5&^<=wKhL*g{&CQw60FKlA=zNz93@ zzUVJigF4ds*tl{RpnNR-B`V{9xJhT|>q~!uLe_LheSx`U_g5|x@{lK7JhodfFB}y1 zM<4lf27T#Sezg(EHy32^;SFDaDARQDl$H+aNVgODnr?yI zpC<+SuQ1QV?b^6c8}b_?XC)IeQ4eGhylE|j2!vk$bn+bPv-a7VJ~c!gX{XG`K(oD= zWAem}I|6;See9=vwIAW0LbmMoibjwcd7ybY%L1gRqbjd|y$4C@qrn_C-$2kTdy+VE z7Z~>@u34%z1LN+s2g~SlV%+w;{c+I&7*VPJj0H9Up?`7T z{T3MH8L{vJtpDt)`Nf;Yfc`~lEp`BPzE!=t@9wt({i>;kOU*34Tb*)|TSR~^W|c9G zd@Sv=RFK`*joAMh-`;lsc@?|0=kD5lK-+H9vi1w#rdjHxUy`6;Y&R`HLH;AVB2&`*2I5yuYWH{Z1L>ICuiTwMK&;F03;Ke20Xr?n zXg{~3F3bI;q8;uXo*z_A70m-V$B^@4{+KI1aM<%K4d1Q(`}UY-V4g{fLBh}>^cQMs z9`5l)A7QQNge2u4;_9#01SC>Gy3sOko7H!a){i$U{W<_reLl4>o#ilJ{C>s{)ibEa z+Az5BW&;TB{_1D1;17(_AHp|1oqGV&BCUmw@}%=}Bvf0lKI^ zbsTO~^SlRiQdiis5JAN4zpawqB5q%Nv}IZYq!x#4h z^?L0QJ-3rU)j4R8qalXAPratvBaNVRr{&I6R1E4-{<@_GdI4op%7$ks3@F!6t)@|~ z0)@ftDCmm5!cu|H>@S5tkxAG)VGwmcX54wcGK)aY`J}<|4flnt1=*)!J~qj^xjpch zJP@Dc-LS;{kVG;56S;z0K>qTQ=3*N1PCwNiyW8fVuD2`GAkZ6i*0(&oqcJ~GJMxX> zyEN3jC$Prnpniv%dHrsqD##Sww|hL3jJYx~-9fK^gLH}Eg(1N=Ag$6CF>u=heF#ej z&KYro6c06jI&l~zH@IU6&@m8{0#!1=UZ8ZbyRD*xR1fU$mVB91-`^f#$_ zKY#7RK6sObf)mz#pM$mt2 zojr~Eqwy5id(tzge^+Zb8rFk8Ll)KpeCjxdNUqx!6^CzQMKot7>$UAuh$X~2d*}C=%U%qszpAIrvl^axJaR2bm!R{kt&oD=HfWRVy zzA3qk4yWVBAXO}18`T$vIAYKaI}O|mvT&tb|N9{jeT3gZ25f3LE3` zH(>M(?RA^R`_PpB!THKpJeOMF3-WC(#1+ z2@Kv7%&m&5K>rq-{UQYGe1%^i`NK}2htfi0oUxu5{D2>6M-g{yiZ-c@M!s>_MkbhD(W8Soi`59-=sUO>i`1+8q%3sWvNiuNwm!^g}Klwvn zgs|VeJ^xC%+zzC-3uLfe#Pi7fx55&MxyiF0?8IO(*g39i{Yp&<1lO}~8r&fRjPZ;0 zz*`TDu??Hew-^EAL*gxaX&zv_*ySbQ$_$Lg`DNPXR(!_>KL}Uu2S(g9dr>C#Utast z!rj(kJz?%lDarwcq(Vp9Od`OUY3md9Cr| zeebh@_S$aXBK;xI;&m#{s77I*RgpCDMH2Pa-@DG8S_EnVmxy4WEzTjPh3pb^)IWai z)N6VUN=3`r^b0>QXZ)$MO)&BvtHB$$9l`$U?*7H#a0$$_zVLRF1n%!{QMP_)$pA(6 zM*^=TGEw)V@9M}x1#;e$W4-4KJddksX##s-DCHk*l_}v5IR`q*P?B77% zuSY${4Clb1v37oW#1jpC-urCP1le-ih+P}cfvimO0ZAiGAlzZ!e%;Fj^WL+L{IT-@ znHZCvVC~n4=dKl*USkF6sJkgQcijeQZn3z*hC3j2%l+5b0a?U#H(u^@5Qd%aQd!G0 zw}8NGskway&gV--3Of9Vn=B|u%n{mvG5x4W*H0N3ql(Lm;*P-RZwwE^9CyZ((~P4- z6Zn4Zrk@MNdVkSynm&YmuyxLF+lSaEE4hwK#SR05rQ-Mzd*pwgXEk1?m4B zN4o8_k?Z=uK;L;wg&Xzuw2x=hFFhXwT1rvF*g!DQ%!0WoW2jqM|BvXeh;v}MN7{(h zJ=Cu*>t#qA0+sW*%&x5gpj08pU?i2Ju9rdRn@4<+Ne)u;aSuYKnrNa`1m^fYaxg`F zP_aX#yyDg^)GHF7j}@DMg0^YpgZ}mA7OHq2wAwmjUChzA^pS6GGwR?TBtJMz zMjb= z7v=%%QK!E@4U9E{-+>qG!1xut|H29{Fh*vb zM#=bob)I~CzO@k;1q)j)pnrrBQ{J5UvjrF~Pu|TP5ySc}cH%eY3Ng0)IqV@s0Qv`? z`+w$82cMhsD>=0R=x&u~OmeY~kb7SpZ7D=ti*NH!^CQ@2l?%UpqK0__Lrm6Lzk$YC zKWcQS^X{q z(m_r~&+JGb7VLO3#=D67BbnFzh{Js$Znyui@Zf%m=RH%4I!%bP$KDw^fH`sZpXxJY zG53|<=Kh~0?60osPXFaYzUiN1%SH!0kHCUm2ci#P-aFesPrn~X`?^MVZDa$fg}MsE zGnfx|c82ef^dLxftnO#Bw1=II%LTU4iI{&S`Gp=k3(5l8*-IPLK$*8J{;O3zD06ZP zah{=qGLvOwcz8VCmxPDwrX;Y=ylBqff_PS~WH4*VIbhsLda;erfOF(t4o7#a{|Ah& ze;>m05N#gd`icG4_YUP-Lw!Imz4*qp!v^OOuF#lQ*l(%c@iGZ51KPYPMa>6!k-{Tx zU87h>96mK0r64ZPFA^j3AOomRl`A{VdyzLh8S#+iFzUA7pE?`KjQrHI+Q~w^Cr%#s z%vW}U(&mL)=QXSw5AJO7vpSBxsf!F6sluId?(sS?m)N#ZQnq;#LWIX2I@2D0A>F?z|J!h}eZ{?m(_+^r#X+EXP$_#q=D>Km-k3r^ zD$PT_!C{CQXs2BoKOIj4nj?YTDQgP(3K!Pz{7pbJRovcr&Iff?A-B`MAudR@tM?@w zLm%3kW;c2f(AXyHnzKAn51dnEaNh&*K@LBIl767p%eQ|&fS>o+Y3ysLgS%MGoiu@U z!UoQ{_ZI?Hwb1hEFy4o)Td3+4>(GbpYwGv~^>OtRNnD+LsJp%xEp_K2VC~V-Hz~wi zKVvIF1H`eI^QI4NumDP*^UX|gORVRqd-cBJyX9!_=V1H?C<=r_>ux!K;xDaTW9q11 zjJW>y0P-D*;yTA&y51moyJ%+@mn_Vz<>^^ugU>VmrIM8RYc$K7DDs7560VsgksJ!+e?ui_VuXKy>hC ziI1Ht_MKv9cmi-fu4&yUKtkPUWx46S%4DEDp8Hc?-V3zcu>KCWc=XMleAMT59%#`S z5$P&Ffp&JcYq;+{)RAbMQ5@sK^Lo_KE9QhgsD$&kE?`{{S$%o6O%dPi)4x~CpAGS*|>vPih5&{k0T;o3f*j{c~c z#s>|nL8y--dA}1zUdpoRPfe#1;)yql<)5K%?R%9k&l@+OlxU~QY(X3=&^S(ZR{~Hp zopuczFa^qny%*%BJrK|OA(7BO4vO-9#~gY#f4~5kUFyd? z%+{g3-*E4syi?u$g)6^7p7ndwZPdfa721SUvDu>UYO9sae&pL%*FWg^<_fX_)x#IN z(66hsJ8mQGD~S3zw*{HkW1ftfr84@)>FYWI4#uJm?ypbq+i)SEEoi`(JTJg?1LwWNhlYd; zQP-eiTBYi_4`{p%OUZ4fK>b-PEhUD2k`7wkS4nQvUmv09`+6Z>rP%$*zX+(h&&s0= zucAIqd+6_B8&LX~IrYs8_0^Bo>sH`9r{ov>z9kCrUXASrr#59m z+ivtBjO^gJY-9ptuj|B=c|9Prq=YdZV4X=)k*?yX2a{}n1 zr15k{v2N=w%+GM>?cWgtH2se@K8vUm7O&rRa`6k|xmPg z6aQm-5w|++ysPwsI8arz4g}@vV(#_S-Z<1bDRo6eJg(CNrR&nHV~QgG``A3QQc*7_ z*zqNM4Dt4NOj{BK5`mI@zai5b^;uS4GMxpkKoM4&6-dQB36=d#9=cTAUm+e+l&1#@ zt%h%Zl%pQVNH0T=hCcN-Ty3e|?Lc-+vyfc53#8faXBI~JfE4!A_VHuXJ@DoPZ5$o} zV%|oI!w~w|HQ0GCWyga2%YtV-ow(o7b)0`MlM3dbly=>e!2URc?F}XI9LQ;W(|e)P z2(m-EN`_ZZA9PNzPg)=SZ`1L=F9o*XJiqIM*&q*W@81)qvvDcjq9+k=l1M4Bszh0wYsGZ*Av`xz+qG2y{W^X(M|dQG^!e{iT1d4S>8}`0Lk6(;)YLa<_V50^W<2 z9jSjtL5}mm`wU0)P3Qf7_hgz5vU;x`)W{TJ-Zqnd0E#%wn zY+kn@K2A5hqv*Oh8u6*3Iv0EFqd4OVpk8jM@e?Ar9ZGbJ7_7Q(dEjY|H9EHep`%^FZG4 zwTwbF_GKiSJ=+W%a6b8V$m4M9O(6Q15RP)(0^&N7fvY_Fb>crSH6)3E{7#Q>NiQ%I1*w>*$^%6n6u?TK>3g z{1p1r#lu86QMV9RHY^k80Cd0kTVbWiKtD3=xl@lF``Ln~6E_5a&Zq0DVDS`nCXH=^ z&rrAhR5gkJlMT?48rGX+A}@97RPcad4%QdrT)$md|Cz&2q!?qqOt)NIVB}WB6U}9O zg;2j}A;LVZj`f5;eK@=;4U}I0#V9*lP)abRX-mzcAG#v*nA9Nly~f>-WNrebQTOEU zHOz4cJkKZQfx2s@@5W967eVnY`y0{0e)N6bs_m;^k9%EQEJqEw(LWV5w9=}DezwM< z0ynJZdbA^*HRxw+@3{7$7IEMM0pgdBSp)H(ytcdqAM_<~u5{3B3 z_bidb6Udua{w^7Lfphntjz1CBK!4Jr{@7#===TKVgGGL!u5qLM$jkuF;prEitRhaO z{(FT1I|HA6531#={ACE;eoF3Yrk_ z<)eo0nOy)%*TOyVF*%@wvgJ!2MV+;(qlmx{*H|#E{b*R98 zchAn(Gq$BbuK!lx{iF@ZXd>Zyf;s#(`c*;&89>_oY;y03UgSqEewZ&80iwRe-^0n5 zK)zS+!!y9WpGWlfh-70w`^A{QS?MXrojK&9k@gw$7frp7bwq*e&0W`TJX8Z&*-gd= zv`}YVS8Tr5f(-~e?wr5eKLOH{bEX!*dqCuEh~ZF9KQJ_YuGHHqATGG2HIU~BFqD18 z7Gr)PzahHr&~!KI8n#$H&!Yl^+k!Pr9q+@++y~t~FY!JtMy<1;qK?k(t_>H?;dyoe z6-#)Ju8gTY_QiW*%h5!cRRFs3cr=q=Fye@@C9I=wf%cxS*GexDXnD6Le?)NL`z7n| z^uL}|ZCtoNA{qS&Gd1?DSm&Eh9E{$s2h=dLPr5rk0#)nVfret_rB<~}s+?6osVw-I zR%j|HxmI7Y{?v#4uh`Ku!&=DS4kn%X%m7N{kAoJ@h{J1ILo7O(#CfTFd0 zrlSD*5T4Z=%hcokZtcErKM!;Px%v>5%w!2I2a8w)Wfr9*hy~3P7%>_=@J5H!yyrH!(!yNnCJwZu-(lI}a+tg^t^aYW^WWhnBs+04^-%z-|s zUvnwzA?mYCE^#sA_ny~hS$DAxaoson7BK&lemIn+Ro5Hna>Ma2alajHd83=CP8Pmj zyhD2~;~W|*neaTB2DC%QDb|>yN)srhm!|+w-*`SddJJ=C60-(aJfeYW?pgWpiX7_S ze;11Uujg$!RKnJC6_f%?j{QBbh;^OP%WScNd8AD7v!O~riD&Q(spw$tOurqM7Z=Wj zN!&&*r*WT)u9b`{>Unz-Ww$2vfP&U#jX&>Hfn2ukmVuZUkcrGEo_@!`C98A=^`w^xP0oKKR4o2!B^Vv&XfYft?bpVj%&cMUbFQ&AOZ|MH<|O- zERgqLU2G@c0S4FCl5LgMsGsAe{s>t`J}PN1J(dXcjGH+kVb~x03$-2JEQxr#<^;!V zBi5DeGat11u@CD#C|i6A=NFHE*$U{la@%gmo{jS*`FC609G=6J;GT1jQ7`u(H_b%` z^*|1-IY$avQQvTby}SYSqt9uYKhCispZ?4w-3a|v%Aqe?NjR^Mg$uI3$pT8^GDq#a z72+qOzS4cT4`IoFFgOa<>= zCXiA%Os{Ws0@5~DJ=1JfAjauVbzi&&M9ynjvi$f?#nR?aQk~GJL(f0lRR?m3p|u5R z#prw9V*T5b8Dw)`kLA33iTiZg=TvfXF!y~(kK&8^Mf1(i;SJ_A6-q|s8yO+q7$Tj; znhqky!G$(g*O1@XA#Wbu1B^n!N0moU03(m-$nEXcz({+aGG~tG5cgPm9CN%F=db** z!kid}voqgi3*P*Ic9mTW9f!^Rg7J$ zsF1l)hyAI9e{>Z4UoIg3XM|WZ{=ZrXY}s ze&X~z74hE_uU?*V4+9Yy7_!3rJ;w7NA|AD>z~~#$n7gwcaonT<_kF^^Xi)YK)<^x% z<8saoUHHA<-TpD78sDvmz=*v2h$p(e`at!mL0u3mkB5Nnh<^f$v&FaLy z*z$^Nnnx|rwpMjt#auz^Gu_>>Kd`P}+N(W_`+TV?GdiWn|0;byeyVLd&g&^p!g+PS zfzn>$cV|Ugpv;fU?B(gi93Yu34Gwr;%oe-P`F;ipvqiROaS-}%y+qQwa9>`ZqPFzv z2T)Lbrz8;-ggmZ&expPf=E*%NX$i4JU;3*XJL&!CW6ONi@Bs6Gd;|@pvR;Dx6k$bk zY7OL1Jyj)0XCQz0IeIeW56GSNZ*=l+L4W6&0S?)xAnW^#{kb3d4*vSTWlh9;5$QZ- zf<6WU-%UmD>}kx2b#IH=IS7zUr;vqdFU$E`~0x`H<1sy717Zfb{6O-zHc|5PDS6<&)sJhaK8Uu zam^qA_0jrz4e64^89C@4spLB|B}Z3_dyFg0q2oD!-FcaCqZfc zWu)eQ)MI6rOtay9s$`a(wSNKiKYvDQtsDb^l9zKsCdvmWmYgj1v3M>UIF~OSX9Go7 zZ4RZHS9l<sD}&P}f`W_MFNk)MZT^W}`g;G8gmpQzYC^asIc=CWlKvoGDt)d4T#8 zCt2nB|M%#8Ffr1KwgP!8fuEdPB|vV#Z_Ci^O^~y+`u5%x^D*93k7wi;fvipB(^b-dt#{1 z+Re@HTwQ{EdSTLsc0I&Jqr9G>O$T5$Fy^r`m<4#o5$Zt{WCOlAvE zHr;Z_Q$7WX?yplbB=NoKdvuURaS;^gcYi-0Qvh;m+ECRPFOWASmx<49!u+yJ-gj$I z-!OLIaG=Wq5Usw>iVY@#e7_EVo$dvY-)sJ<%j`PHJ!LD;FvOg3-DA6UTA(kaRn5|> zfdga>l6H~b7XzW^l<~HL1l-%10bMM3FFw*%h5s&r4Bgf}JN`57QRnMyKllKIYd&eW zANU2zq*3SfcfWwL{KNNGSjRwFiZz;Ca}tyV|9S7M)&ynNo04%ieStCGKgcJI^?kU> zG;7x_>v1Q@ zDV?NWe~tNmkKYn%(B~~n9bT`0Sr`bF4wWtn(WnQq^=3bU`mFZ0%(K?JK}LAr3;)X} zL2B-pX0rQL5Kaw>);`_^%7&DFw#$b>S#O53sY()*wG^c)u6BYlZI(1I1b9ALzq8(F z;62*0EZq|ZjKyr5C^0|0FRwq?^y4{Hw>Q7X`GRpXru%U__QS54;wGB-u4(+DEg=rX z;ApD6!<`58!DoK?dH7zXQ`A{EATHp*Sw+8wpOO)FLwx&z_OZ!ygVssJyFQ7`I4c0n zoU`^@r~uG5dOAv%A`V=ocx2;I)B!mM^yY`kB46m!p<7!IN)5&nG>0lsa$y`I>D&M% zZhM0TNiN)*OY`4kI0qElXTB$7J%GX?#Wle_4~l2(!}M;5;du<4Hgd%Cpxn6Pckc|4 zZ(bSd49G)YdiwMA`4XtJ?icLUK_9})jrD&5vVf>dm-rMV2=Wz%lNqP-K%S&59ycWf za@kYsZ%2uMoWu!go}mTE-n|f|(297KxQ1#1LjnkyF^?JvZ!ovSKK=2>N|1S6#I=c% z4KnL;#%r0@Kx&AIEEzcf!WVjK*FI~2vOPIpTLj;$6Q8A6KYs;ftM$vF2Hl`+blWaw z?L8=KWY}ES_XA})Qi+yS6`qUUaGn`2FlPU-U0TMu<+&YGcc>vS9$wv6&ut2f&?wH6 z?j*b?Ap+H0T3AmmWnDau_|}h7qb=^AfnK7}ApR^4aTbAu@(CxP)34Jm`G%n`tFg2O zb=$ND&r0s;jRNh&Fm-89Ec$Xq{I8#Q3e=Y3H=HTF$QO2JOC3bKOZ4V!)Op0S+SM*p zhoD~3V`m%emY@3C)t_uB!x!oVJ*7685_tPj7}$vXB?i-*7#F2xL*-Wnt=RAk`&z z*RGuelE-A8PSrH>AUl0ElB9unT35_7@F||hbC$J|1l&(i`PUh99#oPzUhubX!5pTd z%bS$Y=V=%DD=T;elpA8I&x*BRUT-0V?RysPLumaiG&zKG$Hb2i#O)Ph|L&h<@S^|u zYiD{I>QBNF4X69Ag8b6_)Vaw>kPq8pHWP#TxV2`r3z^8XUl3@E{;?bP=rASQLX1GB z{8t`J+XoOe7LAafx(tjedFA5A8tv5Ly;w#EH7=Y~fC0m^7ER>S zL(Ys{XTODhgsi}nVF93gX79eIc^N3tV}86f>X_pcd`O%db?zT}0`FsAPYyMnaeN^I zWXZ)^8t!`~JwGz>uIVC>jy;*a(vLcLzTZg!W4M7e|YI%1oScWfOr2QfnIxX zy@!?)(31^sAGbvPkAu*kRvE-AcTTj(UNJ^oa?HTesD^BxQOLLej=l1a&GZ#n#MG6BuP_G!0_MI2^6|269 z5`NQ;e3T+5VV_|&s9X?uJgAxjgyH1c!u^Q1n;yNZJ8=t??_b>eHUM!%v9b4$1jj%r z{^a}fw~m0~(iW|CoeQAoQ)wqFZGw9|_qEBd_F$j;HY;-s^}Jt{w?-MEp48rS_zEXG z?qQSWcDIPbT!6xN*(H`Bd)H8jRpvU#BihJDxez-!CtSl{*ilEf;}f90y?q*0D|arSNfTw9=33RkLq zL>%(OivDE|bHum&IX7Y+A+@)_MS+O(JGz-0+wK5WXVi69Ddsp$*oUj^#kz4tv*IY~ zlqkFE`CiaY19?z*@5gf!K)&D~UqQCOoD=>b|Abz|dBcW0`tiN;{c%|69_oMubckJ9~sKX@M2C+_}j166qg@7EWwuZn6`^qGzXLjN0yfmO`kH_%sJNhn0!3IDZj zQ_SlXP?j#3C_^3TnXVJAsQ;Oome{g91d6U9-!>3%|Jo-G-BULz5m%4>w$r~8*40>(js zL%$UofuXi(G;5;_FgAyET1w&^IdJxQbtL+D?vq6ad{J*2TJ|`_UKr?l;y>1w?xD^% zN5ePa6VRSpc?WV70xjY=DS7uJ#DTdskCrdseCVv*5+8#4iS&~t-*GN6`E=jwdMr@p z98?Pm5RbpUXKN}q;_n7u9kV+&ApWkEJ+xsLkP~yi|G44-WP+(#h%5R$+nZDjG`N9u z($M-@#daVGy~t2fKs`g4&rAc+4$otI&M(U%P?b$2%_6U*ayExx;EOuB9_?_o*T~mu zJ4fc$Jq6|bku^8OyOp_G2?~rg)Gf~BiMV24HDueWZu4xpsefEAof$x{ef>}S-U&fB9=$j7=f&S;X>^Slf^oBUGKOTrbCLaCSpM`je zrE=u8eOk!3{3TiraR9CJ_p#O^h-W40-5ETE_?Dia2{SkXsB@S19@Y{^U)waSuq*=A z%4So1r3LC#{?t6(iTvTsReRC!KS0@2Q0wJ@eEKgDSN;P(5XVZB&)trFFUg$wpT7@~ zItMImT~SYZDo(}$^U_J%Xw+Z5azG4!biq`c3-PO=qEAkE9@0IAq1O{YB`neYs;f8< zy1$sXV15BXt@5{RpCKscaOJ!y_=b5uFW95*d!bJ5?Os&_aoo$jW1WFI_PM4x0)<_e zn^;Th@z{+0745T7u_xY((xC2>=UqTvd0kds+bZV0A13st2!k9UrS{eVH`K|Er=&l0 zz`erRw??&XLF9vTW$_Bm8%q*J^5;E)@i$AcVRZx;(>w>I=*GYpJWEk3bpb}#{7C*{ zC@`L!U1prb`7l>ec!IPDj7av)${skkILg+$+aCZ1xri+^3I86p8z~|LMeKu#-`Gwc z2l{_O>&w*edzY)X=t?x8?|Ag2w=N%OJp4)QfY-e#vVOSU&@Kw&IXq_e~&QHi|kX zf_xQCYWr?$%w2rA$rEz*r z8*_R?E*}mwN&>?BTp2Sl)X7l|h4*ek-NNNlJWu=+KxtXPr2DiFD7g!SIrbQWV&|d8 z&Cg6hQD-F2|K2nxRAg=Rq?|$C>5$31fELK-sfhDBp^r^`>hh6B-1nTFp=`^~3UU%W zWo-$1AnWe?X3w?tAY-^RD!BVLh&05oJmgRVCbvb2-o;J8`TK`{RIB{^uN&vX+D~9VTxyp60_R2n zrN@>^{Xp-dJU{940rBFWQiD0DEA{c>t32j~Jl7Dp$^-fOu`_Pp7Z7hOu*>@I0M3O6 ziXXTJn;>tMY0{Y0gn4KOqQ%z^0`cOP7H3v2@QrXY{29J>Fc<{t|U2pFIDqvjbuzhtRC0 zGoFXbmz_DcKy^oc{55ubuTEFxo6RxCd`TBWGkFP{UW{iALRo2bBfROZM}2{6vX|qG|b~bJ|p1l$?N>M7cY3P z!UcWQSsxeG+=qT!UiHIoxUt{0F0rpq$9#7+u3BYy4I-t9nPMrK?GR5e* zCSL1+DG=#>M1um%4fjre7a#&-_JwKq_!fM}-n|KU9(1HQZ>)IMoIhDxo`WNY9z8JOfdT_an@ejU4Xe|Yf9_X{{DygzJd}zWDqaWG~6AKrUazVuA7;9-9QSt#mdd$0VHwW zm*(=LKs?8vG1Ykn&qMgUv@QDBwhQXJeTxQ_Q*#Et-`WA8EicGuH|~*CWH+K=j+t`& z#vBQ{9p*1(eb7FC2$ZY}UTt`Qyi+ZIRp^c`P*i?*=$`&3P{?^Zq%FGu3S0iY{q-CB z+_>GcyZ0sHUc3wqRqIB~zxwjNF@cPEyBkG0mJfjJ?#yH{L&QrI>!rfy)`Lind&s2z z17NDAJ~*|q3{2&}-@Y&|15<`5++KMIn8KRZbDlN>bG_V7lMtK}CzqbQ--mrx*XxmL z1)Sr{3;Z4q%mO1Jci-d#SDf#=ORj&#Iz#d-_Ho#Pc%2$?+{1X5l3d3pZjPNhdPNc-Y07fK=bi7mK%(Wi5Ga#L$P^6czel!o$9$D2Rrdqjfka1Yze3AUj|BlJrtyq!D06=cNu zxCEExK_roNP;opNnA#6c6}2`2Q){cGa9IK{X=-JDX_tU0FWXyd{R)^{haOW7;`d8|k)?h%U>NJVFZY?4Mmo-mg!}Q$*oSdempCWtWB>c1 ze$oN);Pji5Prf&!FVymW&u#qgJgfuf?ZdIp`Vnzd3w1<6@@MUDUPc^#;SM?bJy72z zI31mP0@U!$&V{mwGfF=xj=K06D6g8x-*nx9a?JVpr`PEJ+}QAx)42k3Fr|BbF6;-g zZrdvhy#J)$;~kv)5myY~O)$TJ_^zY{>v~J%(WCzQ2V^edc|>d+JD3Wp;vzMw^_Yw0 z`+zO>*DoNvpp53#0;Gk^5w#I>aFEWtd0<+J7ea)=+EbUT-?lMZrYhaOv5JAj;rr;l0bU);myDLe1; z7X4CI0f|SPaewNpUeRW25IN&0+sv^InC5D~{$O2T?n$qC)%OXQ`Zq^x3tE852>&b%efhe3qiuHq8Phme6`mnNf2Is>)$5gq# z(10NnIpAlajd-wRN$FMOxo&uFGnz);%PB_v+Agds!nsk`OOQ`&AHHmA;|jFM3tJ6{ z$hQ;APPP?e{r;Nq%;{@BP@|8XP&@Ys=X5u9B^Uup`@>hCr12bluU>rv5I$GRG@>CvTmYn;!B zqD4_SuN`aP`WUXp|EFz0Nw`^i;3dxEjvMj=a+ZLin5pJ`3;FYT zuLglv1E`O?G?y-0gY(Dsm6HGGGg+xV64-1CWHDxijWqI6gL6TqcJ9cB9CWIsQ0n~A+M#qVj_v->? zj?(SkuYyW_P9sapeNZ_R`ShQ>DB|k z+NUMSvuub*zMd5oMO?V=^YwK+h=aLo5MitT2MTLaew#!N!}fa7U85FHk-t-P|G%yx=2U0p&-FKshhAQ5OA< z6m#wq_I&trVTBQg!#j_>xya*9FnG4^qx}#4k0?@a^Yrji68qZ^gs^q0&Al@BHeK+6_L>+cH^TO+(`tCpW@TF)_ zJ(ed^`2p_}%ht3sD>+cf`sMN1@eZia2%Wj?#XxxTn%m(y?tAfmdep{kC;AcA>qtNI z!MXlAi?KEz<~KzttqNkU+2lRre{>~KN)!ESwT63nHeUMBQ}zt~R-~sRFZp2m0ruSa zfMbaB%~ldLu^&P-_TlSCK;Ogytp%w-XG`CE+75Z7Mbh6%)Me4edyCz0uO01c-qQGh zBG6u+Ye`h9Mg082PFJ>TK+CF9N(}4z z9H7q56!l9WF4e{~>UH1(YTm{Q)_mkWP6Z#Xaz(#_erBa5`rfE~VQo*X@bm9cOKpmi z1WHj~_T+>;zEcURe`q*|(Dq2p@4b({TlKHLc%I}MA7≺=7?7!aDsIvCn#NcCIuY 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 z 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 z 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 NCFj>2Drzzr`8O52H>&^u literal 0 HcmV?d00001 diff --git a/tests/regression_results/generate_regression_results.py b/tests/regression_results/generate_regression_results.py new file mode 100644 index 00000000..f643424c --- /dev/null +++ b/tests/regression_results/generate_regression_results.py @@ -0,0 +1,25 @@ +from pathlib import Path + +import xarray as xr + +from cfspopcon.file_io import write_dataset_to_netcdf, write_point_to_file +from cfspopcon.input_file_handling import read_case + +CASES_DIR = Path(__file__).parent.parent.parent / "example_cases" +ALL_CASE_PATHS = list(CASES_DIR.rglob("input.yaml")) +ALL_CASE_NAMES = [path.parent.relative_to(CASES_DIR).stem for path in ALL_CASE_PATHS] + +if __name__ == "__main__": + + for case in ALL_CASE_PATHS: + + input_parameters, algorithm, points = read_case(case) + + dataset = xr.Dataset(input_parameters) + + dataset = algorithm.update_dataset(dataset) + + write_dataset_to_netcdf(dataset, Path(__file__).parent / f"{case.parent.stem}_result.nc") + + for point, point_params in points.items(): + write_point_to_file(dataset, point, point_params, output_dir=Path(__file__).parent) diff --git a/tests/test_algorithms_class.py b/tests/test_algorithms_class.py new file mode 100644 index 00000000..7579ffb6 --- /dev/null +++ b/tests/test_algorithms_class.py @@ -0,0 +1,275 @@ +import contextlib +from typing import Any + +import pytest +import xarray as xr + +from cfspopcon.algorithms import get_algorithm +from cfspopcon.algorithms.algorithm_class import Algorithm, CompositeAlgorithm +from cfspopcon.named_options import Algorithms +from cfspopcon.unit_handling import ureg + + +@pytest.fixture() +def BIRDS(): + return [ + "ducks", + "chooks", + "all_birds", + ] + + +@pytest.fixture() +def how_many_birds(BIRDS): + def count_birds(things_that_quack: int, things_that_cluck: int = 2) -> dict[str, Any]: + ducks = things_that_quack + chooks = things_that_cluck + all_birds = ducks + chooks + + local_vars = locals() + return {key: local_vars[key] for key in BIRDS} + + return Algorithm(function=count_birds, return_keys=BIRDS) + + +@pytest.fixture() +def ANIMALS(): + return [ + "sheep", + "all_birds", + "all_animals", + ] + + +@pytest.fixture() +def how_many_animals(ANIMALS): + def count_animals(things_that_baa: int, all_birds: int, new_chickens_per_count: int = 2) -> dict[str, Any]: + sheep = things_that_baa + + all_birds = all_birds + new_chickens_per_count + all_animals = sheep + all_birds + + local_vars = locals() + return {key: local_vars[key] for key in ANIMALS} + + return Algorithm(function=count_animals, return_keys=ANIMALS) + + +def test_algorithm_kw_only(): + def test(p1, p2, /, p_or_kw, *, kw): + return {"p2_2": 10} + + with pytest.raises(ValueError, match="Algorithm only supports functions with keyword arguments.*?POSITIONAL_ONLY parameter p1"): + _ = Algorithm(function=test, return_keys=["p2_2"]) + + +def test_composite_signature(how_many_birds, how_many_animals): + composite = how_many_birds + how_many_animals + assert ( + str(composite.run.__signature__) + == "(things_that_quack: int, things_that_baa: int, things_that_cluck: int = 2, new_chickens_per_count: int = 2) -> xarray.core.dataset.Dataset" + ) + + +def test_dummy_algorithm(how_many_birds, BIRDS): + + assert how_many_birds.return_keys == BIRDS + assert how_many_birds.input_keys == ["things_that_quack", "things_that_cluck"] + assert how_many_birds.required_input_keys == ["things_that_quack"] + assert how_many_birds.default_keys == ["things_that_cluck"] + assert how_many_birds.default_values["things_that_cluck"] == 2 + + with contextlib.redirect_stdout(None): + repr(how_many_birds) + + result = how_many_birds.run(things_that_quack=1) + assert result["all_birds"] == 3 + assert result["ducks"] == 1 + assert result["chooks"] == 2 + + ds = xr.Dataset(dict(things_that_quack=3)) + resulting_ds = how_many_birds.update_dataset(ds) + assert resulting_ds["all_birds"] == 5 + assert resulting_ds["ducks"] == 3 + assert resulting_ds["chooks"] == 2 + + ds = xr.Dataset(dict(things_that_cluck=3)) + with pytest.raises(KeyError): + resulting_ds = how_many_birds.update_dataset(ds) + + +def test_dummy_composite_algorithm(how_many_birds, BIRDS, how_many_animals, ANIMALS): + + count_the_farm = how_many_birds + how_many_animals + + assert set(count_the_farm.return_keys) == set(BIRDS).union(set(ANIMALS)) + assert set(count_the_farm.input_keys) == {"things_that_quack", "things_that_cluck", "things_that_baa", "new_chickens_per_count"} + assert set(count_the_farm.required_input_keys) == {"things_that_quack", "things_that_baa"} + + with contextlib.redirect_stdout(None): + repr(count_the_farm) + + with pytest.warns(): + result = count_the_farm.run(things_that_quack=1, things_that_baa=4, crocodiles=3) + + assert result["all_birds"] == 5 # N.b. this includes the new chickens + assert result["ducks"] == 1 + assert result["chooks"] == 2 + assert result["sheep"] == 4 + assert result["all_animals"] == 9 + + ds = xr.Dataset(dict(things_that_quack=1, things_that_baa=4, crocodiles=3)) + ds = count_the_farm.update_dataset(ds) + assert ds["all_birds"] == 5 # N.b. this includes the new chickens + assert ds["ducks"] == 1 + assert ds["chooks"] == 2 + assert ds["sheep"] == 4 + assert ds["all_animals"] == 9 + + # Here is a subtlety which is worth considering + # If we call count_the_farm again, how many birds will we have? + # At first glance, we could have 7, since we add 2 new chickens + # each time we call count_the_farm + # However, we actually still have just 5. Why? When we call + # update_dataset, we first call how_many_birds, which sets + # all_birds = ducks + chooks, ignoring the number of chickens + # that we have. Then, all_birds gets passed to how_many_animals + # where we add two more chickens. + # + # A few conclusions + # 1. You should be very careful when relying on the internal + # state of the dataset. The .run() method is more explicit + # and can help to catch some of these tricky cases. + # 2. The algorithm is doing what we asked of it. To be sure, + # see test_repeated_dataset_updates + # 3. Before writing a big unit test, ask yourself how much you + # want to commit to the whole farm thing and not just call + # your variables something boring like 'a' or 'my_var' + # 4. Be careful counting your chickens before they've hatched. + ds = count_the_farm.update_dataset(ds) + assert ds["all_birds"] == 5 + + +def test_composite_of_composite(how_many_birds: Algorithm, how_many_animals: Algorithm): + # add of Algorihtm + Composite should flatten into Composite of all Algorithms + count_the_farm = how_many_birds + CompositeAlgorithm([how_many_animals, how_many_animals]) + # thus the lenght of algorithms should be 3 + assert len(count_the_farm.algorithms) == 3 + + ds = xr.Dataset(dict(things_that_quack=1, things_that_baa=4, crocodiles=3)) + ds = count_the_farm.update_dataset(ds) + assert ds["all_animals"] == 11 # Each time we count how many animals, we get two new chickens + + # test the flattening of composites in __init__ and __add__ + comp = CompositeAlgorithm([how_many_birds, count_the_farm]) + assert len(comp.algorithms) == 4 + comp2 = comp + how_many_birds + assert len(comp2.algorithms) == 5 + comp3 = comp + comp2 + assert len(comp3.algorithms) == 9 + + with pytest.raises(TypeError, match=".*missing arguments.*"): + _ = count_the_farm.run() + + input_ds = xr.Dataset(dict(things_that_quack=1, things_that_baa=4)) + with pytest.warns(UserWarning, match="The following variables were overridden.*"): + assert count_the_farm.validate_inputs( + input_ds, + quiet=False, + raise_error_on_missing_inputs=True, + warn_for_overridden_variables=True, + ) + + input_ds["crocodiles"] = 10 + with pytest.warns(UserWarning, match="Unused input parameters .crocodiles.."): + ret = count_the_farm.validate_inputs( + input_ds, + quiet=False, + raise_error_on_missing_inputs=True, + warn_for_overridden_variables=False, + ) + + assert ret is False + + # missing + unused now + input_ds = input_ds.drop_vars("things_that_baa") + with pytest.raises(RuntimeError, match="Missing input parameters.*Also had unused.*"): + count_the_farm.validate_inputs( + input_ds, + quiet=False, + raise_error_on_missing_inputs=True, + warn_for_overridden_variables=False, + ) + + # missing only + input_ds = input_ds.drop_vars("crocodiles") + with pytest.raises(RuntimeError, match="Missing input parameters .things_that_baa.."): + count_the_farm.validate_inputs( + input_ds, + quiet=False, + raise_error_on_missing_inputs=True, + warn_for_overridden_variables=False, + ) + + wrong_order_comp = how_many_animals + how_many_birds + with pytest.raises(RuntimeError, match="Algorithms out of order. all_birds needed by Algorithm.*"): + wrong_order_comp.validate_inputs( + input_ds, + quiet=False, + raise_error_on_missing_inputs=True, + warn_for_overridden_variables=False, + ) + + +def test_repeated_dataset_updates(how_many_animals): + + ds = xr.Dataset(dict(all_birds=0, things_that_baa=0, new_chickens_per_count=1)) + ds = how_many_animals.update_dataset(ds) + assert ds["all_animals"] == 1 + ds["new_chickens_per_count"] = 10 + ds = how_many_animals.update_dataset(ds) + assert ds["all_animals"] == 11 + + composite = how_many_animals + how_many_animals + ds = xr.Dataset(dict(all_birds=0, things_that_baa=0, new_chickens_per_count=11)) + ds = composite.update_dataset(ds) + assert ds["all_animals"] == 22 + + +def test_composite_of_a_single_algorithm_fails(how_many_birds): + + with pytest.raises(TypeError): + CompositeAlgorithm(how_many_birds) + + +def test_single_function_algorithm(): + def dummy_func(a, b): + """A very descriptive docstring.""" + c, d = b, a + return c, d + + alg = Algorithm.from_single_function(dummy_func, return_keys=["c", "d"], name="test_dummy", skip_unit_conversion=True) + + result = alg.run(a=1, b=2) + assert result["c"] == 2 + assert result["d"] == 1 + + def in_and_out(average_electron_density): + return average_electron_density * 2 + + alg = Algorithm.from_single_function(in_and_out, return_keys=["average_electron_density"], name="test_dummy_in_and_out") + result = alg.run(average_electron_density=1.2 * ureg.n20) + assert result["average_electron_density"] == 24.0 * ureg.n19 + + +def test_get_algorithm(): + + # Pass in Algorithm Enums + for key in Algorithms: + alg = get_algorithm(key) + assert alg._name in [f"run_{key.name}", key.name, ""] + + # Pass in strings instead + for key in Algorithms: + alg = get_algorithm(key.name) + assert alg._name in [f"run_{key.name}", key.name, ""] diff --git a/tests/test_cli.py b/tests/test_cli.py new file mode 100644 index 00000000..654ecd05 --- /dev/null +++ b/tests/test_cli.py @@ -0,0 +1,20 @@ +from pathlib import Path + +import matplotlib +import pytest +from click.testing import CliRunner + +from cfspopcon.cli import run_popcon_cli + + +@pytest.mark.filterwarnings("ignore:Matplotlib is currently using agg") +def test_popcon_cli(): + matplotlib.use("Agg") + + runner = CliRunner() + example_case = Path(__file__).parents[1] / "example_cases" / "SPARC_PRD" + result = runner.invoke( + run_popcon_cli, + [str(example_case), "-p", str(example_case / "plot_popcon.yaml"), "-p", str(example_case / "plot_remapped.yaml"), "--show"], + ) + assert result.exit_code == 0 diff --git a/tests/test_helpers.py b/tests/test_helpers.py new file mode 100644 index 00000000..5261d442 --- /dev/null +++ b/tests/test_helpers.py @@ -0,0 +1,55 @@ +import pytest +import xarray as xr + +from cfspopcon import named_options +from cfspopcon.helpers import ( + convert_named_options, + extend_impurities_array, + make_impurities_array, + make_impurities_array_from_kwargs, +) + + +def test_convert_named_options(): + + for (val, key) in ( + (named_options.Algorithms.predictive_popcon, "algorithms"), + (named_options.ConfinementScaling.ITER98y2, "energy_confinement_scaling"), + (named_options.ProfileForm.analytic, "profile_form"), + (named_options.RadiationMethod.Radas, "radiated_power_method"), + (named_options.ReactionType.DT, "fusion_reaction"), + (named_options.Impurity.Neon, "impurity"), + (named_options.Impurity.Xenon, "core_radiator"), + (named_options.LambdaQScaling.EichRegression15, "lambda_q_scaling"), + (named_options.MomentumLossFunction.KotovReiter, "SOL_momentum_loss_function"), + ): + assert convert_named_options(key=key, val=val.name) == val + + assert convert_named_options(key="ducks", val=23.0) == 23.0 + + da = convert_named_options(key="impurities", val=dict(tungsten=1e-5, helium=1e-2)) + + assert da.sel(dim_species=named_options.Impurity.Tungsten) == 1e-5 + assert da.sel(dim_species=named_options.Impurity.Helium) == 1e-2 + + +def test_impurity_array_helpers(): + + array = xr.DataArray([[1, 2], [3, 4]], coords=dict(a=[1, 2], b=[3, 5])) + + make_impurities_array(xr.DataArray("tungsten"), array) + + from_lists = make_impurities_array([named_options.Impurity.Tungsten, "Xenon"], [array, 2 * array]) + from_kwargs = make_impurities_array_from_kwargs(tungsten=array, xenon=2 * array) + + assert from_lists.equals(from_kwargs) + + from_extension = make_impurities_array(["tungsten"], [array]) + from_extension = extend_impurities_array(from_extension, "xenon", 2 * array) + + assert from_extension.equals(from_kwargs) + + with pytest.raises(ValueError): + from_lists = make_impurities_array("Xenon", [array, 2 * array, 3 * array]) + with pytest.raises(ValueError): + from_lists = make_impurities_array(["Xenon", "tungsten"], [array]) diff --git a/tests/test_infra/conftest.py b/tests/test_infra/conftest.py new file mode 100644 index 00000000..73ff8eb3 --- /dev/null +++ b/tests/test_infra/conftest.py @@ -0,0 +1,42 @@ +import numpy as np +import pytest +import xarray as xr + + +@pytest.fixture() +def x(): + return np.linspace(0, 10, num=400) + + +@pytest.fixture() +def y(): + return np.linspace(-5, 5, num=500) + + +@pytest.fixture() +def z(x, y): + x_grid, y_grid = np.meshgrid(x, y) + return xr.DataArray(x_grid + y_grid, coords=dict(y=y, x=x)) + + +@pytest.fixture() +def z1(x, y): + x_grid, y_grid = np.meshgrid(x, y) + return xr.DataArray(x_grid + y_grid**2, coords=dict(y=y, x=x)) + + +@pytest.fixture() +def z2(x, y): + x_grid, y_grid = np.meshgrid(x, y) + return xr.DataArray(x_grid**2 + y_grid, coords=dict(y=y, x=x)) + + +@pytest.fixture() +def z3(x, y): + x_grid, y_grid = np.meshgrid(x, y) + return xr.DataArray(np.abs(y_grid + x_grid), coords=dict(y=y, x=x)) + + +@pytest.fixture() +def ds(x, y, z, z1, z2, z3): + return xr.Dataset(dict(x=x, y=y, z=z, z1=z1, z2=z2, z3=z3)) diff --git a/tests/test_infra/test_plotting.py b/tests/test_infra/test_plotting.py new file mode 100644 index 00000000..6761b8c0 --- /dev/null +++ b/tests/test_infra/test_plotting.py @@ -0,0 +1,42 @@ +import matplotlib.pyplot as plt +import numpy as np +import pytest + +from cfspopcon import plotting +from cfspopcon.unit_handling import ureg + + +def test_coordinate_formatter(z): + formatter = plotting.CoordinateFormatter(z) + + x_test = 1.23 + y_test = -3.45 + ret_string = formatter(x_test, y_test) + + x_string, y_string, z_string = ret_string.split(",") + + assert np.isclose(float(x_string.split("=")[1]), x_test) + assert np.isclose(float(y_string.split("=")[1]), y_test) + # Nearest-neighbor interpolation is not particularly accurate. + assert np.isclose(float(z_string.split("=")[1]), x_test + y_test, atol=0.01) + + +@pytest.mark.filterwarnings("error") +def test_label_contour(z): + # Make sure that the label contour functionality runs through. + _, ax = plt.subplots() + CS = z.plot.contour(ax=ax, colors=["r"]) + + contour_labels = dict() + contour_labels["z"] = plotting.label_contour(ax=ax, contour_set=CS, format_spec="3.2f", fontsize=12) + + ax.legend(contour_labels.values(), contour_labels.keys()) + + plt.close() + + +def test_units_to_string(): + + assert plotting.units_to_string(ureg.dimensionless) == "" + assert plotting.units_to_string(ureg.m) == "[m]" + assert plotting.units_to_string(ureg.percent) == "[percent]" diff --git a/tests/test_infra/test_point_selection.py b/tests/test_infra/test_point_selection.py new file mode 100644 index 00000000..5a00efd6 --- /dev/null +++ b/tests/test_infra/test_point_selection.py @@ -0,0 +1,21 @@ +import numpy as np + +from cfspopcon.point_selection import find_coords_of_maximum + + +def test_find_coords(ds): + + coords = find_coords_of_maximum(ds.z3) + assert np.isclose(ds.z3.max(), ds.isel(coords).z3) + + coords = find_coords_of_maximum(ds.z3, keep_dims="x") + assert np.allclose(ds.z3.max(dim="y"), ds.isel(coords).z3) + + coords = find_coords_of_maximum(ds.z3, keep_dims="y") + assert np.allclose(ds.z3.max(dim="x"), ds.isel(coords).z3) + + mask = (ds.y < 1.0) & (ds.x < 5.0) + + coords = find_coords_of_maximum(ds.z3, mask=mask) + # z3 is x + y, so must be close to but less than 1 + 5 + assert np.isclose(ds.isel(coords).z3, 6.0, atol=0.1) diff --git a/tests/test_infra/test_transform.py b/tests/test_infra/test_transform.py new file mode 100644 index 00000000..1ffef0c0 --- /dev/null +++ b/tests/test_infra/test_transform.py @@ -0,0 +1,27 @@ +import pytest +import xarray as xr + +from cfspopcon import transform + + +def test_interpolate_onto_new_coords(z, z1, z2): + + z_interp = transform.interpolate_array_onto_new_coords(array=z, new_coords=dict(z1=z1, z2=z2), default_resolution=5) + + assert z_interp.min() >= z.min() + assert z_interp.max() <= z.max() + assert "z1" in z_interp.dims + assert "z2" in z_interp.dims + + +def test_order_dimensions(z): + + assert transform.order_dimensions(z, dims=("x", "y"), order_for_plotting=True).dims == ("y", "x") + assert transform.order_dimensions(z, dims=("x", "y"), order_for_plotting=False).dims == ("x", "y") + + with pytest.raises(ValueError): + assert transform.order_dimensions(z.isel(x=0), dims=("x", "y")).dims == ("x", "y") + + assert transform.order_dimensions(z.isel(x=0), dims=("x", "y"), template=z).dims == ("y", "x") + ds = xr.Dataset(dict(z=z)) + assert transform.order_dimensions(z.isel(x=0), dims=("x", "y"), template=ds).dims == ("y", "x") diff --git a/tests/test_read_atomic_data.py b/tests/test_read_atomic_data.py new file mode 100644 index 00000000..ecd43bfc --- /dev/null +++ b/tests/test_read_atomic_data.py @@ -0,0 +1,20 @@ +import pytest + +import cfspopcon + + +@pytest.mark.filterwarnings("error") +def test_read_atomic_data(): + cfspopcon.atomic_data.read_atomic_data() + + +@pytest.mark.filterwarnings("error") +def test_read_atomic_data_from_explicit_directory(module_directory): + cfspopcon.atomic_data.read_atomic_data(module_directory / "atomic_data") + + +@pytest.mark.filterwarnings("error") +def test_read_atomic_data_from_missing_directory(module_directory): + + with pytest.raises(FileNotFoundError): + cfspopcon.atomic_data.read_atomic_data(module_directory / "this_doesnt_exist") diff --git a/tests/test_regression_against_cases.py b/tests/test_regression_against_cases.py new file mode 100644 index 00000000..0513ae97 --- /dev/null +++ b/tests/test_regression_against_cases.py @@ -0,0 +1,43 @@ +from pathlib import Path + +import pytest +import xarray as xr +from regression_results.generate_regression_results import ( + ALL_CASE_NAMES, + ALL_CASE_PATHS, +) +from xarray.testing import assert_allclose + +from cfspopcon.file_io import read_dataset_from_netcdf +from cfspopcon.input_file_handling import read_case + + +@pytest.mark.parametrize("case", ALL_CASE_PATHS, ids=ALL_CASE_NAMES) +@pytest.mark.filterwarnings("ignore:Not all input parameters were used") +def test_regression_against_case(case: Path): + + input_parameters, algorithm, _ = read_case(case) + case_name = case.parent.stem + + dataset = algorithm.run(**input_parameters) + + reference_dataset = read_dataset_from_netcdf(Path(__file__).parent / "regression_results" / f"{case_name}_result.nc").load() + + assert_allclose(dataset, reference_dataset, rtol=1e-8, atol=0) + + +@pytest.mark.parametrize("case", ALL_CASE_PATHS, ids=ALL_CASE_NAMES) +@pytest.mark.filterwarnings("ignore:Not all input parameters were used") +def test_regression_against_case_with_update(case: Path): + + input_parameters, algorithm, _ = read_case(case) + case_name = case.parent.stem + + dataset = xr.Dataset(input_parameters) + + for alg in algorithm.algorithms: # type: ignore + dataset = alg.update_dataset(dataset) + + reference_dataset = read_dataset_from_netcdf(Path(__file__).parent / "regression_results" / f"{case_name}_result.nc").load() + + assert_allclose(dataset, reference_dataset, rtol=1e-8, atol=0) diff --git a/tests/test_unit_handling/test_custom_units.py b/tests/test_unit_handling/test_custom_units.py new file mode 100644 index 00000000..84314202 --- /dev/null +++ b/tests/test_unit_handling/test_custom_units.py @@ -0,0 +1,13 @@ +import numpy as np + +from cfspopcon.unit_handling import Quantity, ureg + + +def test_custom_units(): + + assert np.isclose(Quantity(10.0, ureg.n19), Quantity(1.0, ureg.n20)) + assert np.isclose(Quantity(1.0, ureg.n19), Quantity(1e19, ureg.m**-3)) + assert np.isclose(Quantity(1.0, ureg.n20), Quantity(1e20, ureg.m**-3)) + + assert np.isclose(Quantity(100.0, ureg.percent), Quantity(1.0, ureg.dimensionless)) + assert np.isclose(Quantity(100.0, ureg.percent), 1.0) diff --git a/tests/test_unit_handling/test_wraps_ufunc_decorator.py b/tests/test_unit_handling/test_wraps_ufunc_decorator.py new file mode 100644 index 00000000..9fac237b --- /dev/null +++ b/tests/test_unit_handling/test_wraps_ufunc_decorator.py @@ -0,0 +1,182 @@ +"""Test the pint-xarray wraps_ufunc decorator.""" + +import warnings + +import numpy as np +import pytest +import xarray as xr + +from cfspopcon.unit_handling import UnitStrippedWarning, dimensionless_magnitude, ureg, wraps_ufunc + + +def check_equal(a, b, **kwargs): + with warnings.catch_warnings(): + warnings.filterwarnings("ignore") + ratio = a / b + ratio[(a == 0) & (b == 0)] = 1.0 + + return np.allclose(dimensionless_magnitude(ratio), 1.0, **kwargs) + + +@pytest.mark.filterwarnings("error") +def test_wraps_simple(): + @wraps_ufunc(return_units=dict(doubled=None), input_units=dict(x=None)) + def simple_function(x): + return 2 * x + + x_test = xr.DataArray(np.linspace(0.0, 100.0)) + assert check_equal(2.0 * x_test, simple_function(x_test)) + assert isinstance(simple_function(x_test), xr.DataArray) + + x_test_2 = np.linspace(0.0, 100.0) + assert check_equal(2.0 * x_test_2, simple_function(x_test_2)) + + +@pytest.mark.filterwarnings("error") +def test_wraps_with_too_many_input_units(): + + with pytest.raises(ValueError): + + @wraps_ufunc(return_units=dict(result=ureg.m), input_units=dict(a=ureg.m, b=ureg.mm)) + def in_and_out(a): + return a + + +@pytest.mark.filterwarnings("error") +def test_wraps_with_too_many_output_units(): + @wraps_ufunc(return_units=dict(a=ureg.m, b=ureg.m), input_units=dict(a=ureg.m)) + def in_and_out(a): + return a + + with pytest.raises(ValueError): + in_and_out(ureg.Quantity(1.2, ureg.m)) + + +@pytest.mark.filterwarnings("error") +def test_wraps_with_wrong_arguments(): + + with pytest.raises(ValueError): + + @wraps_ufunc(return_units=dict(result=ureg.m), input_units=dict(b=ureg.m)) + def in_and_out(a): + return a + + +@pytest.mark.filterwarnings("error") +def test_jumbled_inputs(): + @wraps_ufunc(return_units=dict(result=ureg.m), input_units=dict(a=ureg.m, b=ureg.m)) + def add_together(a, b): + return a + b + + with pytest.raises(RuntimeError): + add_together(ureg.Quantity(7.0, ureg.mm), a=ureg.Quantity(3.0, ureg.m)) + + +@pytest.mark.filterwarnings("error") +def test_pass_as_kwargs(): + @wraps_ufunc(return_units=dict(result=ureg.m), input_units=dict(a=ureg.m, b=ureg.m), pass_as_kwargs=("a", "b")) + def add_together(a, b): + return a + b + + add_together(a=ureg.Quantity(7.0, ureg.m), b=ureg.Quantity(3.0, ureg.feet)) + + +@pytest.mark.filterwarnings("error") +def test_pass_as_kwargs_in_wrong_order(): + with pytest.raises(ValueError): + + @wraps_ufunc(return_units=dict(result=ureg.m), input_units=dict(a=ureg.m, b=ureg.m), pass_as_kwargs=("a")) + def add_together(a, b): + return a + b + + add_together(a=ureg.Quantity(7.0, ureg.m), b=ureg.Quantity(3.0, ureg.feet)) + + +@pytest.mark.filterwarnings("error") +def test_multiple_return(): + @wraps_ufunc( + return_units=dict(b=ureg.m, a=ureg.m), + input_units=dict(a=ureg.m, b=ureg.m), + output_core_dims=[(), ()], + ) + def swap(a, b): + return b, a + + a = xr.DataArray(ureg.Quantity(np.linspace(0.0, 100.0), ureg.m)) + b = ureg.Quantity(np.pi, ureg.m) + + b2, a2 = swap(a, b) + + assert check_equal(a2, a) + assert np.all(np.abs(b2 - b) < ureg.Quantity(1.0, ureg.mm)) + + assert isinstance(a2, xr.DataArray) + assert isinstance(b2, xr.DataArray) + + assert a2.pint.units == ureg.m + assert b2.pint.units == ureg.m + + +@pytest.mark.filterwarnings("error") +def test_multiple_return_with_wrong_number_of_units(): + @wraps_ufunc(return_units=dict(a=ureg.m), input_units=dict(a=ureg.m, b=ureg.m), output_core_dims=[(), ()]) + def swap(a, b): + return b, a + + a = xr.DataArray(ureg.Quantity(np.linspace(0.0, 100.0), ureg.m)) + b = ureg.Quantity(np.pi, ureg.m) + + with pytest.raises(ValueError): + b2, a2 = swap(a, b) + + +@pytest.mark.filterwarnings("error") +def test_no_return(): + @wraps_ufunc(return_units=dict(), input_units=dict(a=ureg.m)) + def do_nothing(a): + pass + + a = ureg.Quantity(np.pi, ureg.m) + do_nothing(a) + + +@pytest.mark.filterwarnings("error") +def test_no_return_with_too_many_units(): + @wraps_ufunc(return_units=dict(a=ureg.m), input_units=dict(a=ureg.m)) + def do_nothing(a): + pass + + a = ureg.Quantity(np.pi, ureg.m) + + # Returns Quantity(None, ureg.m) + do_nothing(a) + + +@pytest.mark.filterwarnings("error") +def test_illegal_chained_call_input(): + @wraps_ufunc(return_units=dict(doubled=None), input_units=dict(x=ureg.m)) + def simple_function(x): + return 2 * x + + @wraps_ufunc(return_units=dict(doubled=None), input_units=dict(x=ureg.m)) + def simple_function2(x): + return simple_function(x) + + with pytest.raises( + RuntimeError, match=r".*Calling `wraps_ufunc` decorated function from within.*\n.*\n.*\n.*simple_function.unitless_func.*" + ): + simple_function2(10 * ureg.m) + + +@pytest.mark.filterwarnings("error") +def test_illegal_chained_call_ouput(): + @wraps_ufunc(return_units=dict(doubled=ureg.m), input_units=dict(x=None)) + def simple_function(x): + return 2 * x + + @wraps_ufunc(return_units=dict(doubled=ureg.m), input_units=dict(x=None)) + def simple_function2(x): + return simple_function(x) + + with pytest.raises(UnitStrippedWarning): + simple_function2(10)